xref: /titanic_44/usr/src/uts/common/os/streamio.c (revision bbc000e522dec6271bdf858a8b013d7fc4c10ed4)
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 /*
26a45f3f93Smeem  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
277c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
287c478bd9Sstevel@tonic-gate  */
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #include <sys/types.h>
317c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
327c478bd9Sstevel@tonic-gate #include <sys/param.h>
337c478bd9Sstevel@tonic-gate #include <sys/errno.h>
347c478bd9Sstevel@tonic-gate #include <sys/signal.h>
357c478bd9Sstevel@tonic-gate #include <sys/stat.h>
367c478bd9Sstevel@tonic-gate #include <sys/proc.h>
377c478bd9Sstevel@tonic-gate #include <sys/cred.h>
387c478bd9Sstevel@tonic-gate #include <sys/user.h>
397c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
407c478bd9Sstevel@tonic-gate #include <sys/file.h>
417c478bd9Sstevel@tonic-gate #include <sys/stream.h>
427c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
437c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
447c478bd9Sstevel@tonic-gate #include <sys/tihdr.h>
457c478bd9Sstevel@tonic-gate #include <sys/var.h>
467c478bd9Sstevel@tonic-gate #include <sys/poll.h>
477c478bd9Sstevel@tonic-gate #include <sys/termio.h>
487c478bd9Sstevel@tonic-gate #include <sys/ttold.h>
497c478bd9Sstevel@tonic-gate #include <sys/systm.h>
507c478bd9Sstevel@tonic-gate #include <sys/uio.h>
517c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
527c478bd9Sstevel@tonic-gate #include <sys/sad.h>
53f4b3ec61Sdh155122 #include <sys/netstack.h>
547c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
557c478bd9Sstevel@tonic-gate #include <sys/jioctl.h>
567c478bd9Sstevel@tonic-gate #include <sys/procset.h>
577c478bd9Sstevel@tonic-gate #include <sys/session.h>
587c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
597c478bd9Sstevel@tonic-gate #include <sys/filio.h>
607c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
617c478bd9Sstevel@tonic-gate #include <sys/debug.h>
627c478bd9Sstevel@tonic-gate #include <sys/strredir.h>
637c478bd9Sstevel@tonic-gate #include <sys/fs/fifonode.h>
647c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
657c478bd9Sstevel@tonic-gate #include <sys/strlog.h>
667c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
677c478bd9Sstevel@tonic-gate #include <sys/project.h>
687c478bd9Sstevel@tonic-gate #include <sys/kbio.h>
697c478bd9Sstevel@tonic-gate #include <sys/msio.h>
707c478bd9Sstevel@tonic-gate #include <sys/tty.h>
717c478bd9Sstevel@tonic-gate #include <sys/ptyvar.h>
727c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h>
737c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
747c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
757c478bd9Sstevel@tonic-gate #include <sys/sunldi_impl.h>
767c478bd9Sstevel@tonic-gate #include <sys/autoconf.h>
777c478bd9Sstevel@tonic-gate #include <sys/policy.h>
78d62bc4baSyz147064 #include <sys/dld.h>
79f4b3ec61Sdh155122 #include <sys/zone.h>
807c478bd9Sstevel@tonic-gate 
819acbbeafSnn35248 /*
829acbbeafSnn35248  * This define helps improve the readability of streams code while
839acbbeafSnn35248  * still maintaining a very old streams performance enhancement.  The
849acbbeafSnn35248  * performance enhancement basically involved having all callers
859acbbeafSnn35248  * of straccess() perform the first check that straccess() will do
869acbbeafSnn35248  * locally before actually calling straccess().  (There by reducing
879acbbeafSnn35248  * the number of unnecessary calls to straccess().)
889acbbeafSnn35248  */
899acbbeafSnn35248 #define	i_straccess(x, y)	((stp->sd_sidp == NULL) ? 0 : \
909acbbeafSnn35248 				    (stp->sd_vnode->v_type == VFIFO) ? 0 : \
919acbbeafSnn35248 				    straccess((x), (y)))
929acbbeafSnn35248 
937c478bd9Sstevel@tonic-gate /*
947c478bd9Sstevel@tonic-gate  * what is mblk_pull_len?
957c478bd9Sstevel@tonic-gate  *
967c478bd9Sstevel@tonic-gate  * If a streams message consists of many short messages,
977c478bd9Sstevel@tonic-gate  * a performance degradation occurs from copyout overhead.
987c478bd9Sstevel@tonic-gate  * To decrease the per mblk overhead, messages that are
997c478bd9Sstevel@tonic-gate  * likely to consist of many small mblks are pulled up into
1007c478bd9Sstevel@tonic-gate  * one continuous chunk of memory.
1017c478bd9Sstevel@tonic-gate  *
1027c478bd9Sstevel@tonic-gate  * To avoid the processing overhead of examining every
1037c478bd9Sstevel@tonic-gate  * mblk, a quick heuristic is used. If the first mblk in
1047c478bd9Sstevel@tonic-gate  * the message is shorter than mblk_pull_len, it is likely
1057c478bd9Sstevel@tonic-gate  * that the rest of the mblk will be short.
1067c478bd9Sstevel@tonic-gate  *
1077c478bd9Sstevel@tonic-gate  * This heuristic was decided upon after performance tests
1087c478bd9Sstevel@tonic-gate  * indicated that anything more complex slowed down the main
1097c478bd9Sstevel@tonic-gate  * code path.
1107c478bd9Sstevel@tonic-gate  */
1117c478bd9Sstevel@tonic-gate #define	MBLK_PULL_LEN 64
1127c478bd9Sstevel@tonic-gate uint32_t mblk_pull_len = MBLK_PULL_LEN;
1137c478bd9Sstevel@tonic-gate 
1147c478bd9Sstevel@tonic-gate /*
1157c478bd9Sstevel@tonic-gate  * The sgttyb_handling flag controls the handling of the old BSD
1167c478bd9Sstevel@tonic-gate  * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:
1177c478bd9Sstevel@tonic-gate  *
1187c478bd9Sstevel@tonic-gate  * 0 - Emit no warnings at all and retain old, broken behavior.
1197c478bd9Sstevel@tonic-gate  * 1 - Emit no warnings and silently handle new semantics.
1207c478bd9Sstevel@tonic-gate  * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used
1217c478bd9Sstevel@tonic-gate  *     (once per system invocation).  Handle with new semantics.
1227c478bd9Sstevel@tonic-gate  * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is
1237c478bd9Sstevel@tonic-gate  *     made (so that offenders drop core and are easy to debug).
1247c478bd9Sstevel@tonic-gate  *
1257c478bd9Sstevel@tonic-gate  * The "new semantics" are that TIOCGETP returns B38400 for
1267c478bd9Sstevel@tonic-gate  * sg_[io]speed if the corresponding value is over B38400, and that
1277c478bd9Sstevel@tonic-gate  * TIOCSET[PN] accept B38400 in these cases to mean "retain current
1287c478bd9Sstevel@tonic-gate  * bit rate."
1297c478bd9Sstevel@tonic-gate  */
1307c478bd9Sstevel@tonic-gate int sgttyb_handling = 1;
1317c478bd9Sstevel@tonic-gate static boolean_t sgttyb_complaint;
1327c478bd9Sstevel@tonic-gate 
1337c478bd9Sstevel@tonic-gate /* don't push drcompat module by default on Style-2 streams */
1347c478bd9Sstevel@tonic-gate static int push_drcompat = 0;
1357c478bd9Sstevel@tonic-gate 
1367c478bd9Sstevel@tonic-gate /*
1377c478bd9Sstevel@tonic-gate  * id value used to distinguish between different ioctl messages
1387c478bd9Sstevel@tonic-gate  */
1397c478bd9Sstevel@tonic-gate static uint32_t ioc_id;
1407c478bd9Sstevel@tonic-gate 
1417c478bd9Sstevel@tonic-gate static void putback(struct stdata *, queue_t *, mblk_t *, int);
1427c478bd9Sstevel@tonic-gate static void strcleanall(struct vnode *);
1437c478bd9Sstevel@tonic-gate static int strwsrv(queue_t *);
144ca9327a6Smeem static int strdocmd(struct stdata *, struct strcmd *, cred_t *);
1457c478bd9Sstevel@tonic-gate 
1467c478bd9Sstevel@tonic-gate /*
1477c478bd9Sstevel@tonic-gate  * qinit and module_info structures for stream head read and write queues
1487c478bd9Sstevel@tonic-gate  */
1497c478bd9Sstevel@tonic-gate struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };
1507c478bd9Sstevel@tonic-gate struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };
1517c478bd9Sstevel@tonic-gate struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };
1527c478bd9Sstevel@tonic-gate struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };
1537c478bd9Sstevel@tonic-gate struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,
1547c478bd9Sstevel@tonic-gate     FIFOLOWAT };
1557c478bd9Sstevel@tonic-gate struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };
1567c478bd9Sstevel@tonic-gate struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };
1577c478bd9Sstevel@tonic-gate struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };
1587c478bd9Sstevel@tonic-gate 
1597c478bd9Sstevel@tonic-gate extern kmutex_t	strresources;	/* protects global resources */
1607c478bd9Sstevel@tonic-gate extern kmutex_t muxifier;	/* single-threads multiplexor creation */
1617c478bd9Sstevel@tonic-gate 
1627c478bd9Sstevel@tonic-gate static boolean_t msghasdata(mblk_t *bp);
1637c478bd9Sstevel@tonic-gate #define	msgnodata(bp) (!msghasdata(bp))
1647c478bd9Sstevel@tonic-gate 
1657c478bd9Sstevel@tonic-gate /*
1667c478bd9Sstevel@tonic-gate  * Stream head locking notes:
1677c478bd9Sstevel@tonic-gate  *	There are four monitors associated with the stream head:
1687c478bd9Sstevel@tonic-gate  *	1. v_stream monitor: in stropen() and strclose() v_lock
1697c478bd9Sstevel@tonic-gate  *		is held while the association of vnode and stream
1707c478bd9Sstevel@tonic-gate  *		head is established or tested for.
1717c478bd9Sstevel@tonic-gate  *	2. open/close/push/pop monitor: sd_lock is held while each
1727c478bd9Sstevel@tonic-gate  *		thread bids for exclusive access to this monitor
1737c478bd9Sstevel@tonic-gate  *		for opening or closing a stream.  In addition, this
1747c478bd9Sstevel@tonic-gate  *		monitor is entered during pushes and pops.  This
1757c478bd9Sstevel@tonic-gate  *		guarantees that during plumbing operations there
1767c478bd9Sstevel@tonic-gate  *		is only one thread trying to change the plumbing.
1777c478bd9Sstevel@tonic-gate  *		Any other threads present in the stream are only
1787c478bd9Sstevel@tonic-gate  *		using the plumbing.
1797c478bd9Sstevel@tonic-gate  *	3. read/write monitor: in the case of read, a thread holds
1807c478bd9Sstevel@tonic-gate  *		sd_lock while trying to get data from the stream
1817c478bd9Sstevel@tonic-gate  *		head queue.  if there is none to fulfill a read
1827c478bd9Sstevel@tonic-gate  *		request, it sets RSLEEP and calls cv_wait_sig() down
1837c478bd9Sstevel@tonic-gate  *		in strwaitq() to await the arrival of new data.
1847c478bd9Sstevel@tonic-gate  *		when new data arrives in strrput(), sd_lock is acquired
1857c478bd9Sstevel@tonic-gate  *		before testing for RSLEEP and calling cv_broadcast().
1867c478bd9Sstevel@tonic-gate  *		the behavior of strwrite(), strwsrv(), and WSLEEP
1877c478bd9Sstevel@tonic-gate  *		mirror this.
1887c478bd9Sstevel@tonic-gate  *	4. ioctl monitor: sd_lock is gotten to ensure that only one
1897c478bd9Sstevel@tonic-gate  *		thread is doing an ioctl at a time.
1907c478bd9Sstevel@tonic-gate  */
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate static int
1937c478bd9Sstevel@tonic-gate push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,
194f4b3ec61Sdh155122     int anchor, cred_t *crp, uint_t anchor_zoneid)
1957c478bd9Sstevel@tonic-gate {
1967c478bd9Sstevel@tonic-gate 	int error;
1977c478bd9Sstevel@tonic-gate 	fmodsw_impl_t *fp;
1987c478bd9Sstevel@tonic-gate 
1997c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {
2007c478bd9Sstevel@tonic-gate 		error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;
2017c478bd9Sstevel@tonic-gate 		return (error);
2027c478bd9Sstevel@tonic-gate 	}
2037c478bd9Sstevel@tonic-gate 	if (stp->sd_pushcnt >= nstrpush) {
2047c478bd9Sstevel@tonic-gate 		return (EINVAL);
2057c478bd9Sstevel@tonic-gate 	}
2067c478bd9Sstevel@tonic-gate 
2077c478bd9Sstevel@tonic-gate 	if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {
2087c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STREOPENFAIL;
2097c478bd9Sstevel@tonic-gate 		return (EINVAL);
2107c478bd9Sstevel@tonic-gate 	}
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate 	/*
2137c478bd9Sstevel@tonic-gate 	 * push new module and call its open routine via qattach
2147c478bd9Sstevel@tonic-gate 	 */
2157c478bd9Sstevel@tonic-gate 	if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)
2167c478bd9Sstevel@tonic-gate 		return (error);
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 	/*
2197c478bd9Sstevel@tonic-gate 	 * Check to see if caller wants a STREAMS anchor
2207c478bd9Sstevel@tonic-gate 	 * put at this place in the stream, and add if so.
2217c478bd9Sstevel@tonic-gate 	 */
2227c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
223f4b3ec61Sdh155122 	if (anchor == stp->sd_pushcnt) {
2247c478bd9Sstevel@tonic-gate 		stp->sd_anchor = stp->sd_pushcnt;
225f4b3ec61Sdh155122 		stp->sd_anchorzone = anchor_zoneid;
226f4b3ec61Sdh155122 	}
2277c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
2287c478bd9Sstevel@tonic-gate 
2297c478bd9Sstevel@tonic-gate 	return (0);
2307c478bd9Sstevel@tonic-gate }
2317c478bd9Sstevel@tonic-gate 
2327c478bd9Sstevel@tonic-gate /*
2337c478bd9Sstevel@tonic-gate  * Open a stream device.
2347c478bd9Sstevel@tonic-gate  */
2357c478bd9Sstevel@tonic-gate int
2367c478bd9Sstevel@tonic-gate stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)
2377c478bd9Sstevel@tonic-gate {
2387c478bd9Sstevel@tonic-gate 	struct stdata *stp;
2397c478bd9Sstevel@tonic-gate 	queue_t *qp;
2407c478bd9Sstevel@tonic-gate 	int s;
241d62bc4baSyz147064 	dev_t dummydev, savedev;
2427c478bd9Sstevel@tonic-gate 	struct autopush *ap;
243d62bc4baSyz147064 	struct dlautopush dlap;
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;
249f4b3ec61Sdh155122 	str_stack_t *ss;
250f4b3ec61Sdh155122 	zoneid_t zoneid;
251f4b3ec61Sdh155122 	uint_t anchor;
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	if (audit_active)
2547c478bd9Sstevel@tonic-gate 		audit_stropen(vp, devp, flag, crp);
2557c478bd9Sstevel@tonic-gate 
2567c478bd9Sstevel@tonic-gate 	/*
2577c478bd9Sstevel@tonic-gate 	 * If the stream already exists, wait for any open in progress
2587c478bd9Sstevel@tonic-gate 	 * to complete, then call the open function of each module and
2597c478bd9Sstevel@tonic-gate 	 * driver in the stream.  Otherwise create the stream.
2607c478bd9Sstevel@tonic-gate 	 */
2617c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);
2627c478bd9Sstevel@tonic-gate retry:
2637c478bd9Sstevel@tonic-gate 	mutex_enter(&vp->v_lock);
2647c478bd9Sstevel@tonic-gate 	if ((stp = vp->v_stream) != NULL) {
2657c478bd9Sstevel@tonic-gate 
2667c478bd9Sstevel@tonic-gate 		/*
2677c478bd9Sstevel@tonic-gate 		 * Waiting for stream to be created to device
2687c478bd9Sstevel@tonic-gate 		 * due to another open.
2697c478bd9Sstevel@tonic-gate 		 */
2707c478bd9Sstevel@tonic-gate 		mutex_exit(&vp->v_lock);
2717c478bd9Sstevel@tonic-gate 
2727c478bd9Sstevel@tonic-gate 		if (STRMATED(stp)) {
2737c478bd9Sstevel@tonic-gate 			struct stdata *strmatep = stp->sd_mate;
2747c478bd9Sstevel@tonic-gate 
2757c478bd9Sstevel@tonic-gate 			STRLOCKMATES(stp);
2767c478bd9Sstevel@tonic-gate 			if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
2777c478bd9Sstevel@tonic-gate 				if (flag & (FNDELAY|FNONBLOCK)) {
2787c478bd9Sstevel@tonic-gate 					error = EAGAIN;
2797c478bd9Sstevel@tonic-gate 					mutex_exit(&strmatep->sd_lock);
2807c478bd9Sstevel@tonic-gate 					goto ckreturn;
2817c478bd9Sstevel@tonic-gate 				}
2827c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
2837c478bd9Sstevel@tonic-gate 				if (!cv_wait_sig(&strmatep->sd_monitor,
2847c478bd9Sstevel@tonic-gate 				    &strmatep->sd_lock)) {
2857c478bd9Sstevel@tonic-gate 					error = EINTR;
2867c478bd9Sstevel@tonic-gate 					mutex_exit(&strmatep->sd_lock);
2877c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
2887c478bd9Sstevel@tonic-gate 					goto ckreturn;
2897c478bd9Sstevel@tonic-gate 				}
2907c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
2917c478bd9Sstevel@tonic-gate 				goto retry;
2927c478bd9Sstevel@tonic-gate 			}
2937c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
2947c478bd9Sstevel@tonic-gate 				if (flag & (FNDELAY|FNONBLOCK)) {
2957c478bd9Sstevel@tonic-gate 					error = EAGAIN;
2967c478bd9Sstevel@tonic-gate 					mutex_exit(&strmatep->sd_lock);
2977c478bd9Sstevel@tonic-gate 					goto ckreturn;
2987c478bd9Sstevel@tonic-gate 				}
2997c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
300d3e55dcdSgww 				if (!cv_wait_sig(&stp->sd_monitor,
301d3e55dcdSgww 				    &stp->sd_lock)) {
3027c478bd9Sstevel@tonic-gate 					error = EINTR;
3037c478bd9Sstevel@tonic-gate 					goto ckreturn;
3047c478bd9Sstevel@tonic-gate 				}
3057c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
3067c478bd9Sstevel@tonic-gate 				goto retry;
3077c478bd9Sstevel@tonic-gate 			}
3087c478bd9Sstevel@tonic-gate 
3097c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STRDERR|STWRERR)) {
3107c478bd9Sstevel@tonic-gate 				error = EIO;
3117c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
3127c478bd9Sstevel@tonic-gate 				goto ckreturn;
3137c478bd9Sstevel@tonic-gate 			}
3147c478bd9Sstevel@tonic-gate 
3157c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STWOPEN;
3167c478bd9Sstevel@tonic-gate 			STRUNLOCKMATES(stp);
3177c478bd9Sstevel@tonic-gate 		} else {
3187c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
3197c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
3207c478bd9Sstevel@tonic-gate 				if (flag & (FNDELAY|FNONBLOCK)) {
3217c478bd9Sstevel@tonic-gate 					error = EAGAIN;
3227c478bd9Sstevel@tonic-gate 					goto ckreturn;
3237c478bd9Sstevel@tonic-gate 				}
324d3e55dcdSgww 				if (!cv_wait_sig(&stp->sd_monitor,
325d3e55dcdSgww 				    &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;
393ca9327a6Smeem 	stp->sd_cmdblk = NULL;
3947c478bd9Sstevel@tonic-gate 	stp->sd_pushcnt = 0;
3957c478bd9Sstevel@tonic-gate 	stp->sd_qn_minpsz = 0;
3967c478bd9Sstevel@tonic-gate 	stp->sd_qn_maxpsz = INFPSZ - 1;	/* used to check for initialization */
3977c478bd9Sstevel@tonic-gate 	stp->sd_maxblk = INFPSZ;
3987c478bd9Sstevel@tonic-gate 	qp->q_ptr = _WR(qp)->q_ptr = stp;
3997c478bd9Sstevel@tonic-gate 	STREAM(qp) = STREAM(_WR(qp)) = stp;
4007c478bd9Sstevel@tonic-gate 	vp->v_stream = stp;
4017c478bd9Sstevel@tonic-gate 	mutex_exit(&vp->v_lock);
4027c478bd9Sstevel@tonic-gate 	if (vp->v_type == VFIFO) {
4037c478bd9Sstevel@tonic-gate 		stp->sd_flag |= OLDNDELAY;
4047c478bd9Sstevel@tonic-gate 		/*
4057c478bd9Sstevel@tonic-gate 		 * This means, both for pipes and fifos
4067c478bd9Sstevel@tonic-gate 		 * strwrite will send SIGPIPE if the other
4077c478bd9Sstevel@tonic-gate 		 * end is closed. For putmsg it depends
4087c478bd9Sstevel@tonic-gate 		 * on whether it is a XPG4_2 application
4097c478bd9Sstevel@tonic-gate 		 * or not
4107c478bd9Sstevel@tonic-gate 		 */
4117c478bd9Sstevel@tonic-gate 		stp->sd_wput_opt = SW_SIGPIPE;
4127c478bd9Sstevel@tonic-gate 
4137c478bd9Sstevel@tonic-gate 		/* setq might sleep in kmem_alloc - avoid holding locks. */
4147c478bd9Sstevel@tonic-gate 		setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,
4157c478bd9Sstevel@tonic-gate 		    SQ_CI|SQ_CO, B_FALSE);
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 		set_qend(qp);
418ad1660d0Smeem 		stp->sd_strtab = fifo_getinfo();
4197c478bd9Sstevel@tonic-gate 		_WR(qp)->q_nfsrv = _WR(qp);
4207c478bd9Sstevel@tonic-gate 		qp->q_nfsrv = qp;
4217c478bd9Sstevel@tonic-gate 		/*
4227c478bd9Sstevel@tonic-gate 		 * Wake up others that are waiting for stream to be created.
4237c478bd9Sstevel@tonic-gate 		 */
4247c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
4257c478bd9Sstevel@tonic-gate 		/*
4267c478bd9Sstevel@tonic-gate 		 * nothing is be pushed on stream yet, so
4277c478bd9Sstevel@tonic-gate 		 * optimized stream head packetsizes are just that
4287c478bd9Sstevel@tonic-gate 		 * of the read queue
4297c478bd9Sstevel@tonic-gate 		 */
4307c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = qp->q_minpsz;
4317c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = qp->q_maxpsz;
4327c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~STWOPEN;
4337c478bd9Sstevel@tonic-gate 		goto fifo_opendone;
4347c478bd9Sstevel@tonic-gate 	}
4357c478bd9Sstevel@tonic-gate 	/* setq might sleep in kmem_alloc - avoid holding locks. */
4367c478bd9Sstevel@tonic-gate 	setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);
4377c478bd9Sstevel@tonic-gate 
4387c478bd9Sstevel@tonic-gate 	set_qend(qp);
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate 	/*
4417c478bd9Sstevel@tonic-gate 	 * Open driver and create stream to it (via qattach).
4427c478bd9Sstevel@tonic-gate 	 */
443d62bc4baSyz147064 	savedev = *devp;
4447c478bd9Sstevel@tonic-gate 	cloneopen = (getmajor(*devp) == clone_major);
4457c478bd9Sstevel@tonic-gate 	if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {
4467c478bd9Sstevel@tonic-gate 		mutex_enter(&vp->v_lock);
4477c478bd9Sstevel@tonic-gate 		vp->v_stream = NULL;
4487c478bd9Sstevel@tonic-gate 		mutex_exit(&vp->v_lock);
4497c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
4507c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
4517c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
4527c478bd9Sstevel@tonic-gate 		freeq(_RD(qp));
4537c478bd9Sstevel@tonic-gate 		shfree(stp);
4547c478bd9Sstevel@tonic-gate 		return (error);
4557c478bd9Sstevel@tonic-gate 	}
4567c478bd9Sstevel@tonic-gate 	/*
4577c478bd9Sstevel@tonic-gate 	 * Set sd_strtab after open in order to handle clonable drivers
4587c478bd9Sstevel@tonic-gate 	 */
4597c478bd9Sstevel@tonic-gate 	stp->sd_strtab = STREAMSTAB(getmajor(*devp));
4607c478bd9Sstevel@tonic-gate 
4617c478bd9Sstevel@tonic-gate 	/*
4627c478bd9Sstevel@tonic-gate 	 * Historical note: dummydev used to be be prior to the initial
4637c478bd9Sstevel@tonic-gate 	 * open (via qattach above), which made the value seen
4647c478bd9Sstevel@tonic-gate 	 * inconsistent between an I_PUSH and an autopush of a module.
4657c478bd9Sstevel@tonic-gate 	 */
4667c478bd9Sstevel@tonic-gate 	dummydev = *devp;
4677c478bd9Sstevel@tonic-gate 
4687c478bd9Sstevel@tonic-gate 	/*
4697c478bd9Sstevel@tonic-gate 	 * For clone open of old style (Q not associated) network driver,
4707c478bd9Sstevel@tonic-gate 	 * push DRMODNAME module to handle DL_ATTACH/DL_DETACH
4717c478bd9Sstevel@tonic-gate 	 */
4727c478bd9Sstevel@tonic-gate 	brq = _RD(_WR(qp)->q_next);
4737c478bd9Sstevel@tonic-gate 	major = getmajor(*devp);
4747c478bd9Sstevel@tonic-gate 	if (push_drcompat && cloneopen && NETWORK_DRV(major) &&
4757c478bd9Sstevel@tonic-gate 	    ((brq->q_flag & _QASSOCIATED) == 0)) {
476f4b3ec61Sdh155122 		if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0)
4777c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "cannot push " DRMODNAME
4787c478bd9Sstevel@tonic-gate 			    " streams module");
4797c478bd9Sstevel@tonic-gate 	}
4807c478bd9Sstevel@tonic-gate 
481d62bc4baSyz147064 	if (!NETWORK_DRV(major)) {
482d62bc4baSyz147064 		savedev = *devp;
483d62bc4baSyz147064 	} else {
4847c478bd9Sstevel@tonic-gate 		/*
485d62bc4baSyz147064 		 * For network devices, process differently based on the
486d62bc4baSyz147064 		 * return value from dld_autopush():
487d62bc4baSyz147064 		 *
488d62bc4baSyz147064 		 *   0: the passed-in device points to a GLDv3 datalink with
489d62bc4baSyz147064 		 *   per-link autopush configuration; use that configuration
490d62bc4baSyz147064 		 *   and ignore any per-driver autopush configuration.
491d62bc4baSyz147064 		 *
492d62bc4baSyz147064 		 *   1: the passed-in device points to a physical GLDv3
493d62bc4baSyz147064 		 *   datalink without per-link autopush configuration.  The
494d62bc4baSyz147064 		 *   passed in device was changed to refer to the actual
495d62bc4baSyz147064 		 *   physical device (if it's not already); we use that new
496d62bc4baSyz147064 		 *   device to look up any per-driver autopush configuration.
497d62bc4baSyz147064 		 *
498d62bc4baSyz147064 		 *   -1: neither of the above cases applied; use the initial
499d62bc4baSyz147064 		 *   device to look up any per-driver autopush configuration.
500d62bc4baSyz147064 		 */
501d62bc4baSyz147064 		switch (dld_autopush(&savedev, &dlap)) {
502d62bc4baSyz147064 		case 0:
503d62bc4baSyz147064 			zoneid = crgetzoneid(crp);
504d62bc4baSyz147064 			for (s = 0; s < dlap.dap_npush; s++) {
505d62bc4baSyz147064 				error = push_mod(qp, &dummydev, stp,
506d62bc4baSyz147064 				    dlap.dap_aplist[s], dlap.dap_anchor, crp,
507d62bc4baSyz147064 				    zoneid);
508d62bc4baSyz147064 				if (error != 0)
509d62bc4baSyz147064 					break;
510d62bc4baSyz147064 			}
511d62bc4baSyz147064 			goto opendone;
512d62bc4baSyz147064 		case 1:
513d62bc4baSyz147064 			break;
514d62bc4baSyz147064 		case -1:
515d62bc4baSyz147064 			savedev = *devp;
516d62bc4baSyz147064 			break;
517d62bc4baSyz147064 		}
518d62bc4baSyz147064 	}
519d62bc4baSyz147064 	/*
520d62bc4baSyz147064 	 * Find the autopush configuration based on "savedev". Start with the
521d62bc4baSyz147064 	 * global zone. If not found check in the local zone.
5227c478bd9Sstevel@tonic-gate 	 */
523f4b3ec61Sdh155122 	zoneid = GLOBAL_ZONEID;
524f4b3ec61Sdh155122 retryap:
525f4b3ec61Sdh155122 	ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))->
526f4b3ec61Sdh155122 	    netstack_str;
527d62bc4baSyz147064 	if ((ap = sad_ap_find_by_dev(savedev, ss)) == NULL) {
528f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
529f4b3ec61Sdh155122 		if (zoneid == GLOBAL_ZONEID) {
530f4b3ec61Sdh155122 			/*
531f4b3ec61Sdh155122 			 * None found. Also look in the zone's autopush table.
532f4b3ec61Sdh155122 			 */
533f4b3ec61Sdh155122 			zoneid = crgetzoneid(crp);
534f4b3ec61Sdh155122 			if (zoneid != GLOBAL_ZONEID)
535f4b3ec61Sdh155122 				goto retryap;
536f4b3ec61Sdh155122 		}
5377c478bd9Sstevel@tonic-gate 		goto opendone;
538f4b3ec61Sdh155122 	}
539f4b3ec61Sdh155122 	anchor = ap->ap_anchor;
540f4b3ec61Sdh155122 	zoneid = crgetzoneid(crp);
5417c478bd9Sstevel@tonic-gate 	for (s = 0; s < ap->ap_npush; s++) {
5427c478bd9Sstevel@tonic-gate 		error = push_mod(qp, &dummydev, stp, ap->ap_list[s],
543f4b3ec61Sdh155122 		    anchor, crp, zoneid);
5447c478bd9Sstevel@tonic-gate 		if (error != 0)
5457c478bd9Sstevel@tonic-gate 			break;
5467c478bd9Sstevel@tonic-gate 	}
547f4b3ec61Sdh155122 	sad_ap_rele(ap, ss);
548f4b3ec61Sdh155122 	netstack_rele(ss->ss_netstack);
5497c478bd9Sstevel@tonic-gate 
550d62bc4baSyz147064 opendone:
551d62bc4baSyz147064 
5527c478bd9Sstevel@tonic-gate 	/*
5537c478bd9Sstevel@tonic-gate 	 * let specfs know that open failed part way through
5547c478bd9Sstevel@tonic-gate 	 */
5557c478bd9Sstevel@tonic-gate 	if (error) {
5567c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
5577c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STREOPENFAIL;
5587c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
5597c478bd9Sstevel@tonic-gate 	}
5607c478bd9Sstevel@tonic-gate 
5617c478bd9Sstevel@tonic-gate 	/*
5627c478bd9Sstevel@tonic-gate 	 * Wake up others that are waiting for stream to be created.
5637c478bd9Sstevel@tonic-gate 	 */
5647c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
5657c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STWOPEN;
5667c478bd9Sstevel@tonic-gate 
5677c478bd9Sstevel@tonic-gate 	/*
5687c478bd9Sstevel@tonic-gate 	 * As a performance concern we are caching the values of
5697c478bd9Sstevel@tonic-gate 	 * q_minpsz and q_maxpsz of the module below the stream
5707c478bd9Sstevel@tonic-gate 	 * head in the stream head.
5717c478bd9Sstevel@tonic-gate 	 */
5727c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(stp->sd_wrq->q_next));
5737c478bd9Sstevel@tonic-gate 	rmin = stp->sd_wrq->q_next->q_minpsz;
5747c478bd9Sstevel@tonic-gate 	rmax = stp->sd_wrq->q_next->q_maxpsz;
5757c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(stp->sd_wrq->q_next));
5767c478bd9Sstevel@tonic-gate 
5777c478bd9Sstevel@tonic-gate 	/* do this processing here as a performance concern */
5787c478bd9Sstevel@tonic-gate 	if (strmsgsz != 0) {
5797c478bd9Sstevel@tonic-gate 		if (rmax == INFPSZ)
5807c478bd9Sstevel@tonic-gate 			rmax = strmsgsz;
5817c478bd9Sstevel@tonic-gate 		else
5827c478bd9Sstevel@tonic-gate 			rmax = MIN(strmsgsz, rmax);
5837c478bd9Sstevel@tonic-gate 	}
5847c478bd9Sstevel@tonic-gate 
5857c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(stp->sd_wrq));
5867c478bd9Sstevel@tonic-gate 	stp->sd_qn_minpsz = rmin;
5877c478bd9Sstevel@tonic-gate 	stp->sd_qn_maxpsz = rmax;
5887c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(stp->sd_wrq));
5897c478bd9Sstevel@tonic-gate 
5907c478bd9Sstevel@tonic-gate fifo_opendone:
5917c478bd9Sstevel@tonic-gate 	cv_broadcast(&stp->sd_monitor);
5927c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
5937c478bd9Sstevel@tonic-gate 	return (error);
5947c478bd9Sstevel@tonic-gate }
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate static int strsink(queue_t *, mblk_t *);
5977c478bd9Sstevel@tonic-gate static struct qinit deadrend = {
5987c478bd9Sstevel@tonic-gate 	strsink, NULL, NULL, NULL, NULL, &strm_info, NULL
5997c478bd9Sstevel@tonic-gate };
6007c478bd9Sstevel@tonic-gate static struct qinit deadwend = {
6017c478bd9Sstevel@tonic-gate 	NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL
6027c478bd9Sstevel@tonic-gate };
6037c478bd9Sstevel@tonic-gate 
6047c478bd9Sstevel@tonic-gate /*
6057c478bd9Sstevel@tonic-gate  * Close a stream.
6067c478bd9Sstevel@tonic-gate  * This is called from closef() on the last close of an open stream.
6077c478bd9Sstevel@tonic-gate  * Strclean() will already have removed the siglist and pollist
6087c478bd9Sstevel@tonic-gate  * information, so all that remains is to remove all multiplexor links
6097c478bd9Sstevel@tonic-gate  * for the stream, pop all the modules (and the driver), and free the
6107c478bd9Sstevel@tonic-gate  * stream structure.
6117c478bd9Sstevel@tonic-gate  */
6127c478bd9Sstevel@tonic-gate 
6137c478bd9Sstevel@tonic-gate int
6147c478bd9Sstevel@tonic-gate strclose(struct vnode *vp, int flag, cred_t *crp)
6157c478bd9Sstevel@tonic-gate {
6167c478bd9Sstevel@tonic-gate 	struct stdata *stp;
6177c478bd9Sstevel@tonic-gate 	queue_t *qp;
6187c478bd9Sstevel@tonic-gate 	int rval;
6197c478bd9Sstevel@tonic-gate 	int freestp = 1;
6207c478bd9Sstevel@tonic-gate 	queue_t *rmq;
6217c478bd9Sstevel@tonic-gate 
6227c478bd9Sstevel@tonic-gate 	if (audit_active)
6237c478bd9Sstevel@tonic-gate 		audit_strclose(vp, flag, crp);
6247c478bd9Sstevel@tonic-gate 
6257c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
6267c478bd9Sstevel@tonic-gate 	    TR_STRCLOSE, "strclose:%p", vp);
6277c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
6307c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
6317c478bd9Sstevel@tonic-gate 	qp = stp->sd_wrq;
6327c478bd9Sstevel@tonic-gate 
6337c478bd9Sstevel@tonic-gate 	/*
6347c478bd9Sstevel@tonic-gate 	 * Needed so that strpoll will return non-zero for this fd.
6357c478bd9Sstevel@tonic-gate 	 * Note that with POLLNOERR STRHUP does still cause POLLHUP.
6367c478bd9Sstevel@tonic-gate 	 */
6377c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
6387c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRHUP;
6397c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
6407c478bd9Sstevel@tonic-gate 
6417c478bd9Sstevel@tonic-gate 	/*
6427c478bd9Sstevel@tonic-gate 	 * If the registered process or process group did not have an
6437c478bd9Sstevel@tonic-gate 	 * open instance of this stream then strclean would not be
6447c478bd9Sstevel@tonic-gate 	 * called. Thus at the time of closing all remaining siglist entries
6457c478bd9Sstevel@tonic-gate 	 * are removed.
6467c478bd9Sstevel@tonic-gate 	 */
6477c478bd9Sstevel@tonic-gate 	if (stp->sd_siglist != NULL)
6487c478bd9Sstevel@tonic-gate 		strcleanall(vp);
6497c478bd9Sstevel@tonic-gate 
6507c478bd9Sstevel@tonic-gate 	ASSERT(stp->sd_siglist == NULL);
6517c478bd9Sstevel@tonic-gate 	ASSERT(stp->sd_sigflags == 0);
6527c478bd9Sstevel@tonic-gate 
6537c478bd9Sstevel@tonic-gate 	if (STRMATED(stp)) {
6547c478bd9Sstevel@tonic-gate 		struct stdata *strmatep = stp->sd_mate;
6557c478bd9Sstevel@tonic-gate 		int waited = 1;
6567c478bd9Sstevel@tonic-gate 
6577c478bd9Sstevel@tonic-gate 		STRLOCKMATES(stp);
6587c478bd9Sstevel@tonic-gate 		while (waited) {
6597c478bd9Sstevel@tonic-gate 			waited = 0;
6607c478bd9Sstevel@tonic-gate 			while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
6617c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
6627c478bd9Sstevel@tonic-gate 				cv_wait(&stp->sd_monitor, &stp->sd_lock);
6637c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
6647c478bd9Sstevel@tonic-gate 				STRLOCKMATES(stp);
6657c478bd9Sstevel@tonic-gate 				waited = 1;
6667c478bd9Sstevel@tonic-gate 			}
6677c478bd9Sstevel@tonic-gate 			while (strmatep->sd_flag &
6687c478bd9Sstevel@tonic-gate 			    (STWOPEN|STRCLOSE|STRPLUMB)) {
6697c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
6707c478bd9Sstevel@tonic-gate 				cv_wait(&strmatep->sd_monitor,
6717c478bd9Sstevel@tonic-gate 				    &strmatep->sd_lock);
6727c478bd9Sstevel@tonic-gate 				mutex_exit(&strmatep->sd_lock);
6737c478bd9Sstevel@tonic-gate 				STRLOCKMATES(stp);
6747c478bd9Sstevel@tonic-gate 				waited = 1;
6757c478bd9Sstevel@tonic-gate 			}
6767c478bd9Sstevel@tonic-gate 		}
6777c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRCLOSE;
6787c478bd9Sstevel@tonic-gate 		STRUNLOCKMATES(stp);
6797c478bd9Sstevel@tonic-gate 	} else {
6807c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
6817c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRCLOSE;
6827c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
6837c478bd9Sstevel@tonic-gate 	}
6847c478bd9Sstevel@tonic-gate 
6857c478bd9Sstevel@tonic-gate 	ASSERT(qp->q_first == NULL);	/* No more delayed write */
6867c478bd9Sstevel@tonic-gate 
6877c478bd9Sstevel@tonic-gate 	/* Check if an I_LINK was ever done on this stream */
6887c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & STRHASLINKS) {
689f4b3ec61Sdh155122 		netstack_t *ns;
690f4b3ec61Sdh155122 		str_stack_t *ss;
691f4b3ec61Sdh155122 
692f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
693f4b3ec61Sdh155122 		ASSERT(ns != NULL);
694f4b3ec61Sdh155122 		ss = ns->netstack_str;
695f4b3ec61Sdh155122 		ASSERT(ss != NULL);
696f4b3ec61Sdh155122 
697f4b3ec61Sdh155122 		(void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss);
698f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
6997c478bd9Sstevel@tonic-gate 	}
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate 	while (_SAMESTR(qp)) {
7027c478bd9Sstevel@tonic-gate 		/*
7037c478bd9Sstevel@tonic-gate 		 * Holding sd_lock prevents q_next from changing in
7047c478bd9Sstevel@tonic-gate 		 * this stream.
7057c478bd9Sstevel@tonic-gate 		 */
7067c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
7077c478bd9Sstevel@tonic-gate 		if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) {
7087c478bd9Sstevel@tonic-gate 
7097c478bd9Sstevel@tonic-gate 			/*
7107c478bd9Sstevel@tonic-gate 			 * sleep until awakened by strwsrv() or timeout
7117c478bd9Sstevel@tonic-gate 			 */
7127c478bd9Sstevel@tonic-gate 			for (;;) {
7137c478bd9Sstevel@tonic-gate 				mutex_enter(QLOCK(qp->q_next));
7147c478bd9Sstevel@tonic-gate 				if (!(qp->q_next->q_mblkcnt)) {
7157c478bd9Sstevel@tonic-gate 					mutex_exit(QLOCK(qp->q_next));
7167c478bd9Sstevel@tonic-gate 					break;
7177c478bd9Sstevel@tonic-gate 				}
7187c478bd9Sstevel@tonic-gate 				stp->sd_flag |= WSLEEP;
7197c478bd9Sstevel@tonic-gate 
7207c478bd9Sstevel@tonic-gate 				/* ensure strwsrv gets enabled */
7217c478bd9Sstevel@tonic-gate 				qp->q_next->q_flag |= QWANTW;
7227c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(qp->q_next));
7237c478bd9Sstevel@tonic-gate 				/* get out if we timed out or recv'd a signal */
7247c478bd9Sstevel@tonic-gate 				if (str_cv_wait(&qp->q_wait, &stp->sd_lock,
7257c478bd9Sstevel@tonic-gate 				    stp->sd_closetime, 0) <= 0) {
7267c478bd9Sstevel@tonic-gate 					break;
7277c478bd9Sstevel@tonic-gate 				}
7287c478bd9Sstevel@tonic-gate 			}
7297c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~WSLEEP;
7307c478bd9Sstevel@tonic-gate 		}
7317c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
7327c478bd9Sstevel@tonic-gate 
7337c478bd9Sstevel@tonic-gate 		rmq = qp->q_next;
7347c478bd9Sstevel@tonic-gate 		if (rmq->q_flag & QISDRV) {
7357c478bd9Sstevel@tonic-gate 			ASSERT(!_SAMESTR(rmq));
7367c478bd9Sstevel@tonic-gate 			wait_sq_svc(_RD(qp)->q_syncq);
7377c478bd9Sstevel@tonic-gate 		}
7387c478bd9Sstevel@tonic-gate 
7397c478bd9Sstevel@tonic-gate 		qdetach(_RD(rmq), 1, flag, crp, B_FALSE);
7407c478bd9Sstevel@tonic-gate 	}
7417c478bd9Sstevel@tonic-gate 
7428ec5a142Sedp 	/*
7438ec5a142Sedp 	 * Since we call pollwakeup in close() now, the poll list should
7448ec5a142Sedp 	 * be empty in most cases. The only exception is the layered devices
7458ec5a142Sedp 	 * (e.g. the console drivers with redirection modules pushed on top
7468ec5a142Sedp 	 * of it).  We have to do this after calling qdetach() because
7478ec5a142Sedp 	 * the redirection module won't have torn down the console
7488ec5a142Sedp 	 * redirection until after qdetach() has been invoked.
7498ec5a142Sedp 	 */
7508ec5a142Sedp 	if (stp->sd_pollist.ph_list != NULL) {
7518ec5a142Sedp 		pollwakeup(&stp->sd_pollist, POLLERR);
7528ec5a142Sedp 		pollhead_clean(&stp->sd_pollist);
7538ec5a142Sedp 	}
7548ec5a142Sedp 	ASSERT(stp->sd_pollist.ph_list == NULL);
7558ec5a142Sedp 	ASSERT(stp->sd_sidp == NULL);
7568ec5a142Sedp 	ASSERT(stp->sd_pgidp == NULL);
7578ec5a142Sedp 
7587c478bd9Sstevel@tonic-gate 	/* Prevent qenable from re-enabling the stream head queue */
7597c478bd9Sstevel@tonic-gate 	disable_svc(_RD(qp));
7607c478bd9Sstevel@tonic-gate 
7617c478bd9Sstevel@tonic-gate 	/*
7627c478bd9Sstevel@tonic-gate 	 * Wait until service procedure of each queue is
7637c478bd9Sstevel@tonic-gate 	 * run, if QINSERVICE is set.
7647c478bd9Sstevel@tonic-gate 	 */
7657c478bd9Sstevel@tonic-gate 	wait_svc(_RD(qp));
7667c478bd9Sstevel@tonic-gate 
7677c478bd9Sstevel@tonic-gate 	/*
7687c478bd9Sstevel@tonic-gate 	 * Now, flush both queues.
7697c478bd9Sstevel@tonic-gate 	 */
7707c478bd9Sstevel@tonic-gate 	flushq(_RD(qp), FLUSHALL);
7717c478bd9Sstevel@tonic-gate 	flushq(qp, FLUSHALL);
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate 	/*
7747c478bd9Sstevel@tonic-gate 	 * If the write queue of the stream head is pointing to a
7757c478bd9Sstevel@tonic-gate 	 * read queue, we have a twisted stream.  If the read queue
7767c478bd9Sstevel@tonic-gate 	 * is alive, convert the stream head queues into a dead end.
7777c478bd9Sstevel@tonic-gate 	 * If the read queue is dead, free the dead pair.
7787c478bd9Sstevel@tonic-gate 	 */
7797c478bd9Sstevel@tonic-gate 	if (qp->q_next && !_SAMESTR(qp)) {
7807c478bd9Sstevel@tonic-gate 		if (qp->q_next->q_qinfo == &deadrend) {	/* half-closed pipe */
7817c478bd9Sstevel@tonic-gate 			flushq(qp->q_next, FLUSHALL); /* ensure no message */
7827c478bd9Sstevel@tonic-gate 			shfree(qp->q_next->q_stream);
7837c478bd9Sstevel@tonic-gate 			freeq(qp->q_next);
7847c478bd9Sstevel@tonic-gate 			freeq(_RD(qp));
7857c478bd9Sstevel@tonic-gate 		} else if (qp->q_next == _RD(qp)) {	/* fifo */
7867c478bd9Sstevel@tonic-gate 			freeq(_RD(qp));
7877c478bd9Sstevel@tonic-gate 		} else {				/* pipe */
7887c478bd9Sstevel@tonic-gate 			freestp = 0;
7897c478bd9Sstevel@tonic-gate 			/*
7907c478bd9Sstevel@tonic-gate 			 * The q_info pointers are never accessed when
7917c478bd9Sstevel@tonic-gate 			 * SQLOCK is held.
7927c478bd9Sstevel@tonic-gate 			 */
7937c478bd9Sstevel@tonic-gate 			ASSERT(qp->q_syncq == _RD(qp)->q_syncq);
7947c478bd9Sstevel@tonic-gate 			mutex_enter(SQLOCK(qp->q_syncq));
7957c478bd9Sstevel@tonic-gate 			qp->q_qinfo = &deadwend;
7967c478bd9Sstevel@tonic-gate 			_RD(qp)->q_qinfo = &deadrend;
7977c478bd9Sstevel@tonic-gate 			mutex_exit(SQLOCK(qp->q_syncq));
7987c478bd9Sstevel@tonic-gate 		}
7997c478bd9Sstevel@tonic-gate 	} else {
8007c478bd9Sstevel@tonic-gate 		freeq(_RD(qp)); /* free stream head queue pair */
8017c478bd9Sstevel@tonic-gate 	}
8027c478bd9Sstevel@tonic-gate 
8037c478bd9Sstevel@tonic-gate 	mutex_enter(&vp->v_lock);
8047c478bd9Sstevel@tonic-gate 	if (stp->sd_iocblk) {
8057c478bd9Sstevel@tonic-gate 		if (stp->sd_iocblk != (mblk_t *)-1) {
8067c478bd9Sstevel@tonic-gate 			freemsg(stp->sd_iocblk);
8077c478bd9Sstevel@tonic-gate 		}
8087c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = NULL;
8097c478bd9Sstevel@tonic-gate 	}
8107c478bd9Sstevel@tonic-gate 	stp->sd_vnode = NULL;
8117c478bd9Sstevel@tonic-gate 	vp->v_stream = NULL;
8127c478bd9Sstevel@tonic-gate 	mutex_exit(&vp->v_lock);
8137c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
814ca9327a6Smeem 	freemsg(stp->sd_cmdblk);
815ca9327a6Smeem 	stp->sd_cmdblk = NULL;
8167c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRCLOSE;
8177c478bd9Sstevel@tonic-gate 	cv_broadcast(&stp->sd_monitor);
8187c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	if (freestp)
8217c478bd9Sstevel@tonic-gate 		shfree(stp);
8227c478bd9Sstevel@tonic-gate 	return (0);
8237c478bd9Sstevel@tonic-gate }
8247c478bd9Sstevel@tonic-gate 
8257c478bd9Sstevel@tonic-gate static int
8267c478bd9Sstevel@tonic-gate strsink(queue_t *q, mblk_t *bp)
8277c478bd9Sstevel@tonic-gate {
8287c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
8297c478bd9Sstevel@tonic-gate 
8307c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
8317c478bd9Sstevel@tonic-gate 	case M_FLUSH:
8327c478bd9Sstevel@tonic-gate 		if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
8337c478bd9Sstevel@tonic-gate 			*bp->b_rptr &= ~FLUSHR;
8347c478bd9Sstevel@tonic-gate 			bp->b_flag |= MSGNOLOOP;
8357c478bd9Sstevel@tonic-gate 			/*
8367c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
8377c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
8387c478bd9Sstevel@tonic-gate 			 */
8397c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
8407c478bd9Sstevel@tonic-gate 				freemsg(bp);
8417c478bd9Sstevel@tonic-gate 			else
8427c478bd9Sstevel@tonic-gate 				qreply(q, bp);
8437c478bd9Sstevel@tonic-gate 		} else {
8447c478bd9Sstevel@tonic-gate 			freemsg(bp);
8457c478bd9Sstevel@tonic-gate 		}
8467c478bd9Sstevel@tonic-gate 		break;
8477c478bd9Sstevel@tonic-gate 
8487c478bd9Sstevel@tonic-gate 	case M_COPYIN:
8497c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
8507c478bd9Sstevel@tonic-gate 		if (bp->b_cont) {
8517c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
8527c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
8537c478bd9Sstevel@tonic-gate 		}
8547c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
8557c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
8567c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
8577c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)1;	/* failure */
8587c478bd9Sstevel@tonic-gate 		/*
8597c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
8607c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
8617c478bd9Sstevel@tonic-gate 		 */
8627c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
8637c478bd9Sstevel@tonic-gate 			freemsg(bp);
8647c478bd9Sstevel@tonic-gate 		else
8657c478bd9Sstevel@tonic-gate 			qreply(q, bp);
8667c478bd9Sstevel@tonic-gate 		break;
8677c478bd9Sstevel@tonic-gate 
8687c478bd9Sstevel@tonic-gate 	case M_IOCTL:
8697c478bd9Sstevel@tonic-gate 		if (bp->b_cont) {
8707c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
8717c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
8727c478bd9Sstevel@tonic-gate 		}
8737c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCNAK;
8747c478bd9Sstevel@tonic-gate 		/*
8757c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
8767c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
8777c478bd9Sstevel@tonic-gate 		 */
8787c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
8797c478bd9Sstevel@tonic-gate 			freemsg(bp);
8807c478bd9Sstevel@tonic-gate 		else
8817c478bd9Sstevel@tonic-gate 			qreply(q, bp);
8827c478bd9Sstevel@tonic-gate 		break;
8837c478bd9Sstevel@tonic-gate 
8847c478bd9Sstevel@tonic-gate 	default:
8857c478bd9Sstevel@tonic-gate 		freemsg(bp);
8867c478bd9Sstevel@tonic-gate 		break;
8877c478bd9Sstevel@tonic-gate 	}
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate 	return (0);
8907c478bd9Sstevel@tonic-gate }
8917c478bd9Sstevel@tonic-gate 
8927c478bd9Sstevel@tonic-gate /*
8937c478bd9Sstevel@tonic-gate  * Clean up after a process when it closes a stream.  This is called
8947c478bd9Sstevel@tonic-gate  * from closef for all closes, whereas strclose is called only for the
8957c478bd9Sstevel@tonic-gate  * last close on a stream.  The siglist is scanned for entries for the
8967c478bd9Sstevel@tonic-gate  * current process, and these are removed.
8977c478bd9Sstevel@tonic-gate  */
8987c478bd9Sstevel@tonic-gate void
8997c478bd9Sstevel@tonic-gate strclean(struct vnode *vp)
9007c478bd9Sstevel@tonic-gate {
9017c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *pssp, *tssp;
9027c478bd9Sstevel@tonic-gate 	stdata_t *stp;
9037c478bd9Sstevel@tonic-gate 	int update = 0;
9047c478bd9Sstevel@tonic-gate 
9057c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
9067c478bd9Sstevel@tonic-gate 	    TR_STRCLEAN, "strclean:%p", vp);
9077c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
9087c478bd9Sstevel@tonic-gate 	pssp = NULL;
9097c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
9107c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
9117c478bd9Sstevel@tonic-gate 	while (ssp) {
9127c478bd9Sstevel@tonic-gate 		if (ssp->ss_pidp == curproc->p_pidp) {
9137c478bd9Sstevel@tonic-gate 			tssp = ssp->ss_next;
9147c478bd9Sstevel@tonic-gate 			if (pssp)
9157c478bd9Sstevel@tonic-gate 				pssp->ss_next = tssp;
9167c478bd9Sstevel@tonic-gate 			else
9177c478bd9Sstevel@tonic-gate 				stp->sd_siglist = tssp;
9187c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
9197c478bd9Sstevel@tonic-gate 			PID_RELE(ssp->ss_pidp);
9207c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
9217c478bd9Sstevel@tonic-gate 			kmem_free(ssp, sizeof (strsig_t));
9227c478bd9Sstevel@tonic-gate 			update = 1;
9237c478bd9Sstevel@tonic-gate 			ssp = tssp;
9247c478bd9Sstevel@tonic-gate 		} else {
9257c478bd9Sstevel@tonic-gate 			pssp = ssp;
9267c478bd9Sstevel@tonic-gate 			ssp = ssp->ss_next;
9277c478bd9Sstevel@tonic-gate 		}
9287c478bd9Sstevel@tonic-gate 	}
9297c478bd9Sstevel@tonic-gate 	if (update) {
9307c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
9317c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
9327c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
9337c478bd9Sstevel@tonic-gate 	}
9347c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
9357c478bd9Sstevel@tonic-gate }
9367c478bd9Sstevel@tonic-gate 
9377c478bd9Sstevel@tonic-gate /*
9387c478bd9Sstevel@tonic-gate  * Used on the last close to remove any remaining items on the siglist.
9397c478bd9Sstevel@tonic-gate  * These could be present on the siglist due to I_ESETSIG calls that
9407c478bd9Sstevel@tonic-gate  * use process groups or processed that do not have an open file descriptor
9417c478bd9Sstevel@tonic-gate  * for this stream (Such entries would not be removed by strclean).
9427c478bd9Sstevel@tonic-gate  */
9437c478bd9Sstevel@tonic-gate static void
9447c478bd9Sstevel@tonic-gate strcleanall(struct vnode *vp)
9457c478bd9Sstevel@tonic-gate {
9467c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *nssp;
9477c478bd9Sstevel@tonic-gate 	stdata_t *stp;
9487c478bd9Sstevel@tonic-gate 
9497c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
9507c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
9517c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
9527c478bd9Sstevel@tonic-gate 	stp->sd_siglist = NULL;
9537c478bd9Sstevel@tonic-gate 	while (ssp) {
9547c478bd9Sstevel@tonic-gate 		nssp = ssp->ss_next;
9557c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
9567c478bd9Sstevel@tonic-gate 		PID_RELE(ssp->ss_pidp);
9577c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
9587c478bd9Sstevel@tonic-gate 		kmem_free(ssp, sizeof (strsig_t));
9597c478bd9Sstevel@tonic-gate 		ssp = nssp;
9607c478bd9Sstevel@tonic-gate 	}
9617c478bd9Sstevel@tonic-gate 	stp->sd_sigflags = 0;
9627c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
9637c478bd9Sstevel@tonic-gate }
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate /*
9667c478bd9Sstevel@tonic-gate  * Retrieve the next message from the logical stream head read queue
9677c478bd9Sstevel@tonic-gate  * using either rwnext (if sync stream) or getq_noenab.
9687c478bd9Sstevel@tonic-gate  * It is the callers responsibility to call qbackenable after
9697c478bd9Sstevel@tonic-gate  * it is finished with the message. The caller should not call
9707c478bd9Sstevel@tonic-gate  * qbackenable until after any putback calls to avoid spurious backenabling.
9717c478bd9Sstevel@tonic-gate  */
9727c478bd9Sstevel@tonic-gate mblk_t *
9737c478bd9Sstevel@tonic-gate strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first,
9747c478bd9Sstevel@tonic-gate     int *errorp)
9757c478bd9Sstevel@tonic-gate {
9767c478bd9Sstevel@tonic-gate 	mblk_t *bp;
9777c478bd9Sstevel@tonic-gate 	int error;
978301ce41fSja97890 	ssize_t rbytes = 0;
9797c478bd9Sstevel@tonic-gate 
9807c478bd9Sstevel@tonic-gate 	/* Holding sd_lock prevents the read queue from changing  */
981301ce41fSja97890 	ASSERT(MUTEX_HELD(&stp->sd_lock));
9827c478bd9Sstevel@tonic-gate 
9837c478bd9Sstevel@tonic-gate 	if (uiop != NULL && stp->sd_struiordq != NULL &&
9847c478bd9Sstevel@tonic-gate 	    q->q_first == NULL &&
9857c478bd9Sstevel@tonic-gate 	    (!first || (stp->sd_wakeq & RSLEEP))) {
9867c478bd9Sstevel@tonic-gate 		/*
9877c478bd9Sstevel@tonic-gate 		 * Stream supports rwnext() for the read side.
9887c478bd9Sstevel@tonic-gate 		 * If this is the first time we're called by e.g. strread
9897c478bd9Sstevel@tonic-gate 		 * only do the downcall if there is a deferred wakeup
9907c478bd9Sstevel@tonic-gate 		 * (registered in sd_wakeq).
9917c478bd9Sstevel@tonic-gate 		 */
9927c478bd9Sstevel@tonic-gate 		struiod_t uiod;
9937c478bd9Sstevel@tonic-gate 
9947c478bd9Sstevel@tonic-gate 		if (first)
9957c478bd9Sstevel@tonic-gate 			stp->sd_wakeq &= ~RSLEEP;
9967c478bd9Sstevel@tonic-gate 
9977c478bd9Sstevel@tonic-gate 		(void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
9987c478bd9Sstevel@tonic-gate 		    sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
9997c478bd9Sstevel@tonic-gate 		uiod.d_mp = 0;
10007c478bd9Sstevel@tonic-gate 		/*
10017c478bd9Sstevel@tonic-gate 		 * Mark that a thread is in rwnext on the read side
10027c478bd9Sstevel@tonic-gate 		 * to prevent strrput from nacking ioctls immediately.
10037c478bd9Sstevel@tonic-gate 		 * When the last concurrent rwnext returns
10047c478bd9Sstevel@tonic-gate 		 * the ioctls are nack'ed.
10057c478bd9Sstevel@tonic-gate 		 */
10067c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
10077c478bd9Sstevel@tonic-gate 		stp->sd_struiodnak++;
10087c478bd9Sstevel@tonic-gate 		/*
10097c478bd9Sstevel@tonic-gate 		 * Note: rwnext will drop sd_lock.
10107c478bd9Sstevel@tonic-gate 		 */
10117c478bd9Sstevel@tonic-gate 		error = rwnext(q, &uiod);
10127c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
10137c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
10147c478bd9Sstevel@tonic-gate 		stp->sd_struiodnak--;
10157c478bd9Sstevel@tonic-gate 		while (stp->sd_struiodnak == 0 &&
10167c478bd9Sstevel@tonic-gate 		    ((bp = stp->sd_struionak) != NULL)) {
10177c478bd9Sstevel@tonic-gate 			stp->sd_struionak = bp->b_next;
10187c478bd9Sstevel@tonic-gate 			bp->b_next = NULL;
10197c478bd9Sstevel@tonic-gate 			bp->b_datap->db_type = M_IOCNAK;
10207c478bd9Sstevel@tonic-gate 			/*
10217c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
10227c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
10237c478bd9Sstevel@tonic-gate 			 */
10247c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
10257c478bd9Sstevel@tonic-gate 				freemsg(bp);
10267c478bd9Sstevel@tonic-gate 			else {
10277c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
10287c478bd9Sstevel@tonic-gate 				qreply(q, bp);
10297c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
10307c478bd9Sstevel@tonic-gate 			}
10317c478bd9Sstevel@tonic-gate 		}
10327c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
10337c478bd9Sstevel@tonic-gate 		if (error == 0 || error == EWOULDBLOCK) {
10347c478bd9Sstevel@tonic-gate 			if ((bp = uiod.d_mp) != NULL) {
10357c478bd9Sstevel@tonic-gate 				*errorp = 0;
10367c478bd9Sstevel@tonic-gate 				ASSERT(MUTEX_HELD(&stp->sd_lock));
10377c478bd9Sstevel@tonic-gate 				return (bp);
10387c478bd9Sstevel@tonic-gate 			}
10397c478bd9Sstevel@tonic-gate 			error = 0;
10407c478bd9Sstevel@tonic-gate 		} else if (error == EINVAL) {
10417c478bd9Sstevel@tonic-gate 			/*
10427c478bd9Sstevel@tonic-gate 			 * The stream plumbing must have
10437c478bd9Sstevel@tonic-gate 			 * changed while we were away, so
10447c478bd9Sstevel@tonic-gate 			 * just turn off rwnext()s.
10457c478bd9Sstevel@tonic-gate 			 */
10467c478bd9Sstevel@tonic-gate 			error = 0;
10477c478bd9Sstevel@tonic-gate 		} else if (error == EBUSY) {
10487c478bd9Sstevel@tonic-gate 			/*
10497c478bd9Sstevel@tonic-gate 			 * The module might have data in transit using putnext
10507c478bd9Sstevel@tonic-gate 			 * Fall back on waiting + getq.
10517c478bd9Sstevel@tonic-gate 			 */
10527c478bd9Sstevel@tonic-gate 			error = 0;
10537c478bd9Sstevel@tonic-gate 		} else {
10547c478bd9Sstevel@tonic-gate 			*errorp = error;
10557c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
10567c478bd9Sstevel@tonic-gate 			return (NULL);
10577c478bd9Sstevel@tonic-gate 		}
10587c478bd9Sstevel@tonic-gate 		/*
10597c478bd9Sstevel@tonic-gate 		 * Try a getq in case a rwnext() generated mblk
10607c478bd9Sstevel@tonic-gate 		 * has bubbled up via strrput().
10617c478bd9Sstevel@tonic-gate 		 */
10627c478bd9Sstevel@tonic-gate 	}
10637c478bd9Sstevel@tonic-gate 	*errorp = 0;
10647c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
1065301ce41fSja97890 
1066301ce41fSja97890 	/*
1067301ce41fSja97890 	 * If we have a valid uio, try and use this as a guide for how
1068301ce41fSja97890 	 * many bytes to retrieve from the queue via getq_noenab().
1069301ce41fSja97890 	 * Doing this can avoid unneccesary counting of overlong
1070267a241bSkrishna 	 * messages in putback(). We currently only do this for sockets
1071267a241bSkrishna 	 * and only if there is no sd_rputdatafunc hook.
1072267a241bSkrishna 	 *
1073267a241bSkrishna 	 * The sd_rputdatafunc hook transforms the entire message
1074267a241bSkrishna 	 * before any bytes in it can be given to a client. So, rbytes
1075267a241bSkrishna 	 * must be 0 if there is a hook.
1076301ce41fSja97890 	 */
1077267a241bSkrishna 	if ((uiop != NULL) && (stp->sd_vnode->v_type == VSOCK) &&
1078267a241bSkrishna 	    (stp->sd_rputdatafunc == NULL))
1079301ce41fSja97890 		rbytes = uiop->uio_resid;
108017169044Sbrutus 
1081*bbc000e5SAnders Persson 	return (getq_noenab(q, rbytes));
10827c478bd9Sstevel@tonic-gate }
10837c478bd9Sstevel@tonic-gate 
10847c478bd9Sstevel@tonic-gate /*
10857c478bd9Sstevel@tonic-gate  * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'.
10867c478bd9Sstevel@tonic-gate  * If the message does not fit in the uio the remainder of it is returned;
10877c478bd9Sstevel@tonic-gate  * otherwise NULL is returned.  Any embedded zero-length mblk_t's are
10887c478bd9Sstevel@tonic-gate  * consumed, even if uio_resid reaches zero.  On error, `*errorp' is set to
10897c478bd9Sstevel@tonic-gate  * the error code, the message is consumed, and NULL is returned.
10907c478bd9Sstevel@tonic-gate  */
10917c478bd9Sstevel@tonic-gate static mblk_t *
10927c478bd9Sstevel@tonic-gate struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp)
10937c478bd9Sstevel@tonic-gate {
10947c478bd9Sstevel@tonic-gate 	int error;
10957c478bd9Sstevel@tonic-gate 	ptrdiff_t n;
10967c478bd9Sstevel@tonic-gate 	mblk_t *nbp;
10977c478bd9Sstevel@tonic-gate 
10987c478bd9Sstevel@tonic-gate 	ASSERT(bp->b_wptr >= bp->b_rptr);
10997c478bd9Sstevel@tonic-gate 
11007c478bd9Sstevel@tonic-gate 	do {
11017c478bd9Sstevel@tonic-gate 		if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) {
11027c478bd9Sstevel@tonic-gate 			ASSERT(n > 0);
11037c478bd9Sstevel@tonic-gate 
11047c478bd9Sstevel@tonic-gate 			error = uiomove(bp->b_rptr, n, UIO_READ, uiop);
11057c478bd9Sstevel@tonic-gate 			if (error != 0) {
11067c478bd9Sstevel@tonic-gate 				freemsg(bp);
11077c478bd9Sstevel@tonic-gate 				*errorp = error;
11087c478bd9Sstevel@tonic-gate 				return (NULL);
11097c478bd9Sstevel@tonic-gate 			}
11107c478bd9Sstevel@tonic-gate 		}
11117c478bd9Sstevel@tonic-gate 
11127c478bd9Sstevel@tonic-gate 		bp->b_rptr += n;
11137c478bd9Sstevel@tonic-gate 		while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) {
11147c478bd9Sstevel@tonic-gate 			nbp = bp;
11157c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
11167c478bd9Sstevel@tonic-gate 			freeb(nbp);
11177c478bd9Sstevel@tonic-gate 		}
11187c478bd9Sstevel@tonic-gate 	} while (bp != NULL && uiop->uio_resid > 0);
11197c478bd9Sstevel@tonic-gate 
11207c478bd9Sstevel@tonic-gate 	*errorp = 0;
11217c478bd9Sstevel@tonic-gate 	return (bp);
11227c478bd9Sstevel@tonic-gate }
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate /*
11257c478bd9Sstevel@tonic-gate  * Read a stream according to the mode flags in sd_flag:
11267c478bd9Sstevel@tonic-gate  *
11277c478bd9Sstevel@tonic-gate  * (default mode)		- Byte stream, msg boundaries are ignored
11287c478bd9Sstevel@tonic-gate  * RD_MSGDIS (msg discard)	- Read on msg boundaries and throw away
11297c478bd9Sstevel@tonic-gate  *				any data remaining in msg
11307c478bd9Sstevel@tonic-gate  * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back
11317c478bd9Sstevel@tonic-gate  *				any remaining data on head of read queue
11327c478bd9Sstevel@tonic-gate  *
11337c478bd9Sstevel@tonic-gate  * Consume readable messages on the front of the queue until
11347c478bd9Sstevel@tonic-gate  * ttolwp(curthread)->lwp_count
11357c478bd9Sstevel@tonic-gate  * is satisfied, the readable messages are exhausted, or a message
11367c478bd9Sstevel@tonic-gate  * boundary is reached in a message mode.  If no data was read and
11377c478bd9Sstevel@tonic-gate  * the stream was not opened with the NDELAY flag, block until data arrives.
11387c478bd9Sstevel@tonic-gate  * Otherwise return the data read and update the count.
11397c478bd9Sstevel@tonic-gate  *
11407c478bd9Sstevel@tonic-gate  * In default mode a 0 length message signifies end-of-file and terminates
11417c478bd9Sstevel@tonic-gate  * a read in progress.  The 0 length message is removed from the queue
11427c478bd9Sstevel@tonic-gate  * only if it is the only message read (no data is read).
11437c478bd9Sstevel@tonic-gate  *
11447c478bd9Sstevel@tonic-gate  * An attempt to read an M_PROTO or M_PCPROTO message results in an
11457c478bd9Sstevel@tonic-gate  * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set.
11467c478bd9Sstevel@tonic-gate  * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data.
11477c478bd9Sstevel@tonic-gate  * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message
11487c478bd9Sstevel@tonic-gate  * are unlinked from and M_DATA blocks in the message, the protos are
11497c478bd9Sstevel@tonic-gate  * thrown away, and the data is read.
11507c478bd9Sstevel@tonic-gate  */
11517c478bd9Sstevel@tonic-gate /* ARGSUSED */
11527c478bd9Sstevel@tonic-gate int
11537c478bd9Sstevel@tonic-gate strread(struct vnode *vp, struct uio *uiop, cred_t *crp)
11547c478bd9Sstevel@tonic-gate {
11557c478bd9Sstevel@tonic-gate 	struct stdata *stp;
11567c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
11577c478bd9Sstevel@tonic-gate 	queue_t *q;
11587c478bd9Sstevel@tonic-gate 	int error = 0;
11597c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
11607c478bd9Sstevel@tonic-gate 	int first;
11617c478bd9Sstevel@tonic-gate 	char rflg;
11627c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
11637c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
11647c478bd9Sstevel@tonic-gate 	short delim;
11657c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
11667c478bd9Sstevel@tonic-gate 	char waitflag;
11677c478bd9Sstevel@tonic-gate 	unsigned char type;
11687c478bd9Sstevel@tonic-gate 
11697c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
11707c478bd9Sstevel@tonic-gate 	    TR_STRREAD_ENTER, "strread:%p", vp);
11717c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
11727c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
11759acbbeafSnn35248 
11769acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
11779acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
11789acbbeafSnn35248 		return (error);
11799acbbeafSnn35248 	}
11809acbbeafSnn35248 
11817c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRDERR|STPLEX)) {
11827c478bd9Sstevel@tonic-gate 		error = strgeterr(stp, STRDERR|STPLEX, 0);
11837c478bd9Sstevel@tonic-gate 		if (error != 0) {
11847c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
11857c478bd9Sstevel@tonic-gate 			return (error);
11867c478bd9Sstevel@tonic-gate 		}
11877c478bd9Sstevel@tonic-gate 	}
11887c478bd9Sstevel@tonic-gate 
11897c478bd9Sstevel@tonic-gate 	/*
11907c478bd9Sstevel@tonic-gate 	 * Loop terminates when uiop->uio_resid == 0.
11917c478bd9Sstevel@tonic-gate 	 */
11927c478bd9Sstevel@tonic-gate 	rflg = 0;
11937c478bd9Sstevel@tonic-gate 	waitflag = READWAIT;
11947c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
11957c478bd9Sstevel@tonic-gate 	for (;;) {
11967c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
11977c478bd9Sstevel@tonic-gate 		old_sd_flag = stp->sd_flag;
11987c478bd9Sstevel@tonic-gate 		mark = 0;
11997c478bd9Sstevel@tonic-gate 		delim = 0;
12007c478bd9Sstevel@tonic-gate 		first = 1;
12017c478bd9Sstevel@tonic-gate 		while ((bp = strget(stp, q, uiop, first, &error)) == NULL) {
12027c478bd9Sstevel@tonic-gate 			int done = 0;
12037c478bd9Sstevel@tonic-gate 
12047c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
12057c478bd9Sstevel@tonic-gate 
12067c478bd9Sstevel@tonic-gate 			if (error != 0)
12077c478bd9Sstevel@tonic-gate 				goto oops;
12087c478bd9Sstevel@tonic-gate 
12097c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STRHUP|STREOF)) {
12107c478bd9Sstevel@tonic-gate 				goto oops;
12117c478bd9Sstevel@tonic-gate 			}
12127c478bd9Sstevel@tonic-gate 			if (rflg && !(stp->sd_flag & STRDELIM)) {
12137c478bd9Sstevel@tonic-gate 				goto oops;
12147c478bd9Sstevel@tonic-gate 			}
12157c478bd9Sstevel@tonic-gate 			/*
12167c478bd9Sstevel@tonic-gate 			 * If a read(fd,buf,0) has been done, there is no
12177c478bd9Sstevel@tonic-gate 			 * need to sleep. We always have zero bytes to
12187c478bd9Sstevel@tonic-gate 			 * return.
12197c478bd9Sstevel@tonic-gate 			 */
12207c478bd9Sstevel@tonic-gate 			if (uiop->uio_resid == 0) {
12217c478bd9Sstevel@tonic-gate 				goto oops;
12227c478bd9Sstevel@tonic-gate 			}
12237c478bd9Sstevel@tonic-gate 
12247c478bd9Sstevel@tonic-gate 			qbackenable(q, 0);
12257c478bd9Sstevel@tonic-gate 
12267c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT,
12277c478bd9Sstevel@tonic-gate 			    "strread calls strwaitq:%p, %p, %p",
12287c478bd9Sstevel@tonic-gate 			    vp, uiop, crp);
12297c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, waitflag, uiop->uio_resid,
12307c478bd9Sstevel@tonic-gate 			    uiop->uio_fmode, -1, &done)) != 0 || done) {
12317c478bd9Sstevel@tonic-gate 				TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE,
12327c478bd9Sstevel@tonic-gate 				    "strread error or done:%p, %p, %p",
12337c478bd9Sstevel@tonic-gate 				    vp, uiop, crp);
12347c478bd9Sstevel@tonic-gate 				if ((uiop->uio_fmode & FNDELAY) &&
12357c478bd9Sstevel@tonic-gate 				    (stp->sd_flag & OLDNDELAY) &&
12367c478bd9Sstevel@tonic-gate 				    (error == EAGAIN))
12377c478bd9Sstevel@tonic-gate 					error = 0;
12387c478bd9Sstevel@tonic-gate 				goto oops;
12397c478bd9Sstevel@tonic-gate 			}
12407c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE,
12417c478bd9Sstevel@tonic-gate 			    "strread awakes:%p, %p, %p", vp, uiop, crp);
12429acbbeafSnn35248 			if ((error = i_straccess(stp, JCREAD)) != 0) {
12439acbbeafSnn35248 				goto oops;
12447c478bd9Sstevel@tonic-gate 			}
12457c478bd9Sstevel@tonic-gate 			first = 0;
12467c478bd9Sstevel@tonic-gate 		}
124717169044Sbrutus 
12487c478bd9Sstevel@tonic-gate 		ASSERT(MUTEX_HELD(&stp->sd_lock));
12497c478bd9Sstevel@tonic-gate 		ASSERT(bp);
12507c478bd9Sstevel@tonic-gate 		pri = bp->b_band;
12517c478bd9Sstevel@tonic-gate 		/*
12527c478bd9Sstevel@tonic-gate 		 * Extract any mark information. If the message is not
12537c478bd9Sstevel@tonic-gate 		 * completely consumed this information will be put in the mblk
12547c478bd9Sstevel@tonic-gate 		 * that is putback.
12557c478bd9Sstevel@tonic-gate 		 * If MSGMARKNEXT is set and the message is completely consumed
12567c478bd9Sstevel@tonic-gate 		 * the STRATMARK flag will be set below. Likewise, if
12577c478bd9Sstevel@tonic-gate 		 * MSGNOTMARKNEXT is set and the message is
12587c478bd9Sstevel@tonic-gate 		 * completely consumed STRNOTATMARK will be set.
12597c478bd9Sstevel@tonic-gate 		 *
12607c478bd9Sstevel@tonic-gate 		 * For some unknown reason strread only breaks the read at the
12617c478bd9Sstevel@tonic-gate 		 * last mark.
12627c478bd9Sstevel@tonic-gate 		 */
12637c478bd9Sstevel@tonic-gate 		mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
12647c478bd9Sstevel@tonic-gate 		ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
12657c478bd9Sstevel@tonic-gate 		    (MSGMARKNEXT|MSGNOTMARKNEXT));
12667c478bd9Sstevel@tonic-gate 		if (mark != 0 && bp == stp->sd_mark) {
12677c478bd9Sstevel@tonic-gate 			if (rflg) {
12687c478bd9Sstevel@tonic-gate 				putback(stp, q, bp, pri);
12697c478bd9Sstevel@tonic-gate 				goto oops;
12707c478bd9Sstevel@tonic-gate 			}
12717c478bd9Sstevel@tonic-gate 			mark |= _LASTMARK;
12727c478bd9Sstevel@tonic-gate 			stp->sd_mark = NULL;
12737c478bd9Sstevel@tonic-gate 		}
12747c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM))
12757c478bd9Sstevel@tonic-gate 			delim = 1;
12767c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
12797c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
12807c478bd9Sstevel@tonic-gate 
12817c478bd9Sstevel@tonic-gate 		type = bp->b_datap->db_type;
12827c478bd9Sstevel@tonic-gate 
12837c478bd9Sstevel@tonic-gate 		switch (type) {
12847c478bd9Sstevel@tonic-gate 
12857c478bd9Sstevel@tonic-gate 		case M_DATA:
12867c478bd9Sstevel@tonic-gate ismdata:
12877c478bd9Sstevel@tonic-gate 			if (msgnodata(bp)) {
12887c478bd9Sstevel@tonic-gate 				if (mark || delim) {
12897c478bd9Sstevel@tonic-gate 					freemsg(bp);
12907c478bd9Sstevel@tonic-gate 				} else if (rflg) {
12917c478bd9Sstevel@tonic-gate 
12927c478bd9Sstevel@tonic-gate 					/*
12937c478bd9Sstevel@tonic-gate 					 * If already read data put zero
12947c478bd9Sstevel@tonic-gate 					 * length message back on queue else
12957c478bd9Sstevel@tonic-gate 					 * free msg and return 0.
12967c478bd9Sstevel@tonic-gate 					 */
12977c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
12987c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
12997c478bd9Sstevel@tonic-gate 					putback(stp, q, bp, pri);
13007c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
13017c478bd9Sstevel@tonic-gate 				} else {
13027c478bd9Sstevel@tonic-gate 					freemsg(bp);
13037c478bd9Sstevel@tonic-gate 				}
13047c478bd9Sstevel@tonic-gate 				error =  0;
13057c478bd9Sstevel@tonic-gate 				goto oops1;
13067c478bd9Sstevel@tonic-gate 			}
13077c478bd9Sstevel@tonic-gate 
13087c478bd9Sstevel@tonic-gate 			rflg = 1;
13097c478bd9Sstevel@tonic-gate 			waitflag |= NOINTR;
13107c478bd9Sstevel@tonic-gate 			bp = struiocopyout(bp, uiop, &error);
13117c478bd9Sstevel@tonic-gate 			if (error != 0)
13127c478bd9Sstevel@tonic-gate 				goto oops1;
13137c478bd9Sstevel@tonic-gate 
13147c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
13157c478bd9Sstevel@tonic-gate 			if (bp) {
13167c478bd9Sstevel@tonic-gate 				/*
13177c478bd9Sstevel@tonic-gate 				 * Have remaining data in message.
13187c478bd9Sstevel@tonic-gate 				 * Free msg if in discard mode.
13197c478bd9Sstevel@tonic-gate 				 */
13207c478bd9Sstevel@tonic-gate 				if (stp->sd_read_opt & RD_MSGDIS) {
13217c478bd9Sstevel@tonic-gate 					freemsg(bp);
13227c478bd9Sstevel@tonic-gate 				} else {
13237c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
13247c478bd9Sstevel@tonic-gate 					if ((mark & _LASTMARK) &&
13257c478bd9Sstevel@tonic-gate 					    (stp->sd_mark == NULL))
13267c478bd9Sstevel@tonic-gate 						stp->sd_mark = bp;
13277c478bd9Sstevel@tonic-gate 					bp->b_flag |= mark & ~_LASTMARK;
13287c478bd9Sstevel@tonic-gate 					if (delim)
13297c478bd9Sstevel@tonic-gate 						bp->b_flag |= MSGDELIM;
13307c478bd9Sstevel@tonic-gate 					if (msgnodata(bp))
13317c478bd9Sstevel@tonic-gate 						freemsg(bp);
13327c478bd9Sstevel@tonic-gate 					else
13337c478bd9Sstevel@tonic-gate 						putback(stp, q, bp, pri);
13347c478bd9Sstevel@tonic-gate 				}
13357c478bd9Sstevel@tonic-gate 			} else {
13367c478bd9Sstevel@tonic-gate 				/*
13377c478bd9Sstevel@tonic-gate 				 * Consumed the complete message.
13387c478bd9Sstevel@tonic-gate 				 * Move the MSG*MARKNEXT information
13397c478bd9Sstevel@tonic-gate 				 * to the stream head just in case
13407c478bd9Sstevel@tonic-gate 				 * the read queue becomes empty.
13417c478bd9Sstevel@tonic-gate 				 *
13427c478bd9Sstevel@tonic-gate 				 * If the stream head was at the mark
13437c478bd9Sstevel@tonic-gate 				 * (STRATMARK) before we dropped sd_lock above
13447c478bd9Sstevel@tonic-gate 				 * and some data was consumed then we have
13457c478bd9Sstevel@tonic-gate 				 * moved past the mark thus STRATMARK is
13467c478bd9Sstevel@tonic-gate 				 * cleared. However, if a message arrived in
13477c478bd9Sstevel@tonic-gate 				 * strrput during the copyout above causing
13487c478bd9Sstevel@tonic-gate 				 * STRATMARK to be set we can not clear that
13497c478bd9Sstevel@tonic-gate 				 * flag.
13507c478bd9Sstevel@tonic-gate 				 */
13517c478bd9Sstevel@tonic-gate 				if (mark &
13527c478bd9Sstevel@tonic-gate 				    (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
13537c478bd9Sstevel@tonic-gate 					if (mark & MSGMARKNEXT) {
13547c478bd9Sstevel@tonic-gate 						stp->sd_flag &= ~STRNOTATMARK;
13557c478bd9Sstevel@tonic-gate 						stp->sd_flag |= STRATMARK;
13567c478bd9Sstevel@tonic-gate 					} else if (mark & MSGNOTMARKNEXT) {
13577c478bd9Sstevel@tonic-gate 						stp->sd_flag &= ~STRATMARK;
13587c478bd9Sstevel@tonic-gate 						stp->sd_flag |= STRNOTATMARK;
13597c478bd9Sstevel@tonic-gate 					} else {
13607c478bd9Sstevel@tonic-gate 						stp->sd_flag &=
13617c478bd9Sstevel@tonic-gate 						    ~(STRATMARK|STRNOTATMARK);
13627c478bd9Sstevel@tonic-gate 					}
13637c478bd9Sstevel@tonic-gate 				} else if (rflg && (old_sd_flag & STRATMARK)) {
13647c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRATMARK;
13657c478bd9Sstevel@tonic-gate 				}
13667c478bd9Sstevel@tonic-gate 			}
13677c478bd9Sstevel@tonic-gate 
13687c478bd9Sstevel@tonic-gate 			/*
13697c478bd9Sstevel@tonic-gate 			 * Check for signal messages at the front of the read
13707c478bd9Sstevel@tonic-gate 			 * queue and generate the signal(s) if appropriate.
13717c478bd9Sstevel@tonic-gate 			 * The only signal that can be on queue is M_SIG at
13727c478bd9Sstevel@tonic-gate 			 * this point.
13737c478bd9Sstevel@tonic-gate 			 */
13747c478bd9Sstevel@tonic-gate 			while ((((bp = q->q_first)) != NULL) &&
13757c478bd9Sstevel@tonic-gate 			    (bp->b_datap->db_type == M_SIG)) {
1376301ce41fSja97890 				bp = getq_noenab(q, 0);
13777c478bd9Sstevel@tonic-gate 				/*
13787c478bd9Sstevel@tonic-gate 				 * sd_lock is held so the content of the
13797c478bd9Sstevel@tonic-gate 				 * read queue can not change.
13807c478bd9Sstevel@tonic-gate 				 */
1381a45f3f93Smeem 				ASSERT(bp != NULL && DB_TYPE(bp) == M_SIG);
1382a45f3f93Smeem 				strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
13837c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
13847c478bd9Sstevel@tonic-gate 				freemsg(bp);
13857c478bd9Sstevel@tonic-gate 				if (STREAM_NEEDSERVICE(stp))
13867c478bd9Sstevel@tonic-gate 					stream_runservice(stp);
13877c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
13887c478bd9Sstevel@tonic-gate 			}
13897c478bd9Sstevel@tonic-gate 
13907c478bd9Sstevel@tonic-gate 			if ((uiop->uio_resid == 0) || (mark & _LASTMARK) ||
13917c478bd9Sstevel@tonic-gate 			    delim ||
13927c478bd9Sstevel@tonic-gate 			    (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) {
13937c478bd9Sstevel@tonic-gate 				goto oops;
13947c478bd9Sstevel@tonic-gate 			}
13957c478bd9Sstevel@tonic-gate 			continue;
13967c478bd9Sstevel@tonic-gate 
13977c478bd9Sstevel@tonic-gate 		case M_SIG:
13987c478bd9Sstevel@tonic-gate 			strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band);
13997c478bd9Sstevel@tonic-gate 			freemsg(bp);
14007c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
14017c478bd9Sstevel@tonic-gate 			continue;
14027c478bd9Sstevel@tonic-gate 
14037c478bd9Sstevel@tonic-gate 		case M_PROTO:
14047c478bd9Sstevel@tonic-gate 		case M_PCPROTO:
14057c478bd9Sstevel@tonic-gate 			/*
14067c478bd9Sstevel@tonic-gate 			 * Only data messages are readable.
14077c478bd9Sstevel@tonic-gate 			 * Any others generate an error, unless
14087c478bd9Sstevel@tonic-gate 			 * RD_PROTDIS or RD_PROTDAT is set.
14097c478bd9Sstevel@tonic-gate 			 */
14107c478bd9Sstevel@tonic-gate 			if (stp->sd_read_opt & RD_PROTDAT) {
14117c478bd9Sstevel@tonic-gate 				for (nbp = bp; nbp; nbp = nbp->b_next) {
1412d3e55dcdSgww 					if ((nbp->b_datap->db_type ==
1413d3e55dcdSgww 					    M_PROTO) ||
1414d3e55dcdSgww 					    (nbp->b_datap->db_type ==
1415d3e55dcdSgww 					    M_PCPROTO)) {
14167c478bd9Sstevel@tonic-gate 						nbp->b_datap->db_type = M_DATA;
1417d3e55dcdSgww 					} else {
14187c478bd9Sstevel@tonic-gate 						break;
14197c478bd9Sstevel@tonic-gate 					}
1420d3e55dcdSgww 				}
14217c478bd9Sstevel@tonic-gate 				/*
14227c478bd9Sstevel@tonic-gate 				 * clear stream head hi pri flag based on
14237c478bd9Sstevel@tonic-gate 				 * first message
14247c478bd9Sstevel@tonic-gate 				 */
14257c478bd9Sstevel@tonic-gate 				if (type == M_PCPROTO) {
14267c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
14277c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
14287c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
14297c478bd9Sstevel@tonic-gate 				}
14307c478bd9Sstevel@tonic-gate 				goto ismdata;
14317c478bd9Sstevel@tonic-gate 			} else if (stp->sd_read_opt & RD_PROTDIS) {
14327c478bd9Sstevel@tonic-gate 				/*
14337c478bd9Sstevel@tonic-gate 				 * discard non-data messages
14347c478bd9Sstevel@tonic-gate 				 */
14357c478bd9Sstevel@tonic-gate 				while (bp &&
14367c478bd9Sstevel@tonic-gate 				    ((bp->b_datap->db_type == M_PROTO) ||
14377c478bd9Sstevel@tonic-gate 				    (bp->b_datap->db_type == M_PCPROTO))) {
14387c478bd9Sstevel@tonic-gate 					nbp = unlinkb(bp);
14397c478bd9Sstevel@tonic-gate 					freeb(bp);
14407c478bd9Sstevel@tonic-gate 					bp = nbp;
14417c478bd9Sstevel@tonic-gate 				}
14427c478bd9Sstevel@tonic-gate 				/*
14437c478bd9Sstevel@tonic-gate 				 * clear stream head hi pri flag based on
14447c478bd9Sstevel@tonic-gate 				 * first message
14457c478bd9Sstevel@tonic-gate 				 */
14467c478bd9Sstevel@tonic-gate 				if (type == M_PCPROTO) {
14477c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
14487c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
14497c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
14507c478bd9Sstevel@tonic-gate 				}
14517c478bd9Sstevel@tonic-gate 				if (bp) {
14527c478bd9Sstevel@tonic-gate 					bp->b_band = pri;
14537c478bd9Sstevel@tonic-gate 					goto ismdata;
14547c478bd9Sstevel@tonic-gate 				} else {
14557c478bd9Sstevel@tonic-gate 					break;
14567c478bd9Sstevel@tonic-gate 				}
14577c478bd9Sstevel@tonic-gate 			}
14587c478bd9Sstevel@tonic-gate 			/* FALLTHRU */
14597c478bd9Sstevel@tonic-gate 		case M_PASSFP:
14607c478bd9Sstevel@tonic-gate 			if ((bp->b_datap->db_type == M_PASSFP) &&
14617c478bd9Sstevel@tonic-gate 			    (stp->sd_read_opt & RD_PROTDIS)) {
14627c478bd9Sstevel@tonic-gate 				freemsg(bp);
14637c478bd9Sstevel@tonic-gate 				break;
14647c478bd9Sstevel@tonic-gate 			}
14657c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
14667c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
14677c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
14687c478bd9Sstevel@tonic-gate 			if (rflg == 0)
14697c478bd9Sstevel@tonic-gate 				error = EBADMSG;
14707c478bd9Sstevel@tonic-gate 			goto oops1;
14717c478bd9Sstevel@tonic-gate 
14727c478bd9Sstevel@tonic-gate 		default:
14737c478bd9Sstevel@tonic-gate 			/*
14747c478bd9Sstevel@tonic-gate 			 * Garbage on stream head read queue.
14757c478bd9Sstevel@tonic-gate 			 */
14767c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "bad %x found at stream head\n",
14777c478bd9Sstevel@tonic-gate 			    bp->b_datap->db_type);
14787c478bd9Sstevel@tonic-gate 			freemsg(bp);
14797c478bd9Sstevel@tonic-gate 			goto oops1;
14807c478bd9Sstevel@tonic-gate 		}
14817c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
14827c478bd9Sstevel@tonic-gate 	}
14837c478bd9Sstevel@tonic-gate oops:
14847c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
14857c478bd9Sstevel@tonic-gate oops1:
14867c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
14877c478bd9Sstevel@tonic-gate 	return (error);
14887c478bd9Sstevel@tonic-gate #undef	_LASTMARK
14897c478bd9Sstevel@tonic-gate }
14907c478bd9Sstevel@tonic-gate 
14917c478bd9Sstevel@tonic-gate /*
14927c478bd9Sstevel@tonic-gate  * Default processing of M_PROTO/M_PCPROTO messages.
14937c478bd9Sstevel@tonic-gate  * Determine which wakeups and signals are needed.
14947c478bd9Sstevel@tonic-gate  * This can be replaced by a user-specified procedure for kernel users
14957c478bd9Sstevel@tonic-gate  * of STREAMS.
14967c478bd9Sstevel@tonic-gate  */
14977c478bd9Sstevel@tonic-gate /* ARGSUSED */
14987c478bd9Sstevel@tonic-gate mblk_t *
14997c478bd9Sstevel@tonic-gate strrput_proto(vnode_t *vp, mblk_t *mp,
15007c478bd9Sstevel@tonic-gate     strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
15017c478bd9Sstevel@tonic-gate     strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
15027c478bd9Sstevel@tonic-gate {
15037c478bd9Sstevel@tonic-gate 	*wakeups = RSLEEP;
15047c478bd9Sstevel@tonic-gate 	*allmsgsigs = 0;
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	switch (mp->b_datap->db_type) {
15077c478bd9Sstevel@tonic-gate 	case M_PROTO:
15087c478bd9Sstevel@tonic-gate 		if (mp->b_band == 0) {
15097c478bd9Sstevel@tonic-gate 			*firstmsgsigs = S_INPUT | S_RDNORM;
15107c478bd9Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDNORM;
15117c478bd9Sstevel@tonic-gate 		} else {
15127c478bd9Sstevel@tonic-gate 			*firstmsgsigs = S_INPUT | S_RDBAND;
15137c478bd9Sstevel@tonic-gate 			*pollwakeups = POLLIN | POLLRDBAND;
15147c478bd9Sstevel@tonic-gate 		}
15157c478bd9Sstevel@tonic-gate 		break;
15167c478bd9Sstevel@tonic-gate 	case M_PCPROTO:
15177c478bd9Sstevel@tonic-gate 		*firstmsgsigs = S_HIPRI;
15187c478bd9Sstevel@tonic-gate 		*pollwakeups = POLLPRI;
15197c478bd9Sstevel@tonic-gate 		break;
15207c478bd9Sstevel@tonic-gate 	}
15217c478bd9Sstevel@tonic-gate 	return (mp);
15227c478bd9Sstevel@tonic-gate }
15237c478bd9Sstevel@tonic-gate 
15247c478bd9Sstevel@tonic-gate /*
15257c478bd9Sstevel@tonic-gate  * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and
15267c478bd9Sstevel@tonic-gate  * M_PASSFP messages.
15277c478bd9Sstevel@tonic-gate  * Determine which wakeups and signals are needed.
15287c478bd9Sstevel@tonic-gate  * This can be replaced by a user-specified procedure for kernel users
15297c478bd9Sstevel@tonic-gate  * of STREAMS.
15307c478bd9Sstevel@tonic-gate  */
15317c478bd9Sstevel@tonic-gate /* ARGSUSED */
15327c478bd9Sstevel@tonic-gate mblk_t *
15337c478bd9Sstevel@tonic-gate strrput_misc(vnode_t *vp, mblk_t *mp,
15347c478bd9Sstevel@tonic-gate     strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
15357c478bd9Sstevel@tonic-gate     strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
15367c478bd9Sstevel@tonic-gate {
15377c478bd9Sstevel@tonic-gate 	*wakeups = 0;
15387c478bd9Sstevel@tonic-gate 	*firstmsgsigs = 0;
15397c478bd9Sstevel@tonic-gate 	*allmsgsigs = 0;
15407c478bd9Sstevel@tonic-gate 	*pollwakeups = 0;
15417c478bd9Sstevel@tonic-gate 	return (mp);
15427c478bd9Sstevel@tonic-gate }
15437c478bd9Sstevel@tonic-gate 
15447c478bd9Sstevel@tonic-gate /*
15457c478bd9Sstevel@tonic-gate  * Stream read put procedure.  Called from downstream driver/module
15467c478bd9Sstevel@tonic-gate  * with messages for the stream head.  Data, protocol, and in-stream
15477c478bd9Sstevel@tonic-gate  * signal messages are placed on the queue, others are handled directly.
15487c478bd9Sstevel@tonic-gate  */
15497c478bd9Sstevel@tonic-gate int
15507c478bd9Sstevel@tonic-gate strrput(queue_t *q, mblk_t *bp)
15517c478bd9Sstevel@tonic-gate {
15527c478bd9Sstevel@tonic-gate 	struct stdata	*stp;
15537c478bd9Sstevel@tonic-gate 	ulong_t		rput_opt;
15547c478bd9Sstevel@tonic-gate 	strwakeup_t	wakeups;
15557c478bd9Sstevel@tonic-gate 	strsigset_t	firstmsgsigs;	/* Signals if first message on queue */
15567c478bd9Sstevel@tonic-gate 	strsigset_t	allmsgsigs;	/* Signals for all messages */
15577c478bd9Sstevel@tonic-gate 	strsigset_t	signals;	/* Signals events to generate */
15587c478bd9Sstevel@tonic-gate 	strpollset_t	pollwakeups;
15597c478bd9Sstevel@tonic-gate 	mblk_t		*nextbp;
15607c478bd9Sstevel@tonic-gate 	uchar_t		band = 0;
15617c478bd9Sstevel@tonic-gate 	int		hipri_sig;
15627c478bd9Sstevel@tonic-gate 
15637c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
15647c478bd9Sstevel@tonic-gate 	/*
15657c478bd9Sstevel@tonic-gate 	 * Use rput_opt for optimized access to the SR_ flags except
15667c478bd9Sstevel@tonic-gate 	 * SR_POLLIN. That flag has to be checked under sd_lock since it
15677c478bd9Sstevel@tonic-gate 	 * is modified by strpoll().
15687c478bd9Sstevel@tonic-gate 	 */
15697c478bd9Sstevel@tonic-gate 	rput_opt = stp->sd_rput_opt;
15707c478bd9Sstevel@tonic-gate 
15717c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
15727c478bd9Sstevel@tonic-gate 	TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER,
15737c478bd9Sstevel@tonic-gate 	    "strrput called with message type:q %p bp %p", q, bp);
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	/*
15767c478bd9Sstevel@tonic-gate 	 * Perform initial processing and pass to the parameterized functions.
15777c478bd9Sstevel@tonic-gate 	 */
15787c478bd9Sstevel@tonic-gate 	ASSERT(bp->b_next == NULL);
15797c478bd9Sstevel@tonic-gate 
15807c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
15817c478bd9Sstevel@tonic-gate 	case M_DATA:
15827c478bd9Sstevel@tonic-gate 		/*
15837c478bd9Sstevel@tonic-gate 		 * sockfs is the only consumer of STREOF and when it is set,
15847c478bd9Sstevel@tonic-gate 		 * it implies that the receiver is not interested in receiving
15857c478bd9Sstevel@tonic-gate 		 * any more data, hence the mblk is freed to prevent unnecessary
15867c478bd9Sstevel@tonic-gate 		 * message queueing at the stream head.
15877c478bd9Sstevel@tonic-gate 		 */
15887c478bd9Sstevel@tonic-gate 		if (stp->sd_flag == STREOF) {
15897c478bd9Sstevel@tonic-gate 			freemsg(bp);
15907c478bd9Sstevel@tonic-gate 			return (0);
15917c478bd9Sstevel@tonic-gate 		}
15927c478bd9Sstevel@tonic-gate 		if ((rput_opt & SR_IGN_ZEROLEN) &&
15937c478bd9Sstevel@tonic-gate 		    bp->b_rptr == bp->b_wptr && msgnodata(bp)) {
15947c478bd9Sstevel@tonic-gate 			/*
15957c478bd9Sstevel@tonic-gate 			 * Ignore zero-length M_DATA messages. These might be
15967c478bd9Sstevel@tonic-gate 			 * generated by some transports.
15977c478bd9Sstevel@tonic-gate 			 * The zero-length M_DATA messages, even if they
15987c478bd9Sstevel@tonic-gate 			 * are ignored, should effect the atmark tracking and
15997c478bd9Sstevel@tonic-gate 			 * should wake up a thread sleeping in strwaitmark.
16007c478bd9Sstevel@tonic-gate 			 */
16017c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
16027c478bd9Sstevel@tonic-gate 			if (bp->b_flag & MSGMARKNEXT) {
16037c478bd9Sstevel@tonic-gate 				/*
16047c478bd9Sstevel@tonic-gate 				 * Record the position of the mark either
16057c478bd9Sstevel@tonic-gate 				 * in q_last or in STRATMARK.
16067c478bd9Sstevel@tonic-gate 				 */
16077c478bd9Sstevel@tonic-gate 				if (q->q_last != NULL) {
16087c478bd9Sstevel@tonic-gate 					q->q_last->b_flag &= ~MSGNOTMARKNEXT;
16097c478bd9Sstevel@tonic-gate 					q->q_last->b_flag |= MSGMARKNEXT;
16107c478bd9Sstevel@tonic-gate 				} else {
16117c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRNOTATMARK;
16127c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRATMARK;
16137c478bd9Sstevel@tonic-gate 				}
16147c478bd9Sstevel@tonic-gate 			} else if (bp->b_flag & MSGNOTMARKNEXT) {
16157c478bd9Sstevel@tonic-gate 				/*
16167c478bd9Sstevel@tonic-gate 				 * Record that this is not the position of
16177c478bd9Sstevel@tonic-gate 				 * the mark either in q_last or in
16187c478bd9Sstevel@tonic-gate 				 * STRNOTATMARK.
16197c478bd9Sstevel@tonic-gate 				 */
16207c478bd9Sstevel@tonic-gate 				if (q->q_last != NULL) {
16217c478bd9Sstevel@tonic-gate 					q->q_last->b_flag &= ~MSGMARKNEXT;
16227c478bd9Sstevel@tonic-gate 					q->q_last->b_flag |= MSGNOTMARKNEXT;
16237c478bd9Sstevel@tonic-gate 				} else {
16247c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRATMARK;
16257c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRNOTATMARK;
16267c478bd9Sstevel@tonic-gate 				}
16277c478bd9Sstevel@tonic-gate 			}
16287c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & RSLEEP) {
16297c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~RSLEEP;
16307c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait);
16317c478bd9Sstevel@tonic-gate 			}
16327c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
16337c478bd9Sstevel@tonic-gate 			freemsg(bp);
16347c478bd9Sstevel@tonic-gate 			return (0);
16357c478bd9Sstevel@tonic-gate 		}
16367c478bd9Sstevel@tonic-gate 		wakeups = RSLEEP;
16377c478bd9Sstevel@tonic-gate 		if (bp->b_band == 0) {
16387c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDNORM;
16397c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDNORM;
16407c478bd9Sstevel@tonic-gate 		} else {
16417c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDBAND;
16427c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDBAND;
16437c478bd9Sstevel@tonic-gate 		}
16447c478bd9Sstevel@tonic-gate 		if (rput_opt & SR_SIGALLDATA)
16457c478bd9Sstevel@tonic-gate 			allmsgsigs = firstmsgsigs;
16467c478bd9Sstevel@tonic-gate 		else
16477c478bd9Sstevel@tonic-gate 			allmsgsigs = 0;
16487c478bd9Sstevel@tonic-gate 
16497c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
16507c478bd9Sstevel@tonic-gate 		if ((rput_opt & SR_CONSOL_DATA) &&
16513584396bSja97890 		    (q->q_last != NULL) &&
16527c478bd9Sstevel@tonic-gate 		    (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) {
16537c478bd9Sstevel@tonic-gate 			/*
16543584396bSja97890 			 * Consolidate an M_DATA message onto an M_DATA,
16557c478bd9Sstevel@tonic-gate 			 * M_PROTO, or M_PCPROTO by merging it with q_last.
16567c478bd9Sstevel@tonic-gate 			 * The consolidation does not take place if
16577c478bd9Sstevel@tonic-gate 			 * the old message is marked with either of the
16587c478bd9Sstevel@tonic-gate 			 * marks or the delim flag or if the new
16597c478bd9Sstevel@tonic-gate 			 * message is marked with MSGMARK. The MSGMARK
16607c478bd9Sstevel@tonic-gate 			 * check is needed to handle the odd semantics of
16617c478bd9Sstevel@tonic-gate 			 * MSGMARK where essentially the whole message
16627c478bd9Sstevel@tonic-gate 			 * is to be treated as marked.
16637c478bd9Sstevel@tonic-gate 			 * Carry any MSGMARKNEXT  and MSGNOTMARKNEXT from the
16647c478bd9Sstevel@tonic-gate 			 * new message to the front of the b_cont chain.
16657c478bd9Sstevel@tonic-gate 			 */
16663584396bSja97890 			mblk_t *lbp = q->q_last;
16673584396bSja97890 			unsigned char db_type = lbp->b_datap->db_type;
16687c478bd9Sstevel@tonic-gate 
16693584396bSja97890 			if ((db_type == M_DATA || db_type == M_PROTO ||
16703584396bSja97890 			    db_type == M_PCPROTO) &&
16713584396bSja97890 			    !(lbp->b_flag & (MSGDELIM|MSGMARK|MSGMARKNEXT))) {
16727c478bd9Sstevel@tonic-gate 				rmvq_noenab(q, lbp);
16737c478bd9Sstevel@tonic-gate 				/*
16747c478bd9Sstevel@tonic-gate 				 * The first message in the b_cont list
16757c478bd9Sstevel@tonic-gate 				 * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
16767c478bd9Sstevel@tonic-gate 				 * We need to handle the case where we
16773584396bSja97890 				 * are appending:
16787c478bd9Sstevel@tonic-gate 				 *
16797c478bd9Sstevel@tonic-gate 				 * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
16807c478bd9Sstevel@tonic-gate 				 * 2) a MSGMARKNEXT to a plain message.
16817c478bd9Sstevel@tonic-gate 				 * 3) a MSGNOTMARKNEXT to a plain message
16827c478bd9Sstevel@tonic-gate 				 * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
16837c478bd9Sstevel@tonic-gate 				 *    message.
16847c478bd9Sstevel@tonic-gate 				 *
16857c478bd9Sstevel@tonic-gate 				 * Thus we never append a MSGMARKNEXT or
16867c478bd9Sstevel@tonic-gate 				 * MSGNOTMARKNEXT to a MSGMARKNEXT message.
16877c478bd9Sstevel@tonic-gate 				 */
16887c478bd9Sstevel@tonic-gate 				if (bp->b_flag & MSGMARKNEXT) {
16897c478bd9Sstevel@tonic-gate 					lbp->b_flag |= MSGMARKNEXT;
16907c478bd9Sstevel@tonic-gate 					lbp->b_flag &= ~MSGNOTMARKNEXT;
16917c478bd9Sstevel@tonic-gate 					bp->b_flag &= ~MSGMARKNEXT;
16927c478bd9Sstevel@tonic-gate 				} else if (bp->b_flag & MSGNOTMARKNEXT) {
16937c478bd9Sstevel@tonic-gate 					lbp->b_flag |= MSGNOTMARKNEXT;
16947c478bd9Sstevel@tonic-gate 					bp->b_flag &= ~MSGNOTMARKNEXT;
16957c478bd9Sstevel@tonic-gate 				}
16967c478bd9Sstevel@tonic-gate 
16977c478bd9Sstevel@tonic-gate 				linkb(lbp, bp);
16987c478bd9Sstevel@tonic-gate 				bp = lbp;
16997c478bd9Sstevel@tonic-gate 				/*
17007c478bd9Sstevel@tonic-gate 				 * The new message logically isn't the first
17017c478bd9Sstevel@tonic-gate 				 * even though the q_first check below thinks
17027c478bd9Sstevel@tonic-gate 				 * it is. Clear the firstmsgsigs to make it
17037c478bd9Sstevel@tonic-gate 				 * not appear to be first.
17047c478bd9Sstevel@tonic-gate 				 */
17057c478bd9Sstevel@tonic-gate 				firstmsgsigs = 0;
17067c478bd9Sstevel@tonic-gate 			}
17077c478bd9Sstevel@tonic-gate 		}
17087c478bd9Sstevel@tonic-gate 		break;
17097c478bd9Sstevel@tonic-gate 
17107c478bd9Sstevel@tonic-gate 	case M_PASSFP:
17117c478bd9Sstevel@tonic-gate 		wakeups = RSLEEP;
17127c478bd9Sstevel@tonic-gate 		allmsgsigs = 0;
17137c478bd9Sstevel@tonic-gate 		if (bp->b_band == 0) {
17147c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDNORM;
17157c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDNORM;
17167c478bd9Sstevel@tonic-gate 		} else {
17177c478bd9Sstevel@tonic-gate 			firstmsgsigs = S_INPUT | S_RDBAND;
17187c478bd9Sstevel@tonic-gate 			pollwakeups = POLLIN | POLLRDBAND;
17197c478bd9Sstevel@tonic-gate 		}
17207c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
17217c478bd9Sstevel@tonic-gate 		break;
17227c478bd9Sstevel@tonic-gate 
17237c478bd9Sstevel@tonic-gate 	case M_PROTO:
17247c478bd9Sstevel@tonic-gate 	case M_PCPROTO:
17257c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_rprotofunc != NULL);
17267c478bd9Sstevel@tonic-gate 		bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp,
17277c478bd9Sstevel@tonic-gate 		    &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
17287c478bd9Sstevel@tonic-gate #define	ALLSIG	(S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\
17297c478bd9Sstevel@tonic-gate 		S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)
17307c478bd9Sstevel@tonic-gate #define	ALLPOLL	(POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\
17317c478bd9Sstevel@tonic-gate 		POLLWRBAND)
17327c478bd9Sstevel@tonic-gate 
17337c478bd9Sstevel@tonic-gate 		ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
17347c478bd9Sstevel@tonic-gate 		ASSERT((firstmsgsigs & ~ALLSIG) == 0);
17357c478bd9Sstevel@tonic-gate 		ASSERT((allmsgsigs & ~ALLSIG) == 0);
17367c478bd9Sstevel@tonic-gate 		ASSERT((pollwakeups & ~ALLPOLL) == 0);
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
17397c478bd9Sstevel@tonic-gate 		break;
17407c478bd9Sstevel@tonic-gate 
17417c478bd9Sstevel@tonic-gate 	default:
17427c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_rmiscfunc != NULL);
17437c478bd9Sstevel@tonic-gate 		bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp,
17447c478bd9Sstevel@tonic-gate 		    &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
17457c478bd9Sstevel@tonic-gate 		ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
17467c478bd9Sstevel@tonic-gate 		ASSERT((firstmsgsigs & ~ALLSIG) == 0);
17477c478bd9Sstevel@tonic-gate 		ASSERT((allmsgsigs & ~ALLSIG) == 0);
17487c478bd9Sstevel@tonic-gate 		ASSERT((pollwakeups & ~ALLPOLL) == 0);
17497c478bd9Sstevel@tonic-gate #undef	ALLSIG
17507c478bd9Sstevel@tonic-gate #undef	ALLPOLL
17517c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
17527c478bd9Sstevel@tonic-gate 		break;
17537c478bd9Sstevel@tonic-gate 	}
17547c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
17557c478bd9Sstevel@tonic-gate 
17567c478bd9Sstevel@tonic-gate 	/* By default generate superset of signals */
17577c478bd9Sstevel@tonic-gate 	signals = (firstmsgsigs | allmsgsigs);
17587c478bd9Sstevel@tonic-gate 
17597c478bd9Sstevel@tonic-gate 	/*
17607c478bd9Sstevel@tonic-gate 	 * The  proto and misc functions can return multiple messages
17617c478bd9Sstevel@tonic-gate 	 * as a b_next chain. Such messages are processed separately.
17627c478bd9Sstevel@tonic-gate 	 */
17637c478bd9Sstevel@tonic-gate one_more:
17647c478bd9Sstevel@tonic-gate 	hipri_sig = 0;
17657c478bd9Sstevel@tonic-gate 	if (bp == NULL) {
17667c478bd9Sstevel@tonic-gate 		nextbp = NULL;
17677c478bd9Sstevel@tonic-gate 	} else {
17687c478bd9Sstevel@tonic-gate 		nextbp = bp->b_next;
17697c478bd9Sstevel@tonic-gate 		bp->b_next = NULL;
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 		switch (bp->b_datap->db_type) {
17727c478bd9Sstevel@tonic-gate 		case M_PCPROTO:
17737c478bd9Sstevel@tonic-gate 			/*
17747c478bd9Sstevel@tonic-gate 			 * Only one priority protocol message is allowed at the
17757c478bd9Sstevel@tonic-gate 			 * stream head at a time.
17767c478bd9Sstevel@tonic-gate 			 */
17777c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & STRPRI) {
17787c478bd9Sstevel@tonic-gate 				TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR,
17797c478bd9Sstevel@tonic-gate 				    "M_PCPROTO already at head");
17807c478bd9Sstevel@tonic-gate 				freemsg(bp);
17817c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
17827c478bd9Sstevel@tonic-gate 				goto done;
17837c478bd9Sstevel@tonic-gate 			}
17847c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRPRI;
17857c478bd9Sstevel@tonic-gate 			hipri_sig = 1;
17867c478bd9Sstevel@tonic-gate 			/* FALLTHRU */
17877c478bd9Sstevel@tonic-gate 		case M_DATA:
17887c478bd9Sstevel@tonic-gate 		case M_PROTO:
17897c478bd9Sstevel@tonic-gate 		case M_PASSFP:
17907c478bd9Sstevel@tonic-gate 			band = bp->b_band;
17917c478bd9Sstevel@tonic-gate 			/*
17927c478bd9Sstevel@tonic-gate 			 * Marking doesn't work well when messages
17937c478bd9Sstevel@tonic-gate 			 * are marked in more than one band.  We only
17947c478bd9Sstevel@tonic-gate 			 * remember the last message received, even if
17957c478bd9Sstevel@tonic-gate 			 * it is placed on the queue ahead of other
17967c478bd9Sstevel@tonic-gate 			 * marked messages.
17977c478bd9Sstevel@tonic-gate 			 */
17987c478bd9Sstevel@tonic-gate 			if (bp->b_flag & MSGMARK)
17997c478bd9Sstevel@tonic-gate 				stp->sd_mark = bp;
18007c478bd9Sstevel@tonic-gate 			(void) putq(q, bp);
18017c478bd9Sstevel@tonic-gate 
18027c478bd9Sstevel@tonic-gate 			/*
18037c478bd9Sstevel@tonic-gate 			 * If message is a PCPROTO message, always use
18047c478bd9Sstevel@tonic-gate 			 * firstmsgsigs to determine if a signal should be
18057c478bd9Sstevel@tonic-gate 			 * sent as strrput is the only place to send
18067c478bd9Sstevel@tonic-gate 			 * signals for PCPROTO. Other messages are based on
18077c478bd9Sstevel@tonic-gate 			 * the STRGETINPROG flag. The flag determines if
18087c478bd9Sstevel@tonic-gate 			 * strrput or (k)strgetmsg will be responsible for
18097c478bd9Sstevel@tonic-gate 			 * sending the signals, in the firstmsgsigs case.
18107c478bd9Sstevel@tonic-gate 			 */
18117c478bd9Sstevel@tonic-gate 			if ((hipri_sig == 1) ||
18127c478bd9Sstevel@tonic-gate 			    (((stp->sd_flag & STRGETINPROG) == 0) &&
18137c478bd9Sstevel@tonic-gate 			    (q->q_first == bp)))
18147c478bd9Sstevel@tonic-gate 				signals = (firstmsgsigs | allmsgsigs);
18157c478bd9Sstevel@tonic-gate 			else
18167c478bd9Sstevel@tonic-gate 				signals = allmsgsigs;
18177c478bd9Sstevel@tonic-gate 			break;
18187c478bd9Sstevel@tonic-gate 
18197c478bd9Sstevel@tonic-gate 		default:
18207c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
18217c478bd9Sstevel@tonic-gate 			(void) strrput_nondata(q, bp);
18227c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
18237c478bd9Sstevel@tonic-gate 			break;
18247c478bd9Sstevel@tonic-gate 		}
18257c478bd9Sstevel@tonic-gate 	}
18267c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
18277c478bd9Sstevel@tonic-gate 	/*
18287c478bd9Sstevel@tonic-gate 	 * Wake sleeping read/getmsg and cancel deferred wakeup
18297c478bd9Sstevel@tonic-gate 	 */
18307c478bd9Sstevel@tonic-gate 	if (wakeups & RSLEEP)
18317c478bd9Sstevel@tonic-gate 		stp->sd_wakeq &= ~RSLEEP;
18327c478bd9Sstevel@tonic-gate 
18337c478bd9Sstevel@tonic-gate 	wakeups &= stp->sd_flag;
18347c478bd9Sstevel@tonic-gate 	if (wakeups & RSLEEP) {
18357c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~RSLEEP;
18367c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);
18377c478bd9Sstevel@tonic-gate 	}
18387c478bd9Sstevel@tonic-gate 	if (wakeups & WSLEEP) {
18397c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~WSLEEP;
18407c478bd9Sstevel@tonic-gate 		cv_broadcast(&_WR(q)->q_wait);
18417c478bd9Sstevel@tonic-gate 	}
18427c478bd9Sstevel@tonic-gate 
18437c478bd9Sstevel@tonic-gate 	if (pollwakeups != 0) {
18447c478bd9Sstevel@tonic-gate 		if (pollwakeups == (POLLIN | POLLRDNORM)) {
18457c478bd9Sstevel@tonic-gate 			/*
18467c478bd9Sstevel@tonic-gate 			 * Can't use rput_opt since it was not
18477c478bd9Sstevel@tonic-gate 			 * read when sd_lock was held and SR_POLLIN is changed
18487c478bd9Sstevel@tonic-gate 			 * by strpoll() under sd_lock.
18497c478bd9Sstevel@tonic-gate 			 */
18507c478bd9Sstevel@tonic-gate 			if (!(stp->sd_rput_opt & SR_POLLIN))
18517c478bd9Sstevel@tonic-gate 				goto no_pollwake;
18527c478bd9Sstevel@tonic-gate 			stp->sd_rput_opt &= ~SR_POLLIN;
18537c478bd9Sstevel@tonic-gate 		}
18547c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
18557c478bd9Sstevel@tonic-gate 		pollwakeup(&stp->sd_pollist, pollwakeups);
18567c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
18577c478bd9Sstevel@tonic-gate 	}
18587c478bd9Sstevel@tonic-gate no_pollwake:
18597c478bd9Sstevel@tonic-gate 
18607c478bd9Sstevel@tonic-gate 	/*
18617c478bd9Sstevel@tonic-gate 	 * strsendsig can handle multiple signals with a
18627c478bd9Sstevel@tonic-gate 	 * single call.
18637c478bd9Sstevel@tonic-gate 	 */
18647c478bd9Sstevel@tonic-gate 	if (stp->sd_sigflags & signals)
18657c478bd9Sstevel@tonic-gate 		strsendsig(stp->sd_siglist, signals, band, 0);
18667c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
18677c478bd9Sstevel@tonic-gate 
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate done:
18707c478bd9Sstevel@tonic-gate 	if (nextbp == NULL)
18717c478bd9Sstevel@tonic-gate 		return (0);
18727c478bd9Sstevel@tonic-gate 
18737c478bd9Sstevel@tonic-gate 	/*
18747c478bd9Sstevel@tonic-gate 	 * Any signals were handled the first time.
18757c478bd9Sstevel@tonic-gate 	 * Wakeups and pollwakeups are redone to avoid any race
18767c478bd9Sstevel@tonic-gate 	 * conditions - all the messages are not queued until the
18777c478bd9Sstevel@tonic-gate 	 * last message has been processed by strrput.
18787c478bd9Sstevel@tonic-gate 	 */
18797c478bd9Sstevel@tonic-gate 	bp = nextbp;
18807c478bd9Sstevel@tonic-gate 	signals = firstmsgsigs = allmsgsigs = 0;
18817c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
18827c478bd9Sstevel@tonic-gate 	goto one_more;
18837c478bd9Sstevel@tonic-gate }
18847c478bd9Sstevel@tonic-gate 
18857c478bd9Sstevel@tonic-gate static void
18867c478bd9Sstevel@tonic-gate log_dupioc(queue_t *rq, mblk_t *bp)
18877c478bd9Sstevel@tonic-gate {
18887c478bd9Sstevel@tonic-gate 	queue_t *wq, *qp;
18897c478bd9Sstevel@tonic-gate 	char *modnames, *mnp, *dname;
18907c478bd9Sstevel@tonic-gate 	size_t maxmodstr;
18917c478bd9Sstevel@tonic-gate 	boolean_t islast;
18927c478bd9Sstevel@tonic-gate 
18937c478bd9Sstevel@tonic-gate 	/*
18947c478bd9Sstevel@tonic-gate 	 * Allocate a buffer large enough to hold the names of nstrpush modules
18957c478bd9Sstevel@tonic-gate 	 * and one driver, with spaces between and NUL terminator.  If we can't
18967c478bd9Sstevel@tonic-gate 	 * get memory, then we'll just log the driver name.
18977c478bd9Sstevel@tonic-gate 	 */
18987c478bd9Sstevel@tonic-gate 	maxmodstr = nstrpush * (FMNAMESZ + 1);
18997c478bd9Sstevel@tonic-gate 	mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP);
19007c478bd9Sstevel@tonic-gate 
19017c478bd9Sstevel@tonic-gate 	/* march down write side to print log message down to the driver */
19027c478bd9Sstevel@tonic-gate 	wq = WR(rq);
19037c478bd9Sstevel@tonic-gate 
19047c478bd9Sstevel@tonic-gate 	/* make sure q_next doesn't shift around while we're grabbing data */
19057c478bd9Sstevel@tonic-gate 	claimstr(wq);
19067c478bd9Sstevel@tonic-gate 	qp = wq->q_next;
19077c478bd9Sstevel@tonic-gate 	do {
1908a45f3f93Smeem 		dname = Q2NAME(qp);
19097c478bd9Sstevel@tonic-gate 		islast = !SAMESTR(qp) || qp->q_next == NULL;
19107c478bd9Sstevel@tonic-gate 		if (modnames == NULL) {
19117c478bd9Sstevel@tonic-gate 			/*
19127c478bd9Sstevel@tonic-gate 			 * If we don't have memory, then get the driver name in
19137c478bd9Sstevel@tonic-gate 			 * the log where we can see it.  Note that memory
19147c478bd9Sstevel@tonic-gate 			 * pressure is a possible cause of these sorts of bugs.
19157c478bd9Sstevel@tonic-gate 			 */
19167c478bd9Sstevel@tonic-gate 			if (islast) {
19177c478bd9Sstevel@tonic-gate 				modnames = dname;
19187c478bd9Sstevel@tonic-gate 				maxmodstr = 0;
19197c478bd9Sstevel@tonic-gate 			}
19207c478bd9Sstevel@tonic-gate 		} else {
19217c478bd9Sstevel@tonic-gate 			mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname);
19227c478bd9Sstevel@tonic-gate 			if (!islast)
19237c478bd9Sstevel@tonic-gate 				*mnp++ = ' ';
19247c478bd9Sstevel@tonic-gate 		}
19257c478bd9Sstevel@tonic-gate 		qp = qp->q_next;
19267c478bd9Sstevel@tonic-gate 	} while (!islast);
19277c478bd9Sstevel@tonic-gate 	releasestr(wq);
19287c478bd9Sstevel@tonic-gate 	/* Cannot happen unless stream head is corrupt. */
19297c478bd9Sstevel@tonic-gate 	ASSERT(modnames != NULL);
19307c478bd9Sstevel@tonic-gate 	(void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1,
19317c478bd9Sstevel@tonic-gate 	    SL_CONSOLE|SL_TRACE|SL_ERROR,
19327c478bd9Sstevel@tonic-gate 	    "Warning: stream %p received duplicate %X M_IOC%s; module list: %s",
19337c478bd9Sstevel@tonic-gate 	    rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd,
19347c478bd9Sstevel@tonic-gate 	    (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames);
19357c478bd9Sstevel@tonic-gate 	if (maxmodstr != 0)
19367c478bd9Sstevel@tonic-gate 		kmem_free(modnames, maxmodstr);
19377c478bd9Sstevel@tonic-gate }
19387c478bd9Sstevel@tonic-gate 
19397c478bd9Sstevel@tonic-gate int
19407c478bd9Sstevel@tonic-gate strrput_nondata(queue_t *q, mblk_t *bp)
19417c478bd9Sstevel@tonic-gate {
19427c478bd9Sstevel@tonic-gate 	struct stdata *stp;
19437c478bd9Sstevel@tonic-gate 	struct iocblk *iocbp;
19447c478bd9Sstevel@tonic-gate 	struct stroptions *sop;
19457c478bd9Sstevel@tonic-gate 	struct copyreq *reqp;
19467c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
19477c478bd9Sstevel@tonic-gate 	unsigned char bpri;
19487c478bd9Sstevel@tonic-gate 	unsigned char  flushed_already = 0;
19497c478bd9Sstevel@tonic-gate 
19507c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
19517c478bd9Sstevel@tonic-gate 
19527c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
19537c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
19547c478bd9Sstevel@tonic-gate 
19557c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
19567c478bd9Sstevel@tonic-gate 	case M_ERROR:
19577c478bd9Sstevel@tonic-gate 		/*
19587c478bd9Sstevel@tonic-gate 		 * An error has occurred downstream, the errno is in the first
19597c478bd9Sstevel@tonic-gate 		 * bytes of the message.
19607c478bd9Sstevel@tonic-gate 		 */
19617c478bd9Sstevel@tonic-gate 		if ((bp->b_wptr - bp->b_rptr) == 2) {	/* New flavor */
19627c478bd9Sstevel@tonic-gate 			unsigned char rw = 0;
19637c478bd9Sstevel@tonic-gate 
19647c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
19657c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr != NOERROR) {	/* read error */
19667c478bd9Sstevel@tonic-gate 				if (*bp->b_rptr != 0) {
19677c478bd9Sstevel@tonic-gate 					if (stp->sd_flag & STRDERR)
19687c478bd9Sstevel@tonic-gate 						flushed_already |= FLUSHR;
19697c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRDERR;
19707c478bd9Sstevel@tonic-gate 					rw |= FLUSHR;
19717c478bd9Sstevel@tonic-gate 				} else {
19727c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRDERR;
19737c478bd9Sstevel@tonic-gate 				}
19747c478bd9Sstevel@tonic-gate 				stp->sd_rerror = *bp->b_rptr;
19757c478bd9Sstevel@tonic-gate 			}
19767c478bd9Sstevel@tonic-gate 			bp->b_rptr++;
19777c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr != NOERROR) {	/* write error */
19787c478bd9Sstevel@tonic-gate 				if (*bp->b_rptr != 0) {
19797c478bd9Sstevel@tonic-gate 					if (stp->sd_flag & STWRERR)
19807c478bd9Sstevel@tonic-gate 						flushed_already |= FLUSHW;
19817c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STWRERR;
19827c478bd9Sstevel@tonic-gate 					rw |= FLUSHW;
19837c478bd9Sstevel@tonic-gate 				} else {
19847c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STWRERR;
19857c478bd9Sstevel@tonic-gate 				}
19867c478bd9Sstevel@tonic-gate 				stp->sd_werror = *bp->b_rptr;
19877c478bd9Sstevel@tonic-gate 			}
19887c478bd9Sstevel@tonic-gate 			if (rw) {
19897c478bd9Sstevel@tonic-gate 				TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE,
19907c478bd9Sstevel@tonic-gate 				    "strrput cv_broadcast:q %p, bp %p",
19917c478bd9Sstevel@tonic-gate 				    q, bp);
19927c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait); /* readers */
19937c478bd9Sstevel@tonic-gate 				cv_broadcast(&_WR(q)->q_wait); /* writers */
19947c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_monitor); /* ioctllers */
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
19977c478bd9Sstevel@tonic-gate 				pollwakeup(&stp->sd_pollist, POLLERR);
19987c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
19997c478bd9Sstevel@tonic-gate 
20007c478bd9Sstevel@tonic-gate 				if (stp->sd_sigflags & S_ERROR)
20017c478bd9Sstevel@tonic-gate 					strsendsig(stp->sd_siglist, S_ERROR, 0,
20027c478bd9Sstevel@tonic-gate 					    ((rw & FLUSHR) ? stp->sd_rerror :
20037c478bd9Sstevel@tonic-gate 					    stp->sd_werror));
20047c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
20057c478bd9Sstevel@tonic-gate 				/*
20067c478bd9Sstevel@tonic-gate 				 * Send the M_FLUSH only
20077c478bd9Sstevel@tonic-gate 				 * for the first M_ERROR
20087c478bd9Sstevel@tonic-gate 				 * message on the stream
20097c478bd9Sstevel@tonic-gate 				 */
20107c478bd9Sstevel@tonic-gate 				if (flushed_already == rw) {
20117c478bd9Sstevel@tonic-gate 					freemsg(bp);
20127c478bd9Sstevel@tonic-gate 					return (0);
20137c478bd9Sstevel@tonic-gate 				}
20147c478bd9Sstevel@tonic-gate 
20157c478bd9Sstevel@tonic-gate 				bp->b_datap->db_type = M_FLUSH;
20167c478bd9Sstevel@tonic-gate 				*bp->b_rptr = rw;
20177c478bd9Sstevel@tonic-gate 				bp->b_wptr = bp->b_rptr + 1;
20187c478bd9Sstevel@tonic-gate 				/*
20197c478bd9Sstevel@tonic-gate 				 * Protect against the driver
20207c478bd9Sstevel@tonic-gate 				 * passing up messages after
20217c478bd9Sstevel@tonic-gate 				 * it has done a qprocsoff
20227c478bd9Sstevel@tonic-gate 				 */
20237c478bd9Sstevel@tonic-gate 				if (_OTHERQ(q)->q_next == NULL)
20247c478bd9Sstevel@tonic-gate 					freemsg(bp);
20257c478bd9Sstevel@tonic-gate 				else
20267c478bd9Sstevel@tonic-gate 					qreply(q, bp);
20277c478bd9Sstevel@tonic-gate 				return (0);
20287c478bd9Sstevel@tonic-gate 			} else
20297c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
20307c478bd9Sstevel@tonic-gate 		} else if (*bp->b_rptr != 0) {		/* Old flavor */
20317c478bd9Sstevel@tonic-gate 				if (stp->sd_flag & (STRDERR|STWRERR))
20327c478bd9Sstevel@tonic-gate 					flushed_already = FLUSHRW;
20337c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
20347c478bd9Sstevel@tonic-gate 				stp->sd_flag |= (STRDERR|STWRERR);
20357c478bd9Sstevel@tonic-gate 				stp->sd_rerror = *bp->b_rptr;
20367c478bd9Sstevel@tonic-gate 				stp->sd_werror = *bp->b_rptr;
20377c478bd9Sstevel@tonic-gate 				TRACE_2(TR_FAC_STREAMS_FR,
20387c478bd9Sstevel@tonic-gate 				    TR_STRRPUT_WAKE2,
20397c478bd9Sstevel@tonic-gate 				    "strrput wakeup #2:q %p, bp %p", q, bp);
20407c478bd9Sstevel@tonic-gate 				cv_broadcast(&q->q_wait); /* the readers */
20417c478bd9Sstevel@tonic-gate 				cv_broadcast(&_WR(q)->q_wait); /* the writers */
20427c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_monitor); /* ioctllers */
20437c478bd9Sstevel@tonic-gate 
20447c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
20457c478bd9Sstevel@tonic-gate 				pollwakeup(&stp->sd_pollist, POLLERR);
20467c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
20477c478bd9Sstevel@tonic-gate 
20487c478bd9Sstevel@tonic-gate 				if (stp->sd_sigflags & S_ERROR)
20497c478bd9Sstevel@tonic-gate 					strsendsig(stp->sd_siglist, S_ERROR, 0,
20507c478bd9Sstevel@tonic-gate 					    (stp->sd_werror ? stp->sd_werror :
20517c478bd9Sstevel@tonic-gate 					    stp->sd_rerror));
20527c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 				/*
20557c478bd9Sstevel@tonic-gate 				 * Send the M_FLUSH only
20567c478bd9Sstevel@tonic-gate 				 * for the first M_ERROR
20577c478bd9Sstevel@tonic-gate 				 * message on the stream
20587c478bd9Sstevel@tonic-gate 				 */
20597c478bd9Sstevel@tonic-gate 				if (flushed_already != FLUSHRW) {
20607c478bd9Sstevel@tonic-gate 					bp->b_datap->db_type = M_FLUSH;
20617c478bd9Sstevel@tonic-gate 					*bp->b_rptr = FLUSHRW;
20627c478bd9Sstevel@tonic-gate 					/*
20637c478bd9Sstevel@tonic-gate 					 * Protect against the driver passing up
20647c478bd9Sstevel@tonic-gate 					 * messages after it has done a
20657c478bd9Sstevel@tonic-gate 					 * qprocsoff.
20667c478bd9Sstevel@tonic-gate 					 */
20677c478bd9Sstevel@tonic-gate 				if (_OTHERQ(q)->q_next == NULL)
20687c478bd9Sstevel@tonic-gate 					freemsg(bp);
20697c478bd9Sstevel@tonic-gate 				else
20707c478bd9Sstevel@tonic-gate 					qreply(q, bp);
20717c478bd9Sstevel@tonic-gate 				return (0);
20727c478bd9Sstevel@tonic-gate 				}
20737c478bd9Sstevel@tonic-gate 		}
20747c478bd9Sstevel@tonic-gate 		freemsg(bp);
20757c478bd9Sstevel@tonic-gate 		return (0);
20767c478bd9Sstevel@tonic-gate 
20777c478bd9Sstevel@tonic-gate 	case M_HANGUP:
20787c478bd9Sstevel@tonic-gate 
20797c478bd9Sstevel@tonic-gate 		freemsg(bp);
20807c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
20817c478bd9Sstevel@tonic-gate 		stp->sd_werror = ENXIO;
20827c478bd9Sstevel@tonic-gate 		stp->sd_flag |= STRHUP;
20837c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~(WSLEEP|RSLEEP);
20847c478bd9Sstevel@tonic-gate 
20857c478bd9Sstevel@tonic-gate 		/*
20867c478bd9Sstevel@tonic-gate 		 * send signal if controlling tty
20877c478bd9Sstevel@tonic-gate 		 */
20887c478bd9Sstevel@tonic-gate 
20897c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp) {
20907c478bd9Sstevel@tonic-gate 			prsignal(stp->sd_sidp, SIGHUP);
20917c478bd9Sstevel@tonic-gate 			if (stp->sd_sidp != stp->sd_pgidp)
20927c478bd9Sstevel@tonic-gate 				pgsignal(stp->sd_pgidp, SIGTSTP);
20937c478bd9Sstevel@tonic-gate 		}
20947c478bd9Sstevel@tonic-gate 
20957c478bd9Sstevel@tonic-gate 		/*
20967c478bd9Sstevel@tonic-gate 		 * wake up read, write, and exception pollers and
20977c478bd9Sstevel@tonic-gate 		 * reset wakeup mechanism.
20987c478bd9Sstevel@tonic-gate 		 */
20997c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);	/* the readers */
21007c478bd9Sstevel@tonic-gate 		cv_broadcast(&_WR(q)->q_wait);	/* the writers */
21017c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);	/* the ioctllers */
21027c478bd9Sstevel@tonic-gate 		strhup(stp);
21039acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
21047c478bd9Sstevel@tonic-gate 		return (0);
21057c478bd9Sstevel@tonic-gate 
21067c478bd9Sstevel@tonic-gate 	case M_UNHANGUP:
21077c478bd9Sstevel@tonic-gate 		freemsg(bp);
21087c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
21097c478bd9Sstevel@tonic-gate 		stp->sd_werror = 0;
21107c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~STRHUP;
21117c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
21127c478bd9Sstevel@tonic-gate 		return (0);
21137c478bd9Sstevel@tonic-gate 
21147c478bd9Sstevel@tonic-gate 	case M_SIG:
21157c478bd9Sstevel@tonic-gate 		/*
21167c478bd9Sstevel@tonic-gate 		 * Someone downstream wants to post a signal.  The
21177c478bd9Sstevel@tonic-gate 		 * signal to post is contained in the first byte of the
21187c478bd9Sstevel@tonic-gate 		 * message.  If the message would go on the front of
21197c478bd9Sstevel@tonic-gate 		 * the queue, send a signal to the process group
21207c478bd9Sstevel@tonic-gate 		 * (if not SIGPOLL) or to the siglist processes
21217c478bd9Sstevel@tonic-gate 		 * (SIGPOLL).  If something is already on the queue,
21227c478bd9Sstevel@tonic-gate 		 * OR if we are delivering a delayed suspend (*sigh*
21237c478bd9Sstevel@tonic-gate 		 * another "tty" hack) and there's no one sleeping already,
21247c478bd9Sstevel@tonic-gate 		 * just enqueue the message.
21257c478bd9Sstevel@tonic-gate 		 */
21267c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
21277c478bd9Sstevel@tonic-gate 		if (q->q_first || (*bp->b_rptr == SIGTSTP &&
21287c478bd9Sstevel@tonic-gate 		    !(stp->sd_flag & RSLEEP))) {
21297c478bd9Sstevel@tonic-gate 			(void) putq(q, bp);
21307c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
21317c478bd9Sstevel@tonic-gate 			return (0);
21327c478bd9Sstevel@tonic-gate 		}
21337c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
21347c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
21357c478bd9Sstevel@tonic-gate 
21367c478bd9Sstevel@tonic-gate 	case M_PCSIG:
21377c478bd9Sstevel@tonic-gate 		/*
21387c478bd9Sstevel@tonic-gate 		 * Don't enqueue, just post the signal.
21397c478bd9Sstevel@tonic-gate 		 */
21407c478bd9Sstevel@tonic-gate 		strsignal(stp, *bp->b_rptr, 0L);
21417c478bd9Sstevel@tonic-gate 		freemsg(bp);
21427c478bd9Sstevel@tonic-gate 		return (0);
21437c478bd9Sstevel@tonic-gate 
2144ca9327a6Smeem 	case M_CMD:
2145ca9327a6Smeem 		if (MBLKL(bp) != sizeof (cmdblk_t)) {
2146ca9327a6Smeem 			freemsg(bp);
2147ca9327a6Smeem 			return (0);
2148ca9327a6Smeem 		}
2149ca9327a6Smeem 
2150ca9327a6Smeem 		mutex_enter(&stp->sd_lock);
2151ca9327a6Smeem 		if (stp->sd_flag & STRCMDWAIT) {
2152ca9327a6Smeem 			ASSERT(stp->sd_cmdblk == NULL);
2153ca9327a6Smeem 			stp->sd_cmdblk = bp;
2154ca9327a6Smeem 			cv_broadcast(&stp->sd_monitor);
2155ca9327a6Smeem 			mutex_exit(&stp->sd_lock);
2156ca9327a6Smeem 		} else {
2157ca9327a6Smeem 			mutex_exit(&stp->sd_lock);
2158ca9327a6Smeem 			freemsg(bp);
2159ca9327a6Smeem 		}
2160ca9327a6Smeem 		return (0);
2161ca9327a6Smeem 
21627c478bd9Sstevel@tonic-gate 	case M_FLUSH:
21637c478bd9Sstevel@tonic-gate 		/*
21647c478bd9Sstevel@tonic-gate 		 * Flush queues.  The indication of which queues to flush
21657c478bd9Sstevel@tonic-gate 		 * is in the first byte of the message.  If the read queue
21667c478bd9Sstevel@tonic-gate 		 * is specified, then flush it.  If FLUSHBAND is set, just
21677c478bd9Sstevel@tonic-gate 		 * flush the band specified by the second byte of the message.
21687c478bd9Sstevel@tonic-gate 		 *
21697c478bd9Sstevel@tonic-gate 		 * If a module has issued a M_SETOPT to not flush hi
21707c478bd9Sstevel@tonic-gate 		 * priority messages off of the stream head, then pass this
21717c478bd9Sstevel@tonic-gate 		 * flag into the flushq code to preserve such messages.
21727c478bd9Sstevel@tonic-gate 		 */
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 		if (*bp->b_rptr & FLUSHR) {
21757c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
21767c478bd9Sstevel@tonic-gate 			if (*bp->b_rptr & FLUSHBAND) {
21777c478bd9Sstevel@tonic-gate 				ASSERT((bp->b_wptr - bp->b_rptr) >= 2);
21787c478bd9Sstevel@tonic-gate 				flushband(q, *(bp->b_rptr + 1), FLUSHALL);
21797c478bd9Sstevel@tonic-gate 			} else
21807c478bd9Sstevel@tonic-gate 				flushq_common(q, FLUSHALL,
21817c478bd9Sstevel@tonic-gate 				    stp->sd_read_opt & RFLUSHPCPROT);
21827c478bd9Sstevel@tonic-gate 			if ((q->q_first == NULL) ||
21837c478bd9Sstevel@tonic-gate 			    (q->q_first->b_datap->db_type < QPCTL))
21847c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
21857c478bd9Sstevel@tonic-gate 			else {
21867c478bd9Sstevel@tonic-gate 				ASSERT(stp->sd_flag & STRPRI);
21877c478bd9Sstevel@tonic-gate 			}
21887c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
21897c478bd9Sstevel@tonic-gate 		}
21907c478bd9Sstevel@tonic-gate 		if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
21917c478bd9Sstevel@tonic-gate 			*bp->b_rptr &= ~FLUSHR;
21927c478bd9Sstevel@tonic-gate 			bp->b_flag |= MSGNOLOOP;
21937c478bd9Sstevel@tonic-gate 			/*
21947c478bd9Sstevel@tonic-gate 			 * Protect against the driver passing up
21957c478bd9Sstevel@tonic-gate 			 * messages after it has done a qprocsoff.
21967c478bd9Sstevel@tonic-gate 			 */
21977c478bd9Sstevel@tonic-gate 			if (_OTHERQ(q)->q_next == NULL)
21987c478bd9Sstevel@tonic-gate 				freemsg(bp);
21997c478bd9Sstevel@tonic-gate 			else
22007c478bd9Sstevel@tonic-gate 				qreply(q, bp);
22017c478bd9Sstevel@tonic-gate 			return (0);
22027c478bd9Sstevel@tonic-gate 		}
22037c478bd9Sstevel@tonic-gate 		freemsg(bp);
22047c478bd9Sstevel@tonic-gate 		return (0);
22057c478bd9Sstevel@tonic-gate 
22067c478bd9Sstevel@tonic-gate 	case M_IOCACK:
22077c478bd9Sstevel@tonic-gate 	case M_IOCNAK:
22087c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
22097c478bd9Sstevel@tonic-gate 		/*
22107c478bd9Sstevel@tonic-gate 		 * If not waiting for ACK or NAK then just free msg.
22117c478bd9Sstevel@tonic-gate 		 * If incorrect id sequence number then just free msg.
22127c478bd9Sstevel@tonic-gate 		 * If already have ACK or NAK for user then this is a
22137c478bd9Sstevel@tonic-gate 		 *    duplicate, display a warning and free the msg.
22147c478bd9Sstevel@tonic-gate 		 */
22157c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
22167c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
22177c478bd9Sstevel@tonic-gate 		    (stp->sd_iocid != iocbp->ioc_id)) {
22187c478bd9Sstevel@tonic-gate 			/*
22197c478bd9Sstevel@tonic-gate 			 * If the ACK/NAK is a dup, display a message
22207c478bd9Sstevel@tonic-gate 			 * Dup is when sd_iocid == ioc_id, and
22217c478bd9Sstevel@tonic-gate 			 * sd_iocblk == <valid ptr> or -1 (the former
22227c478bd9Sstevel@tonic-gate 			 * is when an ioctl has been put on the stream
22237c478bd9Sstevel@tonic-gate 			 * head, but has not yet been consumed, the
22247c478bd9Sstevel@tonic-gate 			 * later is when it has been consumed).
22257c478bd9Sstevel@tonic-gate 			 */
22267c478bd9Sstevel@tonic-gate 			if ((stp->sd_iocid == iocbp->ioc_id) &&
22277c478bd9Sstevel@tonic-gate 			    (stp->sd_iocblk != NULL)) {
22287c478bd9Sstevel@tonic-gate 				log_dupioc(q, bp);
22297c478bd9Sstevel@tonic-gate 			}
22307c478bd9Sstevel@tonic-gate 			freemsg(bp);
22317c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
22327c478bd9Sstevel@tonic-gate 			return (0);
22337c478bd9Sstevel@tonic-gate 		}
22347c478bd9Sstevel@tonic-gate 
22357c478bd9Sstevel@tonic-gate 		/*
22367c478bd9Sstevel@tonic-gate 		 * Assign ACK or NAK to user and wake up.
22377c478bd9Sstevel@tonic-gate 		 */
22387c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = bp;
22397c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
22407c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
22417c478bd9Sstevel@tonic-gate 		return (0);
22427c478bd9Sstevel@tonic-gate 
22437c478bd9Sstevel@tonic-gate 	case M_COPYIN:
22447c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
22457c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
22467c478bd9Sstevel@tonic-gate 
22477c478bd9Sstevel@tonic-gate 		/*
22487c478bd9Sstevel@tonic-gate 		 * If not waiting for ACK or NAK then just fail request.
22497c478bd9Sstevel@tonic-gate 		 * If already have ACK, NAK, or copy request, then just
22507c478bd9Sstevel@tonic-gate 		 * fail request.
22517c478bd9Sstevel@tonic-gate 		 * If incorrect id sequence number then just fail request.
22527c478bd9Sstevel@tonic-gate 		 */
22537c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
22547c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
22557c478bd9Sstevel@tonic-gate 		    (stp->sd_iocid != reqp->cq_id)) {
22567c478bd9Sstevel@tonic-gate 			if (bp->b_cont) {
22577c478bd9Sstevel@tonic-gate 				freemsg(bp->b_cont);
22587c478bd9Sstevel@tonic-gate 				bp->b_cont = NULL;
22597c478bd9Sstevel@tonic-gate 			}
22607c478bd9Sstevel@tonic-gate 			bp->b_datap->db_type = M_IOCDATA;
22617c478bd9Sstevel@tonic-gate 			bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
22627c478bd9Sstevel@tonic-gate 			resp = (struct copyresp *)bp->b_rptr;
22637c478bd9Sstevel@tonic-gate 			resp->cp_rval = (caddr_t)1;	/* failure */
22647c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
22657c478bd9Sstevel@tonic-gate 			putnext(stp->sd_wrq, bp);
22667c478bd9Sstevel@tonic-gate 			return (0);
22677c478bd9Sstevel@tonic-gate 		}
22687c478bd9Sstevel@tonic-gate 
22697c478bd9Sstevel@tonic-gate 		/*
22707c478bd9Sstevel@tonic-gate 		 * Assign copy request to user and wake up.
22717c478bd9Sstevel@tonic-gate 		 */
22727c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = bp;
22737c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_monitor);
22747c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
22757c478bd9Sstevel@tonic-gate 		return (0);
22767c478bd9Sstevel@tonic-gate 
22777c478bd9Sstevel@tonic-gate 	case M_SETOPTS:
22787c478bd9Sstevel@tonic-gate 		/*
22797c478bd9Sstevel@tonic-gate 		 * Set stream head options (read option, write offset,
22807c478bd9Sstevel@tonic-gate 		 * min/max packet size, and/or high/low water marks for
22817c478bd9Sstevel@tonic-gate 		 * the read side only).
22827c478bd9Sstevel@tonic-gate 		 */
22837c478bd9Sstevel@tonic-gate 
22847c478bd9Sstevel@tonic-gate 		bpri = 0;
22857c478bd9Sstevel@tonic-gate 		sop = (struct stroptions *)bp->b_rptr;
22867c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
22877c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_READOPT) {
22887c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RMODEMASK) {
22897c478bd9Sstevel@tonic-gate 			case RNORM:
22907c478bd9Sstevel@tonic-gate 				stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
22917c478bd9Sstevel@tonic-gate 				break;
22927c478bd9Sstevel@tonic-gate 
22937c478bd9Sstevel@tonic-gate 			case RMSGD:
22947c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
22957c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_MSGNODIS) |
22967c478bd9Sstevel@tonic-gate 				    RD_MSGDIS);
22977c478bd9Sstevel@tonic-gate 				break;
22987c478bd9Sstevel@tonic-gate 
22997c478bd9Sstevel@tonic-gate 			case RMSGN:
23007c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
23017c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_MSGDIS) |
23027c478bd9Sstevel@tonic-gate 				    RD_MSGNODIS);
23037c478bd9Sstevel@tonic-gate 				break;
23047c478bd9Sstevel@tonic-gate 			}
23057c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RPROTMASK) {
23067c478bd9Sstevel@tonic-gate 			case RPROTNORM:
23077c478bd9Sstevel@tonic-gate 				stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
23087c478bd9Sstevel@tonic-gate 				break;
23097c478bd9Sstevel@tonic-gate 
23107c478bd9Sstevel@tonic-gate 			case RPROTDAT:
23117c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
23127c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_PROTDIS) |
23137c478bd9Sstevel@tonic-gate 				    RD_PROTDAT);
23147c478bd9Sstevel@tonic-gate 				break;
23157c478bd9Sstevel@tonic-gate 
23167c478bd9Sstevel@tonic-gate 			case RPROTDIS:
23177c478bd9Sstevel@tonic-gate 				stp->sd_read_opt =
23187c478bd9Sstevel@tonic-gate 				    ((stp->sd_read_opt & ~RD_PROTDAT) |
23197c478bd9Sstevel@tonic-gate 				    RD_PROTDIS);
23207c478bd9Sstevel@tonic-gate 				break;
23217c478bd9Sstevel@tonic-gate 			}
23227c478bd9Sstevel@tonic-gate 			switch (sop->so_readopt & RFLUSHMASK) {
23237c478bd9Sstevel@tonic-gate 			case RFLUSHPCPROT:
23247c478bd9Sstevel@tonic-gate 				/*
23257c478bd9Sstevel@tonic-gate 				 * This sets the stream head to NOT flush
23267c478bd9Sstevel@tonic-gate 				 * M_PCPROTO messages.
23277c478bd9Sstevel@tonic-gate 				 */
23287c478bd9Sstevel@tonic-gate 				stp->sd_read_opt |= RFLUSHPCPROT;
23297c478bd9Sstevel@tonic-gate 				break;
23307c478bd9Sstevel@tonic-gate 			}
23317c478bd9Sstevel@tonic-gate 		}
23327c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ERROPT) {
23337c478bd9Sstevel@tonic-gate 			switch (sop->so_erropt & RERRMASK) {
23347c478bd9Sstevel@tonic-gate 			case RERRNORM:
23357c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRDERRNONPERSIST;
23367c478bd9Sstevel@tonic-gate 				break;
23377c478bd9Sstevel@tonic-gate 			case RERRNONPERSIST:
23387c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRDERRNONPERSIST;
23397c478bd9Sstevel@tonic-gate 				break;
23407c478bd9Sstevel@tonic-gate 			}
23417c478bd9Sstevel@tonic-gate 			switch (sop->so_erropt & WERRMASK) {
23427c478bd9Sstevel@tonic-gate 			case WERRNORM:
23437c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STWRERRNONPERSIST;
23447c478bd9Sstevel@tonic-gate 				break;
23457c478bd9Sstevel@tonic-gate 			case WERRNONPERSIST:
23467c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STWRERRNONPERSIST;
23477c478bd9Sstevel@tonic-gate 				break;
23487c478bd9Sstevel@tonic-gate 			}
23497c478bd9Sstevel@tonic-gate 		}
23507c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_COPYOPT) {
23517c478bd9Sstevel@tonic-gate 			if (sop->so_copyopt & ZCVMSAFE) {
23527c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STZCVMSAFE;
23537c478bd9Sstevel@tonic-gate 				stp->sd_copyflag &= ~STZCVMUNSAFE;
23547c478bd9Sstevel@tonic-gate 			} else if (sop->so_copyopt & ZCVMUNSAFE) {
23557c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STZCVMUNSAFE;
23567c478bd9Sstevel@tonic-gate 				stp->sd_copyflag &= ~STZCVMSAFE;
23577c478bd9Sstevel@tonic-gate 			}
23587c478bd9Sstevel@tonic-gate 
23597c478bd9Sstevel@tonic-gate 			if (sop->so_copyopt & COPYCACHED) {
23607c478bd9Sstevel@tonic-gate 				stp->sd_copyflag |= STRCOPYCACHED;
23617c478bd9Sstevel@tonic-gate 			}
23627c478bd9Sstevel@tonic-gate 		}
23637c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_WROFF)
23647c478bd9Sstevel@tonic-gate 			stp->sd_wroff = sop->so_wroff;
2365c28749e9Skais 		if (sop->so_flags & SO_TAIL)
2366c28749e9Skais 			stp->sd_tail = sop->so_tail;
23677c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MINPSZ)
23687c478bd9Sstevel@tonic-gate 			q->q_minpsz = sop->so_minpsz;
23697c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MAXPSZ)
23707c478bd9Sstevel@tonic-gate 			q->q_maxpsz = sop->so_maxpsz;
23717c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MAXBLK)
23727c478bd9Sstevel@tonic-gate 			stp->sd_maxblk = sop->so_maxblk;
23737c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_HIWAT) {
23747c478bd9Sstevel@tonic-gate 			if (sop->so_flags & SO_BAND) {
2375d3e55dcdSgww 				if (strqset(q, QHIWAT,
2376d3e55dcdSgww 				    sop->so_band, sop->so_hiwat)) {
2377d3e55dcdSgww 					cmn_err(CE_WARN, "strrput: could not "
2378d3e55dcdSgww 					    "allocate qband\n");
2379d3e55dcdSgww 				} else {
23807c478bd9Sstevel@tonic-gate 					bpri = sop->so_band;
2381d3e55dcdSgww 				}
23827c478bd9Sstevel@tonic-gate 			} else {
23837c478bd9Sstevel@tonic-gate 				q->q_hiwat = sop->so_hiwat;
23847c478bd9Sstevel@tonic-gate 			}
23857c478bd9Sstevel@tonic-gate 		}
23867c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_LOWAT) {
23877c478bd9Sstevel@tonic-gate 			if (sop->so_flags & SO_BAND) {
2388d3e55dcdSgww 				if (strqset(q, QLOWAT,
2389d3e55dcdSgww 				    sop->so_band, sop->so_lowat)) {
2390d3e55dcdSgww 					cmn_err(CE_WARN, "strrput: could not "
2391d3e55dcdSgww 					    "allocate qband\n");
2392d3e55dcdSgww 				} else {
23937c478bd9Sstevel@tonic-gate 					bpri = sop->so_band;
2394d3e55dcdSgww 				}
23957c478bd9Sstevel@tonic-gate 			} else {
23967c478bd9Sstevel@tonic-gate 				q->q_lowat = sop->so_lowat;
23977c478bd9Sstevel@tonic-gate 			}
23987c478bd9Sstevel@tonic-gate 		}
23997c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MREADON)
24007c478bd9Sstevel@tonic-gate 			stp->sd_flag |= SNDMREAD;
24017c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_MREADOFF)
24027c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~SNDMREAD;
24037c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NDELON)
24047c478bd9Sstevel@tonic-gate 			stp->sd_flag |= OLDNDELAY;
24057c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NDELOFF)
24067c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~OLDNDELAY;
24077c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ISTTY)
24087c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRISTTY;
24097c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_ISNTTY)
24107c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRISTTY;
24117c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_TOSTOP)
24127c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRTOSTOP;
24137c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_TONSTOP)
24147c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRTOSTOP;
24157c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_DELIM)
24167c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRDELIM;
24177c478bd9Sstevel@tonic-gate 		if (sop->so_flags & SO_NODELIM)
24187c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRDELIM;
24197c478bd9Sstevel@tonic-gate 
24207c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
24217c478bd9Sstevel@tonic-gate 		freemsg(bp);
24227c478bd9Sstevel@tonic-gate 
24237c478bd9Sstevel@tonic-gate 		/* Check backenable in case the water marks changed */
24247c478bd9Sstevel@tonic-gate 		qbackenable(q, bpri);
24257c478bd9Sstevel@tonic-gate 		return (0);
24267c478bd9Sstevel@tonic-gate 
24277c478bd9Sstevel@tonic-gate 	/*
24287c478bd9Sstevel@tonic-gate 	 * The following set of cases deal with situations where two stream
24297c478bd9Sstevel@tonic-gate 	 * heads are connected to each other (twisted streams).  These messages
24307c478bd9Sstevel@tonic-gate 	 * have no meaning at the stream head.
24317c478bd9Sstevel@tonic-gate 	 */
24327c478bd9Sstevel@tonic-gate 	case M_BREAK:
24337c478bd9Sstevel@tonic-gate 	case M_CTL:
24347c478bd9Sstevel@tonic-gate 	case M_DELAY:
24357c478bd9Sstevel@tonic-gate 	case M_START:
24367c478bd9Sstevel@tonic-gate 	case M_STOP:
24377c478bd9Sstevel@tonic-gate 	case M_IOCDATA:
24387c478bd9Sstevel@tonic-gate 	case M_STARTI:
24397c478bd9Sstevel@tonic-gate 	case M_STOPI:
24407c478bd9Sstevel@tonic-gate 		freemsg(bp);
24417c478bd9Sstevel@tonic-gate 		return (0);
24427c478bd9Sstevel@tonic-gate 
24437c478bd9Sstevel@tonic-gate 	case M_IOCTL:
24447c478bd9Sstevel@tonic-gate 		/*
24457c478bd9Sstevel@tonic-gate 		 * Always NAK this condition
24467c478bd9Sstevel@tonic-gate 		 * (makes no sense)
24477c478bd9Sstevel@tonic-gate 		 * If there is one or more threads in the read side
24487c478bd9Sstevel@tonic-gate 		 * rwnext we have to defer the nacking until that thread
24497c478bd9Sstevel@tonic-gate 		 * returns (in strget).
24507c478bd9Sstevel@tonic-gate 		 */
24517c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
24527c478bd9Sstevel@tonic-gate 		if (stp->sd_struiodnak != 0) {
24537c478bd9Sstevel@tonic-gate 			/*
24547c478bd9Sstevel@tonic-gate 			 * Defer NAK to the streamhead. Queue at the end
24557c478bd9Sstevel@tonic-gate 			 * the list.
24567c478bd9Sstevel@tonic-gate 			 */
24577c478bd9Sstevel@tonic-gate 			mblk_t *mp = stp->sd_struionak;
24587c478bd9Sstevel@tonic-gate 
24597c478bd9Sstevel@tonic-gate 			while (mp && mp->b_next)
24607c478bd9Sstevel@tonic-gate 				mp = mp->b_next;
24617c478bd9Sstevel@tonic-gate 			if (mp)
24627c478bd9Sstevel@tonic-gate 				mp->b_next = bp;
24637c478bd9Sstevel@tonic-gate 			else
24647c478bd9Sstevel@tonic-gate 				stp->sd_struionak = bp;
24657c478bd9Sstevel@tonic-gate 			bp->b_next = NULL;
24667c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
24677c478bd9Sstevel@tonic-gate 			return (0);
24687c478bd9Sstevel@tonic-gate 		}
24697c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
24707c478bd9Sstevel@tonic-gate 
24717c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCNAK;
24727c478bd9Sstevel@tonic-gate 		/*
24737c478bd9Sstevel@tonic-gate 		 * Protect against the driver passing up
24747c478bd9Sstevel@tonic-gate 		 * messages after it has done a qprocsoff.
24757c478bd9Sstevel@tonic-gate 		 */
24767c478bd9Sstevel@tonic-gate 		if (_OTHERQ(q)->q_next == NULL)
24777c478bd9Sstevel@tonic-gate 			freemsg(bp);
24787c478bd9Sstevel@tonic-gate 		else
24797c478bd9Sstevel@tonic-gate 			qreply(q, bp);
24807c478bd9Sstevel@tonic-gate 		return (0);
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 	default:
24837c478bd9Sstevel@tonic-gate #ifdef DEBUG
24847c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN,
24857c478bd9Sstevel@tonic-gate 		    "bad message type %x received at stream head\n",
24867c478bd9Sstevel@tonic-gate 		    bp->b_datap->db_type);
24877c478bd9Sstevel@tonic-gate #endif
24887c478bd9Sstevel@tonic-gate 		freemsg(bp);
24897c478bd9Sstevel@tonic-gate 		return (0);
24907c478bd9Sstevel@tonic-gate 	}
24917c478bd9Sstevel@tonic-gate 
24927c478bd9Sstevel@tonic-gate 	/* NOTREACHED */
24937c478bd9Sstevel@tonic-gate }
24947c478bd9Sstevel@tonic-gate 
24957c478bd9Sstevel@tonic-gate /*
24967c478bd9Sstevel@tonic-gate  * Check if the stream pointed to by `stp' can be written to, and return an
24977c478bd9Sstevel@tonic-gate  * error code if not.  If `eiohup' is set, then return EIO if STRHUP is set.
24987c478bd9Sstevel@tonic-gate  * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream,
24997c478bd9Sstevel@tonic-gate  * then always return EPIPE and send a SIGPIPE to the invoking thread.
25007c478bd9Sstevel@tonic-gate  */
25017c478bd9Sstevel@tonic-gate static int
25027c478bd9Sstevel@tonic-gate strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok)
25037c478bd9Sstevel@tonic-gate {
25047c478bd9Sstevel@tonic-gate 	int error;
25057c478bd9Sstevel@tonic-gate 
25067c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 	/*
25097c478bd9Sstevel@tonic-gate 	 * For modem support, POSIX states that on writes, EIO should
25107c478bd9Sstevel@tonic-gate 	 * be returned if the stream has been hung up.
25117c478bd9Sstevel@tonic-gate 	 */
25127c478bd9Sstevel@tonic-gate 	if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP)
25137c478bd9Sstevel@tonic-gate 		error = EIO;
25147c478bd9Sstevel@tonic-gate 	else
25157c478bd9Sstevel@tonic-gate 		error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0);
25167c478bd9Sstevel@tonic-gate 
25177c478bd9Sstevel@tonic-gate 	if (error != 0) {
25187c478bd9Sstevel@tonic-gate 		if (!(stp->sd_flag & STPLEX) &&
25197c478bd9Sstevel@tonic-gate 		    (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) {
25207c478bd9Sstevel@tonic-gate 			tsignal(curthread, SIGPIPE);
25217c478bd9Sstevel@tonic-gate 			error = EPIPE;
25227c478bd9Sstevel@tonic-gate 		}
25237c478bd9Sstevel@tonic-gate 	}
25247c478bd9Sstevel@tonic-gate 
25257c478bd9Sstevel@tonic-gate 	return (error);
25267c478bd9Sstevel@tonic-gate }
25277c478bd9Sstevel@tonic-gate 
25287c478bd9Sstevel@tonic-gate /*
25297c478bd9Sstevel@tonic-gate  * Copyin and send data down a stream.
25307c478bd9Sstevel@tonic-gate  * The caller will allocate and copyin any control part that precedes the
2531de8c4a14SErik Nordmark  * message and pass that in as mctl.
25327c478bd9Sstevel@tonic-gate  *
25337c478bd9Sstevel@tonic-gate  * Caller should *not* hold sd_lock.
25347c478bd9Sstevel@tonic-gate  * When EWOULDBLOCK is returned the caller has to redo the canputnext
25357c478bd9Sstevel@tonic-gate  * under sd_lock in order to avoid missing a backenabling wakeup.
25367c478bd9Sstevel@tonic-gate  *
25377c478bd9Sstevel@tonic-gate  * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA.
25387c478bd9Sstevel@tonic-gate  *
25397c478bd9Sstevel@tonic-gate  * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages.
25407c478bd9Sstevel@tonic-gate  * For sync streams we can only ignore flow control by reverting to using
25417c478bd9Sstevel@tonic-gate  * putnext.
25427c478bd9Sstevel@tonic-gate  *
25437c478bd9Sstevel@tonic-gate  * If sd_maxblk is less than *iosize this routine might return without
25447c478bd9Sstevel@tonic-gate  * transferring all of *iosize. In all cases, on return *iosize will contain
25457c478bd9Sstevel@tonic-gate  * the amount of data that was transferred.
25467c478bd9Sstevel@tonic-gate  */
25477c478bd9Sstevel@tonic-gate static int
25487c478bd9Sstevel@tonic-gate strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize,
25497c478bd9Sstevel@tonic-gate     int b_flag, int pri, int flags)
25507c478bd9Sstevel@tonic-gate {
25517c478bd9Sstevel@tonic-gate 	struiod_t uiod;
25527c478bd9Sstevel@tonic-gate 	mblk_t *mp;
25537c478bd9Sstevel@tonic-gate 	queue_t *wqp = stp->sd_wrq;
25547c478bd9Sstevel@tonic-gate 	int error = 0;
25557c478bd9Sstevel@tonic-gate 	ssize_t count = *iosize;
25567c478bd9Sstevel@tonic-gate 
25577c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 	if (uiop != NULL && count >= 0)
25607c478bd9Sstevel@tonic-gate 		flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0;
25617c478bd9Sstevel@tonic-gate 
25627c478bd9Sstevel@tonic-gate 	if (!(flags & STRUIO_POSTPONE)) {
25637c478bd9Sstevel@tonic-gate 		/*
25647c478bd9Sstevel@tonic-gate 		 * Use regular canputnext, strmakedata, putnext sequence.
25657c478bd9Sstevel@tonic-gate 		 */
25667c478bd9Sstevel@tonic-gate 		if (pri == 0) {
25677c478bd9Sstevel@tonic-gate 			if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
25687c478bd9Sstevel@tonic-gate 				freemsg(mctl);
25697c478bd9Sstevel@tonic-gate 				return (EWOULDBLOCK);
25707c478bd9Sstevel@tonic-gate 			}
25717c478bd9Sstevel@tonic-gate 		} else {
25727c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) {
25737c478bd9Sstevel@tonic-gate 				freemsg(mctl);
25747c478bd9Sstevel@tonic-gate 				return (EWOULDBLOCK);
25757c478bd9Sstevel@tonic-gate 			}
25767c478bd9Sstevel@tonic-gate 		}
25777c478bd9Sstevel@tonic-gate 
25787c478bd9Sstevel@tonic-gate 		if ((error = strmakedata(iosize, uiop, stp, flags,
25797c478bd9Sstevel@tonic-gate 		    &mp)) != 0) {
25807c478bd9Sstevel@tonic-gate 			freemsg(mctl);
25817c478bd9Sstevel@tonic-gate 			/*
25827c478bd9Sstevel@tonic-gate 			 * need to change return code to ENOMEM
25837c478bd9Sstevel@tonic-gate 			 * so that this is not confused with
25847c478bd9Sstevel@tonic-gate 			 * flow control, EAGAIN.
25857c478bd9Sstevel@tonic-gate 			 */
25867c478bd9Sstevel@tonic-gate 
25877c478bd9Sstevel@tonic-gate 			if (error == EAGAIN)
25887c478bd9Sstevel@tonic-gate 				return (ENOMEM);
25897c478bd9Sstevel@tonic-gate 			else
25907c478bd9Sstevel@tonic-gate 				return (error);
25917c478bd9Sstevel@tonic-gate 		}
25927c478bd9Sstevel@tonic-gate 		if (mctl != NULL) {
25937c478bd9Sstevel@tonic-gate 			if (mctl->b_cont == NULL)
25947c478bd9Sstevel@tonic-gate 				mctl->b_cont = mp;
25957c478bd9Sstevel@tonic-gate 			else if (mp != NULL)
25967c478bd9Sstevel@tonic-gate 				linkb(mctl, mp);
25977c478bd9Sstevel@tonic-gate 			mp = mctl;
25987c478bd9Sstevel@tonic-gate 		} else if (mp == NULL)
25997c478bd9Sstevel@tonic-gate 			return (0);
26007c478bd9Sstevel@tonic-gate 
26017c478bd9Sstevel@tonic-gate 		mp->b_flag |= b_flag;
26027c478bd9Sstevel@tonic-gate 		mp->b_band = (uchar_t)pri;
26037c478bd9Sstevel@tonic-gate 
26047c478bd9Sstevel@tonic-gate 		if (flags & MSG_IGNFLOW) {
26057c478bd9Sstevel@tonic-gate 			/*
26067c478bd9Sstevel@tonic-gate 			 * XXX Hack: Don't get stuck running service
26077c478bd9Sstevel@tonic-gate 			 * procedures. This is needed for sockfs when
26087c478bd9Sstevel@tonic-gate 			 * sending the unbind message out of the rput
26097c478bd9Sstevel@tonic-gate 			 * procedure - we don't want a put procedure
26107c478bd9Sstevel@tonic-gate 			 * to run service procedures.
26117c478bd9Sstevel@tonic-gate 			 */
26127c478bd9Sstevel@tonic-gate 			putnext(wqp, mp);
26137c478bd9Sstevel@tonic-gate 		} else {
26147c478bd9Sstevel@tonic-gate 			stream_willservice(stp);
26157c478bd9Sstevel@tonic-gate 			putnext(wqp, mp);
26167c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
26177c478bd9Sstevel@tonic-gate 		}
26187c478bd9Sstevel@tonic-gate 		return (0);
26197c478bd9Sstevel@tonic-gate 	}
26207c478bd9Sstevel@tonic-gate 	/*
26217c478bd9Sstevel@tonic-gate 	 * Stream supports rwnext() for the write side.
26227c478bd9Sstevel@tonic-gate 	 */
26237c478bd9Sstevel@tonic-gate 	if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) {
26247c478bd9Sstevel@tonic-gate 		freemsg(mctl);
26257c478bd9Sstevel@tonic-gate 		/*
26267c478bd9Sstevel@tonic-gate 		 * map EAGAIN to ENOMEM since EAGAIN means "flow controlled".
26277c478bd9Sstevel@tonic-gate 		 */
26287c478bd9Sstevel@tonic-gate 		return (error == EAGAIN ? ENOMEM : error);
26297c478bd9Sstevel@tonic-gate 	}
26307c478bd9Sstevel@tonic-gate 	if (mctl != NULL) {
26317c478bd9Sstevel@tonic-gate 		if (mctl->b_cont == NULL)
26327c478bd9Sstevel@tonic-gate 			mctl->b_cont = mp;
26337c478bd9Sstevel@tonic-gate 		else if (mp != NULL)
26347c478bd9Sstevel@tonic-gate 			linkb(mctl, mp);
26357c478bd9Sstevel@tonic-gate 		mp = mctl;
26367c478bd9Sstevel@tonic-gate 	} else if (mp == NULL) {
26377c478bd9Sstevel@tonic-gate 		return (0);
26387c478bd9Sstevel@tonic-gate 	}
26397c478bd9Sstevel@tonic-gate 
26407c478bd9Sstevel@tonic-gate 	mp->b_flag |= b_flag;
26417c478bd9Sstevel@tonic-gate 	mp->b_band = (uchar_t)pri;
26427c478bd9Sstevel@tonic-gate 
26437c478bd9Sstevel@tonic-gate 	(void) uiodup(uiop, &uiod.d_uio, uiod.d_iov,
26447c478bd9Sstevel@tonic-gate 	    sizeof (uiod.d_iov) / sizeof (*uiod.d_iov));
26457c478bd9Sstevel@tonic-gate 	uiod.d_uio.uio_offset = 0;
26467c478bd9Sstevel@tonic-gate 	uiod.d_mp = mp;
26477c478bd9Sstevel@tonic-gate 	error = rwnext(wqp, &uiod);
26487c478bd9Sstevel@tonic-gate 	if (! uiod.d_mp) {
26497c478bd9Sstevel@tonic-gate 		uioskip(uiop, *iosize);
26507c478bd9Sstevel@tonic-gate 		return (error);
26517c478bd9Sstevel@tonic-gate 	}
26527c478bd9Sstevel@tonic-gate 	ASSERT(mp == uiod.d_mp);
26537c478bd9Sstevel@tonic-gate 	if (error == EINVAL) {
26547c478bd9Sstevel@tonic-gate 		/*
26557c478bd9Sstevel@tonic-gate 		 * The stream plumbing must have changed while
26567c478bd9Sstevel@tonic-gate 		 * we were away, so just turn off rwnext()s.
26577c478bd9Sstevel@tonic-gate 		 */
26587c478bd9Sstevel@tonic-gate 		error = 0;
26597c478bd9Sstevel@tonic-gate 	} else if (error == EBUSY || error == EWOULDBLOCK) {
26607c478bd9Sstevel@tonic-gate 		/*
26617c478bd9Sstevel@tonic-gate 		 * Couldn't enter a perimeter or took a page fault,
26627c478bd9Sstevel@tonic-gate 		 * so fall-back to putnext().
26637c478bd9Sstevel@tonic-gate 		 */
26647c478bd9Sstevel@tonic-gate 		error = 0;
26657c478bd9Sstevel@tonic-gate 	} else {
26667c478bd9Sstevel@tonic-gate 		freemsg(mp);
26677c478bd9Sstevel@tonic-gate 		return (error);
26687c478bd9Sstevel@tonic-gate 	}
26697c478bd9Sstevel@tonic-gate 	/* Have to check canput before consuming data from the uio */
26707c478bd9Sstevel@tonic-gate 	if (pri == 0) {
26717c478bd9Sstevel@tonic-gate 		if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
26727c478bd9Sstevel@tonic-gate 			freemsg(mp);
26737c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
26747c478bd9Sstevel@tonic-gate 		}
26757c478bd9Sstevel@tonic-gate 	} else {
26767c478bd9Sstevel@tonic-gate 		if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) {
26777c478bd9Sstevel@tonic-gate 			freemsg(mp);
26787c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
26797c478bd9Sstevel@tonic-gate 		}
26807c478bd9Sstevel@tonic-gate 	}
26817c478bd9Sstevel@tonic-gate 	ASSERT(mp == uiod.d_mp);
26827c478bd9Sstevel@tonic-gate 	/* Copyin data from the uio */
26837c478bd9Sstevel@tonic-gate 	if ((error = struioget(wqp, mp, &uiod, 0)) != 0) {
26847c478bd9Sstevel@tonic-gate 		freemsg(mp);
26857c478bd9Sstevel@tonic-gate 		return (error);
26867c478bd9Sstevel@tonic-gate 	}
26877c478bd9Sstevel@tonic-gate 	uioskip(uiop, *iosize);
26887c478bd9Sstevel@tonic-gate 	if (flags & MSG_IGNFLOW) {
26897c478bd9Sstevel@tonic-gate 		/*
26907c478bd9Sstevel@tonic-gate 		 * XXX Hack: Don't get stuck running service procedures.
26917c478bd9Sstevel@tonic-gate 		 * This is needed for sockfs when sending the unbind message
26927c478bd9Sstevel@tonic-gate 		 * out of the rput procedure - we don't want a put procedure
26937c478bd9Sstevel@tonic-gate 		 * to run service procedures.
26947c478bd9Sstevel@tonic-gate 		 */
26957c478bd9Sstevel@tonic-gate 		putnext(wqp, mp);
26967c478bd9Sstevel@tonic-gate 	} else {
26977c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
26987c478bd9Sstevel@tonic-gate 		putnext(wqp, mp);
26997c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
27007c478bd9Sstevel@tonic-gate 	}
27017c478bd9Sstevel@tonic-gate 	return (0);
27027c478bd9Sstevel@tonic-gate }
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate /*
27057c478bd9Sstevel@tonic-gate  * Write attempts to break the write request into messages conforming
27067c478bd9Sstevel@tonic-gate  * with the minimum and maximum packet sizes set downstream.
27077c478bd9Sstevel@tonic-gate  *
27087c478bd9Sstevel@tonic-gate  * Write will not block if downstream queue is full and
27097c478bd9Sstevel@tonic-gate  * O_NDELAY is set, otherwise it will block waiting for the queue to get room.
27107c478bd9Sstevel@tonic-gate  *
27117c478bd9Sstevel@tonic-gate  * A write of zero bytes gets packaged into a zero length message and sent
27127c478bd9Sstevel@tonic-gate  * downstream like any other message.
27137c478bd9Sstevel@tonic-gate  *
27147c478bd9Sstevel@tonic-gate  * If buffers of the requested sizes are not available, the write will
27157c478bd9Sstevel@tonic-gate  * sleep until the buffers become available.
27167c478bd9Sstevel@tonic-gate  *
27177c478bd9Sstevel@tonic-gate  * Write (if specified) will supply a write offset in a message if it
27187c478bd9Sstevel@tonic-gate  * makes sense. This can be specified by downstream modules as part of
27197c478bd9Sstevel@tonic-gate  * a M_SETOPTS message.  Write will not supply the write offset if it
27207c478bd9Sstevel@tonic-gate  * cannot supply any data in a buffer.  In other words, write will never
27217c478bd9Sstevel@tonic-gate  * send down an empty packet due to a write offset.
27227c478bd9Sstevel@tonic-gate  */
27237c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
27247c478bd9Sstevel@tonic-gate int
27257c478bd9Sstevel@tonic-gate strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
27267c478bd9Sstevel@tonic-gate {
2727ff550d0eSmasputra 	return (strwrite_common(vp, uiop, crp, 0));
2728ff550d0eSmasputra }
2729ff550d0eSmasputra 
2730ff550d0eSmasputra /* ARGSUSED2 */
2731ff550d0eSmasputra int
2732ff550d0eSmasputra strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag)
2733ff550d0eSmasputra {
27347c478bd9Sstevel@tonic-gate 	struct stdata *stp;
27357c478bd9Sstevel@tonic-gate 	struct queue *wqp;
27367c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
27377c478bd9Sstevel@tonic-gate 	ssize_t iosize;
2738ff550d0eSmasputra 	int waitflag;
27397c478bd9Sstevel@tonic-gate 	int tempmode;
27407c478bd9Sstevel@tonic-gate 	int error = 0;
27417c478bd9Sstevel@tonic-gate 	int b_flag;
27427c478bd9Sstevel@tonic-gate 
27437c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
27447c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
27457c478bd9Sstevel@tonic-gate 
27467c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
27479acbbeafSnn35248 
27489acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
27497c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
27507c478bd9Sstevel@tonic-gate 		return (error);
27517c478bd9Sstevel@tonic-gate 	}
27527c478bd9Sstevel@tonic-gate 
27539acbbeafSnn35248 	if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
27549acbbeafSnn35248 		error = strwriteable(stp, B_TRUE, B_TRUE);
27559acbbeafSnn35248 		if (error != 0) {
27569acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
27579acbbeafSnn35248 			return (error);
27589acbbeafSnn35248 		}
27599acbbeafSnn35248 	}
27609acbbeafSnn35248 
27619acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
27629acbbeafSnn35248 
27637c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
27647c478bd9Sstevel@tonic-gate 
27657c478bd9Sstevel@tonic-gate 	/* get these values from them cached in the stream head */
27667c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
27677c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
27687c478bd9Sstevel@tonic-gate 
27697c478bd9Sstevel@tonic-gate 	/*
27707c478bd9Sstevel@tonic-gate 	 * Check the min/max packet size constraints.  If min packet size
27717c478bd9Sstevel@tonic-gate 	 * is non-zero, the write cannot be split into multiple messages
27727c478bd9Sstevel@tonic-gate 	 * and still guarantee the size constraints.
27737c478bd9Sstevel@tonic-gate 	 */
27747c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp);
27757c478bd9Sstevel@tonic-gate 
27767c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
27777c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
27787c478bd9Sstevel@tonic-gate 		return (0);
27797c478bd9Sstevel@tonic-gate 	}
27807c478bd9Sstevel@tonic-gate 	if (rmin > 0) {
27817c478bd9Sstevel@tonic-gate 		if (uiop->uio_resid < rmin) {
27827c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
27837c478bd9Sstevel@tonic-gate 			    "strwrite out:q %p out %d error %d",
27847c478bd9Sstevel@tonic-gate 			    wqp, 0, ERANGE);
27857c478bd9Sstevel@tonic-gate 			return (ERANGE);
27867c478bd9Sstevel@tonic-gate 		}
27877c478bd9Sstevel@tonic-gate 		if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) {
27887c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
27897c478bd9Sstevel@tonic-gate 			    "strwrite out:q %p out %d error %d",
27907c478bd9Sstevel@tonic-gate 			    wqp, 1, ERANGE);
27917c478bd9Sstevel@tonic-gate 			return (ERANGE);
27927c478bd9Sstevel@tonic-gate 		}
27937c478bd9Sstevel@tonic-gate 	}
27947c478bd9Sstevel@tonic-gate 
27957c478bd9Sstevel@tonic-gate 	/*
27967c478bd9Sstevel@tonic-gate 	 * Do until count satisfied or error.
27977c478bd9Sstevel@tonic-gate 	 */
2798ff550d0eSmasputra 	waitflag = WRITEWAIT | wflag;
27997c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & OLDNDELAY)
28007c478bd9Sstevel@tonic-gate 		tempmode = uiop->uio_fmode & ~FNDELAY;
28017c478bd9Sstevel@tonic-gate 	else
28027c478bd9Sstevel@tonic-gate 		tempmode = uiop->uio_fmode;
28037c478bd9Sstevel@tonic-gate 
28047c478bd9Sstevel@tonic-gate 	if (rmax == INFPSZ)
28057c478bd9Sstevel@tonic-gate 		rmax = uiop->uio_resid;
28067c478bd9Sstevel@tonic-gate 
28077c478bd9Sstevel@tonic-gate 	/*
28087c478bd9Sstevel@tonic-gate 	 * Note that tempmode does not get used in strput/strmakedata
28097c478bd9Sstevel@tonic-gate 	 * but only in strwaitq. The other routines use uio_fmode
28107c478bd9Sstevel@tonic-gate 	 * unmodified.
28117c478bd9Sstevel@tonic-gate 	 */
28127c478bd9Sstevel@tonic-gate 
28137c478bd9Sstevel@tonic-gate 	/* LINTED: constant in conditional context */
28147c478bd9Sstevel@tonic-gate 	while (1) {	/* breaks when uio_resid reaches zero */
28157c478bd9Sstevel@tonic-gate 		/*
28167c478bd9Sstevel@tonic-gate 		 * Determine the size of the next message to be
28177c478bd9Sstevel@tonic-gate 		 * packaged.  May have to break write into several
28187c478bd9Sstevel@tonic-gate 		 * messages based on max packet size.
28197c478bd9Sstevel@tonic-gate 		 */
28207c478bd9Sstevel@tonic-gate 		iosize = MIN(uiop->uio_resid, rmax);
28217c478bd9Sstevel@tonic-gate 
28227c478bd9Sstevel@tonic-gate 		/*
28237c478bd9Sstevel@tonic-gate 		 * Put block downstream when flow control allows it.
28247c478bd9Sstevel@tonic-gate 		 */
28257c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize))
28267c478bd9Sstevel@tonic-gate 			b_flag = MSGDELIM;
28277c478bd9Sstevel@tonic-gate 		else
28287c478bd9Sstevel@tonic-gate 			b_flag = 0;
28297c478bd9Sstevel@tonic-gate 
28307c478bd9Sstevel@tonic-gate 		for (;;) {
28317c478bd9Sstevel@tonic-gate 			int done = 0;
28327c478bd9Sstevel@tonic-gate 
2833d3e55dcdSgww 			error = strput(stp, NULL, uiop, &iosize, b_flag, 0, 0);
28347c478bd9Sstevel@tonic-gate 			if (error == 0)
28357c478bd9Sstevel@tonic-gate 				break;
28367c478bd9Sstevel@tonic-gate 			if (error != EWOULDBLOCK)
28377c478bd9Sstevel@tonic-gate 				goto out;
28387c478bd9Sstevel@tonic-gate 
28397c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
28407c478bd9Sstevel@tonic-gate 			/*
28417c478bd9Sstevel@tonic-gate 			 * Check for a missed wakeup.
28427c478bd9Sstevel@tonic-gate 			 * Needed since strput did not hold sd_lock across
28437c478bd9Sstevel@tonic-gate 			 * the canputnext.
28447c478bd9Sstevel@tonic-gate 			 */
28457c478bd9Sstevel@tonic-gate 			if (canputnext(wqp)) {
28467c478bd9Sstevel@tonic-gate 				/* Try again */
28477c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28487c478bd9Sstevel@tonic-gate 				continue;
28497c478bd9Sstevel@tonic-gate 			}
28507c478bd9Sstevel@tonic-gate 			TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT,
28517c478bd9Sstevel@tonic-gate 			    "strwrite wait:q %p wait", wqp);
28527c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, waitflag, (ssize_t)0,
28537c478bd9Sstevel@tonic-gate 			    tempmode, -1, &done)) != 0 || done) {
28547c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28557c478bd9Sstevel@tonic-gate 				if ((vp->v_type == VFIFO) &&
28567c478bd9Sstevel@tonic-gate 				    (uiop->uio_fmode & FNDELAY) &&
28577c478bd9Sstevel@tonic-gate 				    (error == EAGAIN))
28587c478bd9Sstevel@tonic-gate 					error = 0;
28597c478bd9Sstevel@tonic-gate 				goto out;
28607c478bd9Sstevel@tonic-gate 			}
28617c478bd9Sstevel@tonic-gate 			TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE,
28627c478bd9Sstevel@tonic-gate 			    "strwrite wake:q %p awakes", wqp);
28639acbbeafSnn35248 			if ((error = i_straccess(stp, JCWRITE)) != 0) {
28647c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28657c478bd9Sstevel@tonic-gate 				goto out;
28667c478bd9Sstevel@tonic-gate 			}
28679acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
28689acbbeafSnn35248 		}
28697c478bd9Sstevel@tonic-gate 		waitflag |= NOINTR;
28707c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID,
28717c478bd9Sstevel@tonic-gate 		    "strwrite resid:q %p uiop %p", wqp, uiop);
28727c478bd9Sstevel@tonic-gate 		if (uiop->uio_resid) {
28737c478bd9Sstevel@tonic-gate 			/* Recheck for errors - needed for sockets */
28747c478bd9Sstevel@tonic-gate 			if ((stp->sd_wput_opt & SW_RECHECK_ERR) &&
28757c478bd9Sstevel@tonic-gate 			    (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) {
28767c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
28777c478bd9Sstevel@tonic-gate 				error = strwriteable(stp, B_FALSE, B_TRUE);
28787c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
28797c478bd9Sstevel@tonic-gate 				if (error != 0)
28807c478bd9Sstevel@tonic-gate 					return (error);
28817c478bd9Sstevel@tonic-gate 			}
28827c478bd9Sstevel@tonic-gate 			continue;
28837c478bd9Sstevel@tonic-gate 		}
28847c478bd9Sstevel@tonic-gate 		break;
28857c478bd9Sstevel@tonic-gate 	}
28867c478bd9Sstevel@tonic-gate out:
28877c478bd9Sstevel@tonic-gate 	/*
28887c478bd9Sstevel@tonic-gate 	 * For historical reasons, applications expect EAGAIN when a data
28897c478bd9Sstevel@tonic-gate 	 * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN.
28907c478bd9Sstevel@tonic-gate 	 */
28917c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
28927c478bd9Sstevel@tonic-gate 		error = EAGAIN;
28937c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
28947c478bd9Sstevel@tonic-gate 	    "strwrite out:q %p out %d error %d", wqp, 2, error);
28957c478bd9Sstevel@tonic-gate 	return (error);
28967c478bd9Sstevel@tonic-gate }
28977c478bd9Sstevel@tonic-gate 
28987c478bd9Sstevel@tonic-gate /*
28997c478bd9Sstevel@tonic-gate  * Stream head write service routine.
29007c478bd9Sstevel@tonic-gate  * Its job is to wake up any sleeping writers when a queue
29017c478bd9Sstevel@tonic-gate  * downstream needs data (part of the flow control in putq and getq).
29027c478bd9Sstevel@tonic-gate  * It also must wake anyone sleeping on a poll().
29037c478bd9Sstevel@tonic-gate  * For stream head right below mux module, it must also invoke put procedure
29047c478bd9Sstevel@tonic-gate  * of next downstream module.
29057c478bd9Sstevel@tonic-gate  */
29067c478bd9Sstevel@tonic-gate int
29077c478bd9Sstevel@tonic-gate strwsrv(queue_t *q)
29087c478bd9Sstevel@tonic-gate {
29097c478bd9Sstevel@tonic-gate 	struct stdata *stp;
29107c478bd9Sstevel@tonic-gate 	queue_t *tq;
29117c478bd9Sstevel@tonic-gate 	qband_t *qbp;
29127c478bd9Sstevel@tonic-gate 	int i;
29137c478bd9Sstevel@tonic-gate 	qband_t *myqbp;
29147c478bd9Sstevel@tonic-gate 	int isevent;
29157c478bd9Sstevel@tonic-gate 	unsigned char	qbf[NBAND];	/* band flushing backenable flags */
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
29187c478bd9Sstevel@tonic-gate 	    TR_STRWSRV, "strwsrv:q %p", q);
29197c478bd9Sstevel@tonic-gate 	stp = (struct stdata *)q->q_ptr;
29207c478bd9Sstevel@tonic-gate 	ASSERT(qclaimed(q));
29217c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
29227c478bd9Sstevel@tonic-gate 	ASSERT(!(stp->sd_flag & STPLEX));
29237c478bd9Sstevel@tonic-gate 
29247c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & WSLEEP) {
29257c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~WSLEEP;
29267c478bd9Sstevel@tonic-gate 		cv_broadcast(&q->q_wait);
29277c478bd9Sstevel@tonic-gate 	}
29287c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
29297c478bd9Sstevel@tonic-gate 
29307c478bd9Sstevel@tonic-gate 	/* The other end of a stream pipe went away. */
29317c478bd9Sstevel@tonic-gate 	if ((tq = q->q_next) == NULL) {
29327c478bd9Sstevel@tonic-gate 		return (0);
29337c478bd9Sstevel@tonic-gate 	}
29347c478bd9Sstevel@tonic-gate 
29357c478bd9Sstevel@tonic-gate 	/* Find the next module forward that has a service procedure */
29367c478bd9Sstevel@tonic-gate 	claimstr(q);
29377c478bd9Sstevel@tonic-gate 	tq = q->q_nfsrv;
29387c478bd9Sstevel@tonic-gate 	ASSERT(tq != NULL);
29397c478bd9Sstevel@tonic-gate 
29407c478bd9Sstevel@tonic-gate 	if ((q->q_flag & QBACK)) {
29417c478bd9Sstevel@tonic-gate 		if ((tq->q_flag & QFULL)) {
29427c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(tq));
29437c478bd9Sstevel@tonic-gate 			if (!(tq->q_flag & QFULL)) {
29447c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(tq));
29457c478bd9Sstevel@tonic-gate 				goto wakeup;
29467c478bd9Sstevel@tonic-gate 			}
29477c478bd9Sstevel@tonic-gate 			/*
29487c478bd9Sstevel@tonic-gate 			 * The queue must have become full again. Set QWANTW
29497c478bd9Sstevel@tonic-gate 			 * again so strwsrv will be back enabled when
29507c478bd9Sstevel@tonic-gate 			 * the queue becomes non-full next time.
29517c478bd9Sstevel@tonic-gate 			 */
29527c478bd9Sstevel@tonic-gate 			tq->q_flag |= QWANTW;
29537c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(tq));
29547c478bd9Sstevel@tonic-gate 		} else {
29557c478bd9Sstevel@tonic-gate 		wakeup:
29567c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, POLLWRNORM);
29577c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
29587c478bd9Sstevel@tonic-gate 			if (stp->sd_sigflags & S_WRNORM)
29597c478bd9Sstevel@tonic-gate 				strsendsig(stp->sd_siglist, S_WRNORM, 0, 0);
29607c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
29617c478bd9Sstevel@tonic-gate 		}
29627c478bd9Sstevel@tonic-gate 	}
29637c478bd9Sstevel@tonic-gate 
29647c478bd9Sstevel@tonic-gate 	isevent = 0;
29657c478bd9Sstevel@tonic-gate 	i = 1;
29667c478bd9Sstevel@tonic-gate 	bzero((caddr_t)qbf, NBAND);
29677c478bd9Sstevel@tonic-gate 	mutex_enter(QLOCK(tq));
29687c478bd9Sstevel@tonic-gate 	if ((myqbp = q->q_bandp) != NULL)
29697c478bd9Sstevel@tonic-gate 		for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) {
29707c478bd9Sstevel@tonic-gate 			ASSERT(myqbp);
29717c478bd9Sstevel@tonic-gate 			if ((myqbp->qb_flag & QB_BACK)) {
29727c478bd9Sstevel@tonic-gate 				if (qbp->qb_flag & QB_FULL) {
29737c478bd9Sstevel@tonic-gate 					/*
29747c478bd9Sstevel@tonic-gate 					 * The band must have become full again.
29757c478bd9Sstevel@tonic-gate 					 * Set QB_WANTW again so strwsrv will
29767c478bd9Sstevel@tonic-gate 					 * be back enabled when the band becomes
29777c478bd9Sstevel@tonic-gate 					 * non-full next time.
29787c478bd9Sstevel@tonic-gate 					 */
29797c478bd9Sstevel@tonic-gate 					qbp->qb_flag |= QB_WANTW;
29807c478bd9Sstevel@tonic-gate 				} else {
29817c478bd9Sstevel@tonic-gate 					isevent = 1;
29827c478bd9Sstevel@tonic-gate 					qbf[i] = 1;
29837c478bd9Sstevel@tonic-gate 				}
29847c478bd9Sstevel@tonic-gate 			}
29857c478bd9Sstevel@tonic-gate 			myqbp = myqbp->qb_next;
29867c478bd9Sstevel@tonic-gate 			i++;
29877c478bd9Sstevel@tonic-gate 		}
29887c478bd9Sstevel@tonic-gate 	mutex_exit(QLOCK(tq));
29897c478bd9Sstevel@tonic-gate 
29907c478bd9Sstevel@tonic-gate 	if (isevent) {
29917c478bd9Sstevel@tonic-gate 		for (i = tq->q_nband; i; i--) {
29927c478bd9Sstevel@tonic-gate 			if (qbf[i]) {
29937c478bd9Sstevel@tonic-gate 				pollwakeup(&stp->sd_pollist, POLLWRBAND);
29947c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
29957c478bd9Sstevel@tonic-gate 				if (stp->sd_sigflags & S_WRBAND)
29967c478bd9Sstevel@tonic-gate 					strsendsig(stp->sd_siglist, S_WRBAND,
29977c478bd9Sstevel@tonic-gate 					    (uchar_t)i, 0);
29987c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
29997c478bd9Sstevel@tonic-gate 			}
30007c478bd9Sstevel@tonic-gate 		}
30017c478bd9Sstevel@tonic-gate 	}
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 	releasestr(q);
30047c478bd9Sstevel@tonic-gate 	return (0);
30057c478bd9Sstevel@tonic-gate }
30067c478bd9Sstevel@tonic-gate 
30077c478bd9Sstevel@tonic-gate /*
30087c478bd9Sstevel@tonic-gate  * Special case of strcopyin/strcopyout for copying
30097c478bd9Sstevel@tonic-gate  * struct strioctl that can deal with both data
30107c478bd9Sstevel@tonic-gate  * models.
30117c478bd9Sstevel@tonic-gate  */
30127c478bd9Sstevel@tonic-gate 
30137c478bd9Sstevel@tonic-gate #ifdef	_LP64
30147c478bd9Sstevel@tonic-gate 
30157c478bd9Sstevel@tonic-gate static int
30167c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
30177c478bd9Sstevel@tonic-gate {
30187c478bd9Sstevel@tonic-gate 	struct	strioctl32 strioc32;
30197c478bd9Sstevel@tonic-gate 	struct	strioctl *striocp;
30207c478bd9Sstevel@tonic-gate 
30217c478bd9Sstevel@tonic-gate 	if (copyflag & U_TO_K) {
30227c478bd9Sstevel@tonic-gate 		ASSERT((copyflag & K_TO_K) == 0);
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate 		if ((flag & FMODELS) == DATAMODEL_ILP32) {
30257c478bd9Sstevel@tonic-gate 			if (copyin(from, &strioc32, sizeof (strioc32)))
30267c478bd9Sstevel@tonic-gate 				return (EFAULT);
30277c478bd9Sstevel@tonic-gate 
30287c478bd9Sstevel@tonic-gate 			striocp = (struct strioctl *)to;
30297c478bd9Sstevel@tonic-gate 			striocp->ic_cmd	= strioc32.ic_cmd;
30307c478bd9Sstevel@tonic-gate 			striocp->ic_timout = strioc32.ic_timout;
30317c478bd9Sstevel@tonic-gate 			striocp->ic_len	= strioc32.ic_len;
30327c478bd9Sstevel@tonic-gate 			striocp->ic_dp	= (char *)(uintptr_t)strioc32.ic_dp;
30337c478bd9Sstevel@tonic-gate 
30347c478bd9Sstevel@tonic-gate 		} else { /* NATIVE data model */
30357c478bd9Sstevel@tonic-gate 			if (copyin(from, to, sizeof (struct strioctl))) {
30367c478bd9Sstevel@tonic-gate 				return (EFAULT);
30377c478bd9Sstevel@tonic-gate 			} else {
30387c478bd9Sstevel@tonic-gate 				return (0);
30397c478bd9Sstevel@tonic-gate 			}
30407c478bd9Sstevel@tonic-gate 		}
30417c478bd9Sstevel@tonic-gate 	} else {
30427c478bd9Sstevel@tonic-gate 		ASSERT(copyflag & K_TO_K);
30437c478bd9Sstevel@tonic-gate 		bcopy(from, to, sizeof (struct strioctl));
30447c478bd9Sstevel@tonic-gate 	}
30457c478bd9Sstevel@tonic-gate 	return (0);
30467c478bd9Sstevel@tonic-gate }
30477c478bd9Sstevel@tonic-gate 
30487c478bd9Sstevel@tonic-gate static int
30497c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
30507c478bd9Sstevel@tonic-gate {
30517c478bd9Sstevel@tonic-gate 	struct	strioctl32 strioc32;
30527c478bd9Sstevel@tonic-gate 	struct	strioctl *striocp;
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 	if (copyflag & U_TO_K) {
30557c478bd9Sstevel@tonic-gate 		ASSERT((copyflag & K_TO_K) == 0);
30567c478bd9Sstevel@tonic-gate 
30577c478bd9Sstevel@tonic-gate 		if ((flag & FMODELS) == DATAMODEL_ILP32) {
30587c478bd9Sstevel@tonic-gate 			striocp = (struct strioctl *)from;
30597c478bd9Sstevel@tonic-gate 			strioc32.ic_cmd	= striocp->ic_cmd;
30607c478bd9Sstevel@tonic-gate 			strioc32.ic_timout = striocp->ic_timout;
30617c478bd9Sstevel@tonic-gate 			strioc32.ic_len	= striocp->ic_len;
30627c478bd9Sstevel@tonic-gate 			strioc32.ic_dp	= (caddr32_t)(uintptr_t)striocp->ic_dp;
30637c478bd9Sstevel@tonic-gate 			ASSERT((char *)(uintptr_t)strioc32.ic_dp ==
30647c478bd9Sstevel@tonic-gate 			    striocp->ic_dp);
30657c478bd9Sstevel@tonic-gate 
30667c478bd9Sstevel@tonic-gate 			if (copyout(&strioc32, to, sizeof (strioc32)))
30677c478bd9Sstevel@tonic-gate 				return (EFAULT);
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 		} else { /* NATIVE data model */
30707c478bd9Sstevel@tonic-gate 			if (copyout(from, to, sizeof (struct strioctl))) {
30717c478bd9Sstevel@tonic-gate 				return (EFAULT);
30727c478bd9Sstevel@tonic-gate 			} else {
30737c478bd9Sstevel@tonic-gate 				return (0);
30747c478bd9Sstevel@tonic-gate 			}
30757c478bd9Sstevel@tonic-gate 		}
30767c478bd9Sstevel@tonic-gate 	} else {
30777c478bd9Sstevel@tonic-gate 		ASSERT(copyflag & K_TO_K);
30787c478bd9Sstevel@tonic-gate 		bcopy(from, to, sizeof (struct strioctl));
30797c478bd9Sstevel@tonic-gate 	}
30807c478bd9Sstevel@tonic-gate 	return (0);
30817c478bd9Sstevel@tonic-gate }
30827c478bd9Sstevel@tonic-gate 
30837c478bd9Sstevel@tonic-gate #else	/* ! _LP64 */
30847c478bd9Sstevel@tonic-gate 
30857c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
30867c478bd9Sstevel@tonic-gate static int
30877c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
30887c478bd9Sstevel@tonic-gate {
30897c478bd9Sstevel@tonic-gate 	return (strcopyin(from, to, sizeof (struct strioctl), copyflag));
30907c478bd9Sstevel@tonic-gate }
30917c478bd9Sstevel@tonic-gate 
30927c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
30937c478bd9Sstevel@tonic-gate static int
30947c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
30957c478bd9Sstevel@tonic-gate {
30967c478bd9Sstevel@tonic-gate 	return (strcopyout(from, to, sizeof (struct strioctl), copyflag));
30977c478bd9Sstevel@tonic-gate }
30987c478bd9Sstevel@tonic-gate 
30997c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
31007c478bd9Sstevel@tonic-gate 
31017c478bd9Sstevel@tonic-gate /*
31027c478bd9Sstevel@tonic-gate  * Determine type of job control semantics expected by user.  The
31037c478bd9Sstevel@tonic-gate  * possibilities are:
31047c478bd9Sstevel@tonic-gate  *	JCREAD	- Behaves like read() on fd; send SIGTTIN
31057c478bd9Sstevel@tonic-gate  *	JCWRITE	- Behaves like write() on fd; send SIGTTOU if TOSTOP set
31067c478bd9Sstevel@tonic-gate  *	JCSETP	- Sets a value in the stream; send SIGTTOU, ignore TOSTOP
31077c478bd9Sstevel@tonic-gate  *	JCGETP	- Gets a value in the stream; no signals.
31087c478bd9Sstevel@tonic-gate  * See straccess in strsubr.c for usage of these values.
31097c478bd9Sstevel@tonic-gate  *
31107c478bd9Sstevel@tonic-gate  * This routine also returns -1 for I_STR as a special case; the
31117c478bd9Sstevel@tonic-gate  * caller must call again with the real ioctl number for
31127c478bd9Sstevel@tonic-gate  * classification.
31137c478bd9Sstevel@tonic-gate  */
31147c478bd9Sstevel@tonic-gate static int
31157c478bd9Sstevel@tonic-gate job_control_type(int cmd)
31167c478bd9Sstevel@tonic-gate {
31177c478bd9Sstevel@tonic-gate 	switch (cmd) {
31187c478bd9Sstevel@tonic-gate 	case I_STR:
31197c478bd9Sstevel@tonic-gate 		return (-1);
31207c478bd9Sstevel@tonic-gate 
31217c478bd9Sstevel@tonic-gate 	case I_RECVFD:
31227c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
31237c478bd9Sstevel@tonic-gate 		return (JCREAD);
31247c478bd9Sstevel@tonic-gate 
31257c478bd9Sstevel@tonic-gate 	case I_FDINSERT:
31267c478bd9Sstevel@tonic-gate 	case I_SENDFD:
31277c478bd9Sstevel@tonic-gate 		return (JCWRITE);
31287c478bd9Sstevel@tonic-gate 
31297c478bd9Sstevel@tonic-gate 	case TCSETA:
31307c478bd9Sstevel@tonic-gate 	case TCSETAW:
31317c478bd9Sstevel@tonic-gate 	case TCSETAF:
31327c478bd9Sstevel@tonic-gate 	case TCSBRK:
31337c478bd9Sstevel@tonic-gate 	case TCXONC:
31347c478bd9Sstevel@tonic-gate 	case TCFLSH:
31357c478bd9Sstevel@tonic-gate 	case TCDSET:	/* Obsolete */
31367c478bd9Sstevel@tonic-gate 	case TIOCSWINSZ:
31377c478bd9Sstevel@tonic-gate 	case TCSETS:
31387c478bd9Sstevel@tonic-gate 	case TCSETSW:
31397c478bd9Sstevel@tonic-gate 	case TCSETSF:
31407c478bd9Sstevel@tonic-gate 	case TIOCSETD:
31417c478bd9Sstevel@tonic-gate 	case TIOCHPCL:
31427c478bd9Sstevel@tonic-gate 	case TIOCSETP:
31437c478bd9Sstevel@tonic-gate 	case TIOCSETN:
31447c478bd9Sstevel@tonic-gate 	case TIOCEXCL:
31457c478bd9Sstevel@tonic-gate 	case TIOCNXCL:
31467c478bd9Sstevel@tonic-gate 	case TIOCFLUSH:
31477c478bd9Sstevel@tonic-gate 	case TIOCSETC:
31487c478bd9Sstevel@tonic-gate 	case TIOCLBIS:
31497c478bd9Sstevel@tonic-gate 	case TIOCLBIC:
31507c478bd9Sstevel@tonic-gate 	case TIOCLSET:
31517c478bd9Sstevel@tonic-gate 	case TIOCSBRK:
31527c478bd9Sstevel@tonic-gate 	case TIOCCBRK:
31537c478bd9Sstevel@tonic-gate 	case TIOCSDTR:
31547c478bd9Sstevel@tonic-gate 	case TIOCCDTR:
31557c478bd9Sstevel@tonic-gate 	case TIOCSLTC:
31567c478bd9Sstevel@tonic-gate 	case TIOCSTOP:
31577c478bd9Sstevel@tonic-gate 	case TIOCSTART:
31587c478bd9Sstevel@tonic-gate 	case TIOCSTI:
31597c478bd9Sstevel@tonic-gate 	case TIOCSPGRP:
31607c478bd9Sstevel@tonic-gate 	case TIOCMSET:
31617c478bd9Sstevel@tonic-gate 	case TIOCMBIS:
31627c478bd9Sstevel@tonic-gate 	case TIOCMBIC:
31637c478bd9Sstevel@tonic-gate 	case TIOCREMOTE:
31647c478bd9Sstevel@tonic-gate 	case TIOCSIGNAL:
31657c478bd9Sstevel@tonic-gate 	case LDSETT:
31667c478bd9Sstevel@tonic-gate 	case LDSMAP:	/* Obsolete */
31677c478bd9Sstevel@tonic-gate 	case DIOCSETP:
31687c478bd9Sstevel@tonic-gate 	case I_FLUSH:
31697c478bd9Sstevel@tonic-gate 	case I_SRDOPT:
31707c478bd9Sstevel@tonic-gate 	case I_SETSIG:
31717c478bd9Sstevel@tonic-gate 	case I_SWROPT:
31727c478bd9Sstevel@tonic-gate 	case I_FLUSHBAND:
31737c478bd9Sstevel@tonic-gate 	case I_SETCLTIME:
31747c478bd9Sstevel@tonic-gate 	case I_SERROPT:
31757c478bd9Sstevel@tonic-gate 	case I_ESETSIG:
31767c478bd9Sstevel@tonic-gate 	case FIONBIO:
31777c478bd9Sstevel@tonic-gate 	case FIOASYNC:
31787c478bd9Sstevel@tonic-gate 	case FIOSETOWN:
31797c478bd9Sstevel@tonic-gate 	case JBOOT:	/* Obsolete */
31807c478bd9Sstevel@tonic-gate 	case JTERM:	/* Obsolete */
31817c478bd9Sstevel@tonic-gate 	case JTIMOM:	/* Obsolete */
31827c478bd9Sstevel@tonic-gate 	case JZOMBOOT:	/* Obsolete */
31837c478bd9Sstevel@tonic-gate 	case JAGENT:	/* Obsolete */
31847c478bd9Sstevel@tonic-gate 	case JTRUN:	/* Obsolete */
31857c478bd9Sstevel@tonic-gate 	case JXTPROTO:	/* Obsolete */
31869acbbeafSnn35248 	case TIOCSETLD:
31877c478bd9Sstevel@tonic-gate 		return (JCSETP);
31887c478bd9Sstevel@tonic-gate 	}
31897c478bd9Sstevel@tonic-gate 
31907c478bd9Sstevel@tonic-gate 	return (JCGETP);
31917c478bd9Sstevel@tonic-gate }
31927c478bd9Sstevel@tonic-gate 
31937c478bd9Sstevel@tonic-gate /*
31947c478bd9Sstevel@tonic-gate  * ioctl for streams
31957c478bd9Sstevel@tonic-gate  */
31967c478bd9Sstevel@tonic-gate int
31977c478bd9Sstevel@tonic-gate strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag,
31987c478bd9Sstevel@tonic-gate     cred_t *crp, int *rvalp)
31997c478bd9Sstevel@tonic-gate {
32007c478bd9Sstevel@tonic-gate 	struct stdata *stp;
3201ca9327a6Smeem 	struct strcmd *scp;
32027c478bd9Sstevel@tonic-gate 	struct strioctl strioc;
32037c478bd9Sstevel@tonic-gate 	struct uio uio;
32047c478bd9Sstevel@tonic-gate 	struct iovec iov;
32057c478bd9Sstevel@tonic-gate 	int access;
32067c478bd9Sstevel@tonic-gate 	mblk_t *mp;
32077c478bd9Sstevel@tonic-gate 	int error = 0;
32087c478bd9Sstevel@tonic-gate 	int done = 0;
32097c478bd9Sstevel@tonic-gate 	ssize_t	rmin, rmax;
32107c478bd9Sstevel@tonic-gate 	queue_t *wrq;
32117c478bd9Sstevel@tonic-gate 	queue_t *rdq;
32127c478bd9Sstevel@tonic-gate 	boolean_t kioctl = B_FALSE;
32137c478bd9Sstevel@tonic-gate 
32147c478bd9Sstevel@tonic-gate 	if (flag & FKIOCTL) {
32157c478bd9Sstevel@tonic-gate 		copyflag = K_TO_K;
32167c478bd9Sstevel@tonic-gate 		kioctl = B_TRUE;
32177c478bd9Sstevel@tonic-gate 	}
32187c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
32197c478bd9Sstevel@tonic-gate 	ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
32207c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
32217c478bd9Sstevel@tonic-gate 
32227c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER,
32237c478bd9Sstevel@tonic-gate 	    "strioctl:stp %p cmd %X arg %lX", stp, cmd, arg);
32247c478bd9Sstevel@tonic-gate 
32257c478bd9Sstevel@tonic-gate 	if (audit_active)
32267c478bd9Sstevel@tonic-gate 		audit_strioctl(vp, cmd, arg, flag, copyflag, crp, rvalp);
32277c478bd9Sstevel@tonic-gate 
32287c478bd9Sstevel@tonic-gate 	/*
32297c478bd9Sstevel@tonic-gate 	 * If the copy is kernel to kernel, make sure that the FNATIVE
32307c478bd9Sstevel@tonic-gate 	 * flag is set.  After this it would be a serious error to have
32317c478bd9Sstevel@tonic-gate 	 * no model flag.
32327c478bd9Sstevel@tonic-gate 	 */
32337c478bd9Sstevel@tonic-gate 	if (copyflag == K_TO_K)
32347c478bd9Sstevel@tonic-gate 		flag = (flag & ~FMODELS) | FNATIVE;
32357c478bd9Sstevel@tonic-gate 
32367c478bd9Sstevel@tonic-gate 	ASSERT((flag & FMODELS) != 0);
32377c478bd9Sstevel@tonic-gate 
32387c478bd9Sstevel@tonic-gate 	wrq = stp->sd_wrq;
32397c478bd9Sstevel@tonic-gate 	rdq = _RD(wrq);
32407c478bd9Sstevel@tonic-gate 
32417c478bd9Sstevel@tonic-gate 	access = job_control_type(cmd);
32427c478bd9Sstevel@tonic-gate 
32437c478bd9Sstevel@tonic-gate 	/* We should never see these here, should be handled by iwscn */
32447c478bd9Sstevel@tonic-gate 	if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR)
32457c478bd9Sstevel@tonic-gate 		return (EINVAL);
32467c478bd9Sstevel@tonic-gate 
32479acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
32489acbbeafSnn35248 	if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) {
32499acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
32507c478bd9Sstevel@tonic-gate 		return (error);
32519acbbeafSnn35248 	}
32529acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
32537c478bd9Sstevel@tonic-gate 
32547c478bd9Sstevel@tonic-gate 	/*
32557c478bd9Sstevel@tonic-gate 	 * Check for sgttyb-related ioctls first, and complain as
32567c478bd9Sstevel@tonic-gate 	 * necessary.
32577c478bd9Sstevel@tonic-gate 	 */
32587c478bd9Sstevel@tonic-gate 	switch (cmd) {
32597c478bd9Sstevel@tonic-gate 	case TIOCGETP:
32607c478bd9Sstevel@tonic-gate 	case TIOCSETP:
32617c478bd9Sstevel@tonic-gate 	case TIOCSETN:
32627c478bd9Sstevel@tonic-gate 		if (sgttyb_handling >= 2 && !sgttyb_complaint) {
32637c478bd9Sstevel@tonic-gate 			sgttyb_complaint = B_TRUE;
32647c478bd9Sstevel@tonic-gate 			cmn_err(CE_NOTE,
32657c478bd9Sstevel@tonic-gate 			    "application used obsolete TIOC[GS]ET");
32667c478bd9Sstevel@tonic-gate 		}
32677c478bd9Sstevel@tonic-gate 		if (sgttyb_handling >= 3) {
32687c478bd9Sstevel@tonic-gate 			tsignal(curthread, SIGSYS);
32697c478bd9Sstevel@tonic-gate 			return (EIO);
32707c478bd9Sstevel@tonic-gate 		}
32717c478bd9Sstevel@tonic-gate 		break;
32727c478bd9Sstevel@tonic-gate 	}
32737c478bd9Sstevel@tonic-gate 
32747c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
32757c478bd9Sstevel@tonic-gate 
32767c478bd9Sstevel@tonic-gate 	switch (cmd) {
32777c478bd9Sstevel@tonic-gate 	case I_RECVFD:
32787c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
32797c478bd9Sstevel@tonic-gate 	case I_PEEK:
32807c478bd9Sstevel@tonic-gate 	case I_NREAD:
32817c478bd9Sstevel@tonic-gate 	case FIONREAD:
32827c478bd9Sstevel@tonic-gate 	case FIORDCHK:
32837c478bd9Sstevel@tonic-gate 	case I_ATMARK:
32847c478bd9Sstevel@tonic-gate 	case FIONBIO:
32857c478bd9Sstevel@tonic-gate 	case FIOASYNC:
32867c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STPLEX)) {
32877c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX, 0);
32887c478bd9Sstevel@tonic-gate 			if (error != 0) {
32897c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
32907c478bd9Sstevel@tonic-gate 				return (error);
32917c478bd9Sstevel@tonic-gate 			}
32927c478bd9Sstevel@tonic-gate 		}
32937c478bd9Sstevel@tonic-gate 		break;
32947c478bd9Sstevel@tonic-gate 
32957c478bd9Sstevel@tonic-gate 	default:
32967c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) {
32977c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0);
32987c478bd9Sstevel@tonic-gate 			if (error != 0) {
32997c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
33007c478bd9Sstevel@tonic-gate 				return (error);
33017c478bd9Sstevel@tonic-gate 			}
33027c478bd9Sstevel@tonic-gate 		}
33037c478bd9Sstevel@tonic-gate 	}
33047c478bd9Sstevel@tonic-gate 
33057c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
33067c478bd9Sstevel@tonic-gate 
33077c478bd9Sstevel@tonic-gate 	switch (cmd) {
33087c478bd9Sstevel@tonic-gate 	default:
33097c478bd9Sstevel@tonic-gate 		/*
33107c478bd9Sstevel@tonic-gate 		 * The stream head has hardcoded knowledge of a
33117c478bd9Sstevel@tonic-gate 		 * miscellaneous collection of terminal-, keyboard- and
33127c478bd9Sstevel@tonic-gate 		 * mouse-related ioctls, enumerated below.  This hardcoded
33137c478bd9Sstevel@tonic-gate 		 * knowledge allows the stream head to automatically
33147c478bd9Sstevel@tonic-gate 		 * convert transparent ioctl requests made by userland
33157c478bd9Sstevel@tonic-gate 		 * programs into I_STR ioctls which many old STREAMS
33167c478bd9Sstevel@tonic-gate 		 * modules and drivers require.
33177c478bd9Sstevel@tonic-gate 		 *
33187c478bd9Sstevel@tonic-gate 		 * No new ioctls should ever be added to this list.
33197c478bd9Sstevel@tonic-gate 		 * Instead, the STREAMS module or driver should be written
33207c478bd9Sstevel@tonic-gate 		 * to either handle transparent ioctls or require any
33217c478bd9Sstevel@tonic-gate 		 * userland programs to use I_STR ioctls (by returning
33227c478bd9Sstevel@tonic-gate 		 * EINVAL to any transparent ioctl requests).
33237c478bd9Sstevel@tonic-gate 		 *
33247c478bd9Sstevel@tonic-gate 		 * More importantly, removing ioctls from this list should
33257c478bd9Sstevel@tonic-gate 		 * be done with the utmost care, since our STREAMS modules
33267c478bd9Sstevel@tonic-gate 		 * and drivers *count* on the stream head performing this
33277c478bd9Sstevel@tonic-gate 		 * conversion, and thus may panic while processing
33287c478bd9Sstevel@tonic-gate 		 * transparent ioctl request for one of these ioctls (keep
33297c478bd9Sstevel@tonic-gate 		 * in mind that third party modules and drivers may have
33307c478bd9Sstevel@tonic-gate 		 * similar problems).
33317c478bd9Sstevel@tonic-gate 		 */
33327c478bd9Sstevel@tonic-gate 		if (((cmd & IOCTYPE) == LDIOC) ||
33337c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == tIOC) ||
33347c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == TIOC) ||
33357c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == KIOC) ||
33367c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == MSIOC) ||
33377c478bd9Sstevel@tonic-gate 		    ((cmd & IOCTYPE) == VUIOC)) {
33387c478bd9Sstevel@tonic-gate 			/*
33397c478bd9Sstevel@tonic-gate 			 * The ioctl is a tty ioctl - set up strioc buffer
33407c478bd9Sstevel@tonic-gate 			 * and call strdoioctl() to do the work.
33417c478bd9Sstevel@tonic-gate 			 */
33427c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & STRHUP)
33437c478bd9Sstevel@tonic-gate 				return (ENXIO);
33447c478bd9Sstevel@tonic-gate 			strioc.ic_cmd = cmd;
33457c478bd9Sstevel@tonic-gate 			strioc.ic_timout = INFTIM;
33467c478bd9Sstevel@tonic-gate 
33477c478bd9Sstevel@tonic-gate 			switch (cmd) {
33487c478bd9Sstevel@tonic-gate 
33497c478bd9Sstevel@tonic-gate 			case TCXONC:
33507c478bd9Sstevel@tonic-gate 			case TCSBRK:
33517c478bd9Sstevel@tonic-gate 			case TCFLSH:
33527c478bd9Sstevel@tonic-gate 			case TCDSET:
33537c478bd9Sstevel@tonic-gate 				{
33547c478bd9Sstevel@tonic-gate 				int native_arg = (int)arg;
33557c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (int);
33567c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)&native_arg;
33577c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33587c478bd9Sstevel@tonic-gate 				    K_TO_K, crp, rvalp));
33597c478bd9Sstevel@tonic-gate 				}
33607c478bd9Sstevel@tonic-gate 
33617c478bd9Sstevel@tonic-gate 			case TCSETA:
33627c478bd9Sstevel@tonic-gate 			case TCSETAW:
33637c478bd9Sstevel@tonic-gate 			case TCSETAF:
33647c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termio);
33657c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33667c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33677c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
33687c478bd9Sstevel@tonic-gate 
33697c478bd9Sstevel@tonic-gate 			case TCSETS:
33707c478bd9Sstevel@tonic-gate 			case TCSETSW:
33717c478bd9Sstevel@tonic-gate 			case TCSETSF:
33727c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termios);
33737c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33747c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33757c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
33767c478bd9Sstevel@tonic-gate 
33777c478bd9Sstevel@tonic-gate 			case LDSETT:
33787c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct termcb);
33797c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33807c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33817c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
33827c478bd9Sstevel@tonic-gate 
33837c478bd9Sstevel@tonic-gate 			case TIOCSETP:
33847c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct sgttyb);
33857c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
33867c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
33877c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
33887c478bd9Sstevel@tonic-gate 
33897c478bd9Sstevel@tonic-gate 			case TIOCSTI:
33907c478bd9Sstevel@tonic-gate 				if ((flag & FREAD) == 0 &&
33917c478bd9Sstevel@tonic-gate 				    secpolicy_sti(crp) != 0) {
33927c478bd9Sstevel@tonic-gate 					return (EPERM);
33937c478bd9Sstevel@tonic-gate 				}
33949acbbeafSnn35248 				mutex_enter(&stp->sd_lock);
33959acbbeafSnn35248 				mutex_enter(&curproc->p_splock);
33969acbbeafSnn35248 				if (stp->sd_sidp != curproc->p_sessp->s_sidp &&
33977c478bd9Sstevel@tonic-gate 				    secpolicy_sti(crp) != 0) {
33989acbbeafSnn35248 					mutex_exit(&curproc->p_splock);
33999acbbeafSnn35248 					mutex_exit(&stp->sd_lock);
34007c478bd9Sstevel@tonic-gate 					return (EACCES);
34017c478bd9Sstevel@tonic-gate 				}
34029acbbeafSnn35248 				mutex_exit(&curproc->p_splock);
34039acbbeafSnn35248 				mutex_exit(&stp->sd_lock);
34047c478bd9Sstevel@tonic-gate 
34057c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (char);
34067c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34077c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34087c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34097c478bd9Sstevel@tonic-gate 
34107c478bd9Sstevel@tonic-gate 			case TIOCSWINSZ:
34117c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct winsize);
34127c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34137c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34147c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34157c478bd9Sstevel@tonic-gate 
34167c478bd9Sstevel@tonic-gate 			case TIOCSSIZE:
34177c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct ttysize);
34187c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34197c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34207c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34217c478bd9Sstevel@tonic-gate 
34227c478bd9Sstevel@tonic-gate 			case TIOCSSOFTCAR:
34237c478bd9Sstevel@tonic-gate 			case KIOCTRANS:
34247c478bd9Sstevel@tonic-gate 			case KIOCTRANSABLE:
34257c478bd9Sstevel@tonic-gate 			case KIOCCMD:
34267c478bd9Sstevel@tonic-gate 			case KIOCSDIRECT:
34277c478bd9Sstevel@tonic-gate 			case KIOCSCOMPAT:
34287c478bd9Sstevel@tonic-gate 			case KIOCSKABORTEN:
34297c478bd9Sstevel@tonic-gate 			case KIOCSRPTDELAY:
34307c478bd9Sstevel@tonic-gate 			case KIOCSRPTRATE:
34317c478bd9Sstevel@tonic-gate 			case VUIDSFORMAT:
34327c478bd9Sstevel@tonic-gate 			case TIOCSPPS:
34337c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (int);
34347c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34357c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34367c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34377c478bd9Sstevel@tonic-gate 
34387c478bd9Sstevel@tonic-gate 			case KIOCSETKEY:
34397c478bd9Sstevel@tonic-gate 			case KIOCGETKEY:
34407c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct kiockey);
34417c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34427c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34437c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34447c478bd9Sstevel@tonic-gate 
34457c478bd9Sstevel@tonic-gate 			case KIOCSKEY:
34467c478bd9Sstevel@tonic-gate 			case KIOCGKEY:
34477c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct kiockeymap);
34487c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34497c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34507c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34517c478bd9Sstevel@tonic-gate 
34527c478bd9Sstevel@tonic-gate 			case KIOCSLED:
34537c478bd9Sstevel@tonic-gate 				/* arg is a pointer to char */
34547c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (char);
34557c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34567c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34577c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34587c478bd9Sstevel@tonic-gate 
34597c478bd9Sstevel@tonic-gate 			case MSIOSETPARMS:
34607c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (Ms_parms);
34617c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34627c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34637c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34647c478bd9Sstevel@tonic-gate 
34657c478bd9Sstevel@tonic-gate 			case VUIDSADDR:
34667c478bd9Sstevel@tonic-gate 			case VUIDGADDR:
34677c478bd9Sstevel@tonic-gate 				strioc.ic_len = sizeof (struct vuid_addr_probe);
34687c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
34697c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
34707c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
34717c478bd9Sstevel@tonic-gate 
34727c478bd9Sstevel@tonic-gate 			/*
34737c478bd9Sstevel@tonic-gate 			 * These M_IOCTL's don't require any data to be sent
34747c478bd9Sstevel@tonic-gate 			 * downstream, and the driver will allocate and link
34757c478bd9Sstevel@tonic-gate 			 * on its own mblk_t upon M_IOCACK -- thus we set
34767c478bd9Sstevel@tonic-gate 			 * ic_len to zero and set ic_dp to arg so we know
34777c478bd9Sstevel@tonic-gate 			 * where to copyout to later.
34787c478bd9Sstevel@tonic-gate 			 */
34797c478bd9Sstevel@tonic-gate 			case TIOCGSOFTCAR:
34807c478bd9Sstevel@tonic-gate 			case TIOCGWINSZ:
34817c478bd9Sstevel@tonic-gate 			case TIOCGSIZE:
34827c478bd9Sstevel@tonic-gate 			case KIOCGTRANS:
34837c478bd9Sstevel@tonic-gate 			case KIOCGTRANSABLE:
34847c478bd9Sstevel@tonic-gate 			case KIOCTYPE:
34857c478bd9Sstevel@tonic-gate 			case KIOCGDIRECT:
34867c478bd9Sstevel@tonic-gate 			case KIOCGCOMPAT:
34877c478bd9Sstevel@tonic-gate 			case KIOCLAYOUT:
34887c478bd9Sstevel@tonic-gate 			case KIOCGLED:
34897c478bd9Sstevel@tonic-gate 			case MSIOGETPARMS:
34907c478bd9Sstevel@tonic-gate 			case MSIOBUTTONS:
34917c478bd9Sstevel@tonic-gate 			case VUIDGFORMAT:
34927c478bd9Sstevel@tonic-gate 			case TIOCGPPS:
34937c478bd9Sstevel@tonic-gate 			case TIOCGPPSEV:
34947c478bd9Sstevel@tonic-gate 			case TCGETA:
34957c478bd9Sstevel@tonic-gate 			case TCGETS:
34967c478bd9Sstevel@tonic-gate 			case LDGETT:
34977c478bd9Sstevel@tonic-gate 			case TIOCGETP:
34987c478bd9Sstevel@tonic-gate 			case KIOCGRPTDELAY:
34997c478bd9Sstevel@tonic-gate 			case KIOCGRPTRATE:
35007c478bd9Sstevel@tonic-gate 				strioc.ic_len = 0;
35017c478bd9Sstevel@tonic-gate 				strioc.ic_dp = (char *)arg;
35027c478bd9Sstevel@tonic-gate 				return (strdoioctl(stp, &strioc, flag,
35037c478bd9Sstevel@tonic-gate 				    copyflag, crp, rvalp));
35047c478bd9Sstevel@tonic-gate 			}
35057c478bd9Sstevel@tonic-gate 		}
35067c478bd9Sstevel@tonic-gate 
35077c478bd9Sstevel@tonic-gate 		/*
35087c478bd9Sstevel@tonic-gate 		 * Unknown cmd - send it down as a transparent ioctl.
35097c478bd9Sstevel@tonic-gate 		 */
35107c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = cmd;
35117c478bd9Sstevel@tonic-gate 		strioc.ic_timout = INFTIM;
35127c478bd9Sstevel@tonic-gate 		strioc.ic_len = TRANSPARENT;
35137c478bd9Sstevel@tonic-gate 		strioc.ic_dp = (char *)&arg;
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 		return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp));
35167c478bd9Sstevel@tonic-gate 
35177c478bd9Sstevel@tonic-gate 	case I_STR:
35187c478bd9Sstevel@tonic-gate 		/*
35197c478bd9Sstevel@tonic-gate 		 * Stream ioctl.  Read in an strioctl buffer from the user
35207c478bd9Sstevel@tonic-gate 		 * along with any data specified and send it downstream.
35217c478bd9Sstevel@tonic-gate 		 * Strdoioctl will wait allow only one ioctl message at
35227c478bd9Sstevel@tonic-gate 		 * a time, and waits for the acknowledgement.
35237c478bd9Sstevel@tonic-gate 		 */
35247c478bd9Sstevel@tonic-gate 
35257c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
35267c478bd9Sstevel@tonic-gate 			return (ENXIO);
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 		error = strcopyin_strioctl((void *)arg, &strioc, flag,
35297c478bd9Sstevel@tonic-gate 		    copyflag);
35307c478bd9Sstevel@tonic-gate 		if (error != 0)
35317c478bd9Sstevel@tonic-gate 			return (error);
35327c478bd9Sstevel@tonic-gate 
35337c478bd9Sstevel@tonic-gate 		if ((strioc.ic_len < 0) || (strioc.ic_timout < -1))
35347c478bd9Sstevel@tonic-gate 			return (EINVAL);
35357c478bd9Sstevel@tonic-gate 
35367c478bd9Sstevel@tonic-gate 		access = job_control_type(strioc.ic_cmd);
35379acbbeafSnn35248 		mutex_enter(&stp->sd_lock);
35389acbbeafSnn35248 		if ((access != -1) &&
35399acbbeafSnn35248 		    ((error = i_straccess(stp, access)) != 0)) {
35409acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
35417c478bd9Sstevel@tonic-gate 			return (error);
35429acbbeafSnn35248 		}
35439acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
35447c478bd9Sstevel@tonic-gate 
35457c478bd9Sstevel@tonic-gate 		/*
35467c478bd9Sstevel@tonic-gate 		 * The I_STR facility provides a trap door for malicious
35477c478bd9Sstevel@tonic-gate 		 * code to send down bogus streamio(7I) ioctl commands to
35487c478bd9Sstevel@tonic-gate 		 * unsuspecting STREAMS modules and drivers which expect to
35497c478bd9Sstevel@tonic-gate 		 * only get these messages from the stream head.
35507c478bd9Sstevel@tonic-gate 		 * Explicitly prohibit any streamio ioctls which can be
35517c478bd9Sstevel@tonic-gate 		 * passed downstream by the stream head.  Note that we do
35527c478bd9Sstevel@tonic-gate 		 * not block all streamio ioctls because the ioctl
35537c478bd9Sstevel@tonic-gate 		 * numberspace is not well managed and thus it's possible
35547c478bd9Sstevel@tonic-gate 		 * that a module or driver's ioctl numbers may accidentally
35557c478bd9Sstevel@tonic-gate 		 * collide with them.
35567c478bd9Sstevel@tonic-gate 		 */
35577c478bd9Sstevel@tonic-gate 		switch (strioc.ic_cmd) {
35587c478bd9Sstevel@tonic-gate 		case I_LINK:
35597c478bd9Sstevel@tonic-gate 		case I_PLINK:
35607c478bd9Sstevel@tonic-gate 		case I_UNLINK:
35617c478bd9Sstevel@tonic-gate 		case I_PUNLINK:
35627c478bd9Sstevel@tonic-gate 		case _I_GETPEERCRED:
35637c478bd9Sstevel@tonic-gate 		case _I_PLINK_LH:
35647c478bd9Sstevel@tonic-gate 			return (EINVAL);
35657c478bd9Sstevel@tonic-gate 		}
35667c478bd9Sstevel@tonic-gate 
35677c478bd9Sstevel@tonic-gate 		error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp);
35687c478bd9Sstevel@tonic-gate 		if (error == 0) {
35697c478bd9Sstevel@tonic-gate 			error = strcopyout_strioctl(&strioc, (void *)arg,
35707c478bd9Sstevel@tonic-gate 			    flag, copyflag);
35717c478bd9Sstevel@tonic-gate 		}
35727c478bd9Sstevel@tonic-gate 		return (error);
35737c478bd9Sstevel@tonic-gate 
3574ca9327a6Smeem 	case _I_CMD:
3575ca9327a6Smeem 		/*
3576ca9327a6Smeem 		 * Like I_STR, but without using M_IOC* messages and without
3577ca9327a6Smeem 		 * copyins/copyouts beyond the passed-in argument.
3578ca9327a6Smeem 		 */
3579ca9327a6Smeem 		if (stp->sd_flag & STRHUP)
3580ca9327a6Smeem 			return (ENXIO);
3581ca9327a6Smeem 
3582ca9327a6Smeem 		if ((scp = kmem_alloc(sizeof (strcmd_t), KM_NOSLEEP)) == NULL)
3583ca9327a6Smeem 			return (ENOMEM);
3584ca9327a6Smeem 
3585ca9327a6Smeem 		if (copyin((void *)arg, scp, sizeof (strcmd_t))) {
3586ca9327a6Smeem 			kmem_free(scp, sizeof (strcmd_t));
3587ca9327a6Smeem 			return (EFAULT);
3588ca9327a6Smeem 		}
3589ca9327a6Smeem 
3590ca9327a6Smeem 		access = job_control_type(scp->sc_cmd);
3591ca9327a6Smeem 		mutex_enter(&stp->sd_lock);
3592ca9327a6Smeem 		if (access != -1 && (error = i_straccess(stp, access)) != 0) {
3593ca9327a6Smeem 			mutex_exit(&stp->sd_lock);
3594ca9327a6Smeem 			kmem_free(scp, sizeof (strcmd_t));
3595ca9327a6Smeem 			return (error);
3596ca9327a6Smeem 		}
3597ca9327a6Smeem 		mutex_exit(&stp->sd_lock);
3598ca9327a6Smeem 
3599ca9327a6Smeem 		*rvalp = 0;
3600ca9327a6Smeem 		if ((error = strdocmd(stp, scp, crp)) == 0) {
3601ca9327a6Smeem 			if (copyout(scp, (void *)arg, sizeof (strcmd_t)))
3602ca9327a6Smeem 				error = EFAULT;
3603ca9327a6Smeem 		}
3604ca9327a6Smeem 		kmem_free(scp, sizeof (strcmd_t));
3605ca9327a6Smeem 		return (error);
3606ca9327a6Smeem 
36077c478bd9Sstevel@tonic-gate 	case I_NREAD:
36087c478bd9Sstevel@tonic-gate 		/*
36097c478bd9Sstevel@tonic-gate 		 * Return number of bytes of data in first message
36107c478bd9Sstevel@tonic-gate 		 * in queue in "arg" and return the number of messages
36117c478bd9Sstevel@tonic-gate 		 * in queue in return value.
36127c478bd9Sstevel@tonic-gate 		 */
36137c478bd9Sstevel@tonic-gate 	{
36147c478bd9Sstevel@tonic-gate 		size_t	size;
36157c478bd9Sstevel@tonic-gate 		int	retval;
36167c478bd9Sstevel@tonic-gate 		int	count = 0;
36177c478bd9Sstevel@tonic-gate 
36187c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
36197c478bd9Sstevel@tonic-gate 
36207c478bd9Sstevel@tonic-gate 		size = msgdsize(rdq->q_first);
36217c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
36227c478bd9Sstevel@tonic-gate 			count++;
36237c478bd9Sstevel@tonic-gate 
36247c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
36257c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
36267c478bd9Sstevel@tonic-gate 			infod_t infod;
36277c478bd9Sstevel@tonic-gate 
36287c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_COUNT;
36297c478bd9Sstevel@tonic-gate 			infod.d_count = 0;
36307c478bd9Sstevel@tonic-gate 			if (count == 0) {
36317c478bd9Sstevel@tonic-gate 				infod.d_cmd |= INFOD_FIRSTBYTES;
36327c478bd9Sstevel@tonic-gate 				infod.d_bytes = 0;
36337c478bd9Sstevel@tonic-gate 			}
36347c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
36357c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
36367c478bd9Sstevel@tonic-gate 			count += infod.d_count;
36377c478bd9Sstevel@tonic-gate 			if (infod.d_res & INFOD_FIRSTBYTES)
36387c478bd9Sstevel@tonic-gate 				size = infod.d_bytes;
36397c478bd9Sstevel@tonic-gate 		}
36407c478bd9Sstevel@tonic-gate 
36417c478bd9Sstevel@tonic-gate 		/*
36427c478bd9Sstevel@tonic-gate 		 * Drop down from size_t to the "int" required by the
36437c478bd9Sstevel@tonic-gate 		 * interface.  Cap at INT_MAX.
36447c478bd9Sstevel@tonic-gate 		 */
36457c478bd9Sstevel@tonic-gate 		retval = MIN(size, INT_MAX);
36467c478bd9Sstevel@tonic-gate 		error = strcopyout(&retval, (void *)arg, sizeof (retval),
36477c478bd9Sstevel@tonic-gate 		    copyflag);
36487c478bd9Sstevel@tonic-gate 		if (!error)
36497c478bd9Sstevel@tonic-gate 			*rvalp = count;
36507c478bd9Sstevel@tonic-gate 		return (error);
36517c478bd9Sstevel@tonic-gate 	}
36527c478bd9Sstevel@tonic-gate 
36537c478bd9Sstevel@tonic-gate 	case FIONREAD:
36547c478bd9Sstevel@tonic-gate 		/*
36557c478bd9Sstevel@tonic-gate 		 * Return number of bytes of data in all data messages
36567c478bd9Sstevel@tonic-gate 		 * in queue in "arg".
36577c478bd9Sstevel@tonic-gate 		 */
36587c478bd9Sstevel@tonic-gate 	{
36597c478bd9Sstevel@tonic-gate 		size_t	size = 0;
36607c478bd9Sstevel@tonic-gate 		int	retval;
36617c478bd9Sstevel@tonic-gate 
36627c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
36637c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
36647c478bd9Sstevel@tonic-gate 			size += msgdsize(mp);
36657c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
36687c478bd9Sstevel@tonic-gate 			infod_t infod;
36697c478bd9Sstevel@tonic-gate 
36707c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_BYTES;
36717c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
36727c478bd9Sstevel@tonic-gate 			infod.d_bytes = 0;
36737c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
36747c478bd9Sstevel@tonic-gate 			size += infod.d_bytes;
36757c478bd9Sstevel@tonic-gate 		}
36767c478bd9Sstevel@tonic-gate 
36777c478bd9Sstevel@tonic-gate 		/*
36787c478bd9Sstevel@tonic-gate 		 * Drop down from size_t to the "int" required by the
36797c478bd9Sstevel@tonic-gate 		 * interface.  Cap at INT_MAX.
36807c478bd9Sstevel@tonic-gate 		 */
36817c478bd9Sstevel@tonic-gate 		retval = MIN(size, INT_MAX);
36827c478bd9Sstevel@tonic-gate 		error = strcopyout(&retval, (void *)arg, sizeof (retval),
36837c478bd9Sstevel@tonic-gate 		    copyflag);
36847c478bd9Sstevel@tonic-gate 
36857c478bd9Sstevel@tonic-gate 		*rvalp = 0;
36867c478bd9Sstevel@tonic-gate 		return (error);
36877c478bd9Sstevel@tonic-gate 	}
36887c478bd9Sstevel@tonic-gate 	case FIORDCHK:
36897c478bd9Sstevel@tonic-gate 		/*
36907c478bd9Sstevel@tonic-gate 		 * FIORDCHK does not use arg value (like FIONREAD),
36917c478bd9Sstevel@tonic-gate 		 * instead a count is returned. I_NREAD value may
36927c478bd9Sstevel@tonic-gate 		 * not be accurate but safe. The real thing to do is
36937c478bd9Sstevel@tonic-gate 		 * to add the msgdsizes of all data  messages until
36947c478bd9Sstevel@tonic-gate 		 * a non-data message.
36957c478bd9Sstevel@tonic-gate 		 */
36967c478bd9Sstevel@tonic-gate 	{
36977c478bd9Sstevel@tonic-gate 		size_t size = 0;
36987c478bd9Sstevel@tonic-gate 
36997c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
37007c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
37017c478bd9Sstevel@tonic-gate 			size += msgdsize(mp);
37027c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
37037c478bd9Sstevel@tonic-gate 
37047c478bd9Sstevel@tonic-gate 		if (stp->sd_struiordq) {
37057c478bd9Sstevel@tonic-gate 			infod_t infod;
37067c478bd9Sstevel@tonic-gate 
37077c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_BYTES;
37087c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
37097c478bd9Sstevel@tonic-gate 			infod.d_bytes = 0;
37107c478bd9Sstevel@tonic-gate 			(void) infonext(rdq, &infod);
37117c478bd9Sstevel@tonic-gate 			size += infod.d_bytes;
37127c478bd9Sstevel@tonic-gate 		}
37137c478bd9Sstevel@tonic-gate 
37147c478bd9Sstevel@tonic-gate 		/*
37157c478bd9Sstevel@tonic-gate 		 * Since ioctl returns an int, and memory sizes under
37167c478bd9Sstevel@tonic-gate 		 * LP64 may not fit, we return INT_MAX if the count was
37177c478bd9Sstevel@tonic-gate 		 * actually greater.
37187c478bd9Sstevel@tonic-gate 		 */
37197c478bd9Sstevel@tonic-gate 		*rvalp = MIN(size, INT_MAX);
37207c478bd9Sstevel@tonic-gate 		return (0);
37217c478bd9Sstevel@tonic-gate 	}
37227c478bd9Sstevel@tonic-gate 
37237c478bd9Sstevel@tonic-gate 	case I_FIND:
37247c478bd9Sstevel@tonic-gate 		/*
37257c478bd9Sstevel@tonic-gate 		 * Get module name.
37267c478bd9Sstevel@tonic-gate 		 */
37277c478bd9Sstevel@tonic-gate 	{
37287c478bd9Sstevel@tonic-gate 		char mname[FMNAMESZ + 1];
37297c478bd9Sstevel@tonic-gate 		queue_t *q;
37307c478bd9Sstevel@tonic-gate 
37317c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
37327c478bd9Sstevel@tonic-gate 		    mname, FMNAMESZ + 1, NULL);
37337c478bd9Sstevel@tonic-gate 		if (error)
37347c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
37357c478bd9Sstevel@tonic-gate 
37367c478bd9Sstevel@tonic-gate 		/*
37377c478bd9Sstevel@tonic-gate 		 * Return EINVAL if we're handed a bogus module name.
37387c478bd9Sstevel@tonic-gate 		 */
37397c478bd9Sstevel@tonic-gate 		if (fmodsw_find(mname, FMODSW_LOAD) == NULL) {
37407c478bd9Sstevel@tonic-gate 			TRACE_0(TR_FAC_STREAMS_FR,
37417c478bd9Sstevel@tonic-gate 			    TR_I_CANT_FIND, "couldn't I_FIND");
37427c478bd9Sstevel@tonic-gate 			return (EINVAL);
37437c478bd9Sstevel@tonic-gate 		}
37447c478bd9Sstevel@tonic-gate 
37457c478bd9Sstevel@tonic-gate 		*rvalp = 0;
37467c478bd9Sstevel@tonic-gate 
37477c478bd9Sstevel@tonic-gate 		/* Look downstream to see if module is there. */
37487c478bd9Sstevel@tonic-gate 		claimstr(stp->sd_wrq);
37497c478bd9Sstevel@tonic-gate 		for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
37507c478bd9Sstevel@tonic-gate 			if (q->q_flag & QREADR) {
37517c478bd9Sstevel@tonic-gate 				q = NULL;
37527c478bd9Sstevel@tonic-gate 				break;
37537c478bd9Sstevel@tonic-gate 			}
3754a45f3f93Smeem 			if (strcmp(mname, Q2NAME(q)) == 0)
37557c478bd9Sstevel@tonic-gate 				break;
37567c478bd9Sstevel@tonic-gate 		}
37577c478bd9Sstevel@tonic-gate 		releasestr(stp->sd_wrq);
37587c478bd9Sstevel@tonic-gate 
37597c478bd9Sstevel@tonic-gate 		*rvalp = (q ? 1 : 0);
37607c478bd9Sstevel@tonic-gate 		return (error);
37617c478bd9Sstevel@tonic-gate 	}
37627c478bd9Sstevel@tonic-gate 
37637c478bd9Sstevel@tonic-gate 	case I_PUSH:
37647c478bd9Sstevel@tonic-gate 	case __I_PUSH_NOCTTY:
37657c478bd9Sstevel@tonic-gate 		/*
37667c478bd9Sstevel@tonic-gate 		 * Push a module.
37677c478bd9Sstevel@tonic-gate 		 * For the case __I_PUSH_NOCTTY push a module but
37687c478bd9Sstevel@tonic-gate 		 * do not allocate controlling tty. See bugid 4025044
37697c478bd9Sstevel@tonic-gate 		 */
37707c478bd9Sstevel@tonic-gate 
37717c478bd9Sstevel@tonic-gate 	{
37727c478bd9Sstevel@tonic-gate 		char mname[FMNAMESZ + 1];
37737c478bd9Sstevel@tonic-gate 		fmodsw_impl_t *fp;
37747c478bd9Sstevel@tonic-gate 		dev_t dummydev;
37757c478bd9Sstevel@tonic-gate 
37767c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
37777c478bd9Sstevel@tonic-gate 			return (ENXIO);
37787c478bd9Sstevel@tonic-gate 
37797c478bd9Sstevel@tonic-gate 		/*
37807c478bd9Sstevel@tonic-gate 		 * Get module name and look up in fmodsw.
37817c478bd9Sstevel@tonic-gate 		 */
37827c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
37837c478bd9Sstevel@tonic-gate 		    mname, FMNAMESZ + 1, NULL);
37847c478bd9Sstevel@tonic-gate 		if (error)
37857c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
37867c478bd9Sstevel@tonic-gate 
37877c478bd9Sstevel@tonic-gate 		if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) ==
37887c478bd9Sstevel@tonic-gate 		    NULL)
37897c478bd9Sstevel@tonic-gate 			return (EINVAL);
37907c478bd9Sstevel@tonic-gate 
37917c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH,
37927c478bd9Sstevel@tonic-gate 		    "I_PUSH:fp %p stp %p", fp, stp);
37937c478bd9Sstevel@tonic-gate 
37947c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd)) {
37957c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
37967c478bd9Sstevel@tonic-gate 			return (error);
37977c478bd9Sstevel@tonic-gate 		}
37987c478bd9Sstevel@tonic-gate 
37997c478bd9Sstevel@tonic-gate 		/*
38007c478bd9Sstevel@tonic-gate 		 * See if any more modules can be pushed on this stream.
38017c478bd9Sstevel@tonic-gate 		 * Note that this check must be done after strstartplumb()
38027c478bd9Sstevel@tonic-gate 		 * since otherwise multiple threads issuing I_PUSHes on
38037c478bd9Sstevel@tonic-gate 		 * the same stream will be able to exceed nstrpush.
38047c478bd9Sstevel@tonic-gate 		 */
38057c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
38067c478bd9Sstevel@tonic-gate 		if (stp->sd_pushcnt >= nstrpush) {
38077c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
38087c478bd9Sstevel@tonic-gate 			strendplumb(stp);
38097c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
38107c478bd9Sstevel@tonic-gate 			return (EINVAL);
38117c478bd9Sstevel@tonic-gate 		}
38127c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
38137c478bd9Sstevel@tonic-gate 
38147c478bd9Sstevel@tonic-gate 		/*
38157c478bd9Sstevel@tonic-gate 		 * Push new module and call its open routine
38167c478bd9Sstevel@tonic-gate 		 * via qattach().  Modules don't change device
38177c478bd9Sstevel@tonic-gate 		 * numbers, so just ignore dummydev here.
38187c478bd9Sstevel@tonic-gate 		 */
38197c478bd9Sstevel@tonic-gate 		dummydev = vp->v_rdev;
38207c478bd9Sstevel@tonic-gate 		if ((error = qattach(rdq, &dummydev, 0, crp, fp,
38217c478bd9Sstevel@tonic-gate 		    B_FALSE)) == 0) {
38227c478bd9Sstevel@tonic-gate 			if (vp->v_type == VCHR && /* sorry, no pipes allowed */
38237c478bd9Sstevel@tonic-gate 			    (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) {
38247c478bd9Sstevel@tonic-gate 				/*
38257c478bd9Sstevel@tonic-gate 				 * try to allocate it as a controlling terminal
38267c478bd9Sstevel@tonic-gate 				 */
38279acbbeafSnn35248 				(void) strctty(stp);
38287c478bd9Sstevel@tonic-gate 			}
38297c478bd9Sstevel@tonic-gate 		}
38307c478bd9Sstevel@tonic-gate 
38317c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
38327c478bd9Sstevel@tonic-gate 
38337c478bd9Sstevel@tonic-gate 		/*
38347c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
38357c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
38367c478bd9Sstevel@tonic-gate 		 * head in the stream head.
38377c478bd9Sstevel@tonic-gate 		 */
38387c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(stp->sd_wrq->q_next));
38397c478bd9Sstevel@tonic-gate 		rmin = stp->sd_wrq->q_next->q_minpsz;
38407c478bd9Sstevel@tonic-gate 		rmax = stp->sd_wrq->q_next->q_maxpsz;
38417c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(stp->sd_wrq->q_next));
38427c478bd9Sstevel@tonic-gate 
38437c478bd9Sstevel@tonic-gate 		/* Do this processing here as a performance concern */
38447c478bd9Sstevel@tonic-gate 		if (strmsgsz != 0) {
38457c478bd9Sstevel@tonic-gate 			if (rmax == INFPSZ)
38467c478bd9Sstevel@tonic-gate 				rmax = strmsgsz;
38477c478bd9Sstevel@tonic-gate 			else  {
38487c478bd9Sstevel@tonic-gate 				if (vp->v_type == VFIFO)
38497c478bd9Sstevel@tonic-gate 					rmax = MIN(PIPE_BUF, rmax);
38507c478bd9Sstevel@tonic-gate 				else	rmax = MIN(strmsgsz, rmax);
38517c478bd9Sstevel@tonic-gate 			}
38527c478bd9Sstevel@tonic-gate 		}
38537c478bd9Sstevel@tonic-gate 
38547c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq));
38557c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = rmin;
38567c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = rmax;
38577c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq));
38587c478bd9Sstevel@tonic-gate 
38597c478bd9Sstevel@tonic-gate 		strendplumb(stp);
38607c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
38617c478bd9Sstevel@tonic-gate 		return (error);
38627c478bd9Sstevel@tonic-gate 	}
38637c478bd9Sstevel@tonic-gate 
38647c478bd9Sstevel@tonic-gate 	case I_POP:
38657c478bd9Sstevel@tonic-gate 	{
38667c478bd9Sstevel@tonic-gate 		queue_t	*q;
38677c478bd9Sstevel@tonic-gate 
38687c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
38697c478bd9Sstevel@tonic-gate 			return (ENXIO);
38707c478bd9Sstevel@tonic-gate 		if (!wrq->q_next)	/* for broken pipes */
38717c478bd9Sstevel@tonic-gate 			return (EINVAL);
38727c478bd9Sstevel@tonic-gate 
38737c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd))
38747c478bd9Sstevel@tonic-gate 			return (error);
38757c478bd9Sstevel@tonic-gate 
38767c478bd9Sstevel@tonic-gate 		/*
38777c478bd9Sstevel@tonic-gate 		 * If there is an anchor on this stream and popping
38787c478bd9Sstevel@tonic-gate 		 * the current module would attempt to pop through the
38797c478bd9Sstevel@tonic-gate 		 * anchor, then disallow the pop unless we have sufficient
38807c478bd9Sstevel@tonic-gate 		 * privileges; take the cheapest (non-locking) check
38817c478bd9Sstevel@tonic-gate 		 * first.
38827c478bd9Sstevel@tonic-gate 		 */
3883f4b3ec61Sdh155122 		if (secpolicy_ip_config(crp, B_TRUE) != 0 ||
3884f4b3ec61Sdh155122 		    (stp->sd_anchorzone != crgetzoneid(crp))) {
38857c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
38867c478bd9Sstevel@tonic-gate 			/*
38877c478bd9Sstevel@tonic-gate 			 * Anchors only apply if there's at least one
38887c478bd9Sstevel@tonic-gate 			 * module on the stream (sd_pushcnt > 0).
38897c478bd9Sstevel@tonic-gate 			 */
38907c478bd9Sstevel@tonic-gate 			if (stp->sd_pushcnt > 0 &&
38917c478bd9Sstevel@tonic-gate 			    stp->sd_pushcnt == stp->sd_anchor &&
38927c478bd9Sstevel@tonic-gate 			    stp->sd_vnode->v_type != VFIFO) {
38937c478bd9Sstevel@tonic-gate 				strendplumb(stp);
38947c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
3895f4b3ec61Sdh155122 				if (stp->sd_anchorzone != crgetzoneid(crp))
3896f4b3ec61Sdh155122 					return (EINVAL);
38977c478bd9Sstevel@tonic-gate 				/* Audit and report error */
3898f4b3ec61Sdh155122 				return (secpolicy_ip_config(crp, B_FALSE));
38997c478bd9Sstevel@tonic-gate 			}
39007c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
39017c478bd9Sstevel@tonic-gate 		}
39027c478bd9Sstevel@tonic-gate 
39037c478bd9Sstevel@tonic-gate 		q = wrq->q_next;
39047c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP,
39057c478bd9Sstevel@tonic-gate 		    "I_POP:%p from %p", q, stp);
39067c478bd9Sstevel@tonic-gate 		if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) {
39077c478bd9Sstevel@tonic-gate 			error = EINVAL;
39087c478bd9Sstevel@tonic-gate 		} else {
39097c478bd9Sstevel@tonic-gate 			qdetach(_RD(q), 1, flag, crp, B_FALSE);
39107c478bd9Sstevel@tonic-gate 			error = 0;
39117c478bd9Sstevel@tonic-gate 		}
39127c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
39137c478bd9Sstevel@tonic-gate 
39147c478bd9Sstevel@tonic-gate 		/*
39157c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
39167c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
39177c478bd9Sstevel@tonic-gate 		 * head in the stream head.
39187c478bd9Sstevel@tonic-gate 		 */
39197c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq->q_next));
39207c478bd9Sstevel@tonic-gate 		rmin = wrq->q_next->q_minpsz;
39217c478bd9Sstevel@tonic-gate 		rmax = wrq->q_next->q_maxpsz;
39227c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq->q_next));
39237c478bd9Sstevel@tonic-gate 
39247c478bd9Sstevel@tonic-gate 		/* Do this processing here as a performance concern */
39257c478bd9Sstevel@tonic-gate 		if (strmsgsz != 0) {
39267c478bd9Sstevel@tonic-gate 			if (rmax == INFPSZ)
39277c478bd9Sstevel@tonic-gate 				rmax = strmsgsz;
39287c478bd9Sstevel@tonic-gate 			else  {
39297c478bd9Sstevel@tonic-gate 				if (vp->v_type == VFIFO)
39307c478bd9Sstevel@tonic-gate 					rmax = MIN(PIPE_BUF, rmax);
39317c478bd9Sstevel@tonic-gate 				else	rmax = MIN(strmsgsz, rmax);
39327c478bd9Sstevel@tonic-gate 			}
39337c478bd9Sstevel@tonic-gate 		}
39347c478bd9Sstevel@tonic-gate 
39357c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(wrq));
39367c478bd9Sstevel@tonic-gate 		stp->sd_qn_minpsz = rmin;
39377c478bd9Sstevel@tonic-gate 		stp->sd_qn_maxpsz = rmax;
39387c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(wrq));
39397c478bd9Sstevel@tonic-gate 
39407c478bd9Sstevel@tonic-gate 		/* If we popped through the anchor, then reset the anchor. */
3941f4b3ec61Sdh155122 		if (stp->sd_pushcnt < stp->sd_anchor) {
39427c478bd9Sstevel@tonic-gate 			stp->sd_anchor = 0;
3943f4b3ec61Sdh155122 			stp->sd_anchorzone = 0;
3944f4b3ec61Sdh155122 		}
39457c478bd9Sstevel@tonic-gate 		strendplumb(stp);
39467c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
39477c478bd9Sstevel@tonic-gate 		return (error);
39487c478bd9Sstevel@tonic-gate 	}
39497c478bd9Sstevel@tonic-gate 
39507c478bd9Sstevel@tonic-gate 	case _I_MUXID2FD:
39517c478bd9Sstevel@tonic-gate 	{
39527c478bd9Sstevel@tonic-gate 		/*
39537c478bd9Sstevel@tonic-gate 		 * Create a fd for a I_PLINK'ed lower stream with a given
39547c478bd9Sstevel@tonic-gate 		 * muxid.  With the fd, application can send down ioctls,
39557c478bd9Sstevel@tonic-gate 		 * like I_LIST, to the previously I_PLINK'ed stream.  Note
39567c478bd9Sstevel@tonic-gate 		 * that after getting the fd, the application has to do an
39577c478bd9Sstevel@tonic-gate 		 * I_PUNLINK on the muxid before it can do any operation
39587c478bd9Sstevel@tonic-gate 		 * on the lower stream.  This is required by spec1170.
39597c478bd9Sstevel@tonic-gate 		 *
39607c478bd9Sstevel@tonic-gate 		 * The fd used to do this ioctl should point to the same
39617c478bd9Sstevel@tonic-gate 		 * controlling device used to do the I_PLINK.  If it uses
39627c478bd9Sstevel@tonic-gate 		 * a different stream or an invalid muxid, I_MUXID2FD will
39637c478bd9Sstevel@tonic-gate 		 * fail.  The error code is set to EINVAL.
39647c478bd9Sstevel@tonic-gate 		 *
39657c478bd9Sstevel@tonic-gate 		 * The intended use of this interface is the following.
39667c478bd9Sstevel@tonic-gate 		 * An application I_PLINK'ed a stream and exits.  The fd
39677c478bd9Sstevel@tonic-gate 		 * to the lower stream is gone.  Another application
39687c478bd9Sstevel@tonic-gate 		 * wants to get a fd to the lower stream, it uses I_MUXID2FD.
39697c478bd9Sstevel@tonic-gate 		 */
39707c478bd9Sstevel@tonic-gate 		int muxid = (int)arg;
39717c478bd9Sstevel@tonic-gate 		int fd;
39727c478bd9Sstevel@tonic-gate 		linkinfo_t *linkp;
39737c478bd9Sstevel@tonic-gate 		struct file *fp;
3974f4b3ec61Sdh155122 		netstack_t *ns;
3975f4b3ec61Sdh155122 		str_stack_t *ss;
39767c478bd9Sstevel@tonic-gate 
39777c478bd9Sstevel@tonic-gate 		/*
39787c478bd9Sstevel@tonic-gate 		 * Do not allow the wildcard muxid.  This ioctl is not
39797c478bd9Sstevel@tonic-gate 		 * intended to find arbitrary link.
39807c478bd9Sstevel@tonic-gate 		 */
39817c478bd9Sstevel@tonic-gate 		if (muxid == 0) {
39827c478bd9Sstevel@tonic-gate 			return (EINVAL);
39837c478bd9Sstevel@tonic-gate 		}
39847c478bd9Sstevel@tonic-gate 
3985f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
3986f4b3ec61Sdh155122 		ASSERT(ns != NULL);
3987f4b3ec61Sdh155122 		ss = ns->netstack_str;
3988f4b3ec61Sdh155122 		ASSERT(ss != NULL);
3989f4b3ec61Sdh155122 
39907c478bd9Sstevel@tonic-gate 		mutex_enter(&muxifier);
3991f4b3ec61Sdh155122 		linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss);
39927c478bd9Sstevel@tonic-gate 		if (linkp == NULL) {
39937c478bd9Sstevel@tonic-gate 			mutex_exit(&muxifier);
3994f4b3ec61Sdh155122 			netstack_rele(ss->ss_netstack);
39957c478bd9Sstevel@tonic-gate 			return (EINVAL);
39967c478bd9Sstevel@tonic-gate 		}
39977c478bd9Sstevel@tonic-gate 
39987c478bd9Sstevel@tonic-gate 		if ((fd = ufalloc(0)) == -1) {
39997c478bd9Sstevel@tonic-gate 			mutex_exit(&muxifier);
4000f4b3ec61Sdh155122 			netstack_rele(ss->ss_netstack);
40017c478bd9Sstevel@tonic-gate 			return (EMFILE);
40027c478bd9Sstevel@tonic-gate 		}
40037c478bd9Sstevel@tonic-gate 		fp = linkp->li_fpdown;
40047c478bd9Sstevel@tonic-gate 		mutex_enter(&fp->f_tlock);
40057c478bd9Sstevel@tonic-gate 		fp->f_count++;
40067c478bd9Sstevel@tonic-gate 		mutex_exit(&fp->f_tlock);
40077c478bd9Sstevel@tonic-gate 		mutex_exit(&muxifier);
40087c478bd9Sstevel@tonic-gate 		setf(fd, fp);
40097c478bd9Sstevel@tonic-gate 		*rvalp = fd;
4010f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
40117c478bd9Sstevel@tonic-gate 		return (0);
40127c478bd9Sstevel@tonic-gate 	}
40137c478bd9Sstevel@tonic-gate 
40147c478bd9Sstevel@tonic-gate 	case _I_INSERT:
40157c478bd9Sstevel@tonic-gate 	{
40167c478bd9Sstevel@tonic-gate 		/*
40177c478bd9Sstevel@tonic-gate 		 * To insert a module to a given position in a stream.
40187c478bd9Sstevel@tonic-gate 		 * In the first release, only allow privileged user
4019f4b3ec61Sdh155122 		 * to use this ioctl. Furthermore, the insert is only allowed
4020f4b3ec61Sdh155122 		 * below an anchor if the zoneid is the same as the zoneid
4021f4b3ec61Sdh155122 		 * which created the anchor.
40227c478bd9Sstevel@tonic-gate 		 *
40237c478bd9Sstevel@tonic-gate 		 * Note that we do not plan to support this ioctl
40247c478bd9Sstevel@tonic-gate 		 * on pipes in the first release.  We want to learn more
40257c478bd9Sstevel@tonic-gate 		 * about the implications of these ioctls before extending
40267c478bd9Sstevel@tonic-gate 		 * their support.  And we do not think these features are
40277c478bd9Sstevel@tonic-gate 		 * valuable for pipes.
40287c478bd9Sstevel@tonic-gate 		 */
40297c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strmodconf, strmodinsert);
40307c478bd9Sstevel@tonic-gate 		char mod_name[FMNAMESZ + 1];
40317c478bd9Sstevel@tonic-gate 		fmodsw_impl_t *fp;
40327c478bd9Sstevel@tonic-gate 		dev_t dummydev;
40337c478bd9Sstevel@tonic-gate 		queue_t *tmp_wrq;
40347c478bd9Sstevel@tonic-gate 		int pos;
40357c478bd9Sstevel@tonic-gate 		boolean_t is_insert;
40367c478bd9Sstevel@tonic-gate 
40377c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strmodinsert, flag);
40387c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
40397c478bd9Sstevel@tonic-gate 			return (ENXIO);
40407c478bd9Sstevel@tonic-gate 		if (STRMATED(stp))
40417c478bd9Sstevel@tonic-gate 			return (EINVAL);
40427c478bd9Sstevel@tonic-gate 		if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
40437c478bd9Sstevel@tonic-gate 			return (error);
4044f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
4045f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp))
4046f4b3ec61Sdh155122 			return (EINVAL);
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert),
40497c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strmodinsert), copyflag);
40507c478bd9Sstevel@tonic-gate 		if (error)
40517c478bd9Sstevel@tonic-gate 			return (error);
40527c478bd9Sstevel@tonic-gate 
40537c478bd9Sstevel@tonic-gate 		/*
40547c478bd9Sstevel@tonic-gate 		 * Get module name and look up in fmodsw.
40557c478bd9Sstevel@tonic-gate 		 */
40567c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr :
40577c478bd9Sstevel@tonic-gate 		    copystr)(STRUCT_FGETP(strmodinsert, mod_name),
40587c478bd9Sstevel@tonic-gate 		    mod_name, FMNAMESZ + 1, NULL);
40597c478bd9Sstevel@tonic-gate 		if (error)
40607c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
40617c478bd9Sstevel@tonic-gate 
40627c478bd9Sstevel@tonic-gate 		if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) ==
40637c478bd9Sstevel@tonic-gate 		    NULL)
40647c478bd9Sstevel@tonic-gate 			return (EINVAL);
40657c478bd9Sstevel@tonic-gate 
40667c478bd9Sstevel@tonic-gate 		if (error = strstartplumb(stp, flag, cmd)) {
40677c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
40687c478bd9Sstevel@tonic-gate 			return (error);
40697c478bd9Sstevel@tonic-gate 		}
40707c478bd9Sstevel@tonic-gate 
40717c478bd9Sstevel@tonic-gate 		/*
40727c478bd9Sstevel@tonic-gate 		 * Is this _I_INSERT just like an I_PUSH?  We need to know
40737c478bd9Sstevel@tonic-gate 		 * this because we do some optimizations if this is a
40747c478bd9Sstevel@tonic-gate 		 * module being pushed.
40757c478bd9Sstevel@tonic-gate 		 */
40767c478bd9Sstevel@tonic-gate 		pos = STRUCT_FGET(strmodinsert, pos);
40777c478bd9Sstevel@tonic-gate 		is_insert = (pos != 0);
40787c478bd9Sstevel@tonic-gate 
40797c478bd9Sstevel@tonic-gate 		/*
40807c478bd9Sstevel@tonic-gate 		 * Make sure pos is valid.  Even though it is not an I_PUSH,
40817c478bd9Sstevel@tonic-gate 		 * we impose the same limit on the number of modules in a
40827c478bd9Sstevel@tonic-gate 		 * stream.
40837c478bd9Sstevel@tonic-gate 		 */
40847c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
40857c478bd9Sstevel@tonic-gate 		if (stp->sd_pushcnt >= nstrpush || pos < 0 ||
40867c478bd9Sstevel@tonic-gate 		    pos > stp->sd_pushcnt) {
40877c478bd9Sstevel@tonic-gate 			fmodsw_rele(fp);
40887c478bd9Sstevel@tonic-gate 			strendplumb(stp);
40897c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
40907c478bd9Sstevel@tonic-gate 			return (EINVAL);
40917c478bd9Sstevel@tonic-gate 		}
4092f4b3ec61Sdh155122 		if (stp->sd_anchor != 0) {
4093f4b3ec61Sdh155122 			/*
4094f4b3ec61Sdh155122 			 * Is this insert below the anchor?
4095f4b3ec61Sdh155122 			 * Pushcnt hasn't been increased yet hence
4096f4b3ec61Sdh155122 			 * we test for greater than here, and greater or
4097f4b3ec61Sdh155122 			 * equal after qattach.
4098f4b3ec61Sdh155122 			 */
4099f4b3ec61Sdh155122 			if (pos > (stp->sd_pushcnt - stp->sd_anchor) &&
4100f4b3ec61Sdh155122 			    stp->sd_anchorzone != crgetzoneid(crp)) {
4101f4b3ec61Sdh155122 				fmodsw_rele(fp);
4102f4b3ec61Sdh155122 				strendplumb(stp);
4103f4b3ec61Sdh155122 				mutex_exit(&stp->sd_lock);
4104f4b3ec61Sdh155122 				return (EPERM);
4105f4b3ec61Sdh155122 			}
4106f4b3ec61Sdh155122 		}
4107f4b3ec61Sdh155122 
41087c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
41097c478bd9Sstevel@tonic-gate 
41107c478bd9Sstevel@tonic-gate 		/*
41117c478bd9Sstevel@tonic-gate 		 * First find the correct position this module to
41127c478bd9Sstevel@tonic-gate 		 * be inserted.  We don't need to call claimstr()
41137c478bd9Sstevel@tonic-gate 		 * as the stream should not be changing at this point.
41147c478bd9Sstevel@tonic-gate 		 *
41157c478bd9Sstevel@tonic-gate 		 * Insert new module and call its open routine
41167c478bd9Sstevel@tonic-gate 		 * via qattach().  Modules don't change device
41177c478bd9Sstevel@tonic-gate 		 * numbers, so just ignore dummydev here.
41187c478bd9Sstevel@tonic-gate 		 */
41197c478bd9Sstevel@tonic-gate 		for (tmp_wrq = stp->sd_wrq; pos > 0;
41207c478bd9Sstevel@tonic-gate 		    tmp_wrq = tmp_wrq->q_next, pos--) {
41217c478bd9Sstevel@tonic-gate 			ASSERT(SAMESTR(tmp_wrq));
41227c478bd9Sstevel@tonic-gate 		}
41237c478bd9Sstevel@tonic-gate 		dummydev = vp->v_rdev;
41247c478bd9Sstevel@tonic-gate 		if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp,
41257c478bd9Sstevel@tonic-gate 		    fp, is_insert)) != 0) {
41267c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
41277c478bd9Sstevel@tonic-gate 			strendplumb(stp);
41287c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
41297c478bd9Sstevel@tonic-gate 			return (error);
41307c478bd9Sstevel@tonic-gate 		}
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
41337c478bd9Sstevel@tonic-gate 
41347c478bd9Sstevel@tonic-gate 		/*
41357c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
41367c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
41377c478bd9Sstevel@tonic-gate 		 * head in the stream head.
41387c478bd9Sstevel@tonic-gate 		 */
41397c478bd9Sstevel@tonic-gate 		if (!is_insert) {
41407c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(stp->sd_wrq->q_next));
41417c478bd9Sstevel@tonic-gate 			rmin = stp->sd_wrq->q_next->q_minpsz;
41427c478bd9Sstevel@tonic-gate 			rmax = stp->sd_wrq->q_next->q_maxpsz;
41437c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(stp->sd_wrq->q_next));
41447c478bd9Sstevel@tonic-gate 
41457c478bd9Sstevel@tonic-gate 			/* Do this processing here as a performance concern */
41467c478bd9Sstevel@tonic-gate 			if (strmsgsz != 0) {
41477c478bd9Sstevel@tonic-gate 				if (rmax == INFPSZ) {
41487c478bd9Sstevel@tonic-gate 					rmax = strmsgsz;
41497c478bd9Sstevel@tonic-gate 				} else  {
41507c478bd9Sstevel@tonic-gate 					rmax = MIN(strmsgsz, rmax);
41517c478bd9Sstevel@tonic-gate 				}
41527c478bd9Sstevel@tonic-gate 			}
41537c478bd9Sstevel@tonic-gate 
41547c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq));
41557c478bd9Sstevel@tonic-gate 			stp->sd_qn_minpsz = rmin;
41567c478bd9Sstevel@tonic-gate 			stp->sd_qn_maxpsz = rmax;
41577c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq));
41587c478bd9Sstevel@tonic-gate 		}
41597c478bd9Sstevel@tonic-gate 
41607c478bd9Sstevel@tonic-gate 		/*
41617c478bd9Sstevel@tonic-gate 		 * Need to update the anchor value if this module is
41627c478bd9Sstevel@tonic-gate 		 * inserted below the anchor point.
41637c478bd9Sstevel@tonic-gate 		 */
41647c478bd9Sstevel@tonic-gate 		if (stp->sd_anchor != 0) {
41657c478bd9Sstevel@tonic-gate 			pos = STRUCT_FGET(strmodinsert, pos);
41667c478bd9Sstevel@tonic-gate 			if (pos >= (stp->sd_pushcnt - stp->sd_anchor))
41677c478bd9Sstevel@tonic-gate 				stp->sd_anchor++;
41687c478bd9Sstevel@tonic-gate 		}
41697c478bd9Sstevel@tonic-gate 
41707c478bd9Sstevel@tonic-gate 		strendplumb(stp);
41717c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
41727c478bd9Sstevel@tonic-gate 		return (0);
41737c478bd9Sstevel@tonic-gate 	}
41747c478bd9Sstevel@tonic-gate 
41757c478bd9Sstevel@tonic-gate 	case _I_REMOVE:
41767c478bd9Sstevel@tonic-gate 	{
41777c478bd9Sstevel@tonic-gate 		/*
41787c478bd9Sstevel@tonic-gate 		 * To remove a module with a given name in a stream.  The
41797c478bd9Sstevel@tonic-gate 		 * caller of this ioctl needs to provide both the name and
41807c478bd9Sstevel@tonic-gate 		 * the position of the module to be removed.  This eliminates
41817c478bd9Sstevel@tonic-gate 		 * the ambiguity of removal if a module is inserted/pushed
41827c478bd9Sstevel@tonic-gate 		 * multiple times in a stream.  In the first release, only
41837c478bd9Sstevel@tonic-gate 		 * allow privileged user to use this ioctl.
4184f4b3ec61Sdh155122 		 * Furthermore, the remove is only allowed
4185f4b3ec61Sdh155122 		 * below an anchor if the zoneid is the same as the zoneid
4186f4b3ec61Sdh155122 		 * which created the anchor.
41877c478bd9Sstevel@tonic-gate 		 *
41887c478bd9Sstevel@tonic-gate 		 * Note that we do not plan to support this ioctl
41897c478bd9Sstevel@tonic-gate 		 * on pipes in the first release.  We want to learn more
41907c478bd9Sstevel@tonic-gate 		 * about the implications of these ioctls before extending
41917c478bd9Sstevel@tonic-gate 		 * their support.  And we do not think these features are
41927c478bd9Sstevel@tonic-gate 		 * valuable for pipes.
41937c478bd9Sstevel@tonic-gate 		 *
41947c478bd9Sstevel@tonic-gate 		 * Also note that _I_REMOVE cannot be used to remove a
41957c478bd9Sstevel@tonic-gate 		 * driver or the stream head.
41967c478bd9Sstevel@tonic-gate 		 */
41977c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strmodconf, strmodremove);
41987c478bd9Sstevel@tonic-gate 		queue_t	*q;
41997c478bd9Sstevel@tonic-gate 		int pos;
42007c478bd9Sstevel@tonic-gate 		char mod_name[FMNAMESZ + 1];
42017c478bd9Sstevel@tonic-gate 		boolean_t is_remove;
42027c478bd9Sstevel@tonic-gate 
42037c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strmodremove, flag);
42047c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
42057c478bd9Sstevel@tonic-gate 			return (ENXIO);
42067c478bd9Sstevel@tonic-gate 		if (STRMATED(stp))
42077c478bd9Sstevel@tonic-gate 			return (EINVAL);
42087c478bd9Sstevel@tonic-gate 		if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
42097c478bd9Sstevel@tonic-gate 			return (error);
4210f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
4211f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp))
4212f4b3ec61Sdh155122 			return (EINVAL);
42137c478bd9Sstevel@tonic-gate 
42147c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strmodremove),
42157c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strmodremove), copyflag);
42167c478bd9Sstevel@tonic-gate 		if (error)
42177c478bd9Sstevel@tonic-gate 			return (error);
42187c478bd9Sstevel@tonic-gate 
42197c478bd9Sstevel@tonic-gate 		error = (copyflag & U_TO_K ? copyinstr :
42207c478bd9Sstevel@tonic-gate 		    copystr)(STRUCT_FGETP(strmodremove, mod_name),
42217c478bd9Sstevel@tonic-gate 		    mod_name, FMNAMESZ + 1, NULL);
42227c478bd9Sstevel@tonic-gate 		if (error)
42237c478bd9Sstevel@tonic-gate 			return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
42247c478bd9Sstevel@tonic-gate 
42257c478bd9Sstevel@tonic-gate 		if ((error = strstartplumb(stp, flag, cmd)) != 0)
42267c478bd9Sstevel@tonic-gate 			return (error);
42277c478bd9Sstevel@tonic-gate 
42287c478bd9Sstevel@tonic-gate 		/*
42297c478bd9Sstevel@tonic-gate 		 * Match the name of given module to the name of module at
42307c478bd9Sstevel@tonic-gate 		 * the given position.
42317c478bd9Sstevel@tonic-gate 		 */
42327c478bd9Sstevel@tonic-gate 		pos = STRUCT_FGET(strmodremove, pos);
42337c478bd9Sstevel@tonic-gate 
42347c478bd9Sstevel@tonic-gate 		is_remove = (pos != 0);
42357c478bd9Sstevel@tonic-gate 		for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0;
42367c478bd9Sstevel@tonic-gate 		    q = q->q_next, pos--)
42377c478bd9Sstevel@tonic-gate 			;
42387c478bd9Sstevel@tonic-gate 		if (pos > 0 || !SAMESTR(q) ||
4239a45f3f93Smeem 		    strcmp(Q2NAME(q), mod_name) != 0) {
42407c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
42417c478bd9Sstevel@tonic-gate 			strendplumb(stp);
42427c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
42437c478bd9Sstevel@tonic-gate 			return (EINVAL);
42447c478bd9Sstevel@tonic-gate 		}
42457c478bd9Sstevel@tonic-gate 
4246f4b3ec61Sdh155122 		/*
4247f4b3ec61Sdh155122 		 * If the position is at or below an anchor, then the zoneid
4248f4b3ec61Sdh155122 		 * must match the zoneid that created the anchor.
4249f4b3ec61Sdh155122 		 */
4250f4b3ec61Sdh155122 		if (stp->sd_anchor != 0) {
4251f4b3ec61Sdh155122 			pos = STRUCT_FGET(strmodremove, pos);
4252f4b3ec61Sdh155122 			if (pos >= (stp->sd_pushcnt - stp->sd_anchor) &&
4253f4b3ec61Sdh155122 			    stp->sd_anchorzone != crgetzoneid(crp)) {
4254f4b3ec61Sdh155122 				mutex_enter(&stp->sd_lock);
4255f4b3ec61Sdh155122 				strendplumb(stp);
4256f4b3ec61Sdh155122 				mutex_exit(&stp->sd_lock);
4257f4b3ec61Sdh155122 				return (EPERM);
4258f4b3ec61Sdh155122 			}
4259f4b3ec61Sdh155122 		}
4260f4b3ec61Sdh155122 
4261f4b3ec61Sdh155122 
42627c478bd9Sstevel@tonic-gate 		ASSERT(!(q->q_flag & QREADR));
42637c478bd9Sstevel@tonic-gate 		qdetach(_RD(q), 1, flag, crp, is_remove);
42647c478bd9Sstevel@tonic-gate 
42657c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
42667c478bd9Sstevel@tonic-gate 
42677c478bd9Sstevel@tonic-gate 		/*
42687c478bd9Sstevel@tonic-gate 		 * As a performance concern we are caching the values of
42697c478bd9Sstevel@tonic-gate 		 * q_minpsz and q_maxpsz of the module below the stream
42707c478bd9Sstevel@tonic-gate 		 * head in the stream head.
42717c478bd9Sstevel@tonic-gate 		 */
42727c478bd9Sstevel@tonic-gate 		if (!is_remove) {
42737c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq->q_next));
42747c478bd9Sstevel@tonic-gate 			rmin = wrq->q_next->q_minpsz;
42757c478bd9Sstevel@tonic-gate 			rmax = wrq->q_next->q_maxpsz;
42767c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq->q_next));
42777c478bd9Sstevel@tonic-gate 
42787c478bd9Sstevel@tonic-gate 			/* Do this processing here as a performance concern */
42797c478bd9Sstevel@tonic-gate 			if (strmsgsz != 0) {
42807c478bd9Sstevel@tonic-gate 				if (rmax == INFPSZ)
42817c478bd9Sstevel@tonic-gate 					rmax = strmsgsz;
42827c478bd9Sstevel@tonic-gate 				else  {
42837c478bd9Sstevel@tonic-gate 					if (vp->v_type == VFIFO)
42847c478bd9Sstevel@tonic-gate 						rmax = MIN(PIPE_BUF, rmax);
42857c478bd9Sstevel@tonic-gate 					else	rmax = MIN(strmsgsz, rmax);
42867c478bd9Sstevel@tonic-gate 				}
42877c478bd9Sstevel@tonic-gate 			}
42887c478bd9Sstevel@tonic-gate 
42897c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(wrq));
42907c478bd9Sstevel@tonic-gate 			stp->sd_qn_minpsz = rmin;
42917c478bd9Sstevel@tonic-gate 			stp->sd_qn_maxpsz = rmax;
42927c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(wrq));
42937c478bd9Sstevel@tonic-gate 		}
42947c478bd9Sstevel@tonic-gate 
42957c478bd9Sstevel@tonic-gate 		/*
42967c478bd9Sstevel@tonic-gate 		 * Need to update the anchor value if this module is removed
42977c478bd9Sstevel@tonic-gate 		 * at or below the anchor point.  If the removed module is at
42987c478bd9Sstevel@tonic-gate 		 * the anchor point, remove the anchor for this stream if
42997c478bd9Sstevel@tonic-gate 		 * there is no module above the anchor point.  Otherwise, if
43007c478bd9Sstevel@tonic-gate 		 * the removed module is below the anchor point, decrement the
43017c478bd9Sstevel@tonic-gate 		 * anchor point by 1.
43027c478bd9Sstevel@tonic-gate 		 */
43037c478bd9Sstevel@tonic-gate 		if (stp->sd_anchor != 0) {
43047c478bd9Sstevel@tonic-gate 			pos = STRUCT_FGET(strmodremove, pos);
4305f4b3ec61Sdh155122 			if (pos == stp->sd_pushcnt - stp->sd_anchor + 1)
43067c478bd9Sstevel@tonic-gate 				stp->sd_anchor = 0;
43077c478bd9Sstevel@tonic-gate 			else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1))
43087c478bd9Sstevel@tonic-gate 				stp->sd_anchor--;
43097c478bd9Sstevel@tonic-gate 		}
43107c478bd9Sstevel@tonic-gate 
43117c478bd9Sstevel@tonic-gate 		strendplumb(stp);
43127c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
43137c478bd9Sstevel@tonic-gate 		return (0);
43147c478bd9Sstevel@tonic-gate 	}
43157c478bd9Sstevel@tonic-gate 
43167c478bd9Sstevel@tonic-gate 	case I_ANCHOR:
43177c478bd9Sstevel@tonic-gate 		/*
43187c478bd9Sstevel@tonic-gate 		 * Set the anchor position on the stream to reside at
43197c478bd9Sstevel@tonic-gate 		 * the top module (in other words, the top module
43207c478bd9Sstevel@tonic-gate 		 * cannot be popped).  Anchors with a FIFO make no
43217c478bd9Sstevel@tonic-gate 		 * obvious sense, so they're not allowed.
43227c478bd9Sstevel@tonic-gate 		 */
43237c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
43247c478bd9Sstevel@tonic-gate 
43257c478bd9Sstevel@tonic-gate 		if (stp->sd_vnode->v_type == VFIFO) {
43267c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
43277c478bd9Sstevel@tonic-gate 			return (EINVAL);
43287c478bd9Sstevel@tonic-gate 		}
4329f4b3ec61Sdh155122 		/* Only allow the same zoneid to update the anchor */
4330f4b3ec61Sdh155122 		if (stp->sd_anchor != 0 &&
4331f4b3ec61Sdh155122 		    stp->sd_anchorzone != crgetzoneid(crp)) {
4332f4b3ec61Sdh155122 			mutex_exit(&stp->sd_lock);
4333f4b3ec61Sdh155122 			return (EINVAL);
4334f4b3ec61Sdh155122 		}
43357c478bd9Sstevel@tonic-gate 		stp->sd_anchor = stp->sd_pushcnt;
4336f4b3ec61Sdh155122 		stp->sd_anchorzone = crgetzoneid(crp);
43377c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
43387c478bd9Sstevel@tonic-gate 		return (0);
43397c478bd9Sstevel@tonic-gate 
43407c478bd9Sstevel@tonic-gate 	case I_LOOK:
43417c478bd9Sstevel@tonic-gate 		/*
43427c478bd9Sstevel@tonic-gate 		 * Get name of first module downstream.
43437c478bd9Sstevel@tonic-gate 		 * If no module, return an error.
43447c478bd9Sstevel@tonic-gate 		 */
43457c478bd9Sstevel@tonic-gate 		claimstr(wrq);
4346a45f3f93Smeem 		if (_SAMESTR(wrq) && wrq->q_next->q_next != NULL) {
4347a45f3f93Smeem 			char *name = Q2NAME(wrq->q_next);
4348a45f3f93Smeem 
43497c478bd9Sstevel@tonic-gate 			error = strcopyout(name, (void *)arg, strlen(name) + 1,
43507c478bd9Sstevel@tonic-gate 			    copyflag);
43517c478bd9Sstevel@tonic-gate 			releasestr(wrq);
43527c478bd9Sstevel@tonic-gate 			return (error);
43537c478bd9Sstevel@tonic-gate 		}
43547c478bd9Sstevel@tonic-gate 		releasestr(wrq);
43557c478bd9Sstevel@tonic-gate 		return (EINVAL);
43567c478bd9Sstevel@tonic-gate 
43577c478bd9Sstevel@tonic-gate 	case I_LINK:
43587c478bd9Sstevel@tonic-gate 	case I_PLINK:
43597c478bd9Sstevel@tonic-gate 		/*
43607c478bd9Sstevel@tonic-gate 		 * Link a multiplexor.
43617c478bd9Sstevel@tonic-gate 		 */
4362a45f3f93Smeem 		return (mlink(vp, cmd, (int)arg, crp, rvalp, 0));
43637c478bd9Sstevel@tonic-gate 
43647c478bd9Sstevel@tonic-gate 	case _I_PLINK_LH:
43657c478bd9Sstevel@tonic-gate 		/*
43667c478bd9Sstevel@tonic-gate 		 * Link a multiplexor: Call must originate from kernel.
43677c478bd9Sstevel@tonic-gate 		 */
43687c478bd9Sstevel@tonic-gate 		if (kioctl)
43697c478bd9Sstevel@tonic-gate 			return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp));
43707c478bd9Sstevel@tonic-gate 
43717c478bd9Sstevel@tonic-gate 		return (EINVAL);
43727c478bd9Sstevel@tonic-gate 	case I_UNLINK:
43737c478bd9Sstevel@tonic-gate 	case I_PUNLINK:
43747c478bd9Sstevel@tonic-gate 		/*
43757c478bd9Sstevel@tonic-gate 		 * Unlink a multiplexor.
43767c478bd9Sstevel@tonic-gate 		 * If arg is -1, unlink all links for which this is the
43777c478bd9Sstevel@tonic-gate 		 * controlling stream.  Otherwise, arg is an index number
43787c478bd9Sstevel@tonic-gate 		 * for a link to be removed.
43797c478bd9Sstevel@tonic-gate 		 */
43807c478bd9Sstevel@tonic-gate 	{
43817c478bd9Sstevel@tonic-gate 		struct linkinfo *linkp;
43827c478bd9Sstevel@tonic-gate 		int native_arg = (int)arg;
43837c478bd9Sstevel@tonic-gate 		int type;
4384f4b3ec61Sdh155122 		netstack_t *ns;
4385f4b3ec61Sdh155122 		str_stack_t *ss;
43867c478bd9Sstevel@tonic-gate 
43877c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR,
43887c478bd9Sstevel@tonic-gate 		    TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp);
43897c478bd9Sstevel@tonic-gate 		if (vp->v_type == VFIFO) {
43907c478bd9Sstevel@tonic-gate 			return (EINVAL);
43917c478bd9Sstevel@tonic-gate 		}
43927c478bd9Sstevel@tonic-gate 		if (cmd == I_UNLINK)
43937c478bd9Sstevel@tonic-gate 			type = LINKNORMAL;
43947c478bd9Sstevel@tonic-gate 		else	/* I_PUNLINK */
43957c478bd9Sstevel@tonic-gate 			type = LINKPERSIST;
43967c478bd9Sstevel@tonic-gate 		if (native_arg == 0) {
43977c478bd9Sstevel@tonic-gate 			return (EINVAL);
43987c478bd9Sstevel@tonic-gate 		}
4399f4b3ec61Sdh155122 		ns = netstack_find_by_cred(crp);
4400f4b3ec61Sdh155122 		ASSERT(ns != NULL);
4401f4b3ec61Sdh155122 		ss = ns->netstack_str;
4402f4b3ec61Sdh155122 		ASSERT(ss != NULL);
4403f4b3ec61Sdh155122 
44047c478bd9Sstevel@tonic-gate 		if (native_arg == MUXID_ALL)
4405f4b3ec61Sdh155122 			error = munlinkall(stp, type, crp, rvalp, ss);
44067c478bd9Sstevel@tonic-gate 		else {
44077c478bd9Sstevel@tonic-gate 			mutex_enter(&muxifier);
4408f4b3ec61Sdh155122 			if (!(linkp = findlinks(stp, (int)arg, type, ss))) {
44097c478bd9Sstevel@tonic-gate 				/* invalid user supplied index number */
44107c478bd9Sstevel@tonic-gate 				mutex_exit(&muxifier);
4411f4b3ec61Sdh155122 				netstack_rele(ss->ss_netstack);
44127c478bd9Sstevel@tonic-gate 				return (EINVAL);
44137c478bd9Sstevel@tonic-gate 			}
44147c478bd9Sstevel@tonic-gate 			/* munlink drops the muxifier lock */
4415f4b3ec61Sdh155122 			error = munlink(stp, linkp, type, crp, rvalp, ss);
44167c478bd9Sstevel@tonic-gate 		}
4417f4b3ec61Sdh155122 		netstack_rele(ss->ss_netstack);
44187c478bd9Sstevel@tonic-gate 		return (error);
44197c478bd9Sstevel@tonic-gate 	}
44207c478bd9Sstevel@tonic-gate 
44217c478bd9Sstevel@tonic-gate 	case I_FLUSH:
44227c478bd9Sstevel@tonic-gate 		/*
44237c478bd9Sstevel@tonic-gate 		 * send a flush message downstream
44247c478bd9Sstevel@tonic-gate 		 * flush message can indicate
44257c478bd9Sstevel@tonic-gate 		 * FLUSHR - flush read queue
44267c478bd9Sstevel@tonic-gate 		 * FLUSHW - flush write queue
44277c478bd9Sstevel@tonic-gate 		 * FLUSHRW - flush read/write queue
44287c478bd9Sstevel@tonic-gate 		 */
44297c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
44307c478bd9Sstevel@tonic-gate 			return (ENXIO);
44317c478bd9Sstevel@tonic-gate 		if (arg & ~FLUSHRW)
44327c478bd9Sstevel@tonic-gate 			return (EINVAL);
44337c478bd9Sstevel@tonic-gate 
44347c478bd9Sstevel@tonic-gate 		for (;;) {
44357c478bd9Sstevel@tonic-gate 			if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) {
44367c478bd9Sstevel@tonic-gate 				break;
44377c478bd9Sstevel@tonic-gate 			}
44387c478bd9Sstevel@tonic-gate 			if (error = strwaitbuf(1, BPRI_HI)) {
44397c478bd9Sstevel@tonic-gate 				return (error);
44407c478bd9Sstevel@tonic-gate 			}
44417c478bd9Sstevel@tonic-gate 		}
44427c478bd9Sstevel@tonic-gate 
44437c478bd9Sstevel@tonic-gate 		/*
44447c478bd9Sstevel@tonic-gate 		 * Send down an unsupported ioctl and wait for the nack
44457c478bd9Sstevel@tonic-gate 		 * in order to allow the M_FLUSH to propagate back
44467c478bd9Sstevel@tonic-gate 		 * up to the stream head.
44477c478bd9Sstevel@tonic-gate 		 * Replaces if (qready()) runqueues();
44487c478bd9Sstevel@tonic-gate 		 */
44497c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = -1;	/* The unsupported ioctl */
44507c478bd9Sstevel@tonic-gate 		strioc.ic_timout = 0;
44517c478bd9Sstevel@tonic-gate 		strioc.ic_len = 0;
44527c478bd9Sstevel@tonic-gate 		strioc.ic_dp = NULL;
44537c478bd9Sstevel@tonic-gate 		(void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
44547c478bd9Sstevel@tonic-gate 		*rvalp = 0;
44557c478bd9Sstevel@tonic-gate 		return (0);
44567c478bd9Sstevel@tonic-gate 
44577c478bd9Sstevel@tonic-gate 	case I_FLUSHBAND:
44587c478bd9Sstevel@tonic-gate 	{
44597c478bd9Sstevel@tonic-gate 		struct bandinfo binfo;
44607c478bd9Sstevel@tonic-gate 
44617c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &binfo, sizeof (binfo),
44627c478bd9Sstevel@tonic-gate 		    copyflag);
44637c478bd9Sstevel@tonic-gate 		if (error)
44647c478bd9Sstevel@tonic-gate 			return (error);
44657c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
44667c478bd9Sstevel@tonic-gate 			return (ENXIO);
44677c478bd9Sstevel@tonic-gate 		if (binfo.bi_flag & ~FLUSHRW)
44687c478bd9Sstevel@tonic-gate 			return (EINVAL);
44697c478bd9Sstevel@tonic-gate 		while (!(mp = allocb(2, BPRI_HI))) {
44707c478bd9Sstevel@tonic-gate 			if (error = strwaitbuf(2, BPRI_HI))
44717c478bd9Sstevel@tonic-gate 				return (error);
44727c478bd9Sstevel@tonic-gate 		}
44737c478bd9Sstevel@tonic-gate 		mp->b_datap->db_type = M_FLUSH;
44747c478bd9Sstevel@tonic-gate 		*mp->b_wptr++ = binfo.bi_flag | FLUSHBAND;
44757c478bd9Sstevel@tonic-gate 		*mp->b_wptr++ = binfo.bi_pri;
44767c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, mp);
44777c478bd9Sstevel@tonic-gate 		/*
44787c478bd9Sstevel@tonic-gate 		 * Send down an unsupported ioctl and wait for the nack
44797c478bd9Sstevel@tonic-gate 		 * in order to allow the M_FLUSH to propagate back
44807c478bd9Sstevel@tonic-gate 		 * up to the stream head.
44817c478bd9Sstevel@tonic-gate 		 * Replaces if (qready()) runqueues();
44827c478bd9Sstevel@tonic-gate 		 */
44837c478bd9Sstevel@tonic-gate 		strioc.ic_cmd = -1;	/* The unsupported ioctl */
44847c478bd9Sstevel@tonic-gate 		strioc.ic_timout = 0;
44857c478bd9Sstevel@tonic-gate 		strioc.ic_len = 0;
44867c478bd9Sstevel@tonic-gate 		strioc.ic_dp = NULL;
44877c478bd9Sstevel@tonic-gate 		(void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
44887c478bd9Sstevel@tonic-gate 		*rvalp = 0;
44897c478bd9Sstevel@tonic-gate 		return (0);
44907c478bd9Sstevel@tonic-gate 	}
44917c478bd9Sstevel@tonic-gate 
44927c478bd9Sstevel@tonic-gate 	case I_SRDOPT:
44937c478bd9Sstevel@tonic-gate 		/*
44947c478bd9Sstevel@tonic-gate 		 * Set read options
44957c478bd9Sstevel@tonic-gate 		 *
44967c478bd9Sstevel@tonic-gate 		 * RNORM - default stream mode
44977c478bd9Sstevel@tonic-gate 		 * RMSGN - message no discard
44987c478bd9Sstevel@tonic-gate 		 * RMSGD - message discard
44997c478bd9Sstevel@tonic-gate 		 * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs
45007c478bd9Sstevel@tonic-gate 		 * RPROTDAT - convert M_[PC]PROTOs to M_DATAs
45017c478bd9Sstevel@tonic-gate 		 * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs
45027c478bd9Sstevel@tonic-gate 		 */
45037c478bd9Sstevel@tonic-gate 		if (arg & ~(RMODEMASK | RPROTMASK))
45047c478bd9Sstevel@tonic-gate 			return (EINVAL);
45057c478bd9Sstevel@tonic-gate 
45067c478bd9Sstevel@tonic-gate 		if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN))
45077c478bd9Sstevel@tonic-gate 			return (EINVAL);
45087c478bd9Sstevel@tonic-gate 
45097c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
45107c478bd9Sstevel@tonic-gate 		switch (arg & RMODEMASK) {
45117c478bd9Sstevel@tonic-gate 		case RNORM:
45127c478bd9Sstevel@tonic-gate 			stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
45137c478bd9Sstevel@tonic-gate 			break;
45147c478bd9Sstevel@tonic-gate 		case RMSGD:
45157c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) |
45167c478bd9Sstevel@tonic-gate 			    RD_MSGDIS;
45177c478bd9Sstevel@tonic-gate 			break;
45187c478bd9Sstevel@tonic-gate 		case RMSGN:
45197c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) |
45207c478bd9Sstevel@tonic-gate 			    RD_MSGNODIS;
45217c478bd9Sstevel@tonic-gate 			break;
45227c478bd9Sstevel@tonic-gate 		}
45237c478bd9Sstevel@tonic-gate 
45247c478bd9Sstevel@tonic-gate 		switch (arg & RPROTMASK) {
45257c478bd9Sstevel@tonic-gate 		case RPROTNORM:
45267c478bd9Sstevel@tonic-gate 			stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
45277c478bd9Sstevel@tonic-gate 			break;
45287c478bd9Sstevel@tonic-gate 
45297c478bd9Sstevel@tonic-gate 		case RPROTDAT:
45307c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) |
45317c478bd9Sstevel@tonic-gate 			    RD_PROTDAT);
45327c478bd9Sstevel@tonic-gate 			break;
45337c478bd9Sstevel@tonic-gate 
45347c478bd9Sstevel@tonic-gate 		case RPROTDIS:
45357c478bd9Sstevel@tonic-gate 			stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) |
45367c478bd9Sstevel@tonic-gate 			    RD_PROTDIS);
45377c478bd9Sstevel@tonic-gate 			break;
45387c478bd9Sstevel@tonic-gate 		}
45397c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
45407c478bd9Sstevel@tonic-gate 		return (0);
45417c478bd9Sstevel@tonic-gate 
45427c478bd9Sstevel@tonic-gate 	case I_GRDOPT:
45437c478bd9Sstevel@tonic-gate 		/*
45447c478bd9Sstevel@tonic-gate 		 * Get read option and return the value
45457c478bd9Sstevel@tonic-gate 		 * to spot pointed to by arg
45467c478bd9Sstevel@tonic-gate 		 */
45477c478bd9Sstevel@tonic-gate 	{
45487c478bd9Sstevel@tonic-gate 		int rdopt;
45497c478bd9Sstevel@tonic-gate 
45507c478bd9Sstevel@tonic-gate 		rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD :
45517c478bd9Sstevel@tonic-gate 		    ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM));
45527c478bd9Sstevel@tonic-gate 		rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT :
45537c478bd9Sstevel@tonic-gate 		    ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM));
45547c478bd9Sstevel@tonic-gate 
45557c478bd9Sstevel@tonic-gate 		return (strcopyout(&rdopt, (void *)arg, sizeof (int),
45567c478bd9Sstevel@tonic-gate 		    copyflag));
45577c478bd9Sstevel@tonic-gate 	}
45587c478bd9Sstevel@tonic-gate 
45597c478bd9Sstevel@tonic-gate 	case I_SERROPT:
45607c478bd9Sstevel@tonic-gate 		/*
45617c478bd9Sstevel@tonic-gate 		 * Set error options
45627c478bd9Sstevel@tonic-gate 		 *
45637c478bd9Sstevel@tonic-gate 		 * RERRNORM - persistent read errors
45647c478bd9Sstevel@tonic-gate 		 * RERRNONPERSIST - non-persistent read errors
45657c478bd9Sstevel@tonic-gate 		 * WERRNORM - persistent write errors
45667c478bd9Sstevel@tonic-gate 		 * WERRNONPERSIST - non-persistent write errors
45677c478bd9Sstevel@tonic-gate 		 */
45687c478bd9Sstevel@tonic-gate 		if (arg & ~(RERRMASK | WERRMASK))
45697c478bd9Sstevel@tonic-gate 			return (EINVAL);
45707c478bd9Sstevel@tonic-gate 
45717c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
45727c478bd9Sstevel@tonic-gate 		switch (arg & RERRMASK) {
45737c478bd9Sstevel@tonic-gate 		case RERRNORM:
45747c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRDERRNONPERSIST;
45757c478bd9Sstevel@tonic-gate 			break;
45767c478bd9Sstevel@tonic-gate 		case RERRNONPERSIST:
45777c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STRDERRNONPERSIST;
45787c478bd9Sstevel@tonic-gate 			break;
45797c478bd9Sstevel@tonic-gate 		}
45807c478bd9Sstevel@tonic-gate 		switch (arg & WERRMASK) {
45817c478bd9Sstevel@tonic-gate 		case WERRNORM:
45827c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STWRERRNONPERSIST;
45837c478bd9Sstevel@tonic-gate 			break;
45847c478bd9Sstevel@tonic-gate 		case WERRNONPERSIST:
45857c478bd9Sstevel@tonic-gate 			stp->sd_flag |= STWRERRNONPERSIST;
45867c478bd9Sstevel@tonic-gate 			break;
45877c478bd9Sstevel@tonic-gate 		}
45887c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
45897c478bd9Sstevel@tonic-gate 		return (0);
45907c478bd9Sstevel@tonic-gate 
45917c478bd9Sstevel@tonic-gate 	case I_GERROPT:
45927c478bd9Sstevel@tonic-gate 		/*
45937c478bd9Sstevel@tonic-gate 		 * Get error option and return the value
45947c478bd9Sstevel@tonic-gate 		 * to spot pointed to by arg
45957c478bd9Sstevel@tonic-gate 		 */
45967c478bd9Sstevel@tonic-gate 	{
45977c478bd9Sstevel@tonic-gate 		int erropt = 0;
45987c478bd9Sstevel@tonic-gate 
45997c478bd9Sstevel@tonic-gate 		erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST :
46007c478bd9Sstevel@tonic-gate 		    RERRNORM;
46017c478bd9Sstevel@tonic-gate 		erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST :
46027c478bd9Sstevel@tonic-gate 		    WERRNORM;
46037c478bd9Sstevel@tonic-gate 		return (strcopyout(&erropt, (void *)arg, sizeof (int),
46047c478bd9Sstevel@tonic-gate 		    copyflag));
46057c478bd9Sstevel@tonic-gate 	}
46067c478bd9Sstevel@tonic-gate 
46077c478bd9Sstevel@tonic-gate 	case I_SETSIG:
46087c478bd9Sstevel@tonic-gate 		/*
46097c478bd9Sstevel@tonic-gate 		 * Register the calling proc to receive the SIGPOLL
46107c478bd9Sstevel@tonic-gate 		 * signal based on the events given in arg.  If
46117c478bd9Sstevel@tonic-gate 		 * arg is zero, remove the proc from register list.
46127c478bd9Sstevel@tonic-gate 		 */
46137c478bd9Sstevel@tonic-gate 	{
46147c478bd9Sstevel@tonic-gate 		strsig_t *ssp, *pssp;
46157c478bd9Sstevel@tonic-gate 		struct pid *pidp;
46167c478bd9Sstevel@tonic-gate 
46177c478bd9Sstevel@tonic-gate 		pssp = NULL;
46187c478bd9Sstevel@tonic-gate 		pidp = curproc->p_pidp;
46197c478bd9Sstevel@tonic-gate 		/*
46207c478bd9Sstevel@tonic-gate 		 * Hold sd_lock to prevent traversal of sd_siglist while
46217c478bd9Sstevel@tonic-gate 		 * it is modified.
46227c478bd9Sstevel@tonic-gate 		 */
46237c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
46247c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp);
46257c478bd9Sstevel@tonic-gate 		    pssp = ssp, ssp = ssp->ss_next)
46267c478bd9Sstevel@tonic-gate 			;
46277c478bd9Sstevel@tonic-gate 
46287c478bd9Sstevel@tonic-gate 		if (arg) {
46297c478bd9Sstevel@tonic-gate 			if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
46307c478bd9Sstevel@tonic-gate 			    S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
46317c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
46327c478bd9Sstevel@tonic-gate 				return (EINVAL);
46337c478bd9Sstevel@tonic-gate 			}
46347c478bd9Sstevel@tonic-gate 			if ((arg & S_BANDURG) && !(arg & S_RDBAND)) {
46357c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
46367c478bd9Sstevel@tonic-gate 				return (EINVAL);
46377c478bd9Sstevel@tonic-gate 			}
46387c478bd9Sstevel@tonic-gate 
46397c478bd9Sstevel@tonic-gate 			/*
46407c478bd9Sstevel@tonic-gate 			 * If proc not already registered, add it
46417c478bd9Sstevel@tonic-gate 			 * to list.
46427c478bd9Sstevel@tonic-gate 			 */
46437c478bd9Sstevel@tonic-gate 			if (!ssp) {
46447c478bd9Sstevel@tonic-gate 				ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
46457c478bd9Sstevel@tonic-gate 				ssp->ss_pidp = pidp;
46467c478bd9Sstevel@tonic-gate 				ssp->ss_pid = pidp->pid_id;
46477c478bd9Sstevel@tonic-gate 				ssp->ss_next = NULL;
46487c478bd9Sstevel@tonic-gate 				if (pssp)
46497c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp;
46507c478bd9Sstevel@tonic-gate 				else
46517c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp;
46527c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
46537c478bd9Sstevel@tonic-gate 				PID_HOLD(pidp);
46547c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
46557c478bd9Sstevel@tonic-gate 			}
46567c478bd9Sstevel@tonic-gate 
46577c478bd9Sstevel@tonic-gate 			/*
46587c478bd9Sstevel@tonic-gate 			 * Set events.
46597c478bd9Sstevel@tonic-gate 			 */
46607c478bd9Sstevel@tonic-gate 			ssp->ss_events = (int)arg;
46617c478bd9Sstevel@tonic-gate 		} else {
46627c478bd9Sstevel@tonic-gate 			/*
46637c478bd9Sstevel@tonic-gate 			 * Remove proc from register list.
46647c478bd9Sstevel@tonic-gate 			 */
46657c478bd9Sstevel@tonic-gate 			if (ssp) {
46667c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
46677c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
46687c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
46697c478bd9Sstevel@tonic-gate 				if (pssp)
46707c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp->ss_next;
46717c478bd9Sstevel@tonic-gate 				else
46727c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp->ss_next;
46737c478bd9Sstevel@tonic-gate 				kmem_free(ssp, sizeof (strsig_t));
46747c478bd9Sstevel@tonic-gate 			} else {
46757c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
46767c478bd9Sstevel@tonic-gate 				return (EINVAL);
46777c478bd9Sstevel@tonic-gate 			}
46787c478bd9Sstevel@tonic-gate 		}
46797c478bd9Sstevel@tonic-gate 
46807c478bd9Sstevel@tonic-gate 		/*
46817c478bd9Sstevel@tonic-gate 		 * Recalculate OR of sig events.
46827c478bd9Sstevel@tonic-gate 		 */
46837c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
46847c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
46857c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
46867c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
46877c478bd9Sstevel@tonic-gate 		return (0);
46887c478bd9Sstevel@tonic-gate 	}
46897c478bd9Sstevel@tonic-gate 
46907c478bd9Sstevel@tonic-gate 	case I_GETSIG:
46917c478bd9Sstevel@tonic-gate 		/*
46927c478bd9Sstevel@tonic-gate 		 * Return (in arg) the current registration of events
46937c478bd9Sstevel@tonic-gate 		 * for which the calling proc is to be signaled.
46947c478bd9Sstevel@tonic-gate 		 */
46957c478bd9Sstevel@tonic-gate 	{
46967c478bd9Sstevel@tonic-gate 		struct strsig *ssp;
46977c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
46987c478bd9Sstevel@tonic-gate 
46997c478bd9Sstevel@tonic-gate 		pidp = curproc->p_pidp;
47007c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
47017c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
47027c478bd9Sstevel@tonic-gate 			if (ssp->ss_pidp == pidp) {
47037c478bd9Sstevel@tonic-gate 				error = strcopyout(&ssp->ss_events, (void *)arg,
47047c478bd9Sstevel@tonic-gate 				    sizeof (int), copyflag);
47057c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47067c478bd9Sstevel@tonic-gate 				return (error);
47077c478bd9Sstevel@tonic-gate 			}
47087c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
47097c478bd9Sstevel@tonic-gate 		return (EINVAL);
47107c478bd9Sstevel@tonic-gate 	}
47117c478bd9Sstevel@tonic-gate 
47127c478bd9Sstevel@tonic-gate 	case I_ESETSIG:
47137c478bd9Sstevel@tonic-gate 		/*
47147c478bd9Sstevel@tonic-gate 		 * Register the ss_pid to receive the SIGPOLL
47157c478bd9Sstevel@tonic-gate 		 * signal based on the events is ss_events arg.  If
47167c478bd9Sstevel@tonic-gate 		 * ss_events is zero, remove the proc from register list.
47177c478bd9Sstevel@tonic-gate 		 */
47187c478bd9Sstevel@tonic-gate 	{
47197c478bd9Sstevel@tonic-gate 		struct strsig *ssp, *pssp;
47207c478bd9Sstevel@tonic-gate 		struct proc *proc;
47217c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
47227c478bd9Sstevel@tonic-gate 		pid_t pid;
47237c478bd9Sstevel@tonic-gate 		struct strsigset ss;
47247c478bd9Sstevel@tonic-gate 
47257c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
47267c478bd9Sstevel@tonic-gate 		if (error)
47277c478bd9Sstevel@tonic-gate 			return (error);
47287c478bd9Sstevel@tonic-gate 
47297c478bd9Sstevel@tonic-gate 		pid = ss.ss_pid;
47307c478bd9Sstevel@tonic-gate 
47317c478bd9Sstevel@tonic-gate 		if (ss.ss_events != 0) {
47327c478bd9Sstevel@tonic-gate 			/*
47337c478bd9Sstevel@tonic-gate 			 * Permissions check by sending signal 0.
47347c478bd9Sstevel@tonic-gate 			 * Note that when kill fails it does a set_errno
47357c478bd9Sstevel@tonic-gate 			 * causing the system call to fail.
47367c478bd9Sstevel@tonic-gate 			 */
47377c478bd9Sstevel@tonic-gate 			error = kill(pid, 0);
47387c478bd9Sstevel@tonic-gate 			if (error) {
47397c478bd9Sstevel@tonic-gate 				return (error);
47407c478bd9Sstevel@tonic-gate 			}
47417c478bd9Sstevel@tonic-gate 		}
47427c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
47437c478bd9Sstevel@tonic-gate 		if (pid == 0)
47447c478bd9Sstevel@tonic-gate 			proc = curproc;
47457c478bd9Sstevel@tonic-gate 		else if (pid < 0)
47467c478bd9Sstevel@tonic-gate 			proc = pgfind(-pid);
47477c478bd9Sstevel@tonic-gate 		else
47487c478bd9Sstevel@tonic-gate 			proc = prfind(pid);
47497c478bd9Sstevel@tonic-gate 		if (proc == NULL) {
47507c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
47517c478bd9Sstevel@tonic-gate 			return (ESRCH);
47527c478bd9Sstevel@tonic-gate 		}
47537c478bd9Sstevel@tonic-gate 		if (pid < 0)
47547c478bd9Sstevel@tonic-gate 			pidp = proc->p_pgidp;
47557c478bd9Sstevel@tonic-gate 		else
47567c478bd9Sstevel@tonic-gate 			pidp = proc->p_pidp;
47577c478bd9Sstevel@tonic-gate 		ASSERT(pidp);
47587c478bd9Sstevel@tonic-gate 		/*
47597c478bd9Sstevel@tonic-gate 		 * Get a hold on the pid structure while referencing it.
47607c478bd9Sstevel@tonic-gate 		 * There is a separate PID_HOLD should it be inserted
47617c478bd9Sstevel@tonic-gate 		 * in the list below.
47627c478bd9Sstevel@tonic-gate 		 */
47637c478bd9Sstevel@tonic-gate 		PID_HOLD(pidp);
47647c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
47657c478bd9Sstevel@tonic-gate 
47667c478bd9Sstevel@tonic-gate 		pssp = NULL;
47677c478bd9Sstevel@tonic-gate 		/*
47687c478bd9Sstevel@tonic-gate 		 * Hold sd_lock to prevent traversal of sd_siglist while
47697c478bd9Sstevel@tonic-gate 		 * it is modified.
47707c478bd9Sstevel@tonic-gate 		 */
47717c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
47727c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid);
47737c478bd9Sstevel@tonic-gate 		    pssp = ssp, ssp = ssp->ss_next)
47747c478bd9Sstevel@tonic-gate 			;
47757c478bd9Sstevel@tonic-gate 
47767c478bd9Sstevel@tonic-gate 		if (ss.ss_events) {
47777c478bd9Sstevel@tonic-gate 			if (ss.ss_events &
47787c478bd9Sstevel@tonic-gate 			    ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
47797c478bd9Sstevel@tonic-gate 			    S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
47807c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47817c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47827c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47837c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47847c478bd9Sstevel@tonic-gate 				return (EINVAL);
47857c478bd9Sstevel@tonic-gate 			}
47867c478bd9Sstevel@tonic-gate 			if ((ss.ss_events & S_BANDURG) &&
47877c478bd9Sstevel@tonic-gate 			    !(ss.ss_events & S_RDBAND)) {
47887c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
47897c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
47907c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
47917c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
47927c478bd9Sstevel@tonic-gate 				return (EINVAL);
47937c478bd9Sstevel@tonic-gate 			}
47947c478bd9Sstevel@tonic-gate 
47957c478bd9Sstevel@tonic-gate 			/*
47967c478bd9Sstevel@tonic-gate 			 * If proc not already registered, add it
47977c478bd9Sstevel@tonic-gate 			 * to list.
47987c478bd9Sstevel@tonic-gate 			 */
47997c478bd9Sstevel@tonic-gate 			if (!ssp) {
48007c478bd9Sstevel@tonic-gate 				ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
48017c478bd9Sstevel@tonic-gate 				ssp->ss_pidp = pidp;
48027c478bd9Sstevel@tonic-gate 				ssp->ss_pid = pid;
48037c478bd9Sstevel@tonic-gate 				ssp->ss_next = NULL;
48047c478bd9Sstevel@tonic-gate 				if (pssp)
48057c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp;
48067c478bd9Sstevel@tonic-gate 				else
48077c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp;
48087c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
48097c478bd9Sstevel@tonic-gate 				PID_HOLD(pidp);
48107c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
48117c478bd9Sstevel@tonic-gate 			}
48127c478bd9Sstevel@tonic-gate 
48137c478bd9Sstevel@tonic-gate 			/*
48147c478bd9Sstevel@tonic-gate 			 * Set events.
48157c478bd9Sstevel@tonic-gate 			 */
48167c478bd9Sstevel@tonic-gate 			ssp->ss_events = ss.ss_events;
48177c478bd9Sstevel@tonic-gate 		} else {
48187c478bd9Sstevel@tonic-gate 			/*
48197c478bd9Sstevel@tonic-gate 			 * Remove proc from register list.
48207c478bd9Sstevel@tonic-gate 			 */
48217c478bd9Sstevel@tonic-gate 			if (ssp) {
48227c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
48237c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
48247c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
48257c478bd9Sstevel@tonic-gate 				if (pssp)
48267c478bd9Sstevel@tonic-gate 					pssp->ss_next = ssp->ss_next;
48277c478bd9Sstevel@tonic-gate 				else
48287c478bd9Sstevel@tonic-gate 					stp->sd_siglist = ssp->ss_next;
48297c478bd9Sstevel@tonic-gate 				kmem_free(ssp, sizeof (strsig_t));
48307c478bd9Sstevel@tonic-gate 			} else {
48317c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
48327c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
48337c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
48347c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
48357c478bd9Sstevel@tonic-gate 				return (EINVAL);
48367c478bd9Sstevel@tonic-gate 			}
48377c478bd9Sstevel@tonic-gate 		}
48387c478bd9Sstevel@tonic-gate 
48397c478bd9Sstevel@tonic-gate 		/*
48407c478bd9Sstevel@tonic-gate 		 * Recalculate OR of sig events.
48417c478bd9Sstevel@tonic-gate 		 */
48427c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
48437c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
48447c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
48457c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
48467c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
48477c478bd9Sstevel@tonic-gate 		PID_RELE(pidp);
48487c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
48497c478bd9Sstevel@tonic-gate 		return (0);
48507c478bd9Sstevel@tonic-gate 	}
48517c478bd9Sstevel@tonic-gate 
48527c478bd9Sstevel@tonic-gate 	case I_EGETSIG:
48537c478bd9Sstevel@tonic-gate 		/*
48547c478bd9Sstevel@tonic-gate 		 * Return (in arg) the current registration of events
48557c478bd9Sstevel@tonic-gate 		 * for which the calling proc is to be signaled.
48567c478bd9Sstevel@tonic-gate 		 */
48577c478bd9Sstevel@tonic-gate 	{
48587c478bd9Sstevel@tonic-gate 		struct strsig *ssp;
48597c478bd9Sstevel@tonic-gate 		struct proc *proc;
48607c478bd9Sstevel@tonic-gate 		pid_t pid;
48617c478bd9Sstevel@tonic-gate 		struct pid  *pidp;
48627c478bd9Sstevel@tonic-gate 		struct strsigset ss;
48637c478bd9Sstevel@tonic-gate 
48647c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
48657c478bd9Sstevel@tonic-gate 		if (error)
48667c478bd9Sstevel@tonic-gate 			return (error);
48677c478bd9Sstevel@tonic-gate 
48687c478bd9Sstevel@tonic-gate 		pid = ss.ss_pid;
48697c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
48707c478bd9Sstevel@tonic-gate 		if (pid == 0)
48717c478bd9Sstevel@tonic-gate 			proc = curproc;
48727c478bd9Sstevel@tonic-gate 		else if (pid < 0)
48737c478bd9Sstevel@tonic-gate 			proc = pgfind(-pid);
48747c478bd9Sstevel@tonic-gate 		else
48757c478bd9Sstevel@tonic-gate 			proc = prfind(pid);
48767c478bd9Sstevel@tonic-gate 		if (proc == NULL) {
48777c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
48787c478bd9Sstevel@tonic-gate 			return (ESRCH);
48797c478bd9Sstevel@tonic-gate 		}
48807c478bd9Sstevel@tonic-gate 		if (pid < 0)
48817c478bd9Sstevel@tonic-gate 			pidp = proc->p_pgidp;
48827c478bd9Sstevel@tonic-gate 		else
48837c478bd9Sstevel@tonic-gate 			pidp = proc->p_pidp;
48847c478bd9Sstevel@tonic-gate 
48857c478bd9Sstevel@tonic-gate 		/* Prevent the pidp from being reassigned */
48867c478bd9Sstevel@tonic-gate 		PID_HOLD(pidp);
48877c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
48887c478bd9Sstevel@tonic-gate 
48897c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
48907c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
48917c478bd9Sstevel@tonic-gate 			if (ssp->ss_pid == pid) {
48927c478bd9Sstevel@tonic-gate 				ss.ss_pid = ssp->ss_pid;
48937c478bd9Sstevel@tonic-gate 				ss.ss_events = ssp->ss_events;
48947c478bd9Sstevel@tonic-gate 				error = strcopyout(&ss, (void *)arg,
48957c478bd9Sstevel@tonic-gate 				    sizeof (struct strsigset), copyflag);
48967c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
48977c478bd9Sstevel@tonic-gate 				mutex_enter(&pidlock);
48987c478bd9Sstevel@tonic-gate 				PID_RELE(pidp);
48997c478bd9Sstevel@tonic-gate 				mutex_exit(&pidlock);
49007c478bd9Sstevel@tonic-gate 				return (error);
49017c478bd9Sstevel@tonic-gate 			}
49027c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
49037c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
49047c478bd9Sstevel@tonic-gate 		PID_RELE(pidp);
49057c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
49067c478bd9Sstevel@tonic-gate 		return (EINVAL);
49077c478bd9Sstevel@tonic-gate 	}
49087c478bd9Sstevel@tonic-gate 
49097c478bd9Sstevel@tonic-gate 	case I_PEEK:
49107c478bd9Sstevel@tonic-gate 	{
49117c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strpeek, strpeek);
49127c478bd9Sstevel@tonic-gate 		size_t n;
49137c478bd9Sstevel@tonic-gate 		mblk_t *fmp, *tmp_mp = NULL;
49147c478bd9Sstevel@tonic-gate 
49157c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strpeek, flag);
49167c478bd9Sstevel@tonic-gate 
49177c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strpeek),
49187c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strpeek), copyflag);
49197c478bd9Sstevel@tonic-gate 		if (error)
49207c478bd9Sstevel@tonic-gate 			return (error);
49217c478bd9Sstevel@tonic-gate 
49227c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(rdq));
49237c478bd9Sstevel@tonic-gate 		/*
49247c478bd9Sstevel@tonic-gate 		 * Skip the invalid messages
49257c478bd9Sstevel@tonic-gate 		 */
49267c478bd9Sstevel@tonic-gate 		for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
49277c478bd9Sstevel@tonic-gate 			if (mp->b_datap->db_type != M_SIG)
49287c478bd9Sstevel@tonic-gate 				break;
49297c478bd9Sstevel@tonic-gate 
49307c478bd9Sstevel@tonic-gate 		/*
49317c478bd9Sstevel@tonic-gate 		 * If user has requested to peek at a high priority message
49327c478bd9Sstevel@tonic-gate 		 * and first message is not, return 0
49337c478bd9Sstevel@tonic-gate 		 */
49347c478bd9Sstevel@tonic-gate 		if (mp != NULL) {
49357c478bd9Sstevel@tonic-gate 			if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) &&
49367c478bd9Sstevel@tonic-gate 			    queclass(mp) == QNORM) {
49377c478bd9Sstevel@tonic-gate 				*rvalp = 0;
49387c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(rdq));
49397c478bd9Sstevel@tonic-gate 				return (0);
49407c478bd9Sstevel@tonic-gate 			}
49417c478bd9Sstevel@tonic-gate 		} else if (stp->sd_struiordq == NULL ||
49427c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) {
49437c478bd9Sstevel@tonic-gate 			/*
49447c478bd9Sstevel@tonic-gate 			 * No mblks to look at at the streamhead and
49457c478bd9Sstevel@tonic-gate 			 * 1). This isn't a synch stream or
49467c478bd9Sstevel@tonic-gate 			 * 2). This is a synch stream but caller wants high
49477c478bd9Sstevel@tonic-gate 			 *	priority messages which is not supported by
49487c478bd9Sstevel@tonic-gate 			 *	the synch stream. (it only supports QNORM)
49497c478bd9Sstevel@tonic-gate 			 */
49507c478bd9Sstevel@tonic-gate 			*rvalp = 0;
49517c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
49527c478bd9Sstevel@tonic-gate 			return (0);
49537c478bd9Sstevel@tonic-gate 		}
49547c478bd9Sstevel@tonic-gate 
49557c478bd9Sstevel@tonic-gate 		fmp = mp;
49567c478bd9Sstevel@tonic-gate 
49577c478bd9Sstevel@tonic-gate 		if (mp && mp->b_datap->db_type == M_PASSFP) {
49587c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
49597c478bd9Sstevel@tonic-gate 			return (EBADMSG);
49607c478bd9Sstevel@tonic-gate 		}
49617c478bd9Sstevel@tonic-gate 
49627c478bd9Sstevel@tonic-gate 		ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO ||
49637c478bd9Sstevel@tonic-gate 		    mp->b_datap->db_type == M_PROTO ||
49647c478bd9Sstevel@tonic-gate 		    mp->b_datap->db_type == M_DATA);
49657c478bd9Sstevel@tonic-gate 
49667c478bd9Sstevel@tonic-gate 		if (mp && mp->b_datap->db_type == M_PCPROTO) {
49677c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, flags, RS_HIPRI);
49687c478bd9Sstevel@tonic-gate 		} else {
49697c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, flags, 0);
49707c478bd9Sstevel@tonic-gate 		}
49717c478bd9Sstevel@tonic-gate 
49727c478bd9Sstevel@tonic-gate 
49737c478bd9Sstevel@tonic-gate 		if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) {
49747c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(rdq));
49757c478bd9Sstevel@tonic-gate 			return (ENOSR);
49767c478bd9Sstevel@tonic-gate 		}
49777c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(rdq));
49787c478bd9Sstevel@tonic-gate 
49797c478bd9Sstevel@tonic-gate 		/*
49807c478bd9Sstevel@tonic-gate 		 * set mp = tmp_mp, so that I_PEEK processing can continue.
49817c478bd9Sstevel@tonic-gate 		 * tmp_mp is used to free the dup'd message.
49827c478bd9Sstevel@tonic-gate 		 */
49837c478bd9Sstevel@tonic-gate 		mp = tmp_mp;
49847c478bd9Sstevel@tonic-gate 
49857c478bd9Sstevel@tonic-gate 		uio.uio_fmode = 0;
49867c478bd9Sstevel@tonic-gate 		uio.uio_extflg = UIO_COPY_CACHED;
49877c478bd9Sstevel@tonic-gate 		uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
49887c478bd9Sstevel@tonic-gate 		    UIO_SYSSPACE;
49897c478bd9Sstevel@tonic-gate 		uio.uio_limit = 0;
49907c478bd9Sstevel@tonic-gate 		/*
49917c478bd9Sstevel@tonic-gate 		 * First process PROTO blocks, if any.
49927c478bd9Sstevel@tonic-gate 		 * If user doesn't want to get ctl info by setting maxlen <= 0,
49937c478bd9Sstevel@tonic-gate 		 * then set len to -1/0 and skip control blocks part.
49947c478bd9Sstevel@tonic-gate 		 */
49957c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0)
49967c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, ctlbuf.len, -1);
49977c478bd9Sstevel@tonic-gate 		else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0)
49987c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, ctlbuf.len, 0);
49997c478bd9Sstevel@tonic-gate 		else {
50007c478bd9Sstevel@tonic-gate 			int	ctl_part = 0;
50017c478bd9Sstevel@tonic-gate 
50027c478bd9Sstevel@tonic-gate 			iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf);
50037c478bd9Sstevel@tonic-gate 			iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen);
50047c478bd9Sstevel@tonic-gate 			uio.uio_iov = &iov;
50057c478bd9Sstevel@tonic-gate 			uio.uio_resid = iov.iov_len;
50067c478bd9Sstevel@tonic-gate 			uio.uio_loffset = 0;
50077c478bd9Sstevel@tonic-gate 			uio.uio_iovcnt = 1;
50087c478bd9Sstevel@tonic-gate 			while (mp && mp->b_datap->db_type != M_DATA &&
50097c478bd9Sstevel@tonic-gate 			    uio.uio_resid >= 0) {
50107c478bd9Sstevel@tonic-gate 				ASSERT(STRUCT_FGET(strpeek, flags) == 0 ?
50117c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_PROTO :
50127c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_PCPROTO);
50137c478bd9Sstevel@tonic-gate 
50147c478bd9Sstevel@tonic-gate 				if ((n = MIN(uio.uio_resid,
50157c478bd9Sstevel@tonic-gate 				    mp->b_wptr - mp->b_rptr)) != 0 &&
50167c478bd9Sstevel@tonic-gate 				    (error = uiomove((char *)mp->b_rptr, n,
50177c478bd9Sstevel@tonic-gate 				    UIO_READ, &uio)) != 0) {
50187c478bd9Sstevel@tonic-gate 					freemsg(tmp_mp);
50197c478bd9Sstevel@tonic-gate 					return (error);
50207c478bd9Sstevel@tonic-gate 				}
50217c478bd9Sstevel@tonic-gate 				ctl_part = 1;
50227c478bd9Sstevel@tonic-gate 				mp = mp->b_cont;
50237c478bd9Sstevel@tonic-gate 			}
50247c478bd9Sstevel@tonic-gate 			/* No ctl message */
50257c478bd9Sstevel@tonic-gate 			if (ctl_part == 0)
50267c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, ctlbuf.len, -1);
50277c478bd9Sstevel@tonic-gate 			else
50287c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, ctlbuf.len,
50297c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strpeek, ctlbuf.maxlen) -
50307c478bd9Sstevel@tonic-gate 				    uio.uio_resid);
50317c478bd9Sstevel@tonic-gate 		}
50327c478bd9Sstevel@tonic-gate 
50337c478bd9Sstevel@tonic-gate 		/*
50347c478bd9Sstevel@tonic-gate 		 * Now process DATA blocks, if any.
50357c478bd9Sstevel@tonic-gate 		 * If user doesn't want to get data info by setting maxlen <= 0,
50367c478bd9Sstevel@tonic-gate 		 * then set len to -1/0 and skip data blocks part.
50377c478bd9Sstevel@tonic-gate 		 */
50387c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, databuf.maxlen) < 0)
50397c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, -1);
50407c478bd9Sstevel@tonic-gate 		else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0)
50417c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, 0);
50427c478bd9Sstevel@tonic-gate 		else {
50437c478bd9Sstevel@tonic-gate 			int	data_part = 0;
50447c478bd9Sstevel@tonic-gate 
50457c478bd9Sstevel@tonic-gate 			iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf);
50467c478bd9Sstevel@tonic-gate 			iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen);
50477c478bd9Sstevel@tonic-gate 			uio.uio_iov = &iov;
50487c478bd9Sstevel@tonic-gate 			uio.uio_resid = iov.iov_len;
50497c478bd9Sstevel@tonic-gate 			uio.uio_loffset = 0;
50507c478bd9Sstevel@tonic-gate 			uio.uio_iovcnt = 1;
50517c478bd9Sstevel@tonic-gate 			while (mp && uio.uio_resid) {
50527c478bd9Sstevel@tonic-gate 				if (mp->b_datap->db_type == M_DATA) {
50537c478bd9Sstevel@tonic-gate 					if ((n = MIN(uio.uio_resid,
50547c478bd9Sstevel@tonic-gate 					    mp->b_wptr - mp->b_rptr)) != 0 &&
50557c478bd9Sstevel@tonic-gate 					    (error = uiomove((char *)mp->b_rptr,
50567c478bd9Sstevel@tonic-gate 					    n, UIO_READ, &uio)) != 0) {
50577c478bd9Sstevel@tonic-gate 						freemsg(tmp_mp);
50587c478bd9Sstevel@tonic-gate 						return (error);
50597c478bd9Sstevel@tonic-gate 					}
50607c478bd9Sstevel@tonic-gate 					data_part = 1;
50617c478bd9Sstevel@tonic-gate 				}
50627c478bd9Sstevel@tonic-gate 				ASSERT(data_part == 0 ||
50637c478bd9Sstevel@tonic-gate 				    mp->b_datap->db_type == M_DATA);
50647c478bd9Sstevel@tonic-gate 				mp = mp->b_cont;
50657c478bd9Sstevel@tonic-gate 			}
50667c478bd9Sstevel@tonic-gate 			/* No data message */
50677c478bd9Sstevel@tonic-gate 			if (data_part == 0)
50687c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len, -1);
50697c478bd9Sstevel@tonic-gate 			else
50707c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len,
50717c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strpeek, databuf.maxlen) -
50727c478bd9Sstevel@tonic-gate 				    uio.uio_resid);
50737c478bd9Sstevel@tonic-gate 		}
50747c478bd9Sstevel@tonic-gate 		freemsg(tmp_mp);
50757c478bd9Sstevel@tonic-gate 
50767c478bd9Sstevel@tonic-gate 		/*
50777c478bd9Sstevel@tonic-gate 		 * It is a synch stream and user wants to get
50787c478bd9Sstevel@tonic-gate 		 * data (maxlen > 0).
50797c478bd9Sstevel@tonic-gate 		 * uio setup is done by the codes that process DATA
50807c478bd9Sstevel@tonic-gate 		 * blocks above.
50817c478bd9Sstevel@tonic-gate 		 */
50827c478bd9Sstevel@tonic-gate 		if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) {
50837c478bd9Sstevel@tonic-gate 			infod_t infod;
50847c478bd9Sstevel@tonic-gate 
50857c478bd9Sstevel@tonic-gate 			infod.d_cmd = INFOD_COPYOUT;
50867c478bd9Sstevel@tonic-gate 			infod.d_res = 0;
50877c478bd9Sstevel@tonic-gate 			infod.d_uiop = &uio;
50887c478bd9Sstevel@tonic-gate 			error = infonext(rdq, &infod);
50897c478bd9Sstevel@tonic-gate 			if (error == EINVAL || error == EBUSY)
50907c478bd9Sstevel@tonic-gate 				error = 0;
50917c478bd9Sstevel@tonic-gate 			if (error)
50927c478bd9Sstevel@tonic-gate 				return (error);
50937c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek,
50947c478bd9Sstevel@tonic-gate 			    databuf.maxlen) - uio.uio_resid);
50957c478bd9Sstevel@tonic-gate 			if (STRUCT_FGET(strpeek, databuf.len) == 0) {
50967c478bd9Sstevel@tonic-gate 				/*
50977c478bd9Sstevel@tonic-gate 				 * No data found by the infonext().
50987c478bd9Sstevel@tonic-gate 				 */
50997c478bd9Sstevel@tonic-gate 				STRUCT_FSET(strpeek, databuf.len, -1);
51007c478bd9Sstevel@tonic-gate 			}
51017c478bd9Sstevel@tonic-gate 		}
51027c478bd9Sstevel@tonic-gate 		error = strcopyout(STRUCT_BUF(strpeek), (void *)arg,
51037c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strpeek), copyflag);
51047c478bd9Sstevel@tonic-gate 		if (error) {
51057c478bd9Sstevel@tonic-gate 			return (error);
51067c478bd9Sstevel@tonic-gate 		}
51077c478bd9Sstevel@tonic-gate 		/*
51087c478bd9Sstevel@tonic-gate 		 * If there is no message retrieved, set return code to 0
51097c478bd9Sstevel@tonic-gate 		 * otherwise, set it to 1.
51107c478bd9Sstevel@tonic-gate 		 */
51117c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 &&
51127c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strpeek, databuf.len) == -1)
51137c478bd9Sstevel@tonic-gate 			*rvalp = 0;
51147c478bd9Sstevel@tonic-gate 		else
51157c478bd9Sstevel@tonic-gate 			*rvalp = 1;
51167c478bd9Sstevel@tonic-gate 		return (0);
51177c478bd9Sstevel@tonic-gate 	}
51187c478bd9Sstevel@tonic-gate 
51197c478bd9Sstevel@tonic-gate 	case I_FDINSERT:
51207c478bd9Sstevel@tonic-gate 	{
51217c478bd9Sstevel@tonic-gate 		STRUCT_DECL(strfdinsert, strfdinsert);
51227c478bd9Sstevel@tonic-gate 		struct file *resftp;
51237c478bd9Sstevel@tonic-gate 		struct stdata *resstp;
51247c478bd9Sstevel@tonic-gate 		t_uscalar_t	ival;
51257c478bd9Sstevel@tonic-gate 		ssize_t msgsize;
51267c478bd9Sstevel@tonic-gate 		struct strbuf mctl;
51277c478bd9Sstevel@tonic-gate 
51287c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strfdinsert, flag);
51297c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRHUP)
51307c478bd9Sstevel@tonic-gate 			return (ENXIO);
51317c478bd9Sstevel@tonic-gate 		/*
51327c478bd9Sstevel@tonic-gate 		 * STRDERR, STWRERR and STPLEX tested above.
51337c478bd9Sstevel@tonic-gate 		 */
51347c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert),
51357c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strfdinsert), copyflag);
51367c478bd9Sstevel@tonic-gate 		if (error)
51377c478bd9Sstevel@tonic-gate 			return (error);
51387c478bd9Sstevel@tonic-gate 
51397c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, offset) < 0 ||
51407c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strfdinsert, offset) %
51417c478bd9Sstevel@tonic-gate 		    sizeof (t_uscalar_t)) != 0)
51427c478bd9Sstevel@tonic-gate 			return (EINVAL);
51437c478bd9Sstevel@tonic-gate 		if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) {
51447c478bd9Sstevel@tonic-gate 			if ((resstp = resftp->f_vnode->v_stream) == NULL) {
51457c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
51467c478bd9Sstevel@tonic-gate 				return (EINVAL);
51477c478bd9Sstevel@tonic-gate 			}
51487c478bd9Sstevel@tonic-gate 		} else
51497c478bd9Sstevel@tonic-gate 			return (EINVAL);
51507c478bd9Sstevel@tonic-gate 
51517c478bd9Sstevel@tonic-gate 		mutex_enter(&resstp->sd_lock);
51527c478bd9Sstevel@tonic-gate 		if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) {
51537c478bd9Sstevel@tonic-gate 			error = strgeterr(resstp,
51547c478bd9Sstevel@tonic-gate 			    STRDERR|STWRERR|STRHUP|STPLEX, 0);
51557c478bd9Sstevel@tonic-gate 			if (error != 0) {
51567c478bd9Sstevel@tonic-gate 				mutex_exit(&resstp->sd_lock);
51577c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
51587c478bd9Sstevel@tonic-gate 				return (error);
51597c478bd9Sstevel@tonic-gate 			}
51607c478bd9Sstevel@tonic-gate 		}
51617c478bd9Sstevel@tonic-gate 		mutex_exit(&resstp->sd_lock);
51627c478bd9Sstevel@tonic-gate 
51637c478bd9Sstevel@tonic-gate #ifdef	_ILP32
51647c478bd9Sstevel@tonic-gate 		{
51657c478bd9Sstevel@tonic-gate 			queue_t	*q;
51667c478bd9Sstevel@tonic-gate 			queue_t	*mate = NULL;
51677c478bd9Sstevel@tonic-gate 
51687c478bd9Sstevel@tonic-gate 			/* get read queue of stream terminus */
51697c478bd9Sstevel@tonic-gate 			claimstr(resstp->sd_wrq);
51707c478bd9Sstevel@tonic-gate 			for (q = resstp->sd_wrq->q_next; q->q_next != NULL;
51717c478bd9Sstevel@tonic-gate 			    q = q->q_next)
51727c478bd9Sstevel@tonic-gate 				if (!STRMATED(resstp) && STREAM(q) != resstp &&
51737c478bd9Sstevel@tonic-gate 				    mate == NULL) {
51747c478bd9Sstevel@tonic-gate 					ASSERT(q->q_qinfo->qi_srvp);
51757c478bd9Sstevel@tonic-gate 					ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp);
51767c478bd9Sstevel@tonic-gate 					claimstr(q);
51777c478bd9Sstevel@tonic-gate 					mate = q;
51787c478bd9Sstevel@tonic-gate 				}
51797c478bd9Sstevel@tonic-gate 			q = _RD(q);
51807c478bd9Sstevel@tonic-gate 			if (mate)
51817c478bd9Sstevel@tonic-gate 				releasestr(mate);
51827c478bd9Sstevel@tonic-gate 			releasestr(resstp->sd_wrq);
51837c478bd9Sstevel@tonic-gate 			ival = (t_uscalar_t)q;
51847c478bd9Sstevel@tonic-gate 		}
51857c478bd9Sstevel@tonic-gate #else
51867c478bd9Sstevel@tonic-gate 		ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev);
51877c478bd9Sstevel@tonic-gate #endif	/* _ILP32 */
51887c478bd9Sstevel@tonic-gate 
51897c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, ctlbuf.len) <
51907c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) {
51917c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
51927c478bd9Sstevel@tonic-gate 			return (EINVAL);
51937c478bd9Sstevel@tonic-gate 		}
51947c478bd9Sstevel@tonic-gate 
51957c478bd9Sstevel@tonic-gate 		/*
51967c478bd9Sstevel@tonic-gate 		 * Check for legal flag value.
51977c478bd9Sstevel@tonic-gate 		 */
51987c478bd9Sstevel@tonic-gate 		if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) {
51997c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
52007c478bd9Sstevel@tonic-gate 			return (EINVAL);
52017c478bd9Sstevel@tonic-gate 		}
52027c478bd9Sstevel@tonic-gate 
52037c478bd9Sstevel@tonic-gate 		/* get these values from those cached in the stream head */
52047c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(stp->sd_wrq));
52057c478bd9Sstevel@tonic-gate 		rmin = stp->sd_qn_minpsz;
52067c478bd9Sstevel@tonic-gate 		rmax = stp->sd_qn_maxpsz;
52077c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(stp->sd_wrq));
52087c478bd9Sstevel@tonic-gate 
52097c478bd9Sstevel@tonic-gate 		/*
52107c478bd9Sstevel@tonic-gate 		 * Make sure ctl and data sizes together fall within
52117c478bd9Sstevel@tonic-gate 		 * the limits of the max and min receive packet sizes
52127c478bd9Sstevel@tonic-gate 		 * and do not exceed system limit.  A negative data
52137c478bd9Sstevel@tonic-gate 		 * length means that no data part is to be sent.
52147c478bd9Sstevel@tonic-gate 		 */
52157c478bd9Sstevel@tonic-gate 		ASSERT((rmax >= 0) || (rmax == INFPSZ));
52167c478bd9Sstevel@tonic-gate 		if (rmax == 0) {
52177c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
52187c478bd9Sstevel@tonic-gate 			return (ERANGE);
52197c478bd9Sstevel@tonic-gate 		}
52207c478bd9Sstevel@tonic-gate 		if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0)
52217c478bd9Sstevel@tonic-gate 			msgsize = 0;
52227c478bd9Sstevel@tonic-gate 		if ((msgsize < rmin) ||
52237c478bd9Sstevel@tonic-gate 		    ((msgsize > rmax) && (rmax != INFPSZ)) ||
52247c478bd9Sstevel@tonic-gate 		    (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) {
52257c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
52267c478bd9Sstevel@tonic-gate 			return (ERANGE);
52277c478bd9Sstevel@tonic-gate 		}
52287c478bd9Sstevel@tonic-gate 
52297c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
52307c478bd9Sstevel@tonic-gate 		while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) &&
52317c478bd9Sstevel@tonic-gate 		    !canputnext(stp->sd_wrq)) {
52327c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0,
52337c478bd9Sstevel@tonic-gate 			    flag, -1, &done)) != 0 || done) {
52347c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52357c478bd9Sstevel@tonic-gate 				releasef(STRUCT_FGET(strfdinsert, fildes));
52367c478bd9Sstevel@tonic-gate 				return (error);
52377c478bd9Sstevel@tonic-gate 			}
52389acbbeafSnn35248 			if ((error = i_straccess(stp, access)) != 0) {
52397c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
52407c478bd9Sstevel@tonic-gate 				releasef(
52417c478bd9Sstevel@tonic-gate 				    STRUCT_FGET(strfdinsert, fildes));
52427c478bd9Sstevel@tonic-gate 				return (error);
52437c478bd9Sstevel@tonic-gate 			}
52447c478bd9Sstevel@tonic-gate 		}
52457c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
52467c478bd9Sstevel@tonic-gate 
52477c478bd9Sstevel@tonic-gate 		/*
52487c478bd9Sstevel@tonic-gate 		 * Copy strfdinsert.ctlbuf into native form of
52497c478bd9Sstevel@tonic-gate 		 * ctlbuf to pass down into strmakemsg().
52507c478bd9Sstevel@tonic-gate 		 */
52517c478bd9Sstevel@tonic-gate 		mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen);
52527c478bd9Sstevel@tonic-gate 		mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len);
52537c478bd9Sstevel@tonic-gate 		mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf);
52547c478bd9Sstevel@tonic-gate 
52557c478bd9Sstevel@tonic-gate 		iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf);
52567c478bd9Sstevel@tonic-gate 		iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len);
52577c478bd9Sstevel@tonic-gate 		uio.uio_iov = &iov;
52587c478bd9Sstevel@tonic-gate 		uio.uio_iovcnt = 1;
52597c478bd9Sstevel@tonic-gate 		uio.uio_loffset = 0;
52607c478bd9Sstevel@tonic-gate 		uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
52617c478bd9Sstevel@tonic-gate 		    UIO_SYSSPACE;
52627c478bd9Sstevel@tonic-gate 		uio.uio_fmode = 0;
52637c478bd9Sstevel@tonic-gate 		uio.uio_extflg = UIO_COPY_CACHED;
52647c478bd9Sstevel@tonic-gate 		uio.uio_resid = iov.iov_len;
52657c478bd9Sstevel@tonic-gate 		if ((error = strmakemsg(&mctl,
52667c478bd9Sstevel@tonic-gate 		    &msgsize, &uio, stp,
52677c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) {
52687c478bd9Sstevel@tonic-gate 			STRUCT_FSET(strfdinsert, databuf.len, msgsize);
52697c478bd9Sstevel@tonic-gate 			releasef(STRUCT_FGET(strfdinsert, fildes));
52707c478bd9Sstevel@tonic-gate 			return (error);
52717c478bd9Sstevel@tonic-gate 		}
52727c478bd9Sstevel@tonic-gate 
52737c478bd9Sstevel@tonic-gate 		STRUCT_FSET(strfdinsert, databuf.len, msgsize);
52747c478bd9Sstevel@tonic-gate 
52757c478bd9Sstevel@tonic-gate 		/*
52767c478bd9Sstevel@tonic-gate 		 * Place the possibly reencoded queue pointer 'offset' bytes
52777c478bd9Sstevel@tonic-gate 		 * from the start of the control portion of the message.
52787c478bd9Sstevel@tonic-gate 		 */
52797c478bd9Sstevel@tonic-gate 		*((t_uscalar_t *)(mp->b_rptr +
52807c478bd9Sstevel@tonic-gate 		    STRUCT_FGET(strfdinsert, offset))) = ival;
52817c478bd9Sstevel@tonic-gate 
52827c478bd9Sstevel@tonic-gate 		/*
52837c478bd9Sstevel@tonic-gate 		 * Put message downstream.
52847c478bd9Sstevel@tonic-gate 		 */
52857c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
52867c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, mp);
52877c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
52887c478bd9Sstevel@tonic-gate 		releasef(STRUCT_FGET(strfdinsert, fildes));
52897c478bd9Sstevel@tonic-gate 		return (error);
52907c478bd9Sstevel@tonic-gate 	}
52917c478bd9Sstevel@tonic-gate 
52927c478bd9Sstevel@tonic-gate 	case I_SENDFD:
52937c478bd9Sstevel@tonic-gate 	{
52947c478bd9Sstevel@tonic-gate 		struct file *fp;
52957c478bd9Sstevel@tonic-gate 
52967c478bd9Sstevel@tonic-gate 		if ((fp = getf((int)arg)) == NULL)
52977c478bd9Sstevel@tonic-gate 			return (EBADF);
52987c478bd9Sstevel@tonic-gate 		error = do_sendfp(stp, fp, crp);
52997c478bd9Sstevel@tonic-gate 		if (audit_active) {
53007c478bd9Sstevel@tonic-gate 			audit_fdsend((int)arg, fp, error);
53017c478bd9Sstevel@tonic-gate 		}
53027c478bd9Sstevel@tonic-gate 		releasef((int)arg);
53037c478bd9Sstevel@tonic-gate 		return (error);
53047c478bd9Sstevel@tonic-gate 	}
53057c478bd9Sstevel@tonic-gate 
53067c478bd9Sstevel@tonic-gate 	case I_RECVFD:
53077c478bd9Sstevel@tonic-gate 	case I_E_RECVFD:
53087c478bd9Sstevel@tonic-gate 	{
53097c478bd9Sstevel@tonic-gate 		struct k_strrecvfd *srf;
53107c478bd9Sstevel@tonic-gate 		int i, fd;
53117c478bd9Sstevel@tonic-gate 
53127c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
53137c478bd9Sstevel@tonic-gate 		while (!(mp = getq(rdq))) {
53147c478bd9Sstevel@tonic-gate 			if (stp->sd_flag & (STRHUP|STREOF)) {
53157c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
53167c478bd9Sstevel@tonic-gate 				return (ENXIO);
53177c478bd9Sstevel@tonic-gate 			}
53187c478bd9Sstevel@tonic-gate 			if ((error = strwaitq(stp, GETWAIT, (ssize_t)0,
53197c478bd9Sstevel@tonic-gate 			    flag, -1, &done)) != 0 || done) {
53207c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
53217c478bd9Sstevel@tonic-gate 				return (error);
53227c478bd9Sstevel@tonic-gate 			}
53239acbbeafSnn35248 			if ((error = i_straccess(stp, access)) != 0) {
53247c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
53257c478bd9Sstevel@tonic-gate 				return (error);
53267c478bd9Sstevel@tonic-gate 			}
53277c478bd9Sstevel@tonic-gate 		}
53287c478bd9Sstevel@tonic-gate 		if (mp->b_datap->db_type != M_PASSFP) {
53297c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
53307c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
53317c478bd9Sstevel@tonic-gate 			return (EBADMSG);
53327c478bd9Sstevel@tonic-gate 		}
53337c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
53347c478bd9Sstevel@tonic-gate 
53357c478bd9Sstevel@tonic-gate 		srf = (struct k_strrecvfd *)mp->b_rptr;
53367c478bd9Sstevel@tonic-gate 		if ((fd = ufalloc(0)) == -1) {
53377c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
53387c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
53397c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
53407c478bd9Sstevel@tonic-gate 			return (EMFILE);
53417c478bd9Sstevel@tonic-gate 		}
53427c478bd9Sstevel@tonic-gate 		if (cmd == I_RECVFD) {
53437c478bd9Sstevel@tonic-gate 			struct o_strrecvfd	ostrfd;
53447c478bd9Sstevel@tonic-gate 
53457c478bd9Sstevel@tonic-gate 			/* check to see if uid/gid values are too large. */
53467c478bd9Sstevel@tonic-gate 
53477c478bd9Sstevel@tonic-gate 			if (srf->uid > (o_uid_t)USHRT_MAX ||
53487c478bd9Sstevel@tonic-gate 			    srf->gid > (o_gid_t)USHRT_MAX) {
53497c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
53507c478bd9Sstevel@tonic-gate 				putback(stp, rdq, mp, mp->b_band);
53517c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
53527c478bd9Sstevel@tonic-gate 				setf(fd, NULL);	/* release fd entry */
53537c478bd9Sstevel@tonic-gate 				return (EOVERFLOW);
53547c478bd9Sstevel@tonic-gate 			}
53557c478bd9Sstevel@tonic-gate 
53567c478bd9Sstevel@tonic-gate 			ostrfd.fd = fd;
53577c478bd9Sstevel@tonic-gate 			ostrfd.uid = (o_uid_t)srf->uid;
53587c478bd9Sstevel@tonic-gate 			ostrfd.gid = (o_gid_t)srf->gid;
53597c478bd9Sstevel@tonic-gate 
53607c478bd9Sstevel@tonic-gate 			/* Null the filler bits */
53617c478bd9Sstevel@tonic-gate 			for (i = 0; i < 8; i++)
53627c478bd9Sstevel@tonic-gate 				ostrfd.fill[i] = 0;
53637c478bd9Sstevel@tonic-gate 
53647c478bd9Sstevel@tonic-gate 			error = strcopyout(&ostrfd, (void *)arg,
53657c478bd9Sstevel@tonic-gate 			    sizeof (struct o_strrecvfd), copyflag);
53667c478bd9Sstevel@tonic-gate 		} else {		/* I_E_RECVFD */
53677c478bd9Sstevel@tonic-gate 			struct strrecvfd	strfd;
53687c478bd9Sstevel@tonic-gate 
53697c478bd9Sstevel@tonic-gate 			strfd.fd = fd;
53707c478bd9Sstevel@tonic-gate 			strfd.uid = srf->uid;
53717c478bd9Sstevel@tonic-gate 			strfd.gid = srf->gid;
53727c478bd9Sstevel@tonic-gate 
53737c478bd9Sstevel@tonic-gate 			/* null the filler bits */
53747c478bd9Sstevel@tonic-gate 			for (i = 0; i < 8; i++)
53757c478bd9Sstevel@tonic-gate 				strfd.fill[i] = 0;
53767c478bd9Sstevel@tonic-gate 
53777c478bd9Sstevel@tonic-gate 			error = strcopyout(&strfd, (void *)arg,
53787c478bd9Sstevel@tonic-gate 			    sizeof (struct strrecvfd), copyflag);
53797c478bd9Sstevel@tonic-gate 		}
53807c478bd9Sstevel@tonic-gate 
53817c478bd9Sstevel@tonic-gate 		if (error) {
53827c478bd9Sstevel@tonic-gate 			setf(fd, NULL);	/* release fd entry */
53837c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
53847c478bd9Sstevel@tonic-gate 			putback(stp, rdq, mp, mp->b_band);
53857c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
53867c478bd9Sstevel@tonic-gate 			return (error);
53877c478bd9Sstevel@tonic-gate 		}
53887c478bd9Sstevel@tonic-gate 		if (audit_active) {
53897c478bd9Sstevel@tonic-gate 			audit_fdrecv(fd, srf->fp);
53907c478bd9Sstevel@tonic-gate 		}
53917c478bd9Sstevel@tonic-gate 
53927c478bd9Sstevel@tonic-gate 		/*
53937c478bd9Sstevel@tonic-gate 		 * Always increment f_count since the freemsg() below will
53947c478bd9Sstevel@tonic-gate 		 * always call free_passfp() which performs a closef().
53957c478bd9Sstevel@tonic-gate 		 */
53967c478bd9Sstevel@tonic-gate 		mutex_enter(&srf->fp->f_tlock);
53977c478bd9Sstevel@tonic-gate 		srf->fp->f_count++;
53987c478bd9Sstevel@tonic-gate 		mutex_exit(&srf->fp->f_tlock);
53997c478bd9Sstevel@tonic-gate 		setf(fd, srf->fp);
54007c478bd9Sstevel@tonic-gate 		freemsg(mp);
54017c478bd9Sstevel@tonic-gate 		return (0);
54027c478bd9Sstevel@tonic-gate 	}
54037c478bd9Sstevel@tonic-gate 
54047c478bd9Sstevel@tonic-gate 	case I_SWROPT:
54057c478bd9Sstevel@tonic-gate 		/*
54067c478bd9Sstevel@tonic-gate 		 * Set/clear the write options. arg is a bit
54077c478bd9Sstevel@tonic-gate 		 * mask with any of the following bits set...
54087c478bd9Sstevel@tonic-gate 		 * 	SNDZERO - send zero length message
54097c478bd9Sstevel@tonic-gate 		 *	SNDPIPE - send sigpipe to process if
54107c478bd9Sstevel@tonic-gate 		 *		sd_werror is set and process is
54117c478bd9Sstevel@tonic-gate 		 *		doing a write or putmsg.
54127c478bd9Sstevel@tonic-gate 		 * The new stream head write options should reflect
54137c478bd9Sstevel@tonic-gate 		 * what is in arg.
54147c478bd9Sstevel@tonic-gate 		 */
54157c478bd9Sstevel@tonic-gate 		if (arg & ~(SNDZERO|SNDPIPE))
54167c478bd9Sstevel@tonic-gate 			return (EINVAL);
54177c478bd9Sstevel@tonic-gate 
54187c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
54197c478bd9Sstevel@tonic-gate 		stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO);
54207c478bd9Sstevel@tonic-gate 		if (arg & SNDZERO)
54217c478bd9Sstevel@tonic-gate 			stp->sd_wput_opt |= SW_SNDZERO;
54227c478bd9Sstevel@tonic-gate 		if (arg & SNDPIPE)
54237c478bd9Sstevel@tonic-gate 			stp->sd_wput_opt |= SW_SIGPIPE;
54247c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
54257c478bd9Sstevel@tonic-gate 		return (0);
54267c478bd9Sstevel@tonic-gate 
54277c478bd9Sstevel@tonic-gate 	case I_GWROPT:
54287c478bd9Sstevel@tonic-gate 	{
54297c478bd9Sstevel@tonic-gate 		int wropt = 0;
54307c478bd9Sstevel@tonic-gate 
54317c478bd9Sstevel@tonic-gate 		if (stp->sd_wput_opt & SW_SNDZERO)
54327c478bd9Sstevel@tonic-gate 			wropt |= SNDZERO;
54337c478bd9Sstevel@tonic-gate 		if (stp->sd_wput_opt & SW_SIGPIPE)
54347c478bd9Sstevel@tonic-gate 			wropt |= SNDPIPE;
54357c478bd9Sstevel@tonic-gate 		return (strcopyout(&wropt, (void *)arg, sizeof (wropt),
54367c478bd9Sstevel@tonic-gate 		    copyflag));
54377c478bd9Sstevel@tonic-gate 	}
54387c478bd9Sstevel@tonic-gate 
54397c478bd9Sstevel@tonic-gate 	case I_LIST:
54407c478bd9Sstevel@tonic-gate 		/*
54417c478bd9Sstevel@tonic-gate 		 * Returns all the modules found on this stream,
54427c478bd9Sstevel@tonic-gate 		 * upto the driver. If argument is NULL, return the
54437c478bd9Sstevel@tonic-gate 		 * number of modules (including driver). If argument
54447c478bd9Sstevel@tonic-gate 		 * is not NULL, copy the names into the structure
54457c478bd9Sstevel@tonic-gate 		 * provided.
54467c478bd9Sstevel@tonic-gate 		 */
54477c478bd9Sstevel@tonic-gate 
54487c478bd9Sstevel@tonic-gate 	{
54497c478bd9Sstevel@tonic-gate 		queue_t *q;
5450a45f3f93Smeem 		char *qname;
5451a45f3f93Smeem 		int i, nmods;
5452a45f3f93Smeem 		struct str_mlist *mlist;
54537c478bd9Sstevel@tonic-gate 		STRUCT_DECL(str_list, strlist);
54547c478bd9Sstevel@tonic-gate 
54557c478bd9Sstevel@tonic-gate 		if (arg == NULL) { /* Return number of modules plus driver */
5456a45f3f93Smeem 			if (stp->sd_vnode->v_type == VFIFO)
54577c478bd9Sstevel@tonic-gate 				*rvalp = stp->sd_pushcnt;
5458a45f3f93Smeem 			else
54597c478bd9Sstevel@tonic-gate 				*rvalp = stp->sd_pushcnt + 1;
5460a45f3f93Smeem 			return (0);
54617c478bd9Sstevel@tonic-gate 		}
5462a45f3f93Smeem 
54637c478bd9Sstevel@tonic-gate 		STRUCT_INIT(strlist, flag);
54647c478bd9Sstevel@tonic-gate 
54657c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, STRUCT_BUF(strlist),
54667c478bd9Sstevel@tonic-gate 		    STRUCT_SIZE(strlist), copyflag);
5467a45f3f93Smeem 		if (error != 0)
54687c478bd9Sstevel@tonic-gate 			return (error);
54697c478bd9Sstevel@tonic-gate 
5470a45f3f93Smeem 		mlist = STRUCT_FGETP(strlist, sl_modlist);
5471a45f3f93Smeem 		nmods = STRUCT_FGET(strlist, sl_nmods);
5472a45f3f93Smeem 		if (nmods <= 0)
54737c478bd9Sstevel@tonic-gate 			return (EINVAL);
5474a45f3f93Smeem 
54757c478bd9Sstevel@tonic-gate 		claimstr(stp->sd_wrq);
54767c478bd9Sstevel@tonic-gate 		q = stp->sd_wrq;
5477a45f3f93Smeem 		for (i = 0; i < nmods && _SAMESTR(q); i++, q = q->q_next) {
5478a45f3f93Smeem 			qname = Q2NAME(q->q_next);
5479a45f3f93Smeem 			error = strcopyout(qname, &mlist[i], strlen(qname) + 1,
5480a45f3f93Smeem 			    copyflag);
5481a45f3f93Smeem 			if (error != 0) {
54827c478bd9Sstevel@tonic-gate 				releasestr(stp->sd_wrq);
54837c478bd9Sstevel@tonic-gate 				return (error);
54847c478bd9Sstevel@tonic-gate 			}
54857c478bd9Sstevel@tonic-gate 		}
54867c478bd9Sstevel@tonic-gate 		releasestr(stp->sd_wrq);
5487a45f3f93Smeem 		return (strcopyout(&i, (void *)arg, sizeof (int), copyflag));
54887c478bd9Sstevel@tonic-gate 	}
54897c478bd9Sstevel@tonic-gate 
54907c478bd9Sstevel@tonic-gate 	case I_CKBAND:
54917c478bd9Sstevel@tonic-gate 	{
54927c478bd9Sstevel@tonic-gate 		queue_t *q;
54937c478bd9Sstevel@tonic-gate 		qband_t *qbp;
54947c478bd9Sstevel@tonic-gate 
54957c478bd9Sstevel@tonic-gate 		if ((arg < 0) || (arg >= NBAND))
54967c478bd9Sstevel@tonic-gate 			return (EINVAL);
54977c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
54987c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(q));
54997c478bd9Sstevel@tonic-gate 		if (arg > (int)q->q_nband) {
55007c478bd9Sstevel@tonic-gate 			*rvalp = 0;
55017c478bd9Sstevel@tonic-gate 		} else {
55027c478bd9Sstevel@tonic-gate 			if (arg == 0) {
55037c478bd9Sstevel@tonic-gate 				if (q->q_first)
55047c478bd9Sstevel@tonic-gate 					*rvalp = 1;
55057c478bd9Sstevel@tonic-gate 				else
55067c478bd9Sstevel@tonic-gate 					*rvalp = 0;
55077c478bd9Sstevel@tonic-gate 			} else {
55087c478bd9Sstevel@tonic-gate 				qbp = q->q_bandp;
55097c478bd9Sstevel@tonic-gate 				while (--arg > 0)
55107c478bd9Sstevel@tonic-gate 					qbp = qbp->qb_next;
55117c478bd9Sstevel@tonic-gate 				if (qbp->qb_first)
55127c478bd9Sstevel@tonic-gate 					*rvalp = 1;
55137c478bd9Sstevel@tonic-gate 				else
55147c478bd9Sstevel@tonic-gate 					*rvalp = 0;
55157c478bd9Sstevel@tonic-gate 			}
55167c478bd9Sstevel@tonic-gate 		}
55177c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(q));
55187c478bd9Sstevel@tonic-gate 		return (0);
55197c478bd9Sstevel@tonic-gate 	}
55207c478bd9Sstevel@tonic-gate 
55217c478bd9Sstevel@tonic-gate 	case I_GETBAND:
55227c478bd9Sstevel@tonic-gate 	{
55237c478bd9Sstevel@tonic-gate 		int intpri;
55247c478bd9Sstevel@tonic-gate 		queue_t *q;
55257c478bd9Sstevel@tonic-gate 
55267c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
55277c478bd9Sstevel@tonic-gate 		mutex_enter(QLOCK(q));
55287c478bd9Sstevel@tonic-gate 		mp = q->q_first;
55297c478bd9Sstevel@tonic-gate 		if (!mp) {
55307c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(q));
55317c478bd9Sstevel@tonic-gate 			return (ENODATA);
55327c478bd9Sstevel@tonic-gate 		}
55337c478bd9Sstevel@tonic-gate 		intpri = (int)mp->b_band;
55347c478bd9Sstevel@tonic-gate 		error = strcopyout(&intpri, (void *)arg, sizeof (int),
55357c478bd9Sstevel@tonic-gate 		    copyflag);
55367c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(q));
55377c478bd9Sstevel@tonic-gate 		return (error);
55387c478bd9Sstevel@tonic-gate 	}
55397c478bd9Sstevel@tonic-gate 
55407c478bd9Sstevel@tonic-gate 	case I_ATMARK:
55417c478bd9Sstevel@tonic-gate 	{
55427c478bd9Sstevel@tonic-gate 		queue_t *q;
55437c478bd9Sstevel@tonic-gate 
55447c478bd9Sstevel@tonic-gate 		if (arg & ~(ANYMARK|LASTMARK))
55457c478bd9Sstevel@tonic-gate 			return (EINVAL);
55467c478bd9Sstevel@tonic-gate 		q = _RD(stp->sd_wrq);
55477c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
55487c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) {
55497c478bd9Sstevel@tonic-gate 			*rvalp = 1;
55507c478bd9Sstevel@tonic-gate 		} else {
55517c478bd9Sstevel@tonic-gate 			mutex_enter(QLOCK(q));
55527c478bd9Sstevel@tonic-gate 			mp = q->q_first;
55537c478bd9Sstevel@tonic-gate 
55547c478bd9Sstevel@tonic-gate 			if (mp == NULL)
55557c478bd9Sstevel@tonic-gate 				*rvalp = 0;
55567c478bd9Sstevel@tonic-gate 			else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK))
55577c478bd9Sstevel@tonic-gate 				*rvalp = 1;
55587c478bd9Sstevel@tonic-gate 			else if ((arg == LASTMARK) && (mp == stp->sd_mark))
55597c478bd9Sstevel@tonic-gate 				*rvalp = 1;
55607c478bd9Sstevel@tonic-gate 			else
55617c478bd9Sstevel@tonic-gate 				*rvalp = 0;
55627c478bd9Sstevel@tonic-gate 			mutex_exit(QLOCK(q));
55637c478bd9Sstevel@tonic-gate 		}
55647c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
55657c478bd9Sstevel@tonic-gate 		return (0);
55667c478bd9Sstevel@tonic-gate 	}
55677c478bd9Sstevel@tonic-gate 
55687c478bd9Sstevel@tonic-gate 	case I_CANPUT:
55697c478bd9Sstevel@tonic-gate 	{
55707c478bd9Sstevel@tonic-gate 		char band;
55717c478bd9Sstevel@tonic-gate 
55727c478bd9Sstevel@tonic-gate 		if ((arg < 0) || (arg >= NBAND))
55737c478bd9Sstevel@tonic-gate 			return (EINVAL);
55747c478bd9Sstevel@tonic-gate 		band = (char)arg;
55757c478bd9Sstevel@tonic-gate 		*rvalp = bcanputnext(stp->sd_wrq, band);
55767c478bd9Sstevel@tonic-gate 		return (0);
55777c478bd9Sstevel@tonic-gate 	}
55787c478bd9Sstevel@tonic-gate 
55797c478bd9Sstevel@tonic-gate 	case I_SETCLTIME:
55807c478bd9Sstevel@tonic-gate 	{
55817c478bd9Sstevel@tonic-gate 		int closetime;
55827c478bd9Sstevel@tonic-gate 
55837c478bd9Sstevel@tonic-gate 		error = strcopyin((void *)arg, &closetime, sizeof (int),
55847c478bd9Sstevel@tonic-gate 		    copyflag);
55857c478bd9Sstevel@tonic-gate 		if (error)
55867c478bd9Sstevel@tonic-gate 			return (error);
55877c478bd9Sstevel@tonic-gate 		if (closetime < 0)
55887c478bd9Sstevel@tonic-gate 			return (EINVAL);
55897c478bd9Sstevel@tonic-gate 
55907c478bd9Sstevel@tonic-gate 		stp->sd_closetime = closetime;
55917c478bd9Sstevel@tonic-gate 		return (0);
55927c478bd9Sstevel@tonic-gate 	}
55937c478bd9Sstevel@tonic-gate 
55947c478bd9Sstevel@tonic-gate 	case I_GETCLTIME:
55957c478bd9Sstevel@tonic-gate 	{
55967c478bd9Sstevel@tonic-gate 		int closetime;
55977c478bd9Sstevel@tonic-gate 
55987c478bd9Sstevel@tonic-gate 		closetime = stp->sd_closetime;
55997c478bd9Sstevel@tonic-gate 		return (strcopyout(&closetime, (void *)arg, sizeof (int),
56007c478bd9Sstevel@tonic-gate 		    copyflag));
56017c478bd9Sstevel@tonic-gate 	}
56027c478bd9Sstevel@tonic-gate 
56037c478bd9Sstevel@tonic-gate 	case TIOCGSID:
56047c478bd9Sstevel@tonic-gate 	{
56057c478bd9Sstevel@tonic-gate 		pid_t sid;
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 		sid = stp->sd_sidp->pid_id;
56139acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
56147c478bd9Sstevel@tonic-gate 		return (strcopyout(&sid, (void *)arg, sizeof (pid_t),
56157c478bd9Sstevel@tonic-gate 		    copyflag));
56167c478bd9Sstevel@tonic-gate 	}
56177c478bd9Sstevel@tonic-gate 
56187c478bd9Sstevel@tonic-gate 	case TIOCSPGRP:
56197c478bd9Sstevel@tonic-gate 	{
56207c478bd9Sstevel@tonic-gate 		pid_t pgrp;
56217c478bd9Sstevel@tonic-gate 		proc_t *q;
56227c478bd9Sstevel@tonic-gate 		pid_t	sid, fg_pgid, bg_pgid;
56237c478bd9Sstevel@tonic-gate 
56247c478bd9Sstevel@tonic-gate 		if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t),
56257c478bd9Sstevel@tonic-gate 		    copyflag))
56267c478bd9Sstevel@tonic-gate 			return (error);
56277c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
56287c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
56297c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) {
56307c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
56317c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
56327c478bd9Sstevel@tonic-gate 			return (ENOTTY);
56337c478bd9Sstevel@tonic-gate 		}
56347c478bd9Sstevel@tonic-gate 		if (pgrp == stp->sd_pgidp->pid_id) {
56357c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
56367c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
56377c478bd9Sstevel@tonic-gate 			return (0);
56387c478bd9Sstevel@tonic-gate 		}
56397c478bd9Sstevel@tonic-gate 		if (pgrp <= 0 || pgrp >= maxpid) {
56407c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
56417c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
56427c478bd9Sstevel@tonic-gate 			return (EINVAL);
56437c478bd9Sstevel@tonic-gate 		}
56447c478bd9Sstevel@tonic-gate 		if ((q = pgfind(pgrp)) == NULL ||
56457c478bd9Sstevel@tonic-gate 		    q->p_sessp != ttoproc(curthread)->p_sessp) {
56467c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
56477c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
56487c478bd9Sstevel@tonic-gate 			return (EPERM);
56497c478bd9Sstevel@tonic-gate 		}
56507c478bd9Sstevel@tonic-gate 		sid = stp->sd_sidp->pid_id;
56517c478bd9Sstevel@tonic-gate 		fg_pgid = q->p_pgrp;
56527c478bd9Sstevel@tonic-gate 		bg_pgid = stp->sd_pgidp->pid_id;
56537c478bd9Sstevel@tonic-gate 		CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid);
56547c478bd9Sstevel@tonic-gate 		PID_RELE(stp->sd_pgidp);
56559acbbeafSnn35248 		ctty_clear_sighuped();
56567c478bd9Sstevel@tonic-gate 		stp->sd_pgidp = q->p_pgidp;
56577c478bd9Sstevel@tonic-gate 		PID_HOLD(stp->sd_pgidp);
56587c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
56597c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
56607c478bd9Sstevel@tonic-gate 		return (0);
56617c478bd9Sstevel@tonic-gate 	}
56627c478bd9Sstevel@tonic-gate 
56637c478bd9Sstevel@tonic-gate 	case TIOCGPGRP:
56647c478bd9Sstevel@tonic-gate 	{
56657c478bd9Sstevel@tonic-gate 		pid_t pgrp;
56667c478bd9Sstevel@tonic-gate 
56679acbbeafSnn35248 		mutex_enter(&stp->sd_lock);
56687c478bd9Sstevel@tonic-gate 		if (stp->sd_sidp == NULL) {
56699acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
56707c478bd9Sstevel@tonic-gate 			return (ENOTTY);
56717c478bd9Sstevel@tonic-gate 		}
56727c478bd9Sstevel@tonic-gate 		pgrp = stp->sd_pgidp->pid_id;
56739acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
56747c478bd9Sstevel@tonic-gate 		return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t),
56757c478bd9Sstevel@tonic-gate 		    copyflag));
56767c478bd9Sstevel@tonic-gate 	}
56777c478bd9Sstevel@tonic-gate 
56789acbbeafSnn35248 	case TIOCSCTTY:
56799acbbeafSnn35248 	{
56809acbbeafSnn35248 		return (strctty(stp));
56819acbbeafSnn35248 	}
56829acbbeafSnn35248 
56839acbbeafSnn35248 	case TIOCNOTTY:
56849acbbeafSnn35248 	{
56859acbbeafSnn35248 		/* freectty() always assumes curproc. */
56869acbbeafSnn35248 		if (freectty(B_FALSE) != 0)
56879acbbeafSnn35248 			return (0);
56889acbbeafSnn35248 		return (ENOTTY);
56899acbbeafSnn35248 	}
56909acbbeafSnn35248 
56917c478bd9Sstevel@tonic-gate 	case FIONBIO:
56927c478bd9Sstevel@tonic-gate 	case FIOASYNC:
56937c478bd9Sstevel@tonic-gate 		return (0);	/* handled by the upper layer */
56947c478bd9Sstevel@tonic-gate 	}
56957c478bd9Sstevel@tonic-gate }
56967c478bd9Sstevel@tonic-gate 
56977c478bd9Sstevel@tonic-gate /*
56987c478bd9Sstevel@tonic-gate  * Custom free routine used for M_PASSFP messages.
56997c478bd9Sstevel@tonic-gate  */
57007c478bd9Sstevel@tonic-gate static void
57017c478bd9Sstevel@tonic-gate free_passfp(struct k_strrecvfd *srf)
57027c478bd9Sstevel@tonic-gate {
57037c478bd9Sstevel@tonic-gate 	(void) closef(srf->fp);
57047c478bd9Sstevel@tonic-gate 	kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t));
57057c478bd9Sstevel@tonic-gate }
57067c478bd9Sstevel@tonic-gate 
57077c478bd9Sstevel@tonic-gate /* ARGSUSED */
57087c478bd9Sstevel@tonic-gate int
57097c478bd9Sstevel@tonic-gate do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr)
57107c478bd9Sstevel@tonic-gate {
57117c478bd9Sstevel@tonic-gate 	queue_t *qp, *nextqp;
57127c478bd9Sstevel@tonic-gate 	struct k_strrecvfd *srf;
57137c478bd9Sstevel@tonic-gate 	mblk_t *mp;
57147c478bd9Sstevel@tonic-gate 	frtn_t *frtnp;
57157c478bd9Sstevel@tonic-gate 	size_t bufsize;
57167c478bd9Sstevel@tonic-gate 	queue_t	*mate = NULL;
57177c478bd9Sstevel@tonic-gate 	syncq_t	*sq = NULL;
57187c478bd9Sstevel@tonic-gate 	int retval = 0;
57197c478bd9Sstevel@tonic-gate 
57207c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & STRHUP)
57217c478bd9Sstevel@tonic-gate 		return (ENXIO);
57227c478bd9Sstevel@tonic-gate 
57237c478bd9Sstevel@tonic-gate 	claimstr(stp->sd_wrq);
57247c478bd9Sstevel@tonic-gate 
57257c478bd9Sstevel@tonic-gate 	/* Fastpath, we have a pipe, and we are already mated, use it. */
57267c478bd9Sstevel@tonic-gate 	if (STRMATED(stp)) {
57277c478bd9Sstevel@tonic-gate 		qp = _RD(stp->sd_mate->sd_wrq);
57287c478bd9Sstevel@tonic-gate 		claimstr(qp);
57297c478bd9Sstevel@tonic-gate 		mate = qp;
57307c478bd9Sstevel@tonic-gate 	} else { /* Not already mated. */
57317c478bd9Sstevel@tonic-gate 
57327c478bd9Sstevel@tonic-gate 		/*
57337c478bd9Sstevel@tonic-gate 		 * Walk the stream to the end of this one.
57347c478bd9Sstevel@tonic-gate 		 * assumes that the claimstr() will prevent
57357c478bd9Sstevel@tonic-gate 		 * plumbing between the stream head and the
57367c478bd9Sstevel@tonic-gate 		 * driver from changing
57377c478bd9Sstevel@tonic-gate 		 */
57387c478bd9Sstevel@tonic-gate 		qp = stp->sd_wrq;
57397c478bd9Sstevel@tonic-gate 
57407c478bd9Sstevel@tonic-gate 		/*
57417c478bd9Sstevel@tonic-gate 		 * Loop until we reach the end of this stream.
57427c478bd9Sstevel@tonic-gate 		 * On completion, qp points to the write queue
57437c478bd9Sstevel@tonic-gate 		 * at the end of the stream, or the read queue
57447c478bd9Sstevel@tonic-gate 		 * at the stream head if this is a fifo.
57457c478bd9Sstevel@tonic-gate 		 */
57467c478bd9Sstevel@tonic-gate 		while (((qp = qp->q_next) != NULL) && _SAMESTR(qp))
57477c478bd9Sstevel@tonic-gate 			;
57487c478bd9Sstevel@tonic-gate 
57497c478bd9Sstevel@tonic-gate 		/*
57507c478bd9Sstevel@tonic-gate 		 * Just in case we get a q_next which is NULL, but
57517c478bd9Sstevel@tonic-gate 		 * not at the end of the stream.  This is actually
57527c478bd9Sstevel@tonic-gate 		 * broken, so we set an assert to catch it in
57537c478bd9Sstevel@tonic-gate 		 * debug, and set an error and return if not debug.
57547c478bd9Sstevel@tonic-gate 		 */
57557c478bd9Sstevel@tonic-gate 		ASSERT(qp);
57567c478bd9Sstevel@tonic-gate 		if (qp == NULL) {
57577c478bd9Sstevel@tonic-gate 			releasestr(stp->sd_wrq);
57587c478bd9Sstevel@tonic-gate 			return (EINVAL);
57597c478bd9Sstevel@tonic-gate 		}
57607c478bd9Sstevel@tonic-gate 
57617c478bd9Sstevel@tonic-gate 		/*
57627c478bd9Sstevel@tonic-gate 		 * Enter the syncq for the driver, so (hopefully)
57637c478bd9Sstevel@tonic-gate 		 * the queue values will not change on us.
57647c478bd9Sstevel@tonic-gate 		 * XXXX - This will only prevent the race IFF only
57657c478bd9Sstevel@tonic-gate 		 *   the write side modifies the q_next member, and
57667c478bd9Sstevel@tonic-gate 		 *   the put procedure is protected by at least
57677c478bd9Sstevel@tonic-gate 		 *   MT_PERQ.
57687c478bd9Sstevel@tonic-gate 		 */
57697c478bd9Sstevel@tonic-gate 		if ((sq = qp->q_syncq) != NULL)
57707c478bd9Sstevel@tonic-gate 			entersq(sq, SQ_PUT);
57717c478bd9Sstevel@tonic-gate 
57727c478bd9Sstevel@tonic-gate 		/* Now get the q_next value from this qp. */
57737c478bd9Sstevel@tonic-gate 		nextqp = qp->q_next;
57747c478bd9Sstevel@tonic-gate 
57757c478bd9Sstevel@tonic-gate 		/*
57767c478bd9Sstevel@tonic-gate 		 * If nextqp exists and the other stream is different
57777c478bd9Sstevel@tonic-gate 		 * from this one claim the stream, set the mate, and
57787c478bd9Sstevel@tonic-gate 		 * get the read queue at the stream head of the other
57797c478bd9Sstevel@tonic-gate 		 * stream.  Assumes that nextqp was at least valid when
57807c478bd9Sstevel@tonic-gate 		 * we got it.  Hopefully the entersq of the driver
57817c478bd9Sstevel@tonic-gate 		 * will prevent it from changing on us.
57827c478bd9Sstevel@tonic-gate 		 */
57837c478bd9Sstevel@tonic-gate 		if ((nextqp != NULL) && (STREAM(nextqp) != stp)) {
57847c478bd9Sstevel@tonic-gate 			ASSERT(qp->q_qinfo->qi_srvp);
57857c478bd9Sstevel@tonic-gate 			ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp);
57867c478bd9Sstevel@tonic-gate 			ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp);
57877c478bd9Sstevel@tonic-gate 			claimstr(nextqp);
57887c478bd9Sstevel@tonic-gate 
57897c478bd9Sstevel@tonic-gate 			/* Make sure we still have a q_next */
57907c478bd9Sstevel@tonic-gate 			if (nextqp != qp->q_next) {
57917c478bd9Sstevel@tonic-gate 				releasestr(stp->sd_wrq);
57927c478bd9Sstevel@tonic-gate 				releasestr(nextqp);
57937c478bd9Sstevel@tonic-gate 				return (EINVAL);
57947c478bd9Sstevel@tonic-gate 			}
57957c478bd9Sstevel@tonic-gate 
57967c478bd9Sstevel@tonic-gate 			qp = _RD(STREAM(nextqp)->sd_wrq);
57977c478bd9Sstevel@tonic-gate 			mate = qp;
57987c478bd9Sstevel@tonic-gate 		}
57997c478bd9Sstevel@tonic-gate 		/* If we entered the synq above, leave it. */
58007c478bd9Sstevel@tonic-gate 		if (sq != NULL)
58017c478bd9Sstevel@tonic-gate 			leavesq(sq, SQ_PUT);
58027c478bd9Sstevel@tonic-gate 	} /*  STRMATED(STP)  */
58037c478bd9Sstevel@tonic-gate 
58047c478bd9Sstevel@tonic-gate 	/* XXX prevents substitution of the ops vector */
58057c478bd9Sstevel@tonic-gate 	if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) {
58067c478bd9Sstevel@tonic-gate 		retval = EINVAL;
58077c478bd9Sstevel@tonic-gate 		goto out;
58087c478bd9Sstevel@tonic-gate 	}
58097c478bd9Sstevel@tonic-gate 
58107c478bd9Sstevel@tonic-gate 	if (qp->q_flag & QFULL) {
58117c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
58127c478bd9Sstevel@tonic-gate 		goto out;
58137c478bd9Sstevel@tonic-gate 	}
58147c478bd9Sstevel@tonic-gate 
58157c478bd9Sstevel@tonic-gate 	/*
58167c478bd9Sstevel@tonic-gate 	 * Since M_PASSFP messages include a file descriptor, we use
58177c478bd9Sstevel@tonic-gate 	 * esballoc() and specify a custom free routine (free_passfp()) that
58187c478bd9Sstevel@tonic-gate 	 * will close the descriptor as part of freeing the message.  For
58197c478bd9Sstevel@tonic-gate 	 * convenience, we stash the frtn_t right after the data block.
58207c478bd9Sstevel@tonic-gate 	 */
58217c478bd9Sstevel@tonic-gate 	bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t);
58227c478bd9Sstevel@tonic-gate 	srf = kmem_alloc(bufsize, KM_NOSLEEP);
58237c478bd9Sstevel@tonic-gate 	if (srf == NULL) {
58247c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
58257c478bd9Sstevel@tonic-gate 		goto out;
58267c478bd9Sstevel@tonic-gate 	}
58277c478bd9Sstevel@tonic-gate 
58287c478bd9Sstevel@tonic-gate 	frtnp = (frtn_t *)(srf + 1);
58297c478bd9Sstevel@tonic-gate 	frtnp->free_arg = (caddr_t)srf;
58307c478bd9Sstevel@tonic-gate 	frtnp->free_func = free_passfp;
58317c478bd9Sstevel@tonic-gate 
58327c478bd9Sstevel@tonic-gate 	mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp);
58337c478bd9Sstevel@tonic-gate 	if (mp == NULL) {
58347c478bd9Sstevel@tonic-gate 		kmem_free(srf, bufsize);
58357c478bd9Sstevel@tonic-gate 		retval = EAGAIN;
58367c478bd9Sstevel@tonic-gate 		goto out;
58377c478bd9Sstevel@tonic-gate 	}
58387c478bd9Sstevel@tonic-gate 	mp->b_wptr += sizeof (struct k_strrecvfd);
58397c478bd9Sstevel@tonic-gate 	mp->b_datap->db_type = M_PASSFP;
58407c478bd9Sstevel@tonic-gate 
58417c478bd9Sstevel@tonic-gate 	srf->fp = fp;
58427c478bd9Sstevel@tonic-gate 	srf->uid = crgetuid(curthread->t_cred);
58437c478bd9Sstevel@tonic-gate 	srf->gid = crgetgid(curthread->t_cred);
58447c478bd9Sstevel@tonic-gate 	mutex_enter(&fp->f_tlock);
58457c478bd9Sstevel@tonic-gate 	fp->f_count++;
58467c478bd9Sstevel@tonic-gate 	mutex_exit(&fp->f_tlock);
58477c478bd9Sstevel@tonic-gate 
58487c478bd9Sstevel@tonic-gate 	put(qp, mp);
58497c478bd9Sstevel@tonic-gate out:
58507c478bd9Sstevel@tonic-gate 	releasestr(stp->sd_wrq);
58517c478bd9Sstevel@tonic-gate 	if (mate)
58527c478bd9Sstevel@tonic-gate 		releasestr(mate);
58537c478bd9Sstevel@tonic-gate 	return (retval);
58547c478bd9Sstevel@tonic-gate }
58557c478bd9Sstevel@tonic-gate 
58567c478bd9Sstevel@tonic-gate /*
58577c478bd9Sstevel@tonic-gate  * Send an ioctl message downstream and wait for acknowledgement.
58587c478bd9Sstevel@tonic-gate  * flags may be set to either U_TO_K or K_TO_K and a combination
58597c478bd9Sstevel@tonic-gate  * of STR_NOERROR or STR_NOSIG
58607c478bd9Sstevel@tonic-gate  * STR_NOSIG: Signals are essentially ignored or held and have
58617c478bd9Sstevel@tonic-gate  *	no effect for the duration of the call.
58627c478bd9Sstevel@tonic-gate  * STR_NOERROR: Ignores stream head read, write and hup errors.
58637c478bd9Sstevel@tonic-gate  *	Additionally, if an existing ioctl times out, it is assumed
58647c478bd9Sstevel@tonic-gate  *	lost and and this ioctl will continue as if the previous ioctl had
58657c478bd9Sstevel@tonic-gate  *	finished.  ETIME may be returned if this ioctl times out (i.e.
58667c478bd9Sstevel@tonic-gate  *	ic_timout is not INFTIM).  Non-stream head errors may be returned if
58677c478bd9Sstevel@tonic-gate  *	the ioc_error indicates that the driver/module had problems,
58687c478bd9Sstevel@tonic-gate  *	an EFAULT was found when accessing user data, a lack of
58697c478bd9Sstevel@tonic-gate  * 	resources, etc.
58707c478bd9Sstevel@tonic-gate  */
58717c478bd9Sstevel@tonic-gate int
58727c478bd9Sstevel@tonic-gate strdoioctl(
58737c478bd9Sstevel@tonic-gate 	struct stdata *stp,
58747c478bd9Sstevel@tonic-gate 	struct strioctl *strioc,
58757c478bd9Sstevel@tonic-gate 	int fflags,		/* file flags with model info */
58767c478bd9Sstevel@tonic-gate 	int flag,
58777c478bd9Sstevel@tonic-gate 	cred_t *crp,
58787c478bd9Sstevel@tonic-gate 	int *rvalp)
58797c478bd9Sstevel@tonic-gate {
58807c478bd9Sstevel@tonic-gate 	mblk_t *bp;
58817c478bd9Sstevel@tonic-gate 	struct iocblk *iocbp;
58827c478bd9Sstevel@tonic-gate 	struct copyreq *reqp;
58837c478bd9Sstevel@tonic-gate 	struct copyresp *resp;
58847c478bd9Sstevel@tonic-gate 	int id;
58857c478bd9Sstevel@tonic-gate 	int transparent = 0;
58867c478bd9Sstevel@tonic-gate 	int error = 0;
58877c478bd9Sstevel@tonic-gate 	int len = 0;
58887c478bd9Sstevel@tonic-gate 	caddr_t taddr;
58897c478bd9Sstevel@tonic-gate 	int copyflag = (flag & (U_TO_K | K_TO_K));
58907c478bd9Sstevel@tonic-gate 	int sigflag = (flag & STR_NOSIG);
58917c478bd9Sstevel@tonic-gate 	int errs;
58927c478bd9Sstevel@tonic-gate 	uint_t waitflags;
58937c478bd9Sstevel@tonic-gate 
58947c478bd9Sstevel@tonic-gate 	ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
58957c478bd9Sstevel@tonic-gate 	ASSERT((fflags & FMODELS) != 0);
58967c478bd9Sstevel@tonic-gate 
58977c478bd9Sstevel@tonic-gate 	TRACE_2(TR_FAC_STREAMS_FR,
58987c478bd9Sstevel@tonic-gate 	    TR_STRDOIOCTL,
58997c478bd9Sstevel@tonic-gate 	    "strdoioctl:stp %p strioc %p", stp, strioc);
59007c478bd9Sstevel@tonic-gate 	if (strioc->ic_len == TRANSPARENT) {	/* send arg in M_DATA block */
59017c478bd9Sstevel@tonic-gate 		transparent = 1;
59027c478bd9Sstevel@tonic-gate 		strioc->ic_len = sizeof (intptr_t);
59037c478bd9Sstevel@tonic-gate 	}
59047c478bd9Sstevel@tonic-gate 
59057c478bd9Sstevel@tonic-gate 	if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz))
59067c478bd9Sstevel@tonic-gate 		return (EINVAL);
59077c478bd9Sstevel@tonic-gate 
59087c478bd9Sstevel@tonic-gate 	if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error,
5909de8c4a14SErik Nordmark 	    crp, curproc->p_pid)) == NULL)
59107c478bd9Sstevel@tonic-gate 			return (error);
59117c478bd9Sstevel@tonic-gate 
59127c478bd9Sstevel@tonic-gate 	bzero(bp->b_wptr, sizeof (union ioctypes));
59137c478bd9Sstevel@tonic-gate 
59147c478bd9Sstevel@tonic-gate 	iocbp = (struct iocblk *)bp->b_wptr;
59157c478bd9Sstevel@tonic-gate 	iocbp->ioc_count = strioc->ic_len;
59167c478bd9Sstevel@tonic-gate 	iocbp->ioc_cmd = strioc->ic_cmd;
59177c478bd9Sstevel@tonic-gate 	iocbp->ioc_flag = (fflags & FMODELS);
59187c478bd9Sstevel@tonic-gate 
59197c478bd9Sstevel@tonic-gate 	crhold(crp);
59207c478bd9Sstevel@tonic-gate 	iocbp->ioc_cr = crp;
59217c478bd9Sstevel@tonic-gate 	DB_TYPE(bp) = M_IOCTL;
59227c478bd9Sstevel@tonic-gate 	bp->b_wptr += sizeof (struct iocblk);
59237c478bd9Sstevel@tonic-gate 
59247c478bd9Sstevel@tonic-gate 	if (flag & STR_NOERROR)
59257c478bd9Sstevel@tonic-gate 		errs = STPLEX;
59267c478bd9Sstevel@tonic-gate 	else
59277c478bd9Sstevel@tonic-gate 		errs = STRHUP|STRDERR|STWRERR|STPLEX;
59287c478bd9Sstevel@tonic-gate 
59297c478bd9Sstevel@tonic-gate 	/*
59307c478bd9Sstevel@tonic-gate 	 * If there is data to copy into ioctl block, do so.
59317c478bd9Sstevel@tonic-gate 	 */
59327c478bd9Sstevel@tonic-gate 	if (iocbp->ioc_count > 0) {
59337c478bd9Sstevel@tonic-gate 		if (transparent)
59347c478bd9Sstevel@tonic-gate 			/*
59357c478bd9Sstevel@tonic-gate 			 * Note: STR_NOERROR does not have an effect
59367c478bd9Sstevel@tonic-gate 			 * in putiocd()
59377c478bd9Sstevel@tonic-gate 			 */
59387c478bd9Sstevel@tonic-gate 			id = K_TO_K | sigflag;
59397c478bd9Sstevel@tonic-gate 		else
59407c478bd9Sstevel@tonic-gate 			id = flag;
59417c478bd9Sstevel@tonic-gate 		if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) {
59427c478bd9Sstevel@tonic-gate 			freemsg(bp);
59437c478bd9Sstevel@tonic-gate 			crfree(crp);
59447c478bd9Sstevel@tonic-gate 			return (error);
59457c478bd9Sstevel@tonic-gate 		}
59467c478bd9Sstevel@tonic-gate 
59477c478bd9Sstevel@tonic-gate 		/*
59487c478bd9Sstevel@tonic-gate 		 * We could have slept copying in user pages.
59497c478bd9Sstevel@tonic-gate 		 * Recheck the stream head state (the other end
59507c478bd9Sstevel@tonic-gate 		 * of a pipe could have gone away).
59517c478bd9Sstevel@tonic-gate 		 */
59527c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & errs) {
59537c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
59547c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
59557c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
59567c478bd9Sstevel@tonic-gate 			if (error != 0) {
59577c478bd9Sstevel@tonic-gate 				freemsg(bp);
59587c478bd9Sstevel@tonic-gate 				crfree(crp);
59597c478bd9Sstevel@tonic-gate 				return (error);
59607c478bd9Sstevel@tonic-gate 			}
59617c478bd9Sstevel@tonic-gate 		}
59627c478bd9Sstevel@tonic-gate 	}
59637c478bd9Sstevel@tonic-gate 	if (transparent)
59647c478bd9Sstevel@tonic-gate 		iocbp->ioc_count = TRANSPARENT;
59657c478bd9Sstevel@tonic-gate 
59667c478bd9Sstevel@tonic-gate 	/*
59677c478bd9Sstevel@tonic-gate 	 * Block for up to STRTIMOUT milliseconds if there is an outstanding
59687c478bd9Sstevel@tonic-gate 	 * ioctl for this stream already running.  All processes
59697c478bd9Sstevel@tonic-gate 	 * sleeping here will be awakened as a result of an ACK
59707c478bd9Sstevel@tonic-gate 	 * or NAK being received for the outstanding ioctl, or
59717c478bd9Sstevel@tonic-gate 	 * as a result of the timer expiring on the outstanding
59727c478bd9Sstevel@tonic-gate 	 * ioctl (a failure), or as a result of any waiting
59737c478bd9Sstevel@tonic-gate 	 * process's timer expiring (also a failure).
59747c478bd9Sstevel@tonic-gate 	 */
59757c478bd9Sstevel@tonic-gate 
59767c478bd9Sstevel@tonic-gate 	error = 0;
59777c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
59787c478bd9Sstevel@tonic-gate 	while (stp->sd_flag & (IOCWAIT | IOCWAITNE)) {
59797c478bd9Sstevel@tonic-gate 		clock_t cv_rval;
59807c478bd9Sstevel@tonic-gate 
59817c478bd9Sstevel@tonic-gate 		TRACE_0(TR_FAC_STREAMS_FR,
59827c478bd9Sstevel@tonic-gate 		    TR_STRDOIOCTL_WAIT,
59837c478bd9Sstevel@tonic-gate 		    "strdoioctl sleeps - IOCWAIT");
59847c478bd9Sstevel@tonic-gate 		cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock,
59857c478bd9Sstevel@tonic-gate 		    STRTIMOUT, sigflag);
59867c478bd9Sstevel@tonic-gate 		if (cv_rval <= 0) {
59877c478bd9Sstevel@tonic-gate 			if (cv_rval == 0) {
59887c478bd9Sstevel@tonic-gate 				error = EINTR;
59897c478bd9Sstevel@tonic-gate 			} else {
59907c478bd9Sstevel@tonic-gate 				if (flag & STR_NOERROR) {
59917c478bd9Sstevel@tonic-gate 					/*
59927c478bd9Sstevel@tonic-gate 					 * Terminating current ioctl in
59937c478bd9Sstevel@tonic-gate 					 * progress -- assume it got lost and
59947c478bd9Sstevel@tonic-gate 					 * wake up the other thread so that the
59957c478bd9Sstevel@tonic-gate 					 * operation completes.
59967c478bd9Sstevel@tonic-gate 					 */
59977c478bd9Sstevel@tonic-gate 					if (!(stp->sd_flag & IOCWAITNE)) {
59987c478bd9Sstevel@tonic-gate 						stp->sd_flag |= IOCWAITNE;
59997c478bd9Sstevel@tonic-gate 						cv_broadcast(&stp->sd_monitor);
60007c478bd9Sstevel@tonic-gate 					}
60017c478bd9Sstevel@tonic-gate 					/*
60027c478bd9Sstevel@tonic-gate 					 * Otherwise, there's a running
60037c478bd9Sstevel@tonic-gate 					 * STR_NOERROR -- we have no choice
60047c478bd9Sstevel@tonic-gate 					 * here but to wait forever (or until
60057c478bd9Sstevel@tonic-gate 					 * interrupted).
60067c478bd9Sstevel@tonic-gate 					 */
60077c478bd9Sstevel@tonic-gate 				} else {
60087c478bd9Sstevel@tonic-gate 					/*
60097c478bd9Sstevel@tonic-gate 					 * pending ioctl has caused
60107c478bd9Sstevel@tonic-gate 					 * us to time out
60117c478bd9Sstevel@tonic-gate 					 */
60127c478bd9Sstevel@tonic-gate 					error = ETIME;
60137c478bd9Sstevel@tonic-gate 				}
60147c478bd9Sstevel@tonic-gate 			}
60157c478bd9Sstevel@tonic-gate 		} else if ((stp->sd_flag & errs)) {
60167c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
60177c478bd9Sstevel@tonic-gate 		}
60187c478bd9Sstevel@tonic-gate 		if (error) {
60197c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
60207c478bd9Sstevel@tonic-gate 			freemsg(bp);
60217c478bd9Sstevel@tonic-gate 			crfree(crp);
60227c478bd9Sstevel@tonic-gate 			return (error);
60237c478bd9Sstevel@tonic-gate 		}
60247c478bd9Sstevel@tonic-gate 	}
60257c478bd9Sstevel@tonic-gate 
60267c478bd9Sstevel@tonic-gate 	/*
60277c478bd9Sstevel@tonic-gate 	 * Have control of ioctl mechanism.
60287c478bd9Sstevel@tonic-gate 	 * Send down ioctl packet and wait for response.
60297c478bd9Sstevel@tonic-gate 	 */
60307c478bd9Sstevel@tonic-gate 	if (stp->sd_iocblk != (mblk_t *)-1) {
60317c478bd9Sstevel@tonic-gate 		freemsg(stp->sd_iocblk);
60327c478bd9Sstevel@tonic-gate 	}
60337c478bd9Sstevel@tonic-gate 	stp->sd_iocblk = NULL;
60347c478bd9Sstevel@tonic-gate 
60357c478bd9Sstevel@tonic-gate 	/*
60367c478bd9Sstevel@tonic-gate 	 * If this is marked with 'noerror' (internal; mostly
60377c478bd9Sstevel@tonic-gate 	 * I_{P,}{UN,}LINK), then make sure nobody else is able to get
60387c478bd9Sstevel@tonic-gate 	 * in here by setting IOCWAITNE.
60397c478bd9Sstevel@tonic-gate 	 */
60407c478bd9Sstevel@tonic-gate 	waitflags = IOCWAIT;
60417c478bd9Sstevel@tonic-gate 	if (flag & STR_NOERROR)
60427c478bd9Sstevel@tonic-gate 		waitflags |= IOCWAITNE;
60437c478bd9Sstevel@tonic-gate 
60447c478bd9Sstevel@tonic-gate 	stp->sd_flag |= waitflags;
60457c478bd9Sstevel@tonic-gate 
60467c478bd9Sstevel@tonic-gate 	/*
60477c478bd9Sstevel@tonic-gate 	 * Assign sequence number.
60487c478bd9Sstevel@tonic-gate 	 */
60497c478bd9Sstevel@tonic-gate 	iocbp->ioc_id = stp->sd_iocid = getiocseqno();
60507c478bd9Sstevel@tonic-gate 
60517c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
60527c478bd9Sstevel@tonic-gate 
60537c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
60547c478bd9Sstevel@tonic-gate 	    TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp);
60557c478bd9Sstevel@tonic-gate 	stream_willservice(stp);
60567c478bd9Sstevel@tonic-gate 	putnext(stp->sd_wrq, bp);
60577c478bd9Sstevel@tonic-gate 	stream_runservice(stp);
60587c478bd9Sstevel@tonic-gate 
60597c478bd9Sstevel@tonic-gate 	/*
60607c478bd9Sstevel@tonic-gate 	 * Timed wait for acknowledgment.  The wait time is limited by the
60617c478bd9Sstevel@tonic-gate 	 * timeout value, which must be a positive integer (number of
6062c28749e9Skais 	 * milliseconds) to wait, or 0 (use default value of STRTIMOUT
60637c478bd9Sstevel@tonic-gate 	 * milliseconds), or -1 (wait forever).  This will be awakened
60647c478bd9Sstevel@tonic-gate 	 * either by an ACK/NAK message arriving, the timer expiring, or
60657c478bd9Sstevel@tonic-gate 	 * the timer expiring on another ioctl waiting for control of the
60667c478bd9Sstevel@tonic-gate 	 * mechanism.
60677c478bd9Sstevel@tonic-gate 	 */
60687c478bd9Sstevel@tonic-gate waitioc:
60697c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
60707c478bd9Sstevel@tonic-gate 
60717c478bd9Sstevel@tonic-gate 
60727c478bd9Sstevel@tonic-gate 	/*
60737c478bd9Sstevel@tonic-gate 	 * If the reply has already arrived, don't sleep.  If awakened from
60747c478bd9Sstevel@tonic-gate 	 * the sleep, fail only if the reply has not arrived by then.
60757c478bd9Sstevel@tonic-gate 	 * Otherwise, process the reply.
60767c478bd9Sstevel@tonic-gate 	 */
60777c478bd9Sstevel@tonic-gate 	while (!stp->sd_iocblk) {
60787c478bd9Sstevel@tonic-gate 		clock_t cv_rval;
60797c478bd9Sstevel@tonic-gate 
60807c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & errs) {
60817c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, errs, 0);
60827c478bd9Sstevel@tonic-gate 			if (error != 0) {
60837c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~waitflags;
60847c478bd9Sstevel@tonic-gate 				cv_broadcast(&stp->sd_iocmonitor);
60857c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
60867c478bd9Sstevel@tonic-gate 				crfree(crp);
60877c478bd9Sstevel@tonic-gate 				return (error);
60887c478bd9Sstevel@tonic-gate 			}
60897c478bd9Sstevel@tonic-gate 		}
60907c478bd9Sstevel@tonic-gate 
60917c478bd9Sstevel@tonic-gate 		TRACE_0(TR_FAC_STREAMS_FR,
60927c478bd9Sstevel@tonic-gate 		    TR_STRDOIOCTL_WAIT2,
60937c478bd9Sstevel@tonic-gate 		    "strdoioctl sleeps awaiting reply");
60947c478bd9Sstevel@tonic-gate 		ASSERT(error == 0);
60957c478bd9Sstevel@tonic-gate 
60967c478bd9Sstevel@tonic-gate 		cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock,
60977c478bd9Sstevel@tonic-gate 		    (strioc->ic_timout ?
60987c478bd9Sstevel@tonic-gate 		    strioc->ic_timout * 1000 : STRTIMOUT), sigflag);
60997c478bd9Sstevel@tonic-gate 
61007c478bd9Sstevel@tonic-gate 		/*
61017c478bd9Sstevel@tonic-gate 		 * There are four possible cases here: interrupt, timeout,
61027c478bd9Sstevel@tonic-gate 		 * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a
61037c478bd9Sstevel@tonic-gate 		 * valid M_IOCTL reply).
61047c478bd9Sstevel@tonic-gate 		 *
61057c478bd9Sstevel@tonic-gate 		 * If we've been awakened by a STR_NOERROR ioctl on some other
61067c478bd9Sstevel@tonic-gate 		 * thread, then sd_iocblk will still be NULL, and IOCWAITNE
61077c478bd9Sstevel@tonic-gate 		 * will be set.  Pretend as if we just timed out.  Note that
61087c478bd9Sstevel@tonic-gate 		 * this other thread waited at least STRTIMOUT before trying to
61097c478bd9Sstevel@tonic-gate 		 * awaken our thread, so this is indistinguishable (even for
61107c478bd9Sstevel@tonic-gate 		 * INFTIM) from the case where we failed with ETIME waiting on
61117c478bd9Sstevel@tonic-gate 		 * IOCWAIT in the prior loop.
61127c478bd9Sstevel@tonic-gate 		 */
61137c478bd9Sstevel@tonic-gate 		if (cv_rval > 0 && !(flag & STR_NOERROR) &&
61147c478bd9Sstevel@tonic-gate 		    stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) {
61157c478bd9Sstevel@tonic-gate 			cv_rval = -1;
61167c478bd9Sstevel@tonic-gate 		}
61177c478bd9Sstevel@tonic-gate 
61187c478bd9Sstevel@tonic-gate 		/*
61197c478bd9Sstevel@tonic-gate 		 * note: STR_NOERROR does not protect
61207c478bd9Sstevel@tonic-gate 		 * us here.. use ic_timout < 0
61217c478bd9Sstevel@tonic-gate 		 */
61227c478bd9Sstevel@tonic-gate 		if (cv_rval <= 0) {
61237c478bd9Sstevel@tonic-gate 			if (cv_rval == 0) {
61247c478bd9Sstevel@tonic-gate 				error = EINTR;
61257c478bd9Sstevel@tonic-gate 			} else {
61267c478bd9Sstevel@tonic-gate 				error =  ETIME;
61277c478bd9Sstevel@tonic-gate 			}
61287c478bd9Sstevel@tonic-gate 			/*
61297c478bd9Sstevel@tonic-gate 			 * A message could have come in after we were scheduled
61307c478bd9Sstevel@tonic-gate 			 * but before we were actually run.
61317c478bd9Sstevel@tonic-gate 			 */
61327c478bd9Sstevel@tonic-gate 			bp = stp->sd_iocblk;
61337c478bd9Sstevel@tonic-gate 			stp->sd_iocblk = NULL;
61347c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
61357c478bd9Sstevel@tonic-gate 				if ((bp->b_datap->db_type == M_COPYIN) ||
61367c478bd9Sstevel@tonic-gate 				    (bp->b_datap->db_type == M_COPYOUT)) {
61377c478bd9Sstevel@tonic-gate 					mutex_exit(&stp->sd_lock);
61387c478bd9Sstevel@tonic-gate 					if (bp->b_cont) {
61397c478bd9Sstevel@tonic-gate 						freemsg(bp->b_cont);
61407c478bd9Sstevel@tonic-gate 						bp->b_cont = NULL;
61417c478bd9Sstevel@tonic-gate 					}
61427c478bd9Sstevel@tonic-gate 					bp->b_datap->db_type = M_IOCDATA;
61437c478bd9Sstevel@tonic-gate 					bp->b_wptr = bp->b_rptr +
61447c478bd9Sstevel@tonic-gate 					    sizeof (struct copyresp);
61457c478bd9Sstevel@tonic-gate 					resp = (struct copyresp *)bp->b_rptr;
61467c478bd9Sstevel@tonic-gate 					resp->cp_rval =
61477c478bd9Sstevel@tonic-gate 					    (caddr_t)1; /* failure */
61487c478bd9Sstevel@tonic-gate 					stream_willservice(stp);
61497c478bd9Sstevel@tonic-gate 					putnext(stp->sd_wrq, bp);
61507c478bd9Sstevel@tonic-gate 					stream_runservice(stp);
61517c478bd9Sstevel@tonic-gate 					mutex_enter(&stp->sd_lock);
61527c478bd9Sstevel@tonic-gate 				} else {
61537c478bd9Sstevel@tonic-gate 					freemsg(bp);
61547c478bd9Sstevel@tonic-gate 				}
61557c478bd9Sstevel@tonic-gate 			}
61567c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
61577c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
61587c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
61597c478bd9Sstevel@tonic-gate 			crfree(crp);
61607c478bd9Sstevel@tonic-gate 			return (error);
61617c478bd9Sstevel@tonic-gate 		}
61627c478bd9Sstevel@tonic-gate 	}
61637c478bd9Sstevel@tonic-gate 	bp = stp->sd_iocblk;
61647c478bd9Sstevel@tonic-gate 	/*
61657c478bd9Sstevel@tonic-gate 	 * Note: it is strictly impossible to get here with sd_iocblk set to
61667c478bd9Sstevel@tonic-gate 	 * -1.  This is because the initial loop above doesn't allow any new
61677c478bd9Sstevel@tonic-gate 	 * ioctls into the fray until all others have passed this point.
61687c478bd9Sstevel@tonic-gate 	 */
61697c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL && bp != (mblk_t *)-1);
61707c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR,
61717c478bd9Sstevel@tonic-gate 	    TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp);
61727c478bd9Sstevel@tonic-gate 	if ((bp->b_datap->db_type == M_IOCACK) ||
61737c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_IOCNAK)) {
61747c478bd9Sstevel@tonic-gate 		/* for detection of duplicate ioctl replies */
61757c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = (mblk_t *)-1;
61767c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~waitflags;
61777c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_iocmonitor);
61787c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
61797c478bd9Sstevel@tonic-gate 	} else {
61807c478bd9Sstevel@tonic-gate 		/*
61817c478bd9Sstevel@tonic-gate 		 * flags not cleared here because we're still doing
61827c478bd9Sstevel@tonic-gate 		 * copy in/out for ioctl.
61837c478bd9Sstevel@tonic-gate 		 */
61847c478bd9Sstevel@tonic-gate 		stp->sd_iocblk = NULL;
61857c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
61867c478bd9Sstevel@tonic-gate 	}
61877c478bd9Sstevel@tonic-gate 
61887c478bd9Sstevel@tonic-gate 
61897c478bd9Sstevel@tonic-gate 	/*
61907c478bd9Sstevel@tonic-gate 	 * Have received acknowledgment.
61917c478bd9Sstevel@tonic-gate 	 */
61927c478bd9Sstevel@tonic-gate 
61937c478bd9Sstevel@tonic-gate 	switch (bp->b_datap->db_type) {
61947c478bd9Sstevel@tonic-gate 	case M_IOCACK:
61957c478bd9Sstevel@tonic-gate 		/*
61967c478bd9Sstevel@tonic-gate 		 * Positive ack.
61977c478bd9Sstevel@tonic-gate 		 */
61987c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
61997c478bd9Sstevel@tonic-gate 
62007c478bd9Sstevel@tonic-gate 		/*
62017c478bd9Sstevel@tonic-gate 		 * Set error if indicated.
62027c478bd9Sstevel@tonic-gate 		 */
62037c478bd9Sstevel@tonic-gate 		if (iocbp->ioc_error) {
62047c478bd9Sstevel@tonic-gate 			error = iocbp->ioc_error;
62057c478bd9Sstevel@tonic-gate 			break;
62067c478bd9Sstevel@tonic-gate 		}
62077c478bd9Sstevel@tonic-gate 
62087c478bd9Sstevel@tonic-gate 		/*
62097c478bd9Sstevel@tonic-gate 		 * Set return value.
62107c478bd9Sstevel@tonic-gate 		 */
62117c478bd9Sstevel@tonic-gate 		*rvalp = iocbp->ioc_rval;
62127c478bd9Sstevel@tonic-gate 
62137c478bd9Sstevel@tonic-gate 		/*
62147c478bd9Sstevel@tonic-gate 		 * Data may have been returned in ACK message (ioc_count > 0).
62157c478bd9Sstevel@tonic-gate 		 * If so, copy it out to the user's buffer.
62167c478bd9Sstevel@tonic-gate 		 */
62177c478bd9Sstevel@tonic-gate 		if (iocbp->ioc_count && !transparent) {
62187c478bd9Sstevel@tonic-gate 			if (error = getiocd(bp, strioc->ic_dp, copyflag))
62197c478bd9Sstevel@tonic-gate 				break;
62207c478bd9Sstevel@tonic-gate 		}
62217c478bd9Sstevel@tonic-gate 		if (!transparent) {
62227c478bd9Sstevel@tonic-gate 			if (len)	/* an M_COPYOUT was used with I_STR */
62237c478bd9Sstevel@tonic-gate 				strioc->ic_len = len;
62247c478bd9Sstevel@tonic-gate 			else
62257c478bd9Sstevel@tonic-gate 				strioc->ic_len = (int)iocbp->ioc_count;
62267c478bd9Sstevel@tonic-gate 		}
62277c478bd9Sstevel@tonic-gate 		break;
62287c478bd9Sstevel@tonic-gate 
62297c478bd9Sstevel@tonic-gate 	case M_IOCNAK:
62307c478bd9Sstevel@tonic-gate 		/*
62317c478bd9Sstevel@tonic-gate 		 * Negative ack.
62327c478bd9Sstevel@tonic-gate 		 *
62337c478bd9Sstevel@tonic-gate 		 * The only thing to do is set error as specified
62347c478bd9Sstevel@tonic-gate 		 * in neg ack packet.
62357c478bd9Sstevel@tonic-gate 		 */
62367c478bd9Sstevel@tonic-gate 		iocbp = (struct iocblk *)bp->b_rptr;
62377c478bd9Sstevel@tonic-gate 
62387c478bd9Sstevel@tonic-gate 		error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL);
62397c478bd9Sstevel@tonic-gate 		break;
62407c478bd9Sstevel@tonic-gate 
62417c478bd9Sstevel@tonic-gate 	case M_COPYIN:
62427c478bd9Sstevel@tonic-gate 		/*
62437c478bd9Sstevel@tonic-gate 		 * Driver or module has requested user ioctl data.
62447c478bd9Sstevel@tonic-gate 		 */
62457c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
62467c478bd9Sstevel@tonic-gate 
62477c478bd9Sstevel@tonic-gate 		/*
62487c478bd9Sstevel@tonic-gate 		 * M_COPYIN should *never* have a message attached, though
62497c478bd9Sstevel@tonic-gate 		 * it's harmless if it does -- thus, panic on a DEBUG
62507c478bd9Sstevel@tonic-gate 		 * kernel and just free it on a non-DEBUG build.
62517c478bd9Sstevel@tonic-gate 		 */
62527c478bd9Sstevel@tonic-gate 		ASSERT(bp->b_cont == NULL);
62537c478bd9Sstevel@tonic-gate 		if (bp->b_cont != NULL) {
62547c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
62557c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
62567c478bd9Sstevel@tonic-gate 		}
62577c478bd9Sstevel@tonic-gate 
62587c478bd9Sstevel@tonic-gate 		error = putiocd(bp, reqp->cq_addr, flag, crp);
62597c478bd9Sstevel@tonic-gate 		if (error && bp->b_cont) {
62607c478bd9Sstevel@tonic-gate 			freemsg(bp->b_cont);
62617c478bd9Sstevel@tonic-gate 			bp->b_cont = NULL;
62627c478bd9Sstevel@tonic-gate 		}
62637c478bd9Sstevel@tonic-gate 
62647c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
62657c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
62667c478bd9Sstevel@tonic-gate 
6267de8c4a14SErik Nordmark 		mblk_setcred(bp, crp, curproc->p_pid);
62687c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
62697c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)(uintptr_t)error;
62707c478bd9Sstevel@tonic-gate 		resp->cp_flag = (fflags & FMODELS);
62717c478bd9Sstevel@tonic-gate 
62727c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
62737c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, bp);
62747c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
62757c478bd9Sstevel@tonic-gate 
62767c478bd9Sstevel@tonic-gate 		if (error) {
62777c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
62787c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
62797c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
62807c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
62817c478bd9Sstevel@tonic-gate 			crfree(crp);
62827c478bd9Sstevel@tonic-gate 			return (error);
62837c478bd9Sstevel@tonic-gate 		}
62847c478bd9Sstevel@tonic-gate 
62857c478bd9Sstevel@tonic-gate 		goto waitioc;
62867c478bd9Sstevel@tonic-gate 
62877c478bd9Sstevel@tonic-gate 	case M_COPYOUT:
62887c478bd9Sstevel@tonic-gate 		/*
62897c478bd9Sstevel@tonic-gate 		 * Driver or module has ioctl data for a user.
62907c478bd9Sstevel@tonic-gate 		 */
62917c478bd9Sstevel@tonic-gate 		reqp = (struct copyreq *)bp->b_rptr;
62927c478bd9Sstevel@tonic-gate 		ASSERT(bp->b_cont != NULL);
62937c478bd9Sstevel@tonic-gate 
62947c478bd9Sstevel@tonic-gate 		/*
62957c478bd9Sstevel@tonic-gate 		 * Always (transparent or non-transparent )
62967c478bd9Sstevel@tonic-gate 		 * use the address specified in the request
62977c478bd9Sstevel@tonic-gate 		 */
62987c478bd9Sstevel@tonic-gate 		taddr = reqp->cq_addr;
62997c478bd9Sstevel@tonic-gate 		if (!transparent)
63007c478bd9Sstevel@tonic-gate 			len = (int)reqp->cq_size;
63017c478bd9Sstevel@tonic-gate 
63027c478bd9Sstevel@tonic-gate 		/* copyout data to the provided address */
63037c478bd9Sstevel@tonic-gate 		error = getiocd(bp, taddr, copyflag);
63047c478bd9Sstevel@tonic-gate 
63057c478bd9Sstevel@tonic-gate 		freemsg(bp->b_cont);
63067c478bd9Sstevel@tonic-gate 		bp->b_cont = NULL;
63077c478bd9Sstevel@tonic-gate 
63087c478bd9Sstevel@tonic-gate 		bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
63097c478bd9Sstevel@tonic-gate 		bp->b_datap->db_type = M_IOCDATA;
63107c478bd9Sstevel@tonic-gate 
6311de8c4a14SErik Nordmark 		mblk_setcred(bp, crp, curproc->p_pid);
63127c478bd9Sstevel@tonic-gate 		resp = (struct copyresp *)bp->b_rptr;
63137c478bd9Sstevel@tonic-gate 		resp->cp_rval = (caddr_t)(uintptr_t)error;
63147c478bd9Sstevel@tonic-gate 		resp->cp_flag = (fflags & FMODELS);
63157c478bd9Sstevel@tonic-gate 
63167c478bd9Sstevel@tonic-gate 		stream_willservice(stp);
63177c478bd9Sstevel@tonic-gate 		putnext(stp->sd_wrq, bp);
63187c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
63197c478bd9Sstevel@tonic-gate 
63207c478bd9Sstevel@tonic-gate 		if (error) {
63217c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
63227c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~waitflags;
63237c478bd9Sstevel@tonic-gate 			cv_broadcast(&stp->sd_iocmonitor);
63247c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
63257c478bd9Sstevel@tonic-gate 			crfree(crp);
63267c478bd9Sstevel@tonic-gate 			return (error);
63277c478bd9Sstevel@tonic-gate 		}
63287c478bd9Sstevel@tonic-gate 		goto waitioc;
63297c478bd9Sstevel@tonic-gate 
63307c478bd9Sstevel@tonic-gate 	default:
63317c478bd9Sstevel@tonic-gate 		ASSERT(0);
63327c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
63337c478bd9Sstevel@tonic-gate 		stp->sd_flag &= ~waitflags;
63347c478bd9Sstevel@tonic-gate 		cv_broadcast(&stp->sd_iocmonitor);
63357c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
63367c478bd9Sstevel@tonic-gate 		break;
63377c478bd9Sstevel@tonic-gate 	}
63387c478bd9Sstevel@tonic-gate 
63397c478bd9Sstevel@tonic-gate 	freemsg(bp);
63407c478bd9Sstevel@tonic-gate 	crfree(crp);
63417c478bd9Sstevel@tonic-gate 	return (error);
63427c478bd9Sstevel@tonic-gate }
63437c478bd9Sstevel@tonic-gate 
63447c478bd9Sstevel@tonic-gate /*
6345ca9327a6Smeem  * Send an M_CMD message downstream and wait for a reply.  This is a ptools
6346ca9327a6Smeem  * special used to retrieve information from modules/drivers a stream without
6347ca9327a6Smeem  * being subjected to flow control or interfering with pending messages on the
6348ca9327a6Smeem  * stream (e.g. an ioctl in flight).
6349ca9327a6Smeem  */
6350ca9327a6Smeem int
6351ca9327a6Smeem strdocmd(struct stdata *stp, struct strcmd *scp, cred_t *crp)
6352ca9327a6Smeem {
6353ca9327a6Smeem 	mblk_t *mp;
6354ca9327a6Smeem 	struct cmdblk *cmdp;
6355ca9327a6Smeem 	int error = 0;
6356ca9327a6Smeem 	int errs = STRHUP|STRDERR|STWRERR|STPLEX;
6357ca9327a6Smeem 	clock_t rval, timeout = STRTIMOUT;
6358ca9327a6Smeem 
6359ca9327a6Smeem 	if (scp->sc_len < 0 || scp->sc_len > sizeof (scp->sc_buf) ||
6360ca9327a6Smeem 	    scp->sc_timeout < -1)
6361ca9327a6Smeem 		return (EINVAL);
6362ca9327a6Smeem 
6363ca9327a6Smeem 	if (scp->sc_timeout > 0)
6364ca9327a6Smeem 		timeout = scp->sc_timeout * MILLISEC;
6365ca9327a6Smeem 
6366de8c4a14SErik Nordmark 	if ((mp = allocb_cred(sizeof (struct cmdblk), crp,
6367de8c4a14SErik Nordmark 	    curproc->p_pid)) == NULL)
6368ca9327a6Smeem 		return (ENOMEM);
6369ca9327a6Smeem 
6370ca9327a6Smeem 	crhold(crp);
6371ca9327a6Smeem 
6372ca9327a6Smeem 	cmdp = (struct cmdblk *)mp->b_wptr;
6373ca9327a6Smeem 	cmdp->cb_cr = crp;
6374ca9327a6Smeem 	cmdp->cb_cmd = scp->sc_cmd;
6375ca9327a6Smeem 	cmdp->cb_len = scp->sc_len;
6376ca9327a6Smeem 	cmdp->cb_error = 0;
6377ca9327a6Smeem 	mp->b_wptr += sizeof (struct cmdblk);
6378ca9327a6Smeem 
6379ca9327a6Smeem 	DB_TYPE(mp) = M_CMD;
6380ca9327a6Smeem 	DB_CPID(mp) = curproc->p_pid;
6381ca9327a6Smeem 
6382ca9327a6Smeem 	/*
6383ca9327a6Smeem 	 * Copy in the payload.
6384ca9327a6Smeem 	 */
6385ca9327a6Smeem 	if (cmdp->cb_len > 0) {
6386de8c4a14SErik Nordmark 		mp->b_cont = allocb_cred(sizeof (scp->sc_buf), crp,
6387de8c4a14SErik Nordmark 		    curproc->p_pid);
6388ca9327a6Smeem 		if (mp->b_cont == NULL) {
6389ca9327a6Smeem 			error = ENOMEM;
6390ca9327a6Smeem 			goto out;
6391ca9327a6Smeem 		}
6392ca9327a6Smeem 
6393ca9327a6Smeem 		/* cb_len comes from sc_len, which has already been checked */
6394ca9327a6Smeem 		ASSERT(cmdp->cb_len <= sizeof (scp->sc_buf));
6395ca9327a6Smeem 		(void) bcopy(scp->sc_buf, mp->b_cont->b_wptr, cmdp->cb_len);
6396ca9327a6Smeem 		mp->b_cont->b_wptr += cmdp->cb_len;
6397ca9327a6Smeem 		DB_CPID(mp->b_cont) = curproc->p_pid;
6398ca9327a6Smeem 	}
6399ca9327a6Smeem 
6400ca9327a6Smeem 	/*
6401ca9327a6Smeem 	 * Since this mechanism is strictly for ptools, and since only one
6402ca9327a6Smeem 	 * process can be grabbed at a time, we simply fail if there's
6403ca9327a6Smeem 	 * currently an operation pending.
6404ca9327a6Smeem 	 */
6405ca9327a6Smeem 	mutex_enter(&stp->sd_lock);
6406ca9327a6Smeem 	if (stp->sd_flag & STRCMDWAIT) {
6407ca9327a6Smeem 		mutex_exit(&stp->sd_lock);
6408ca9327a6Smeem 		error = EBUSY;
6409ca9327a6Smeem 		goto out;
6410ca9327a6Smeem 	}
6411ca9327a6Smeem 	stp->sd_flag |= STRCMDWAIT;
6412ca9327a6Smeem 	ASSERT(stp->sd_cmdblk == NULL);
6413ca9327a6Smeem 	mutex_exit(&stp->sd_lock);
6414ca9327a6Smeem 
6415ca9327a6Smeem 	putnext(stp->sd_wrq, mp);
6416ca9327a6Smeem 	mp = NULL;
6417ca9327a6Smeem 
6418ca9327a6Smeem 	/*
6419ca9327a6Smeem 	 * Timed wait for acknowledgment.  If the reply has already arrived,
6420ca9327a6Smeem 	 * don't sleep.  If awakened from the sleep, fail only if the reply
6421ca9327a6Smeem 	 * has not arrived by then.  Otherwise, process the reply.
6422ca9327a6Smeem 	 */
6423ca9327a6Smeem 	mutex_enter(&stp->sd_lock);
6424ca9327a6Smeem 	while (stp->sd_cmdblk == NULL) {
6425ca9327a6Smeem 		if (stp->sd_flag & errs) {
6426ca9327a6Smeem 			if ((error = strgeterr(stp, errs, 0)) != 0)
6427ca9327a6Smeem 				goto waitout;
6428ca9327a6Smeem 		}
6429ca9327a6Smeem 
6430ca9327a6Smeem 		rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock, timeout, 0);
6431ca9327a6Smeem 		if (stp->sd_cmdblk != NULL)
6432ca9327a6Smeem 			break;
6433ca9327a6Smeem 
6434ca9327a6Smeem 		if (rval <= 0) {
6435ca9327a6Smeem 			error = (rval == 0) ? EINTR : ETIME;
6436ca9327a6Smeem 			goto waitout;
6437ca9327a6Smeem 		}
6438ca9327a6Smeem 	}
6439ca9327a6Smeem 
6440ca9327a6Smeem 	/*
6441ca9327a6Smeem 	 * We received a reply.
6442ca9327a6Smeem 	 */
6443ca9327a6Smeem 	mp = stp->sd_cmdblk;
6444ca9327a6Smeem 	stp->sd_cmdblk = NULL;
6445ca9327a6Smeem 	ASSERT(mp != NULL && DB_TYPE(mp) == M_CMD);
6446ca9327a6Smeem 	ASSERT(stp->sd_flag & STRCMDWAIT);
6447ca9327a6Smeem 	stp->sd_flag &= ~STRCMDWAIT;
6448ca9327a6Smeem 	mutex_exit(&stp->sd_lock);
6449ca9327a6Smeem 
6450ca9327a6Smeem 	cmdp = (struct cmdblk *)mp->b_rptr;
6451ca9327a6Smeem 	if ((error = cmdp->cb_error) != 0)
6452ca9327a6Smeem 		goto out;
6453ca9327a6Smeem 
6454ca9327a6Smeem 	/*
6455ca9327a6Smeem 	 * Data may have been returned in the reply (cb_len > 0).
6456ca9327a6Smeem 	 * If so, copy it out to the user's buffer.
6457ca9327a6Smeem 	 */
6458ca9327a6Smeem 	if (cmdp->cb_len > 0) {
6459ca9327a6Smeem 		if (mp->b_cont == NULL || MBLKL(mp->b_cont) < cmdp->cb_len) {
6460ca9327a6Smeem 			error = EPROTO;
6461ca9327a6Smeem 			goto out;
6462ca9327a6Smeem 		}
6463ca9327a6Smeem 
6464ca9327a6Smeem 		cmdp->cb_len = MIN(cmdp->cb_len, sizeof (scp->sc_buf));
6465ca9327a6Smeem 		(void) bcopy(mp->b_cont->b_rptr, scp->sc_buf, cmdp->cb_len);
6466ca9327a6Smeem 	}
6467ca9327a6Smeem 	scp->sc_len = cmdp->cb_len;
6468ca9327a6Smeem out:
6469ca9327a6Smeem 	freemsg(mp);
6470ca9327a6Smeem 	crfree(crp);
6471ca9327a6Smeem 	return (error);
6472ca9327a6Smeem waitout:
6473ca9327a6Smeem 	ASSERT(stp->sd_cmdblk == NULL);
6474ca9327a6Smeem 	stp->sd_flag &= ~STRCMDWAIT;
6475ca9327a6Smeem 	mutex_exit(&stp->sd_lock);
6476ca9327a6Smeem 	crfree(crp);
6477ca9327a6Smeem 	return (error);
6478ca9327a6Smeem }
6479ca9327a6Smeem 
6480ca9327a6Smeem /*
64817c478bd9Sstevel@tonic-gate  * For the SunOS keyboard driver.
64827c478bd9Sstevel@tonic-gate  * Return the next available "ioctl" sequence number.
64837c478bd9Sstevel@tonic-gate  * Exported, so that streams modules can send "ioctl" messages
64847c478bd9Sstevel@tonic-gate  * downstream from their open routine.
64857c478bd9Sstevel@tonic-gate  */
64867c478bd9Sstevel@tonic-gate int
64877c478bd9Sstevel@tonic-gate getiocseqno(void)
64887c478bd9Sstevel@tonic-gate {
64897c478bd9Sstevel@tonic-gate 	int	i;
64907c478bd9Sstevel@tonic-gate 
64917c478bd9Sstevel@tonic-gate 	mutex_enter(&strresources);
64927c478bd9Sstevel@tonic-gate 	i = ++ioc_id;
64937c478bd9Sstevel@tonic-gate 	mutex_exit(&strresources);
64947c478bd9Sstevel@tonic-gate 	return (i);
64957c478bd9Sstevel@tonic-gate }
64967c478bd9Sstevel@tonic-gate 
64977c478bd9Sstevel@tonic-gate /*
64987c478bd9Sstevel@tonic-gate  * Get the next message from the read queue.  If the message is
64997c478bd9Sstevel@tonic-gate  * priority, STRPRI will have been set by strrput().  This flag
65007c478bd9Sstevel@tonic-gate  * should be reset only when the entire message at the front of the
65017c478bd9Sstevel@tonic-gate  * queue as been consumed.
65027c478bd9Sstevel@tonic-gate  *
65037c478bd9Sstevel@tonic-gate  * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
65047c478bd9Sstevel@tonic-gate  */
65057c478bd9Sstevel@tonic-gate int
65067c478bd9Sstevel@tonic-gate strgetmsg(
65077c478bd9Sstevel@tonic-gate 	struct vnode *vp,
65087c478bd9Sstevel@tonic-gate 	struct strbuf *mctl,
65097c478bd9Sstevel@tonic-gate 	struct strbuf *mdata,
65107c478bd9Sstevel@tonic-gate 	unsigned char *prip,
65117c478bd9Sstevel@tonic-gate 	int *flagsp,
65127c478bd9Sstevel@tonic-gate 	int fmode,
65137c478bd9Sstevel@tonic-gate 	rval_t *rvp)
65147c478bd9Sstevel@tonic-gate {
65157c478bd9Sstevel@tonic-gate 	struct stdata *stp;
65167c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
65177c478bd9Sstevel@tonic-gate 	mblk_t *savemp = NULL;
65187c478bd9Sstevel@tonic-gate 	mblk_t *savemptail = NULL;
65197c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
65207c478bd9Sstevel@tonic-gate 	int flg;
65217c478bd9Sstevel@tonic-gate 	int more = 0;
65227c478bd9Sstevel@tonic-gate 	int error = 0;
65237c478bd9Sstevel@tonic-gate 	char first = 1;
65247c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
65257c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
65267c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
65277c478bd9Sstevel@tonic-gate 	queue_t *q;
65287c478bd9Sstevel@tonic-gate 	int	pr = 0;			/* Partial read successful */
65297c478bd9Sstevel@tonic-gate 	struct uio uios;
65307c478bd9Sstevel@tonic-gate 	struct uio *uiop = &uios;
65317c478bd9Sstevel@tonic-gate 	struct iovec iovs;
65327c478bd9Sstevel@tonic-gate 	unsigned char type;
65337c478bd9Sstevel@tonic-gate 
65347c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER,
65357c478bd9Sstevel@tonic-gate 	    "strgetmsg:%p", vp);
65367c478bd9Sstevel@tonic-gate 
65377c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
65387c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
65397c478bd9Sstevel@tonic-gate 	rvp->r_val1 = 0;
65407c478bd9Sstevel@tonic-gate 
65417c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
65429acbbeafSnn35248 
65439acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
65447c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
65457c478bd9Sstevel@tonic-gate 		return (error);
65467c478bd9Sstevel@tonic-gate 	}
65477c478bd9Sstevel@tonic-gate 
65489acbbeafSnn35248 	if (stp->sd_flag & (STRDERR|STPLEX)) {
65499acbbeafSnn35248 		error = strgeterr(stp, STRDERR|STPLEX, 0);
65509acbbeafSnn35248 		if (error != 0) {
65519acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
65529acbbeafSnn35248 			return (error);
65539acbbeafSnn35248 		}
65549acbbeafSnn35248 	}
65559acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
65569acbbeafSnn35248 
65577c478bd9Sstevel@tonic-gate 	switch (*flagsp) {
65587c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
65597c478bd9Sstevel@tonic-gate 		if (*prip != 0)
65607c478bd9Sstevel@tonic-gate 			return (EINVAL);
65617c478bd9Sstevel@tonic-gate 		break;
65627c478bd9Sstevel@tonic-gate 
65637c478bd9Sstevel@tonic-gate 	case MSG_ANY:
65647c478bd9Sstevel@tonic-gate 	case MSG_BAND:
65657c478bd9Sstevel@tonic-gate 		break;
65667c478bd9Sstevel@tonic-gate 
65677c478bd9Sstevel@tonic-gate 	default:
65687c478bd9Sstevel@tonic-gate 		return (EINVAL);
65697c478bd9Sstevel@tonic-gate 	}
65707c478bd9Sstevel@tonic-gate 	/*
65717c478bd9Sstevel@tonic-gate 	 * Setup uio and iov for data part
65727c478bd9Sstevel@tonic-gate 	 */
65737c478bd9Sstevel@tonic-gate 	iovs.iov_base = mdata->buf;
65747c478bd9Sstevel@tonic-gate 	iovs.iov_len = mdata->maxlen;
65757c478bd9Sstevel@tonic-gate 	uios.uio_iov = &iovs;
65767c478bd9Sstevel@tonic-gate 	uios.uio_iovcnt = 1;
65777c478bd9Sstevel@tonic-gate 	uios.uio_loffset = 0;
65787c478bd9Sstevel@tonic-gate 	uios.uio_segflg = UIO_USERSPACE;
65797c478bd9Sstevel@tonic-gate 	uios.uio_fmode = 0;
65807c478bd9Sstevel@tonic-gate 	uios.uio_extflg = UIO_COPY_CACHED;
65817c478bd9Sstevel@tonic-gate 	uios.uio_resid = mdata->maxlen;
65827c478bd9Sstevel@tonic-gate 	uios.uio_offset = 0;
65837c478bd9Sstevel@tonic-gate 
65847c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
65857c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
65867c478bd9Sstevel@tonic-gate 	old_sd_flag = stp->sd_flag;
65877c478bd9Sstevel@tonic-gate 	mark = 0;
65887c478bd9Sstevel@tonic-gate 	for (;;) {
65897c478bd9Sstevel@tonic-gate 		int done = 0;
65907c478bd9Sstevel@tonic-gate 		mblk_t *q_first = q->q_first;
65917c478bd9Sstevel@tonic-gate 
65927c478bd9Sstevel@tonic-gate 		/*
65937c478bd9Sstevel@tonic-gate 		 * Get the next message of appropriate priority
65947c478bd9Sstevel@tonic-gate 		 * from the stream head.  If the caller is interested
65957c478bd9Sstevel@tonic-gate 		 * in band or hipri messages, then they should already
65967c478bd9Sstevel@tonic-gate 		 * be enqueued at the stream head.  On the other hand
65977c478bd9Sstevel@tonic-gate 		 * if the caller wants normal (band 0) messages, they
65987c478bd9Sstevel@tonic-gate 		 * might be deferred in a synchronous stream and they
65997c478bd9Sstevel@tonic-gate 		 * will need to be pulled up.
66007c478bd9Sstevel@tonic-gate 		 *
66017c478bd9Sstevel@tonic-gate 		 * After we have dequeued a message, we might find that
66027c478bd9Sstevel@tonic-gate 		 * it was a deferred M_SIG that was enqueued at the
66037c478bd9Sstevel@tonic-gate 		 * stream head.  It must now be posted as part of the
66047c478bd9Sstevel@tonic-gate 		 * read by calling strsignal_nolock().
66057c478bd9Sstevel@tonic-gate 		 *
66067c478bd9Sstevel@tonic-gate 		 * Also note that strrput does not enqueue an M_PCSIG,
66077c478bd9Sstevel@tonic-gate 		 * and there cannot be more than one hipri message,
66087c478bd9Sstevel@tonic-gate 		 * so there was no need to have the M_PCSIG case.
66097c478bd9Sstevel@tonic-gate 		 *
66107c478bd9Sstevel@tonic-gate 		 * At some time it might be nice to try and wrap the
66117c478bd9Sstevel@tonic-gate 		 * functionality of kstrgetmsg() and strgetmsg() into
66127c478bd9Sstevel@tonic-gate 		 * a common routine so to reduce the amount of replicated
66137c478bd9Sstevel@tonic-gate 		 * code (since they are extremely similar).
66147c478bd9Sstevel@tonic-gate 		 */
66157c478bd9Sstevel@tonic-gate 		if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) {
66167c478bd9Sstevel@tonic-gate 			/* Asking for normal, band0 data */
66177c478bd9Sstevel@tonic-gate 			bp = strget(stp, q, uiop, first, &error);
66187c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
66197c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
6620a45f3f93Smeem 				if (DB_TYPE(bp) == M_SIG) {
66217c478bd9Sstevel@tonic-gate 					strsignal_nolock(stp, *bp->b_rptr,
6622a45f3f93Smeem 					    bp->b_band);
6623a45f3f93Smeem 					freemsg(bp);
66247c478bd9Sstevel@tonic-gate 					continue;
66257c478bd9Sstevel@tonic-gate 				} else {
66267c478bd9Sstevel@tonic-gate 					break;
66277c478bd9Sstevel@tonic-gate 				}
66287c478bd9Sstevel@tonic-gate 			}
6629a45f3f93Smeem 			if (error != 0)
66307c478bd9Sstevel@tonic-gate 				goto getmout;
66317c478bd9Sstevel@tonic-gate 
66327c478bd9Sstevel@tonic-gate 		/*
66337c478bd9Sstevel@tonic-gate 		 * We can't depend on the value of STRPRI here because
66347c478bd9Sstevel@tonic-gate 		 * the stream head may be in transit. Therefore, we
66357c478bd9Sstevel@tonic-gate 		 * must look at the type of the first message to
66367c478bd9Sstevel@tonic-gate 		 * determine if a high priority messages is waiting
66377c478bd9Sstevel@tonic-gate 		 */
66387c478bd9Sstevel@tonic-gate 		} else if ((*flagsp & MSG_HIPRI) && q_first != NULL &&
6639a45f3f93Smeem 		    DB_TYPE(q_first) >= QPCTL &&
6640301ce41fSja97890 		    (bp = getq_noenab(q, 0)) != NULL) {
66417c478bd9Sstevel@tonic-gate 			/* Asked for HIPRI and got one */
6642a45f3f93Smeem 			ASSERT(DB_TYPE(bp) >= QPCTL);
66437c478bd9Sstevel@tonic-gate 			break;
66447c478bd9Sstevel@tonic-gate 		} else if ((*flagsp & MSG_BAND) && q_first != NULL &&
6645a45f3f93Smeem 		    ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
6646301ce41fSja97890 		    (bp = getq_noenab(q, 0)) != NULL) {
66477c478bd9Sstevel@tonic-gate 			/*
66487c478bd9Sstevel@tonic-gate 			 * Asked for at least band "prip" and got either at
66497c478bd9Sstevel@tonic-gate 			 * least that band or a hipri message.
66507c478bd9Sstevel@tonic-gate 			 */
6651a45f3f93Smeem 			ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
6652a45f3f93Smeem 			if (DB_TYPE(bp) == M_SIG) {
6653a45f3f93Smeem 				strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6654a45f3f93Smeem 				freemsg(bp);
66557c478bd9Sstevel@tonic-gate 				continue;
66567c478bd9Sstevel@tonic-gate 			} else {
66577c478bd9Sstevel@tonic-gate 				break;
66587c478bd9Sstevel@tonic-gate 			}
66597c478bd9Sstevel@tonic-gate 		}
66607c478bd9Sstevel@tonic-gate 
66617c478bd9Sstevel@tonic-gate 		/* No data. Time to sleep? */
66627c478bd9Sstevel@tonic-gate 		qbackenable(q, 0);
66637c478bd9Sstevel@tonic-gate 
66647c478bd9Sstevel@tonic-gate 		/*
66657c478bd9Sstevel@tonic-gate 		 * If STRHUP or STREOF, return 0 length control and data.
66667c478bd9Sstevel@tonic-gate 		 * If resid is 0, then a read(fd,buf,0) was done. Do not
66677c478bd9Sstevel@tonic-gate 		 * sleep to satisfy this request because by default we have
66687c478bd9Sstevel@tonic-gate 		 * zero bytes to return.
66697c478bd9Sstevel@tonic-gate 		 */
66707c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 &&
66717c478bd9Sstevel@tonic-gate 		    mdata->maxlen == 0)) {
66727c478bd9Sstevel@tonic-gate 			mctl->len = mdata->len = 0;
66737c478bd9Sstevel@tonic-gate 			*flagsp = 0;
66747c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
66757c478bd9Sstevel@tonic-gate 			return (0);
66767c478bd9Sstevel@tonic-gate 		}
66777c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT,
66787c478bd9Sstevel@tonic-gate 		    "strgetmsg calls strwaitq:%p, %p",
66797c478bd9Sstevel@tonic-gate 		    vp, uiop);
66807c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1,
66817c478bd9Sstevel@tonic-gate 		    &done)) != 0) || done) {
66827c478bd9Sstevel@tonic-gate 			TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE,
66837c478bd9Sstevel@tonic-gate 			    "strgetmsg error or done:%p, %p",
66847c478bd9Sstevel@tonic-gate 			    vp, uiop);
66857c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
66867c478bd9Sstevel@tonic-gate 			return (error);
66877c478bd9Sstevel@tonic-gate 		}
66887c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE,
66897c478bd9Sstevel@tonic-gate 		    "strgetmsg awakes:%p, %p", vp, uiop);
66909acbbeafSnn35248 		if ((error = i_straccess(stp, JCREAD)) != 0) {
66917c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
66927c478bd9Sstevel@tonic-gate 			return (error);
66937c478bd9Sstevel@tonic-gate 		}
66947c478bd9Sstevel@tonic-gate 		first = 0;
66957c478bd9Sstevel@tonic-gate 	}
66967c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL);
66977c478bd9Sstevel@tonic-gate 	/*
66987c478bd9Sstevel@tonic-gate 	 * Extract any mark information. If the message is not completely
66997c478bd9Sstevel@tonic-gate 	 * consumed this information will be put in the mblk
67007c478bd9Sstevel@tonic-gate 	 * that is putback.
67017c478bd9Sstevel@tonic-gate 	 * If MSGMARKNEXT is set and the message is completely consumed
67027c478bd9Sstevel@tonic-gate 	 * the STRATMARK flag will be set below. Likewise, if
67037c478bd9Sstevel@tonic-gate 	 * MSGNOTMARKNEXT is set and the message is
67047c478bd9Sstevel@tonic-gate 	 * completely consumed STRNOTATMARK will be set.
67057c478bd9Sstevel@tonic-gate 	 */
67067c478bd9Sstevel@tonic-gate 	mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
67077c478bd9Sstevel@tonic-gate 	ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
67087c478bd9Sstevel@tonic-gate 	    (MSGMARKNEXT|MSGNOTMARKNEXT));
67097c478bd9Sstevel@tonic-gate 	if (mark != 0 && bp == stp->sd_mark) {
67107c478bd9Sstevel@tonic-gate 		mark |= _LASTMARK;
67117c478bd9Sstevel@tonic-gate 		stp->sd_mark = NULL;
67127c478bd9Sstevel@tonic-gate 	}
67137c478bd9Sstevel@tonic-gate 	/*
67147c478bd9Sstevel@tonic-gate 	 * keep track of the original message type and priority
67157c478bd9Sstevel@tonic-gate 	 */
67167c478bd9Sstevel@tonic-gate 	pri = bp->b_band;
67177c478bd9Sstevel@tonic-gate 	type = bp->b_datap->db_type;
67187c478bd9Sstevel@tonic-gate 	if (type == M_PASSFP) {
67197c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
67207c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
67217c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
67227c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
67237c478bd9Sstevel@tonic-gate 		qbackenable(q, pri);
67247c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
67257c478bd9Sstevel@tonic-gate 		return (EBADMSG);
67267c478bd9Sstevel@tonic-gate 	}
67277c478bd9Sstevel@tonic-gate 	ASSERT(type != M_SIG);
67287c478bd9Sstevel@tonic-gate 
67297c478bd9Sstevel@tonic-gate 	/*
67307c478bd9Sstevel@tonic-gate 	 * Set this flag so strrput will not generate signals. Need to
67317c478bd9Sstevel@tonic-gate 	 * make sure this flag is cleared before leaving this routine
67327c478bd9Sstevel@tonic-gate 	 * else signals will stop being sent.
67337c478bd9Sstevel@tonic-gate 	 */
67347c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRGETINPROG;
67357c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
67367c478bd9Sstevel@tonic-gate 
67377c478bd9Sstevel@tonic-gate 	if (STREAM_NEEDSERVICE(stp))
67387c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
67397c478bd9Sstevel@tonic-gate 
67407c478bd9Sstevel@tonic-gate 	/*
67417c478bd9Sstevel@tonic-gate 	 * Set HIPRI flag if message is priority.
67427c478bd9Sstevel@tonic-gate 	 */
67437c478bd9Sstevel@tonic-gate 	if (type >= QPCTL)
67447c478bd9Sstevel@tonic-gate 		flg = MSG_HIPRI;
67457c478bd9Sstevel@tonic-gate 	else
67467c478bd9Sstevel@tonic-gate 		flg = MSG_BAND;
67477c478bd9Sstevel@tonic-gate 
67487c478bd9Sstevel@tonic-gate 	/*
67497c478bd9Sstevel@tonic-gate 	 * First process PROTO or PCPROTO blocks, if any.
67507c478bd9Sstevel@tonic-gate 	 */
67517c478bd9Sstevel@tonic-gate 	if (mctl->maxlen >= 0 && type != M_DATA) {
67527c478bd9Sstevel@tonic-gate 		size_t	n, bcnt;
67537c478bd9Sstevel@tonic-gate 		char	*ubuf;
67547c478bd9Sstevel@tonic-gate 
67557c478bd9Sstevel@tonic-gate 		bcnt = mctl->maxlen;
67567c478bd9Sstevel@tonic-gate 		ubuf = mctl->buf;
67577c478bd9Sstevel@tonic-gate 		while (bp != NULL && bp->b_datap->db_type != M_DATA) {
67587c478bd9Sstevel@tonic-gate 			if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 &&
67597c478bd9Sstevel@tonic-gate 			    copyout(bp->b_rptr, ubuf, n)) {
67607c478bd9Sstevel@tonic-gate 				error = EFAULT;
67617c478bd9Sstevel@tonic-gate 				mutex_enter(&stp->sd_lock);
67627c478bd9Sstevel@tonic-gate 				/*
67637c478bd9Sstevel@tonic-gate 				 * clear stream head pri flag based on
67647c478bd9Sstevel@tonic-gate 				 * first message type
67657c478bd9Sstevel@tonic-gate 				 */
67667c478bd9Sstevel@tonic-gate 				if (type >= QPCTL) {
67677c478bd9Sstevel@tonic-gate 					ASSERT(type == M_PCPROTO);
67687c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
67697c478bd9Sstevel@tonic-gate 				}
67707c478bd9Sstevel@tonic-gate 				more = 0;
67717c478bd9Sstevel@tonic-gate 				freemsg(bp);
67727c478bd9Sstevel@tonic-gate 				goto getmout;
67737c478bd9Sstevel@tonic-gate 			}
67747c478bd9Sstevel@tonic-gate 			ubuf += n;
67757c478bd9Sstevel@tonic-gate 			bp->b_rptr += n;
67767c478bd9Sstevel@tonic-gate 			if (bp->b_rptr >= bp->b_wptr) {
67777c478bd9Sstevel@tonic-gate 				nbp = bp;
67787c478bd9Sstevel@tonic-gate 				bp = bp->b_cont;
67797c478bd9Sstevel@tonic-gate 				freeb(nbp);
67807c478bd9Sstevel@tonic-gate 			}
67817c478bd9Sstevel@tonic-gate 			ASSERT(n <= bcnt);
67827c478bd9Sstevel@tonic-gate 			bcnt -= n;
67837c478bd9Sstevel@tonic-gate 			if (bcnt == 0)
67847c478bd9Sstevel@tonic-gate 				break;
67857c478bd9Sstevel@tonic-gate 		}
67867c478bd9Sstevel@tonic-gate 		mctl->len = mctl->maxlen - bcnt;
67877c478bd9Sstevel@tonic-gate 	} else
67887c478bd9Sstevel@tonic-gate 		mctl->len = -1;
67897c478bd9Sstevel@tonic-gate 
67907c478bd9Sstevel@tonic-gate 	if (bp && bp->b_datap->db_type != M_DATA) {
67917c478bd9Sstevel@tonic-gate 		/*
67927c478bd9Sstevel@tonic-gate 		 * More PROTO blocks in msg.
67937c478bd9Sstevel@tonic-gate 		 */
67947c478bd9Sstevel@tonic-gate 		more |= MORECTL;
67957c478bd9Sstevel@tonic-gate 		savemp = bp;
67967c478bd9Sstevel@tonic-gate 		while (bp && bp->b_datap->db_type != M_DATA) {
67977c478bd9Sstevel@tonic-gate 			savemptail = bp;
67987c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
67997c478bd9Sstevel@tonic-gate 		}
68007c478bd9Sstevel@tonic-gate 		savemptail->b_cont = NULL;
68017c478bd9Sstevel@tonic-gate 	}
68027c478bd9Sstevel@tonic-gate 
68037c478bd9Sstevel@tonic-gate 	/*
68047c478bd9Sstevel@tonic-gate 	 * Now process DATA blocks, if any.
68057c478bd9Sstevel@tonic-gate 	 */
68067c478bd9Sstevel@tonic-gate 	if (mdata->maxlen >= 0 && bp) {
68077c478bd9Sstevel@tonic-gate 		/*
68087c478bd9Sstevel@tonic-gate 		 * struiocopyout will consume a potential zero-length
68097c478bd9Sstevel@tonic-gate 		 * M_DATA even if uio_resid is zero.
68107c478bd9Sstevel@tonic-gate 		 */
68117c478bd9Sstevel@tonic-gate 		size_t oldresid = uiop->uio_resid;
68127c478bd9Sstevel@tonic-gate 
68137c478bd9Sstevel@tonic-gate 		bp = struiocopyout(bp, uiop, &error);
68147c478bd9Sstevel@tonic-gate 		if (error != 0) {
68157c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
68167c478bd9Sstevel@tonic-gate 			/*
68177c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
68187c478bd9Sstevel@tonic-gate 			 * first message
68197c478bd9Sstevel@tonic-gate 			 */
68207c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
68217c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
68227c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
68237c478bd9Sstevel@tonic-gate 			}
68247c478bd9Sstevel@tonic-gate 			more = 0;
68257c478bd9Sstevel@tonic-gate 			freemsg(savemp);
68267c478bd9Sstevel@tonic-gate 			goto getmout;
68277c478bd9Sstevel@tonic-gate 		}
68287c478bd9Sstevel@tonic-gate 		/*
68297c478bd9Sstevel@tonic-gate 		 * (pr == 1) indicates a partial read.
68307c478bd9Sstevel@tonic-gate 		 */
68317c478bd9Sstevel@tonic-gate 		if (oldresid > uiop->uio_resid)
68327c478bd9Sstevel@tonic-gate 			pr = 1;
68337c478bd9Sstevel@tonic-gate 		mdata->len = mdata->maxlen - uiop->uio_resid;
68347c478bd9Sstevel@tonic-gate 	} else
68357c478bd9Sstevel@tonic-gate 		mdata->len = -1;
68367c478bd9Sstevel@tonic-gate 
68377c478bd9Sstevel@tonic-gate 	if (bp) {			/* more data blocks in msg */
68387c478bd9Sstevel@tonic-gate 		more |= MOREDATA;
68397c478bd9Sstevel@tonic-gate 		if (savemp)
68407c478bd9Sstevel@tonic-gate 			savemptail->b_cont = bp;
68417c478bd9Sstevel@tonic-gate 		else
68427c478bd9Sstevel@tonic-gate 			savemp = bp;
68437c478bd9Sstevel@tonic-gate 	}
68447c478bd9Sstevel@tonic-gate 
68457c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
68467c478bd9Sstevel@tonic-gate 	if (savemp) {
68477c478bd9Sstevel@tonic-gate 		if (pr && (savemp->b_datap->db_type == M_DATA) &&
68487c478bd9Sstevel@tonic-gate 		    msgnodata(savemp)) {
68497c478bd9Sstevel@tonic-gate 			/*
68507c478bd9Sstevel@tonic-gate 			 * Avoid queuing a zero-length tail part of
68517c478bd9Sstevel@tonic-gate 			 * a message. pr=1 indicates that we read some of
68527c478bd9Sstevel@tonic-gate 			 * the message.
68537c478bd9Sstevel@tonic-gate 			 */
68547c478bd9Sstevel@tonic-gate 			freemsg(savemp);
68557c478bd9Sstevel@tonic-gate 			more &= ~MOREDATA;
68567c478bd9Sstevel@tonic-gate 			/*
68577c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
68587c478bd9Sstevel@tonic-gate 			 * first message
68597c478bd9Sstevel@tonic-gate 			 */
68607c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
68617c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
68627c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
68637c478bd9Sstevel@tonic-gate 			}
68647c478bd9Sstevel@tonic-gate 		} else {
68657c478bd9Sstevel@tonic-gate 			savemp->b_band = pri;
68667c478bd9Sstevel@tonic-gate 			/*
68677c478bd9Sstevel@tonic-gate 			 * If the first message was HIPRI and the one we're
68687c478bd9Sstevel@tonic-gate 			 * putting back isn't, then clear STRPRI, otherwise
68697c478bd9Sstevel@tonic-gate 			 * set STRPRI again.  Note that we must set STRPRI
68707c478bd9Sstevel@tonic-gate 			 * again since the flush logic in strrput_nondata()
68717c478bd9Sstevel@tonic-gate 			 * may have cleared it while we had sd_lock dropped.
68727c478bd9Sstevel@tonic-gate 			 */
68737c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
68747c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
68757c478bd9Sstevel@tonic-gate 				if (queclass(savemp) < QPCTL)
68767c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
68777c478bd9Sstevel@tonic-gate 				else
68787c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRPRI;
68797c478bd9Sstevel@tonic-gate 			} else if (queclass(savemp) >= QPCTL) {
68807c478bd9Sstevel@tonic-gate 				/*
68817c478bd9Sstevel@tonic-gate 				 * The first message was not a HIPRI message,
68827c478bd9Sstevel@tonic-gate 				 * but the one we are about to putback is.
68837c478bd9Sstevel@tonic-gate 				 * For simplicitly, we do not allow for HIPRI
68847c478bd9Sstevel@tonic-gate 				 * messages to be embedded in the message
68857c478bd9Sstevel@tonic-gate 				 * body, so just force it to same type as
68867c478bd9Sstevel@tonic-gate 				 * first message.
68877c478bd9Sstevel@tonic-gate 				 */
68887c478bd9Sstevel@tonic-gate 				ASSERT(type == M_DATA || type == M_PROTO);
68897c478bd9Sstevel@tonic-gate 				ASSERT(savemp->b_datap->db_type == M_PCPROTO);
68907c478bd9Sstevel@tonic-gate 				savemp->b_datap->db_type = type;
68917c478bd9Sstevel@tonic-gate 			}
68927c478bd9Sstevel@tonic-gate 			if (mark != 0) {
68937c478bd9Sstevel@tonic-gate 				savemp->b_flag |= mark & ~_LASTMARK;
68947c478bd9Sstevel@tonic-gate 				if ((mark & _LASTMARK) &&
68957c478bd9Sstevel@tonic-gate 				    (stp->sd_mark == NULL)) {
68967c478bd9Sstevel@tonic-gate 					/*
68977c478bd9Sstevel@tonic-gate 					 * If another marked message arrived
68987c478bd9Sstevel@tonic-gate 					 * while sd_lock was not held sd_mark
68997c478bd9Sstevel@tonic-gate 					 * would be non-NULL.
69007c478bd9Sstevel@tonic-gate 					 */
69017c478bd9Sstevel@tonic-gate 					stp->sd_mark = savemp;
69027c478bd9Sstevel@tonic-gate 				}
69037c478bd9Sstevel@tonic-gate 			}
69047c478bd9Sstevel@tonic-gate 			putback(stp, q, savemp, pri);
69057c478bd9Sstevel@tonic-gate 		}
69067c478bd9Sstevel@tonic-gate 	} else {
69077c478bd9Sstevel@tonic-gate 		/*
69087c478bd9Sstevel@tonic-gate 		 * The complete message was consumed.
69097c478bd9Sstevel@tonic-gate 		 *
69107c478bd9Sstevel@tonic-gate 		 * If another M_PCPROTO arrived while sd_lock was not held
69117c478bd9Sstevel@tonic-gate 		 * it would have been discarded since STRPRI was still set.
69127c478bd9Sstevel@tonic-gate 		 *
69137c478bd9Sstevel@tonic-gate 		 * Move the MSG*MARKNEXT information
69147c478bd9Sstevel@tonic-gate 		 * to the stream head just in case
69157c478bd9Sstevel@tonic-gate 		 * the read queue becomes empty.
69167c478bd9Sstevel@tonic-gate 		 * clear stream head hi pri flag based on
69177c478bd9Sstevel@tonic-gate 		 * first message
69187c478bd9Sstevel@tonic-gate 		 *
69197c478bd9Sstevel@tonic-gate 		 * If the stream head was at the mark
69207c478bd9Sstevel@tonic-gate 		 * (STRATMARK) before we dropped sd_lock above
69217c478bd9Sstevel@tonic-gate 		 * and some data was consumed then we have
69227c478bd9Sstevel@tonic-gate 		 * moved past the mark thus STRATMARK is
69237c478bd9Sstevel@tonic-gate 		 * cleared. However, if a message arrived in
69247c478bd9Sstevel@tonic-gate 		 * strrput during the copyout above causing
69257c478bd9Sstevel@tonic-gate 		 * STRATMARK to be set we can not clear that
69267c478bd9Sstevel@tonic-gate 		 * flag.
69277c478bd9Sstevel@tonic-gate 		 */
69287c478bd9Sstevel@tonic-gate 		if (type >= QPCTL) {
69297c478bd9Sstevel@tonic-gate 			ASSERT(type == M_PCPROTO);
69307c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRPRI;
69317c478bd9Sstevel@tonic-gate 		}
69327c478bd9Sstevel@tonic-gate 		if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
69337c478bd9Sstevel@tonic-gate 			if (mark & MSGMARKNEXT) {
69347c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRNOTATMARK;
69357c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRATMARK;
69367c478bd9Sstevel@tonic-gate 			} else if (mark & MSGNOTMARKNEXT) {
69377c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRATMARK;
69387c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRNOTATMARK;
69397c478bd9Sstevel@tonic-gate 			} else {
69407c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
69417c478bd9Sstevel@tonic-gate 			}
69427c478bd9Sstevel@tonic-gate 		} else if (pr && (old_sd_flag & STRATMARK)) {
69437c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
69447c478bd9Sstevel@tonic-gate 		}
69457c478bd9Sstevel@tonic-gate 	}
69467c478bd9Sstevel@tonic-gate 
69477c478bd9Sstevel@tonic-gate 	*flagsp = flg;
69487c478bd9Sstevel@tonic-gate 	*prip = pri;
69497c478bd9Sstevel@tonic-gate 
69507c478bd9Sstevel@tonic-gate 	/*
69517c478bd9Sstevel@tonic-gate 	 * Getmsg cleanup processing - if the state of the queue has changed
69527c478bd9Sstevel@tonic-gate 	 * some signals may need to be sent and/or poll awakened.
69537c478bd9Sstevel@tonic-gate 	 */
69547c478bd9Sstevel@tonic-gate getmout:
69557c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
69567c478bd9Sstevel@tonic-gate 
69577c478bd9Sstevel@tonic-gate 	/*
69587c478bd9Sstevel@tonic-gate 	 * We dropped the stream head lock above. Send all M_SIG messages
69597c478bd9Sstevel@tonic-gate 	 * before processing stream head for SIGPOLL messages.
69607c478bd9Sstevel@tonic-gate 	 */
69617c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
69627c478bd9Sstevel@tonic-gate 	while ((bp = q->q_first) != NULL &&
69637c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_SIG)) {
69647c478bd9Sstevel@tonic-gate 		/*
69657c478bd9Sstevel@tonic-gate 		 * sd_lock is held so the content of the read queue can not
69667c478bd9Sstevel@tonic-gate 		 * change.
69677c478bd9Sstevel@tonic-gate 		 */
69687c478bd9Sstevel@tonic-gate 		bp = getq(q);
69697c478bd9Sstevel@tonic-gate 		ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
69707c478bd9Sstevel@tonic-gate 
6971a45f3f93Smeem 		strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
69727c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
69737c478bd9Sstevel@tonic-gate 		freemsg(bp);
69747c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
69757c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
69767c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
69777c478bd9Sstevel@tonic-gate 	}
69787c478bd9Sstevel@tonic-gate 
69797c478bd9Sstevel@tonic-gate 	/*
69807c478bd9Sstevel@tonic-gate 	 * stream head cannot change while we make the determination
69817c478bd9Sstevel@tonic-gate 	 * whether or not to send a signal. Drop the flag to allow strrput
69827c478bd9Sstevel@tonic-gate 	 * to send firstmsgsigs again.
69837c478bd9Sstevel@tonic-gate 	 */
69847c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRGETINPROG;
69857c478bd9Sstevel@tonic-gate 
69867c478bd9Sstevel@tonic-gate 	/*
69877c478bd9Sstevel@tonic-gate 	 * If the type of message at the front of the queue changed
69887c478bd9Sstevel@tonic-gate 	 * due to the receive the appropriate signals and pollwakeup events
69897c478bd9Sstevel@tonic-gate 	 * are generated. The type of changes are:
69907c478bd9Sstevel@tonic-gate 	 *	Processed a hipri message, q_first is not hipri.
69917c478bd9Sstevel@tonic-gate 	 *	Processed a band X message, and q_first is band Y.
69927c478bd9Sstevel@tonic-gate 	 * The generated signals and pollwakeups are identical to what
69937c478bd9Sstevel@tonic-gate 	 * strrput() generates should the message that is now on q_first
69947c478bd9Sstevel@tonic-gate 	 * arrive to an empty read queue.
69957c478bd9Sstevel@tonic-gate 	 *
69967c478bd9Sstevel@tonic-gate 	 * Note: only strrput will send a signal for a hipri message.
69977c478bd9Sstevel@tonic-gate 	 */
69987c478bd9Sstevel@tonic-gate 	if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
69997c478bd9Sstevel@tonic-gate 		strsigset_t signals = 0;
70007c478bd9Sstevel@tonic-gate 		strpollset_t pollwakeups = 0;
70017c478bd9Sstevel@tonic-gate 
70027c478bd9Sstevel@tonic-gate 		if (flg & MSG_HIPRI) {
70037c478bd9Sstevel@tonic-gate 			/*
70047c478bd9Sstevel@tonic-gate 			 * Removed a hipri message. Regular data at
70057c478bd9Sstevel@tonic-gate 			 * the front of  the queue.
70067c478bd9Sstevel@tonic-gate 			 */
70077c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
70087c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDNORM;
70097c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
70107c478bd9Sstevel@tonic-gate 			} else {
70117c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDBAND;
70127c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
70137c478bd9Sstevel@tonic-gate 			}
70147c478bd9Sstevel@tonic-gate 		} else if (pri != bp->b_band) {
70157c478bd9Sstevel@tonic-gate 			/*
70167c478bd9Sstevel@tonic-gate 			 * The band is different for the new q_first.
70177c478bd9Sstevel@tonic-gate 			 */
70187c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
70197c478bd9Sstevel@tonic-gate 				signals = S_RDNORM;
70207c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
70217c478bd9Sstevel@tonic-gate 			} else {
70227c478bd9Sstevel@tonic-gate 				signals = S_RDBAND;
70237c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
70247c478bd9Sstevel@tonic-gate 			}
70257c478bd9Sstevel@tonic-gate 		}
70267c478bd9Sstevel@tonic-gate 
70277c478bd9Sstevel@tonic-gate 		if (pollwakeups != 0) {
70287c478bd9Sstevel@tonic-gate 			if (pollwakeups == (POLLIN | POLLRDNORM)) {
70297c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
70307c478bd9Sstevel@tonic-gate 					goto no_pollwake;
70317c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
70327c478bd9Sstevel@tonic-gate 			}
70337c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
70347c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, pollwakeups);
70357c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
70367c478bd9Sstevel@tonic-gate 		}
70377c478bd9Sstevel@tonic-gate no_pollwake:
70387c478bd9Sstevel@tonic-gate 
70397c478bd9Sstevel@tonic-gate 		if (stp->sd_sigflags & signals)
70407c478bd9Sstevel@tonic-gate 			strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
70417c478bd9Sstevel@tonic-gate 	}
70427c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
70437c478bd9Sstevel@tonic-gate 
70447c478bd9Sstevel@tonic-gate 	rvp->r_val1 = more;
70457c478bd9Sstevel@tonic-gate 	return (error);
70467c478bd9Sstevel@tonic-gate #undef	_LASTMARK
70477c478bd9Sstevel@tonic-gate }
70487c478bd9Sstevel@tonic-gate 
70497c478bd9Sstevel@tonic-gate /*
70507c478bd9Sstevel@tonic-gate  * Get the next message from the read queue.  If the message is
70517c478bd9Sstevel@tonic-gate  * priority, STRPRI will have been set by strrput().  This flag
70527c478bd9Sstevel@tonic-gate  * should be reset only when the entire message at the front of the
70537c478bd9Sstevel@tonic-gate  * queue as been consumed.
70547c478bd9Sstevel@tonic-gate  *
70557c478bd9Sstevel@tonic-gate  * If uiop is NULL all data is returned in mctlp.
70567c478bd9Sstevel@tonic-gate  * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed
70577c478bd9Sstevel@tonic-gate  * not enabled.
70587c478bd9Sstevel@tonic-gate  * The timeout parameter is in milliseconds; -1 for infinity.
70597c478bd9Sstevel@tonic-gate  * This routine handles the consolidation private flags:
70607c478bd9Sstevel@tonic-gate  *	MSG_IGNERROR	Ignore any stream head error except STPLEX.
70617c478bd9Sstevel@tonic-gate  *	MSG_DELAYERROR	Defer the error check until the queue is empty.
70627c478bd9Sstevel@tonic-gate  *	MSG_HOLDSIG	Hold signals while waiting for data.
70637c478bd9Sstevel@tonic-gate  *	MSG_IPEEK	Only peek at messages.
70647c478bd9Sstevel@tonic-gate  *	MSG_DISCARDTAIL	Discard the tail M_DATA part of the message
70657c478bd9Sstevel@tonic-gate  *			that doesn't fit.
70667c478bd9Sstevel@tonic-gate  *	MSG_NOMARK	If the message is marked leave it on the queue.
70677c478bd9Sstevel@tonic-gate  *
70687c478bd9Sstevel@tonic-gate  * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
70697c478bd9Sstevel@tonic-gate  */
70707c478bd9Sstevel@tonic-gate int
70717c478bd9Sstevel@tonic-gate kstrgetmsg(
70727c478bd9Sstevel@tonic-gate 	struct vnode *vp,
70737c478bd9Sstevel@tonic-gate 	mblk_t **mctlp,
70747c478bd9Sstevel@tonic-gate 	struct uio *uiop,
70757c478bd9Sstevel@tonic-gate 	unsigned char *prip,
70767c478bd9Sstevel@tonic-gate 	int *flagsp,
70777c478bd9Sstevel@tonic-gate 	clock_t timout,
70787c478bd9Sstevel@tonic-gate 	rval_t *rvp)
70797c478bd9Sstevel@tonic-gate {
70807c478bd9Sstevel@tonic-gate 	struct stdata *stp;
70817c478bd9Sstevel@tonic-gate 	mblk_t *bp, *nbp;
70827c478bd9Sstevel@tonic-gate 	mblk_t *savemp = NULL;
70837c478bd9Sstevel@tonic-gate 	mblk_t *savemptail = NULL;
70847c478bd9Sstevel@tonic-gate 	int flags;
70857c478bd9Sstevel@tonic-gate 	uint_t old_sd_flag;
70867c478bd9Sstevel@tonic-gate 	int flg;
70877c478bd9Sstevel@tonic-gate 	int more = 0;
70887c478bd9Sstevel@tonic-gate 	int error = 0;
70897c478bd9Sstevel@tonic-gate 	char first = 1;
70907c478bd9Sstevel@tonic-gate 	uint_t mark;		/* Contains MSG*MARK and _LASTMARK */
70917c478bd9Sstevel@tonic-gate #define	_LASTMARK	0x8000	/* Distinct from MSG*MARK */
70927c478bd9Sstevel@tonic-gate 	unsigned char pri = 0;
70937c478bd9Sstevel@tonic-gate 	queue_t *q;
70947c478bd9Sstevel@tonic-gate 	int	pr = 0;			/* Partial read successful */
70957c478bd9Sstevel@tonic-gate 	unsigned char type;
70967c478bd9Sstevel@tonic-gate 
70977c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER,
70987c478bd9Sstevel@tonic-gate 	    "kstrgetmsg:%p", vp);
70997c478bd9Sstevel@tonic-gate 
71007c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
71017c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
71027c478bd9Sstevel@tonic-gate 	rvp->r_val1 = 0;
71037c478bd9Sstevel@tonic-gate 
71049acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
71059acbbeafSnn35248 
71069acbbeafSnn35248 	if ((error = i_straccess(stp, JCREAD)) != 0) {
71079acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
71087c478bd9Sstevel@tonic-gate 		return (error);
71099acbbeafSnn35248 	}
71107c478bd9Sstevel@tonic-gate 
71117c478bd9Sstevel@tonic-gate 	flags = *flagsp;
71127c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRDERR|STPLEX)) {
71137c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & STPLEX) ||
71147c478bd9Sstevel@tonic-gate 		    (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) {
71157c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX,
71167c478bd9Sstevel@tonic-gate 			    (flags & MSG_IPEEK));
71179acbbeafSnn35248 			if (error != 0) {
71187c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
71197c478bd9Sstevel@tonic-gate 				return (error);
71207c478bd9Sstevel@tonic-gate 			}
71217c478bd9Sstevel@tonic-gate 		}
71229acbbeafSnn35248 	}
71239acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
71247c478bd9Sstevel@tonic-gate 
71257c478bd9Sstevel@tonic-gate 	switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) {
71267c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
71277c478bd9Sstevel@tonic-gate 		if (*prip != 0)
71287c478bd9Sstevel@tonic-gate 			return (EINVAL);
71297c478bd9Sstevel@tonic-gate 		break;
71307c478bd9Sstevel@tonic-gate 
71317c478bd9Sstevel@tonic-gate 	case MSG_ANY:
71327c478bd9Sstevel@tonic-gate 	case MSG_BAND:
71337c478bd9Sstevel@tonic-gate 		break;
71347c478bd9Sstevel@tonic-gate 
71357c478bd9Sstevel@tonic-gate 	default:
71367c478bd9Sstevel@tonic-gate 		return (EINVAL);
71377c478bd9Sstevel@tonic-gate 	}
71387c478bd9Sstevel@tonic-gate 
71397c478bd9Sstevel@tonic-gate retry:
71407c478bd9Sstevel@tonic-gate 	q = _RD(stp->sd_wrq);
71417c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
71427c478bd9Sstevel@tonic-gate 	old_sd_flag = stp->sd_flag;
71437c478bd9Sstevel@tonic-gate 	mark = 0;
71447c478bd9Sstevel@tonic-gate 	for (;;) {
71457c478bd9Sstevel@tonic-gate 		int done = 0;
71467c478bd9Sstevel@tonic-gate 		int waitflag;
71477c478bd9Sstevel@tonic-gate 		int fmode;
71487c478bd9Sstevel@tonic-gate 		mblk_t *q_first = q->q_first;
71497c478bd9Sstevel@tonic-gate 
71507c478bd9Sstevel@tonic-gate 		/*
71517c478bd9Sstevel@tonic-gate 		 * This section of the code operates just like the code
71527c478bd9Sstevel@tonic-gate 		 * in strgetmsg().  There is a comment there about what
71537c478bd9Sstevel@tonic-gate 		 * is going on here.
71547c478bd9Sstevel@tonic-gate 		 */
71557c478bd9Sstevel@tonic-gate 		if (!(flags & (MSG_HIPRI|MSG_BAND))) {
71567c478bd9Sstevel@tonic-gate 			/* Asking for normal, band0 data */
71577c478bd9Sstevel@tonic-gate 			bp = strget(stp, q, uiop, first, &error);
71587c478bd9Sstevel@tonic-gate 			ASSERT(MUTEX_HELD(&stp->sd_lock));
71597c478bd9Sstevel@tonic-gate 			if (bp != NULL) {
7160a45f3f93Smeem 				if (DB_TYPE(bp) == M_SIG) {
71617c478bd9Sstevel@tonic-gate 					strsignal_nolock(stp, *bp->b_rptr,
7162a45f3f93Smeem 					    bp->b_band);
7163a45f3f93Smeem 					freemsg(bp);
71647c478bd9Sstevel@tonic-gate 					continue;
71657c478bd9Sstevel@tonic-gate 				} else {
71667c478bd9Sstevel@tonic-gate 					break;
71677c478bd9Sstevel@tonic-gate 				}
71687c478bd9Sstevel@tonic-gate 			}
71697c478bd9Sstevel@tonic-gate 			if (error != 0) {
71707c478bd9Sstevel@tonic-gate 				goto getmout;
71717c478bd9Sstevel@tonic-gate 			}
71727c478bd9Sstevel@tonic-gate 		/*
71737c478bd9Sstevel@tonic-gate 		 * We can't depend on the value of STRPRI here because
71747c478bd9Sstevel@tonic-gate 		 * the stream head may be in transit. Therefore, we
71757c478bd9Sstevel@tonic-gate 		 * must look at the type of the first message to
71767c478bd9Sstevel@tonic-gate 		 * determine if a high priority messages is waiting
71777c478bd9Sstevel@tonic-gate 		 */
71787c478bd9Sstevel@tonic-gate 		} else if ((flags & MSG_HIPRI) && q_first != NULL &&
7179a45f3f93Smeem 		    DB_TYPE(q_first) >= QPCTL &&
7180301ce41fSja97890 		    (bp = getq_noenab(q, 0)) != NULL) {
7181a45f3f93Smeem 			ASSERT(DB_TYPE(bp) >= QPCTL);
71827c478bd9Sstevel@tonic-gate 			break;
71837c478bd9Sstevel@tonic-gate 		} else if ((flags & MSG_BAND) && q_first != NULL &&
7184a45f3f93Smeem 		    ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
7185301ce41fSja97890 		    (bp = getq_noenab(q, 0)) != NULL) {
71867c478bd9Sstevel@tonic-gate 			/*
71877c478bd9Sstevel@tonic-gate 			 * Asked for at least band "prip" and got either at
71887c478bd9Sstevel@tonic-gate 			 * least that band or a hipri message.
71897c478bd9Sstevel@tonic-gate 			 */
7190a45f3f93Smeem 			ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
7191a45f3f93Smeem 			if (DB_TYPE(bp) == M_SIG) {
7192a45f3f93Smeem 				strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7193a45f3f93Smeem 				freemsg(bp);
71947c478bd9Sstevel@tonic-gate 				continue;
71957c478bd9Sstevel@tonic-gate 			} else {
71967c478bd9Sstevel@tonic-gate 				break;
71977c478bd9Sstevel@tonic-gate 			}
71987c478bd9Sstevel@tonic-gate 		}
71997c478bd9Sstevel@tonic-gate 
72007c478bd9Sstevel@tonic-gate 		/* No data. Time to sleep? */
72017c478bd9Sstevel@tonic-gate 		qbackenable(q, 0);
72027c478bd9Sstevel@tonic-gate 
72037c478bd9Sstevel@tonic-gate 		/*
72047c478bd9Sstevel@tonic-gate 		 * Delayed error notification?
72057c478bd9Sstevel@tonic-gate 		 */
72067c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRDERR|STPLEX)) &&
72077c478bd9Sstevel@tonic-gate 		    (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) {
72087c478bd9Sstevel@tonic-gate 			error = strgeterr(stp, STRDERR|STPLEX,
72097c478bd9Sstevel@tonic-gate 			    (flags & MSG_IPEEK));
72107c478bd9Sstevel@tonic-gate 			if (error != 0) {
72117c478bd9Sstevel@tonic-gate 				mutex_exit(&stp->sd_lock);
72127c478bd9Sstevel@tonic-gate 				return (error);
72137c478bd9Sstevel@tonic-gate 			}
72147c478bd9Sstevel@tonic-gate 		}
72157c478bd9Sstevel@tonic-gate 
72167c478bd9Sstevel@tonic-gate 		/*
72177c478bd9Sstevel@tonic-gate 		 * If STRHUP or STREOF, return 0 length control and data.
72187c478bd9Sstevel@tonic-gate 		 * If a read(fd,buf,0) has been done, do not sleep, just
72197c478bd9Sstevel@tonic-gate 		 * return.
72207c478bd9Sstevel@tonic-gate 		 *
72217c478bd9Sstevel@tonic-gate 		 * If mctlp == NULL and uiop == NULL, then the code will
72227c478bd9Sstevel@tonic-gate 		 * do the strwaitq. This is an understood way of saying
72237c478bd9Sstevel@tonic-gate 		 * sleep "polling" until a message is received.
72247c478bd9Sstevel@tonic-gate 		 */
72257c478bd9Sstevel@tonic-gate 		if ((stp->sd_flag & (STRHUP|STREOF)) ||
72267c478bd9Sstevel@tonic-gate 		    (uiop != NULL && uiop->uio_resid == 0)) {
72277c478bd9Sstevel@tonic-gate 			if (mctlp != NULL)
72287c478bd9Sstevel@tonic-gate 				*mctlp = NULL;
72297c478bd9Sstevel@tonic-gate 			*flagsp = 0;
72307c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
72317c478bd9Sstevel@tonic-gate 			return (0);
72327c478bd9Sstevel@tonic-gate 		}
72337c478bd9Sstevel@tonic-gate 
72347c478bd9Sstevel@tonic-gate 		waitflag = GETWAIT;
72357c478bd9Sstevel@tonic-gate 		if (flags &
72367c478bd9Sstevel@tonic-gate 		    (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) {
72377c478bd9Sstevel@tonic-gate 			if (flags & MSG_HOLDSIG)
72387c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOSIG;
72397c478bd9Sstevel@tonic-gate 			if (flags & MSG_IGNERROR)
72407c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOERROR;
72417c478bd9Sstevel@tonic-gate 			if (flags & MSG_IPEEK)
72427c478bd9Sstevel@tonic-gate 				waitflag |= STR_PEEK;
72437c478bd9Sstevel@tonic-gate 			if (flags & MSG_DELAYERROR)
72447c478bd9Sstevel@tonic-gate 				waitflag |= STR_DELAYERR;
72457c478bd9Sstevel@tonic-gate 		}
72467c478bd9Sstevel@tonic-gate 		if (uiop != NULL)
72477c478bd9Sstevel@tonic-gate 			fmode = uiop->uio_fmode;
72487c478bd9Sstevel@tonic-gate 		else
72497c478bd9Sstevel@tonic-gate 			fmode = 0;
72507c478bd9Sstevel@tonic-gate 
72517c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT,
72527c478bd9Sstevel@tonic-gate 		    "kstrgetmsg calls strwaitq:%p, %p",
72537c478bd9Sstevel@tonic-gate 		    vp, uiop);
72547c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, waitflag, (ssize_t)0,
725517169044Sbrutus 		    fmode, timout, &done))) != 0 || done) {
72567c478bd9Sstevel@tonic-gate 			TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE,
72577c478bd9Sstevel@tonic-gate 			    "kstrgetmsg error or done:%p, %p",
72587c478bd9Sstevel@tonic-gate 			    vp, uiop);
72597c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
72607c478bd9Sstevel@tonic-gate 			return (error);
72617c478bd9Sstevel@tonic-gate 		}
72627c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE,
72637c478bd9Sstevel@tonic-gate 		    "kstrgetmsg awakes:%p, %p", vp, uiop);
72649acbbeafSnn35248 		if ((error = i_straccess(stp, JCREAD)) != 0) {
72657c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
72667c478bd9Sstevel@tonic-gate 			return (error);
72677c478bd9Sstevel@tonic-gate 		}
72687c478bd9Sstevel@tonic-gate 		first = 0;
72697c478bd9Sstevel@tonic-gate 	}
72707c478bd9Sstevel@tonic-gate 	ASSERT(bp != NULL);
72717c478bd9Sstevel@tonic-gate 	/*
72727c478bd9Sstevel@tonic-gate 	 * Extract any mark information. If the message is not completely
72737c478bd9Sstevel@tonic-gate 	 * consumed this information will be put in the mblk
72747c478bd9Sstevel@tonic-gate 	 * that is putback.
72757c478bd9Sstevel@tonic-gate 	 * If MSGMARKNEXT is set and the message is completely consumed
72767c478bd9Sstevel@tonic-gate 	 * the STRATMARK flag will be set below. Likewise, if
72777c478bd9Sstevel@tonic-gate 	 * MSGNOTMARKNEXT is set and the message is
72787c478bd9Sstevel@tonic-gate 	 * completely consumed STRNOTATMARK will be set.
72797c478bd9Sstevel@tonic-gate 	 */
72807c478bd9Sstevel@tonic-gate 	mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
72817c478bd9Sstevel@tonic-gate 	ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
72827c478bd9Sstevel@tonic-gate 	    (MSGMARKNEXT|MSGNOTMARKNEXT));
72837c478bd9Sstevel@tonic-gate 	pri = bp->b_band;
72847c478bd9Sstevel@tonic-gate 	if (mark != 0) {
72857c478bd9Sstevel@tonic-gate 		/*
72867c478bd9Sstevel@tonic-gate 		 * If the caller doesn't want the mark return.
72877c478bd9Sstevel@tonic-gate 		 * Used to implement MSG_WAITALL in sockets.
72887c478bd9Sstevel@tonic-gate 		 */
72897c478bd9Sstevel@tonic-gate 		if (flags & MSG_NOMARK) {
72907c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
72917c478bd9Sstevel@tonic-gate 			qbackenable(q, pri);
72927c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
72937c478bd9Sstevel@tonic-gate 			return (EWOULDBLOCK);
72947c478bd9Sstevel@tonic-gate 		}
72957c478bd9Sstevel@tonic-gate 		if (bp == stp->sd_mark) {
72967c478bd9Sstevel@tonic-gate 			mark |= _LASTMARK;
72977c478bd9Sstevel@tonic-gate 			stp->sd_mark = NULL;
72987c478bd9Sstevel@tonic-gate 		}
72997c478bd9Sstevel@tonic-gate 	}
73007c478bd9Sstevel@tonic-gate 
73017c478bd9Sstevel@tonic-gate 	/*
73027c478bd9Sstevel@tonic-gate 	 * keep track of the first message type
73037c478bd9Sstevel@tonic-gate 	 */
73047c478bd9Sstevel@tonic-gate 	type = bp->b_datap->db_type;
73057c478bd9Sstevel@tonic-gate 
73067c478bd9Sstevel@tonic-gate 	if (bp->b_datap->db_type == M_PASSFP) {
73077c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
73087c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
73097c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
73107c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
73117c478bd9Sstevel@tonic-gate 		qbackenable(q, pri);
73127c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
73137c478bd9Sstevel@tonic-gate 		return (EBADMSG);
73147c478bd9Sstevel@tonic-gate 	}
73157c478bd9Sstevel@tonic-gate 	ASSERT(type != M_SIG);
73167c478bd9Sstevel@tonic-gate 
73177c478bd9Sstevel@tonic-gate 	if (flags & MSG_IPEEK) {
73187c478bd9Sstevel@tonic-gate 		/*
73197c478bd9Sstevel@tonic-gate 		 * Clear any struioflag - we do the uiomove over again
73207c478bd9Sstevel@tonic-gate 		 * when peeking since it simplifies the code.
73217c478bd9Sstevel@tonic-gate 		 *
73227c478bd9Sstevel@tonic-gate 		 * Dup the message and put the original back on the queue.
73237c478bd9Sstevel@tonic-gate 		 * If dupmsg() fails, try again with copymsg() to see if
73247c478bd9Sstevel@tonic-gate 		 * there is indeed a shortage of memory.  dupmsg() may fail
73257c478bd9Sstevel@tonic-gate 		 * if db_ref in any of the messages reaches its limit.
73267c478bd9Sstevel@tonic-gate 		 */
732717169044Sbrutus 
73287c478bd9Sstevel@tonic-gate 		if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) {
73297c478bd9Sstevel@tonic-gate 			/*
73307c478bd9Sstevel@tonic-gate 			 * Restore the state of the stream head since we
73317c478bd9Sstevel@tonic-gate 			 * need to drop sd_lock (strwaitbuf is sleeping).
73327c478bd9Sstevel@tonic-gate 			 */
73337c478bd9Sstevel@tonic-gate 			size_t size = msgdsize(bp);
73347c478bd9Sstevel@tonic-gate 
73357c478bd9Sstevel@tonic-gate 			if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
73367c478bd9Sstevel@tonic-gate 				stp->sd_mark = bp;
73377c478bd9Sstevel@tonic-gate 			bp->b_flag |= mark & ~_LASTMARK;
73387c478bd9Sstevel@tonic-gate 			putback(stp, q, bp, pri);
73397c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
73407c478bd9Sstevel@tonic-gate 			error = strwaitbuf(size, BPRI_HI);
73417c478bd9Sstevel@tonic-gate 			if (error) {
73427c478bd9Sstevel@tonic-gate 				/*
73437c478bd9Sstevel@tonic-gate 				 * There is no net change to the queue thus
73447c478bd9Sstevel@tonic-gate 				 * no need to qbackenable.
73457c478bd9Sstevel@tonic-gate 				 */
73467c478bd9Sstevel@tonic-gate 				return (error);
73477c478bd9Sstevel@tonic-gate 			}
73487c478bd9Sstevel@tonic-gate 			goto retry;
73497c478bd9Sstevel@tonic-gate 		}
73507c478bd9Sstevel@tonic-gate 
73517c478bd9Sstevel@tonic-gate 		if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
73527c478bd9Sstevel@tonic-gate 			stp->sd_mark = bp;
73537c478bd9Sstevel@tonic-gate 		bp->b_flag |= mark & ~_LASTMARK;
73547c478bd9Sstevel@tonic-gate 		putback(stp, q, bp, pri);
73557c478bd9Sstevel@tonic-gate 		bp = nbp;
73567c478bd9Sstevel@tonic-gate 	}
73577c478bd9Sstevel@tonic-gate 
73587c478bd9Sstevel@tonic-gate 	/*
73597c478bd9Sstevel@tonic-gate 	 * Set this flag so strrput will not generate signals. Need to
73607c478bd9Sstevel@tonic-gate 	 * make sure this flag is cleared before leaving this routine
73617c478bd9Sstevel@tonic-gate 	 * else signals will stop being sent.
73627c478bd9Sstevel@tonic-gate 	 */
73637c478bd9Sstevel@tonic-gate 	stp->sd_flag |= STRGETINPROG;
73647c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
73657c478bd9Sstevel@tonic-gate 
736651dd2c77Svk199839 	if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA)) {
736751dd2c77Svk199839 		mblk_t *tmp, *prevmp;
7368c28749e9Skais 
736951dd2c77Svk199839 		/*
737051dd2c77Svk199839 		 * Put first non-data mblk back to stream head and
737151dd2c77Svk199839 		 * cut the mblk chain so sd_rputdatafunc only sees
737251dd2c77Svk199839 		 * M_DATA mblks. We can skip the first mblk since it
737351dd2c77Svk199839 		 * is M_DATA according to the condition above.
737451dd2c77Svk199839 		 */
737551dd2c77Svk199839 		for (prevmp = bp, tmp = bp->b_cont; tmp != NULL;
737651dd2c77Svk199839 		    prevmp = tmp, tmp = tmp->b_cont) {
737751dd2c77Svk199839 			if (DB_TYPE(tmp) != M_DATA) {
737851dd2c77Svk199839 				prevmp->b_cont = NULL;
737951dd2c77Svk199839 				mutex_enter(&stp->sd_lock);
738051dd2c77Svk199839 				putback(stp, q, tmp, tmp->b_band);
738151dd2c77Svk199839 				mutex_exit(&stp->sd_lock);
738251dd2c77Svk199839 				break;
738351dd2c77Svk199839 			}
738451dd2c77Svk199839 		}
738551dd2c77Svk199839 
738651dd2c77Svk199839 		bp = (stp->sd_rputdatafunc)(stp->sd_vnode, bp,
738751dd2c77Svk199839 		    NULL, NULL, NULL, NULL);
7388c28749e9Skais 
7389c28749e9Skais 		if (bp == NULL)
7390c28749e9Skais 			goto retry;
7391c28749e9Skais 	}
7392c28749e9Skais 
73937c478bd9Sstevel@tonic-gate 	if (STREAM_NEEDSERVICE(stp))
73947c478bd9Sstevel@tonic-gate 		stream_runservice(stp);
73957c478bd9Sstevel@tonic-gate 
73967c478bd9Sstevel@tonic-gate 	/*
73977c478bd9Sstevel@tonic-gate 	 * Set HIPRI flag if message is priority.
73987c478bd9Sstevel@tonic-gate 	 */
73997c478bd9Sstevel@tonic-gate 	if (type >= QPCTL)
74007c478bd9Sstevel@tonic-gate 		flg = MSG_HIPRI;
74017c478bd9Sstevel@tonic-gate 	else
74027c478bd9Sstevel@tonic-gate 		flg = MSG_BAND;
74037c478bd9Sstevel@tonic-gate 
74047c478bd9Sstevel@tonic-gate 	/*
74057c478bd9Sstevel@tonic-gate 	 * First process PROTO or PCPROTO blocks, if any.
74067c478bd9Sstevel@tonic-gate 	 */
74077c478bd9Sstevel@tonic-gate 	if (mctlp != NULL && type != M_DATA) {
74087c478bd9Sstevel@tonic-gate 		mblk_t *nbp;
74097c478bd9Sstevel@tonic-gate 
74107c478bd9Sstevel@tonic-gate 		*mctlp = bp;
74117c478bd9Sstevel@tonic-gate 		while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA)
74127c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
74137c478bd9Sstevel@tonic-gate 		nbp = bp->b_cont;
74147c478bd9Sstevel@tonic-gate 		bp->b_cont = NULL;
74157c478bd9Sstevel@tonic-gate 		bp = nbp;
74167c478bd9Sstevel@tonic-gate 	}
74177c478bd9Sstevel@tonic-gate 
74187c478bd9Sstevel@tonic-gate 	if (bp && bp->b_datap->db_type != M_DATA) {
74197c478bd9Sstevel@tonic-gate 		/*
74207c478bd9Sstevel@tonic-gate 		 * More PROTO blocks in msg. Will only happen if mctlp is NULL.
74217c478bd9Sstevel@tonic-gate 		 */
74227c478bd9Sstevel@tonic-gate 		more |= MORECTL;
74237c478bd9Sstevel@tonic-gate 		savemp = bp;
74247c478bd9Sstevel@tonic-gate 		while (bp && bp->b_datap->db_type != M_DATA) {
74257c478bd9Sstevel@tonic-gate 			savemptail = bp;
74267c478bd9Sstevel@tonic-gate 			bp = bp->b_cont;
74277c478bd9Sstevel@tonic-gate 		}
74287c478bd9Sstevel@tonic-gate 		savemptail->b_cont = NULL;
74297c478bd9Sstevel@tonic-gate 	}
74307c478bd9Sstevel@tonic-gate 
74317c478bd9Sstevel@tonic-gate 	/*
74327c478bd9Sstevel@tonic-gate 	 * Now process DATA blocks, if any.
74337c478bd9Sstevel@tonic-gate 	 */
74347c478bd9Sstevel@tonic-gate 	if (uiop == NULL) {
74357c478bd9Sstevel@tonic-gate 		/* Append data to tail of mctlp */
743617169044Sbrutus 
74377c478bd9Sstevel@tonic-gate 		if (mctlp != NULL) {
74387c478bd9Sstevel@tonic-gate 			mblk_t **mpp = mctlp;
74397c478bd9Sstevel@tonic-gate 
74407c478bd9Sstevel@tonic-gate 			while (*mpp != NULL)
74417c478bd9Sstevel@tonic-gate 				mpp = &((*mpp)->b_cont);
74427c478bd9Sstevel@tonic-gate 			*mpp = bp;
74437c478bd9Sstevel@tonic-gate 			bp = NULL;
74447c478bd9Sstevel@tonic-gate 		}
74457c478bd9Sstevel@tonic-gate 	} else if (uiop->uio_resid >= 0 && bp) {
74467c478bd9Sstevel@tonic-gate 		size_t oldresid = uiop->uio_resid;
74477c478bd9Sstevel@tonic-gate 
74487c478bd9Sstevel@tonic-gate 		/*
74497c478bd9Sstevel@tonic-gate 		 * If a streams message is likely to consist
74507c478bd9Sstevel@tonic-gate 		 * of many small mblks, it is pulled up into
74517c478bd9Sstevel@tonic-gate 		 * one continuous chunk of memory.
745294e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * The size of the first mblk may be bogus because
745394e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * successive read() calls on the socket reduce
745494e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * the size of this mblk until it is exhausted
745594e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * and then the code walks on to the next. Thus
745694e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * the size of the mblk may not be the original size
745794e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * that was passed up, it's simply a remainder
745894e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * and hence can be very small without any
745994e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * implication that the packet is badly fragmented.
746094e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * So the size of the possible second mblk is
746194e7edb1Slucy wang - Sun Microsystems - Beijing China 		 * used to spot a badly fragmented packet.
74627c478bd9Sstevel@tonic-gate 		 * see longer comment at top of page
74637c478bd9Sstevel@tonic-gate 		 * by mblk_pull_len declaration.
74647c478bd9Sstevel@tonic-gate 		 */
74657c478bd9Sstevel@tonic-gate 
746694e7edb1Slucy wang - Sun Microsystems - Beijing China 		if (bp->b_cont != NULL && MBLKL(bp->b_cont) < mblk_pull_len) {
74677c478bd9Sstevel@tonic-gate 			(void) pullupmsg(bp, -1);
74687c478bd9Sstevel@tonic-gate 		}
74697c478bd9Sstevel@tonic-gate 
74707c478bd9Sstevel@tonic-gate 		bp = struiocopyout(bp, uiop, &error);
74717c478bd9Sstevel@tonic-gate 		if (error != 0) {
74727c478bd9Sstevel@tonic-gate 			if (mctlp != NULL) {
74737c478bd9Sstevel@tonic-gate 				freemsg(*mctlp);
74747c478bd9Sstevel@tonic-gate 				*mctlp = NULL;
74757c478bd9Sstevel@tonic-gate 			} else
74767c478bd9Sstevel@tonic-gate 				freemsg(savemp);
74777c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
74787c478bd9Sstevel@tonic-gate 			/*
74797c478bd9Sstevel@tonic-gate 			 * clear stream head hi pri flag based on
74807c478bd9Sstevel@tonic-gate 			 * first message
74817c478bd9Sstevel@tonic-gate 			 */
74827c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
74837c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
74847c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
74857c478bd9Sstevel@tonic-gate 			}
74867c478bd9Sstevel@tonic-gate 			more = 0;
74877c478bd9Sstevel@tonic-gate 			goto getmout;
74887c478bd9Sstevel@tonic-gate 		}
74897c478bd9Sstevel@tonic-gate 		/*
74907c478bd9Sstevel@tonic-gate 		 * (pr == 1) indicates a partial read.
74917c478bd9Sstevel@tonic-gate 		 */
74927c478bd9Sstevel@tonic-gate 		if (oldresid > uiop->uio_resid)
74937c478bd9Sstevel@tonic-gate 			pr = 1;
74947c478bd9Sstevel@tonic-gate 	}
74957c478bd9Sstevel@tonic-gate 
74967c478bd9Sstevel@tonic-gate 	if (bp) {			/* more data blocks in msg */
74977c478bd9Sstevel@tonic-gate 		more |= MOREDATA;
74987c478bd9Sstevel@tonic-gate 		if (savemp)
74997c478bd9Sstevel@tonic-gate 			savemptail->b_cont = bp;
75007c478bd9Sstevel@tonic-gate 		else
75017c478bd9Sstevel@tonic-gate 			savemp = bp;
75027c478bd9Sstevel@tonic-gate 	}
75037c478bd9Sstevel@tonic-gate 
75047c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
75057c478bd9Sstevel@tonic-gate 	if (savemp) {
75067c478bd9Sstevel@tonic-gate 		if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) {
75077c478bd9Sstevel@tonic-gate 			/*
75087c478bd9Sstevel@tonic-gate 			 * When MSG_DISCARDTAIL is set or
75097c478bd9Sstevel@tonic-gate 			 * when peeking discard any tail. When peeking this
75107c478bd9Sstevel@tonic-gate 			 * is the tail of the dup that was copied out - the
75117c478bd9Sstevel@tonic-gate 			 * message has already been putback on the queue.
75127c478bd9Sstevel@tonic-gate 			 * Return MOREDATA to the caller even though the data
75137c478bd9Sstevel@tonic-gate 			 * is discarded. This is used by sockets (to
75147c478bd9Sstevel@tonic-gate 			 * set MSG_TRUNC).
75157c478bd9Sstevel@tonic-gate 			 */
75167c478bd9Sstevel@tonic-gate 			freemsg(savemp);
75177c478bd9Sstevel@tonic-gate 			if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
75187c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
75197c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
75207c478bd9Sstevel@tonic-gate 			}
75217c478bd9Sstevel@tonic-gate 		} else if (pr && (savemp->b_datap->db_type == M_DATA) &&
75227c478bd9Sstevel@tonic-gate 		    msgnodata(savemp)) {
75237c478bd9Sstevel@tonic-gate 			/*
75247c478bd9Sstevel@tonic-gate 			 * Avoid queuing a zero-length tail part of
75257c478bd9Sstevel@tonic-gate 			 * a message. pr=1 indicates that we read some of
75267c478bd9Sstevel@tonic-gate 			 * the message.
75277c478bd9Sstevel@tonic-gate 			 */
75287c478bd9Sstevel@tonic-gate 			freemsg(savemp);
75297c478bd9Sstevel@tonic-gate 			more &= ~MOREDATA;
75307c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
75317c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
75327c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRPRI;
75337c478bd9Sstevel@tonic-gate 			}
75347c478bd9Sstevel@tonic-gate 		} else {
75357c478bd9Sstevel@tonic-gate 			savemp->b_band = pri;
75367c478bd9Sstevel@tonic-gate 			/*
75377c478bd9Sstevel@tonic-gate 			 * If the first message was HIPRI and the one we're
75387c478bd9Sstevel@tonic-gate 			 * putting back isn't, then clear STRPRI, otherwise
75397c478bd9Sstevel@tonic-gate 			 * set STRPRI again.  Note that we must set STRPRI
75407c478bd9Sstevel@tonic-gate 			 * again since the flush logic in strrput_nondata()
75417c478bd9Sstevel@tonic-gate 			 * may have cleared it while we had sd_lock dropped.
75427c478bd9Sstevel@tonic-gate 			 */
754317169044Sbrutus 
75447c478bd9Sstevel@tonic-gate 			if (type >= QPCTL) {
75457c478bd9Sstevel@tonic-gate 				ASSERT(type == M_PCPROTO);
75467c478bd9Sstevel@tonic-gate 				if (queclass(savemp) < QPCTL)
75477c478bd9Sstevel@tonic-gate 					stp->sd_flag &= ~STRPRI;
75487c478bd9Sstevel@tonic-gate 				else
75497c478bd9Sstevel@tonic-gate 					stp->sd_flag |= STRPRI;
75507c478bd9Sstevel@tonic-gate 			} else if (queclass(savemp) >= QPCTL) {
75517c478bd9Sstevel@tonic-gate 				/*
75527c478bd9Sstevel@tonic-gate 				 * The first message was not a HIPRI message,
75537c478bd9Sstevel@tonic-gate 				 * but the one we are about to putback is.
75547c478bd9Sstevel@tonic-gate 				 * For simplicitly, we do not allow for HIPRI
75557c478bd9Sstevel@tonic-gate 				 * messages to be embedded in the message
75567c478bd9Sstevel@tonic-gate 				 * body, so just force it to same type as
75577c478bd9Sstevel@tonic-gate 				 * first message.
75587c478bd9Sstevel@tonic-gate 				 */
75597c478bd9Sstevel@tonic-gate 				ASSERT(type == M_DATA || type == M_PROTO);
75607c478bd9Sstevel@tonic-gate 				ASSERT(savemp->b_datap->db_type == M_PCPROTO);
75617c478bd9Sstevel@tonic-gate 				savemp->b_datap->db_type = type;
75627c478bd9Sstevel@tonic-gate 			}
75637c478bd9Sstevel@tonic-gate 			if (mark != 0) {
75647c478bd9Sstevel@tonic-gate 				if ((mark & _LASTMARK) &&
75657c478bd9Sstevel@tonic-gate 				    (stp->sd_mark == NULL)) {
75667c478bd9Sstevel@tonic-gate 					/*
75677c478bd9Sstevel@tonic-gate 					 * If another marked message arrived
75687c478bd9Sstevel@tonic-gate 					 * while sd_lock was not held sd_mark
75697c478bd9Sstevel@tonic-gate 					 * would be non-NULL.
75707c478bd9Sstevel@tonic-gate 					 */
75717c478bd9Sstevel@tonic-gate 					stp->sd_mark = savemp;
75727c478bd9Sstevel@tonic-gate 				}
75737c478bd9Sstevel@tonic-gate 				savemp->b_flag |= mark & ~_LASTMARK;
75747c478bd9Sstevel@tonic-gate 			}
75757c478bd9Sstevel@tonic-gate 			putback(stp, q, savemp, pri);
75767c478bd9Sstevel@tonic-gate 		}
75777c478bd9Sstevel@tonic-gate 	} else if (!(flags & MSG_IPEEK)) {
75787c478bd9Sstevel@tonic-gate 		/*
75797c478bd9Sstevel@tonic-gate 		 * The complete message was consumed.
75807c478bd9Sstevel@tonic-gate 		 *
75817c478bd9Sstevel@tonic-gate 		 * If another M_PCPROTO arrived while sd_lock was not held
75827c478bd9Sstevel@tonic-gate 		 * it would have been discarded since STRPRI was still set.
75837c478bd9Sstevel@tonic-gate 		 *
75847c478bd9Sstevel@tonic-gate 		 * Move the MSG*MARKNEXT information
75857c478bd9Sstevel@tonic-gate 		 * to the stream head just in case
75867c478bd9Sstevel@tonic-gate 		 * the read queue becomes empty.
75877c478bd9Sstevel@tonic-gate 		 * clear stream head hi pri flag based on
75887c478bd9Sstevel@tonic-gate 		 * first message
75897c478bd9Sstevel@tonic-gate 		 *
75907c478bd9Sstevel@tonic-gate 		 * If the stream head was at the mark
75917c478bd9Sstevel@tonic-gate 		 * (STRATMARK) before we dropped sd_lock above
75927c478bd9Sstevel@tonic-gate 		 * and some data was consumed then we have
75937c478bd9Sstevel@tonic-gate 		 * moved past the mark thus STRATMARK is
75947c478bd9Sstevel@tonic-gate 		 * cleared. However, if a message arrived in
75957c478bd9Sstevel@tonic-gate 		 * strrput during the copyout above causing
75967c478bd9Sstevel@tonic-gate 		 * STRATMARK to be set we can not clear that
75977c478bd9Sstevel@tonic-gate 		 * flag.
75987c478bd9Sstevel@tonic-gate 		 * XXX A "perimeter" would help by single-threading strrput,
75997c478bd9Sstevel@tonic-gate 		 * strread, strgetmsg and kstrgetmsg.
76007c478bd9Sstevel@tonic-gate 		 */
76017c478bd9Sstevel@tonic-gate 		if (type >= QPCTL) {
76027c478bd9Sstevel@tonic-gate 			ASSERT(type == M_PCPROTO);
76037c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRPRI;
76047c478bd9Sstevel@tonic-gate 		}
76057c478bd9Sstevel@tonic-gate 		if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
76067c478bd9Sstevel@tonic-gate 			if (mark & MSGMARKNEXT) {
76077c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRNOTATMARK;
76087c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRATMARK;
76097c478bd9Sstevel@tonic-gate 			} else if (mark & MSGNOTMARKNEXT) {
76107c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~STRATMARK;
76117c478bd9Sstevel@tonic-gate 				stp->sd_flag |= STRNOTATMARK;
76127c478bd9Sstevel@tonic-gate 			} else {
76137c478bd9Sstevel@tonic-gate 				stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
76147c478bd9Sstevel@tonic-gate 			}
76157c478bd9Sstevel@tonic-gate 		} else if (pr && (old_sd_flag & STRATMARK)) {
76167c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
76177c478bd9Sstevel@tonic-gate 		}
76187c478bd9Sstevel@tonic-gate 	}
76197c478bd9Sstevel@tonic-gate 
76207c478bd9Sstevel@tonic-gate 	*flagsp = flg;
76217c478bd9Sstevel@tonic-gate 	*prip = pri;
76227c478bd9Sstevel@tonic-gate 
76237c478bd9Sstevel@tonic-gate 	/*
76247c478bd9Sstevel@tonic-gate 	 * Getmsg cleanup processing - if the state of the queue has changed
76257c478bd9Sstevel@tonic-gate 	 * some signals may need to be sent and/or poll awakened.
76267c478bd9Sstevel@tonic-gate 	 */
76277c478bd9Sstevel@tonic-gate getmout:
76287c478bd9Sstevel@tonic-gate 	qbackenable(q, pri);
76297c478bd9Sstevel@tonic-gate 
76307c478bd9Sstevel@tonic-gate 	/*
76317c478bd9Sstevel@tonic-gate 	 * We dropped the stream head lock above. Send all M_SIG messages
76327c478bd9Sstevel@tonic-gate 	 * before processing stream head for SIGPOLL messages.
76337c478bd9Sstevel@tonic-gate 	 */
76347c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
76357c478bd9Sstevel@tonic-gate 	while ((bp = q->q_first) != NULL &&
76367c478bd9Sstevel@tonic-gate 	    (bp->b_datap->db_type == M_SIG)) {
76377c478bd9Sstevel@tonic-gate 		/*
76387c478bd9Sstevel@tonic-gate 		 * sd_lock is held so the content of the read queue can not
76397c478bd9Sstevel@tonic-gate 		 * change.
76407c478bd9Sstevel@tonic-gate 		 */
76417c478bd9Sstevel@tonic-gate 		bp = getq(q);
76427c478bd9Sstevel@tonic-gate 		ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
76437c478bd9Sstevel@tonic-gate 
7644a45f3f93Smeem 		strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
76457c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
76467c478bd9Sstevel@tonic-gate 		freemsg(bp);
76477c478bd9Sstevel@tonic-gate 		if (STREAM_NEEDSERVICE(stp))
76487c478bd9Sstevel@tonic-gate 			stream_runservice(stp);
76497c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
76507c478bd9Sstevel@tonic-gate 	}
76517c478bd9Sstevel@tonic-gate 
76527c478bd9Sstevel@tonic-gate 	/*
76537c478bd9Sstevel@tonic-gate 	 * stream head cannot change while we make the determination
76547c478bd9Sstevel@tonic-gate 	 * whether or not to send a signal. Drop the flag to allow strrput
76557c478bd9Sstevel@tonic-gate 	 * to send firstmsgsigs again.
76567c478bd9Sstevel@tonic-gate 	 */
76577c478bd9Sstevel@tonic-gate 	stp->sd_flag &= ~STRGETINPROG;
76587c478bd9Sstevel@tonic-gate 
76597c478bd9Sstevel@tonic-gate 	/*
76607c478bd9Sstevel@tonic-gate 	 * If the type of message at the front of the queue changed
76617c478bd9Sstevel@tonic-gate 	 * due to the receive the appropriate signals and pollwakeup events
76627c478bd9Sstevel@tonic-gate 	 * are generated. The type of changes are:
76637c478bd9Sstevel@tonic-gate 	 *	Processed a hipri message, q_first is not hipri.
76647c478bd9Sstevel@tonic-gate 	 *	Processed a band X message, and q_first is band Y.
76657c478bd9Sstevel@tonic-gate 	 * The generated signals and pollwakeups are identical to what
76667c478bd9Sstevel@tonic-gate 	 * strrput() generates should the message that is now on q_first
76677c478bd9Sstevel@tonic-gate 	 * arrive to an empty read queue.
76687c478bd9Sstevel@tonic-gate 	 *
76697c478bd9Sstevel@tonic-gate 	 * Note: only strrput will send a signal for a hipri message.
76707c478bd9Sstevel@tonic-gate 	 */
76717c478bd9Sstevel@tonic-gate 	if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
76727c478bd9Sstevel@tonic-gate 		strsigset_t signals = 0;
76737c478bd9Sstevel@tonic-gate 		strpollset_t pollwakeups = 0;
76747c478bd9Sstevel@tonic-gate 
76757c478bd9Sstevel@tonic-gate 		if (flg & MSG_HIPRI) {
76767c478bd9Sstevel@tonic-gate 			/*
76777c478bd9Sstevel@tonic-gate 			 * Removed a hipri message. Regular data at
76787c478bd9Sstevel@tonic-gate 			 * the front of  the queue.
76797c478bd9Sstevel@tonic-gate 			 */
76807c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
76817c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDNORM;
76827c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
76837c478bd9Sstevel@tonic-gate 			} else {
76847c478bd9Sstevel@tonic-gate 				signals = S_INPUT | S_RDBAND;
76857c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
76867c478bd9Sstevel@tonic-gate 			}
76877c478bd9Sstevel@tonic-gate 		} else if (pri != bp->b_band) {
76887c478bd9Sstevel@tonic-gate 			/*
76897c478bd9Sstevel@tonic-gate 			 * The band is different for the new q_first.
76907c478bd9Sstevel@tonic-gate 			 */
76917c478bd9Sstevel@tonic-gate 			if (bp->b_band == 0) {
76927c478bd9Sstevel@tonic-gate 				signals = S_RDNORM;
76937c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDNORM;
76947c478bd9Sstevel@tonic-gate 			} else {
76957c478bd9Sstevel@tonic-gate 				signals = S_RDBAND;
76967c478bd9Sstevel@tonic-gate 				pollwakeups = POLLIN | POLLRDBAND;
76977c478bd9Sstevel@tonic-gate 			}
76987c478bd9Sstevel@tonic-gate 		}
76997c478bd9Sstevel@tonic-gate 
77007c478bd9Sstevel@tonic-gate 		if (pollwakeups != 0) {
77017c478bd9Sstevel@tonic-gate 			if (pollwakeups == (POLLIN | POLLRDNORM)) {
77027c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
77037c478bd9Sstevel@tonic-gate 					goto no_pollwake;
77047c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
77057c478bd9Sstevel@tonic-gate 			}
77067c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
77077c478bd9Sstevel@tonic-gate 			pollwakeup(&stp->sd_pollist, pollwakeups);
77087c478bd9Sstevel@tonic-gate 			mutex_enter(&stp->sd_lock);
77097c478bd9Sstevel@tonic-gate 		}
77107c478bd9Sstevel@tonic-gate no_pollwake:
77117c478bd9Sstevel@tonic-gate 
77127c478bd9Sstevel@tonic-gate 		if (stp->sd_sigflags & signals)
77137c478bd9Sstevel@tonic-gate 			strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
77147c478bd9Sstevel@tonic-gate 	}
77157c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
77167c478bd9Sstevel@tonic-gate 
77177c478bd9Sstevel@tonic-gate 	rvp->r_val1 = more;
77187c478bd9Sstevel@tonic-gate 	return (error);
77197c478bd9Sstevel@tonic-gate #undef	_LASTMARK
77207c478bd9Sstevel@tonic-gate }
77217c478bd9Sstevel@tonic-gate 
77227c478bd9Sstevel@tonic-gate /*
77237c478bd9Sstevel@tonic-gate  * Put a message downstream.
77247c478bd9Sstevel@tonic-gate  *
77257c478bd9Sstevel@tonic-gate  * NOTE: strputmsg and kstrputmsg have much of the logic in common.
77267c478bd9Sstevel@tonic-gate  */
77277c478bd9Sstevel@tonic-gate int
77287c478bd9Sstevel@tonic-gate strputmsg(
77297c478bd9Sstevel@tonic-gate 	struct vnode *vp,
77307c478bd9Sstevel@tonic-gate 	struct strbuf *mctl,
77317c478bd9Sstevel@tonic-gate 	struct strbuf *mdata,
77327c478bd9Sstevel@tonic-gate 	unsigned char pri,
77337c478bd9Sstevel@tonic-gate 	int flag,
77347c478bd9Sstevel@tonic-gate 	int fmode)
77357c478bd9Sstevel@tonic-gate {
77367c478bd9Sstevel@tonic-gate 	struct stdata *stp;
77377c478bd9Sstevel@tonic-gate 	queue_t *wqp;
77387c478bd9Sstevel@tonic-gate 	mblk_t *mp;
77397c478bd9Sstevel@tonic-gate 	ssize_t msgsize;
77407c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
77417c478bd9Sstevel@tonic-gate 	int error;
77427c478bd9Sstevel@tonic-gate 	struct uio uios;
77437c478bd9Sstevel@tonic-gate 	struct uio *uiop = &uios;
77447c478bd9Sstevel@tonic-gate 	struct iovec iovs;
77457c478bd9Sstevel@tonic-gate 	int xpg4 = 0;
77467c478bd9Sstevel@tonic-gate 
77477c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
77487c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
77497c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
77507c478bd9Sstevel@tonic-gate 
77517c478bd9Sstevel@tonic-gate 	/*
77527c478bd9Sstevel@tonic-gate 	 * If it is an XPG4 application, we need to send
77537c478bd9Sstevel@tonic-gate 	 * SIGPIPE below
77547c478bd9Sstevel@tonic-gate 	 */
77557c478bd9Sstevel@tonic-gate 
77567c478bd9Sstevel@tonic-gate 	xpg4 = (flag & MSG_XPG4) ? 1 : 0;
77577c478bd9Sstevel@tonic-gate 	flag &= ~MSG_XPG4;
77587c478bd9Sstevel@tonic-gate 
77597c478bd9Sstevel@tonic-gate 	if (audit_active)
77607c478bd9Sstevel@tonic-gate 		audit_strputmsg(vp, mctl, mdata, pri, flag, fmode);
77617c478bd9Sstevel@tonic-gate 
77627c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
77639acbbeafSnn35248 
77649acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
77657c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
77667c478bd9Sstevel@tonic-gate 		return (error);
77677c478bd9Sstevel@tonic-gate 	}
77687c478bd9Sstevel@tonic-gate 
77699acbbeafSnn35248 	if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
77709acbbeafSnn35248 		error = strwriteable(stp, B_FALSE, xpg4);
77719acbbeafSnn35248 		if (error != 0) {
77729acbbeafSnn35248 			mutex_exit(&stp->sd_lock);
77739acbbeafSnn35248 			return (error);
77749acbbeafSnn35248 		}
77759acbbeafSnn35248 	}
77769acbbeafSnn35248 
77779acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
77789acbbeafSnn35248 
77797c478bd9Sstevel@tonic-gate 	/*
77807c478bd9Sstevel@tonic-gate 	 * Check for legal flag value.
77817c478bd9Sstevel@tonic-gate 	 */
77827c478bd9Sstevel@tonic-gate 	switch (flag) {
77837c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
77847c478bd9Sstevel@tonic-gate 		if ((mctl->len < 0) || (pri != 0))
77857c478bd9Sstevel@tonic-gate 			return (EINVAL);
77867c478bd9Sstevel@tonic-gate 		break;
77877c478bd9Sstevel@tonic-gate 	case MSG_BAND:
77887c478bd9Sstevel@tonic-gate 		break;
77897c478bd9Sstevel@tonic-gate 
77907c478bd9Sstevel@tonic-gate 	default:
77917c478bd9Sstevel@tonic-gate 		return (EINVAL);
77927c478bd9Sstevel@tonic-gate 	}
77937c478bd9Sstevel@tonic-gate 
77947c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN,
77957c478bd9Sstevel@tonic-gate 	    "strputmsg in:stp %p", stp);
77967c478bd9Sstevel@tonic-gate 
77977c478bd9Sstevel@tonic-gate 	/* get these values from those cached in the stream head */
77987c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
77997c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
78007c478bd9Sstevel@tonic-gate 
78017c478bd9Sstevel@tonic-gate 	/*
78027c478bd9Sstevel@tonic-gate 	 * Make sure ctl and data sizes together fall within the
78037c478bd9Sstevel@tonic-gate 	 * limits of the max and min receive packet sizes and do
78047c478bd9Sstevel@tonic-gate 	 * not exceed system limit.
78057c478bd9Sstevel@tonic-gate 	 */
78067c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
78077c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
78087c478bd9Sstevel@tonic-gate 		return (ERANGE);
78097c478bd9Sstevel@tonic-gate 	}
78107c478bd9Sstevel@tonic-gate 	/*
78117c478bd9Sstevel@tonic-gate 	 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
78127c478bd9Sstevel@tonic-gate 	 * Needed to prevent partial failures in the strmakedata loop.
78137c478bd9Sstevel@tonic-gate 	 */
78147c478bd9Sstevel@tonic-gate 	if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
78157c478bd9Sstevel@tonic-gate 		rmax = stp->sd_maxblk;
78167c478bd9Sstevel@tonic-gate 
78177c478bd9Sstevel@tonic-gate 	if ((msgsize = mdata->len) < 0) {
78187c478bd9Sstevel@tonic-gate 		msgsize = 0;
78197c478bd9Sstevel@tonic-gate 		rmin = 0;	/* no range check for NULL data part */
78207c478bd9Sstevel@tonic-gate 	}
78217c478bd9Sstevel@tonic-gate 	if ((msgsize < rmin) ||
78227c478bd9Sstevel@tonic-gate 	    ((msgsize > rmax) && (rmax != INFPSZ)) ||
78237c478bd9Sstevel@tonic-gate 	    (mctl->len > strctlsz)) {
78247c478bd9Sstevel@tonic-gate 		return (ERANGE);
78257c478bd9Sstevel@tonic-gate 	}
78267c478bd9Sstevel@tonic-gate 
78277c478bd9Sstevel@tonic-gate 	/*
78287c478bd9Sstevel@tonic-gate 	 * Setup uio and iov for data part
78297c478bd9Sstevel@tonic-gate 	 */
78307c478bd9Sstevel@tonic-gate 	iovs.iov_base = mdata->buf;
78317c478bd9Sstevel@tonic-gate 	iovs.iov_len = msgsize;
78327c478bd9Sstevel@tonic-gate 	uios.uio_iov = &iovs;
78337c478bd9Sstevel@tonic-gate 	uios.uio_iovcnt = 1;
78347c478bd9Sstevel@tonic-gate 	uios.uio_loffset = 0;
78357c478bd9Sstevel@tonic-gate 	uios.uio_segflg = UIO_USERSPACE;
78367c478bd9Sstevel@tonic-gate 	uios.uio_fmode = fmode;
78377c478bd9Sstevel@tonic-gate 	uios.uio_extflg = UIO_COPY_DEFAULT;
78387c478bd9Sstevel@tonic-gate 	uios.uio_resid = msgsize;
78397c478bd9Sstevel@tonic-gate 	uios.uio_offset = 0;
78407c478bd9Sstevel@tonic-gate 
78417c478bd9Sstevel@tonic-gate 	/* Ignore flow control in strput for HIPRI */
78427c478bd9Sstevel@tonic-gate 	if (flag & MSG_HIPRI)
78437c478bd9Sstevel@tonic-gate 		flag |= MSG_IGNFLOW;
78447c478bd9Sstevel@tonic-gate 
78457c478bd9Sstevel@tonic-gate 	for (;;) {
78467c478bd9Sstevel@tonic-gate 		int done = 0;
78477c478bd9Sstevel@tonic-gate 
78487c478bd9Sstevel@tonic-gate 		/*
78497c478bd9Sstevel@tonic-gate 		 * strput will always free the ctl mblk - even when strput
78507c478bd9Sstevel@tonic-gate 		 * fails.
78517c478bd9Sstevel@tonic-gate 		 */
78527c478bd9Sstevel@tonic-gate 		if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) {
78537c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
78547c478bd9Sstevel@tonic-gate 			    "strputmsg out:stp %p out %d error %d",
78557c478bd9Sstevel@tonic-gate 			    stp, 1, error);
78567c478bd9Sstevel@tonic-gate 			return (error);
78577c478bd9Sstevel@tonic-gate 		}
78587c478bd9Sstevel@tonic-gate 		/*
78597c478bd9Sstevel@tonic-gate 		 * Verify that the whole message can be transferred by
78607c478bd9Sstevel@tonic-gate 		 * strput.
78617c478bd9Sstevel@tonic-gate 		 */
78627c478bd9Sstevel@tonic-gate 		ASSERT(stp->sd_maxblk == INFPSZ ||
78637c478bd9Sstevel@tonic-gate 		    stp->sd_maxblk >= mdata->len);
78647c478bd9Sstevel@tonic-gate 
78657c478bd9Sstevel@tonic-gate 		msgsize = mdata->len;
78667c478bd9Sstevel@tonic-gate 		error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
78677c478bd9Sstevel@tonic-gate 		mdata->len = msgsize;
78687c478bd9Sstevel@tonic-gate 
78697c478bd9Sstevel@tonic-gate 		if (error == 0)
78707c478bd9Sstevel@tonic-gate 			break;
78717c478bd9Sstevel@tonic-gate 
78727c478bd9Sstevel@tonic-gate 		if (error != EWOULDBLOCK)
78737c478bd9Sstevel@tonic-gate 			goto out;
78747c478bd9Sstevel@tonic-gate 
78757c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
78767c478bd9Sstevel@tonic-gate 		/*
78777c478bd9Sstevel@tonic-gate 		 * Check for a missed wakeup.
78787c478bd9Sstevel@tonic-gate 		 * Needed since strput did not hold sd_lock across
78797c478bd9Sstevel@tonic-gate 		 * the canputnext.
78807c478bd9Sstevel@tonic-gate 		 */
78817c478bd9Sstevel@tonic-gate 		if (bcanputnext(wqp, pri)) {
78827c478bd9Sstevel@tonic-gate 			/* Try again */
78837c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
78847c478bd9Sstevel@tonic-gate 			continue;
78857c478bd9Sstevel@tonic-gate 		}
78867c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT,
78877c478bd9Sstevel@tonic-gate 		    "strputmsg wait:stp %p waits pri %d", stp, pri);
78887c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1,
78897c478bd9Sstevel@tonic-gate 		    &done)) != 0) || done) {
78907c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
78917c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
78927c478bd9Sstevel@tonic-gate 			    "strputmsg out:q %p out %d error %d",
78937c478bd9Sstevel@tonic-gate 			    stp, 0, error);
78947c478bd9Sstevel@tonic-gate 			return (error);
78957c478bd9Sstevel@tonic-gate 		}
78967c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE,
78977c478bd9Sstevel@tonic-gate 		    "strputmsg wake:stp %p wakes", stp);
78989acbbeafSnn35248 		if ((error = i_straccess(stp, JCWRITE)) != 0) {
78997c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
79007c478bd9Sstevel@tonic-gate 			return (error);
79017c478bd9Sstevel@tonic-gate 		}
79029acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
79039acbbeafSnn35248 	}
79047c478bd9Sstevel@tonic-gate out:
79057c478bd9Sstevel@tonic-gate 	/*
79067c478bd9Sstevel@tonic-gate 	 * For historic reasons, applications expect EAGAIN
79077c478bd9Sstevel@tonic-gate 	 * when data mblk could not be allocated. so change
79087c478bd9Sstevel@tonic-gate 	 * ENOMEM back to EAGAIN
79097c478bd9Sstevel@tonic-gate 	 */
79107c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
79117c478bd9Sstevel@tonic-gate 		error = EAGAIN;
79127c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
79137c478bd9Sstevel@tonic-gate 	    "strputmsg out:stp %p out %d error %d", stp, 2, error);
79147c478bd9Sstevel@tonic-gate 	return (error);
79157c478bd9Sstevel@tonic-gate }
79167c478bd9Sstevel@tonic-gate 
79177c478bd9Sstevel@tonic-gate /*
79187c478bd9Sstevel@tonic-gate  * Put a message downstream.
79197c478bd9Sstevel@tonic-gate  * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop.
79207c478bd9Sstevel@tonic-gate  * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio
79217c478bd9Sstevel@tonic-gate  * and the fmode parameter.
79227c478bd9Sstevel@tonic-gate  *
79237c478bd9Sstevel@tonic-gate  * This routine handles the consolidation private flags:
79247c478bd9Sstevel@tonic-gate  *	MSG_IGNERROR	Ignore any stream head error except STPLEX.
79257c478bd9Sstevel@tonic-gate  *	MSG_HOLDSIG	Hold signals while waiting for data.
79267c478bd9Sstevel@tonic-gate  *	MSG_IGNFLOW	Don't check streams flow control.
79277c478bd9Sstevel@tonic-gate  *
79287c478bd9Sstevel@tonic-gate  * NOTE: strputmsg and kstrputmsg have much of the logic in common.
79297c478bd9Sstevel@tonic-gate  */
79307c478bd9Sstevel@tonic-gate int
79317c478bd9Sstevel@tonic-gate kstrputmsg(
79327c478bd9Sstevel@tonic-gate 	struct vnode *vp,
79337c478bd9Sstevel@tonic-gate 	mblk_t *mctl,
79347c478bd9Sstevel@tonic-gate 	struct uio *uiop,
79357c478bd9Sstevel@tonic-gate 	ssize_t msgsize,
79367c478bd9Sstevel@tonic-gate 	unsigned char pri,
79377c478bd9Sstevel@tonic-gate 	int flag,
79387c478bd9Sstevel@tonic-gate 	int fmode)
79397c478bd9Sstevel@tonic-gate {
79407c478bd9Sstevel@tonic-gate 	struct stdata *stp;
79417c478bd9Sstevel@tonic-gate 	queue_t *wqp;
79427c478bd9Sstevel@tonic-gate 	ssize_t rmin, rmax;
79437c478bd9Sstevel@tonic-gate 	int error;
79447c478bd9Sstevel@tonic-gate 
79457c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
79467c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
79477c478bd9Sstevel@tonic-gate 	wqp = stp->sd_wrq;
79487c478bd9Sstevel@tonic-gate 	if (audit_active)
79497c478bd9Sstevel@tonic-gate 		audit_strputmsg(vp, NULL, NULL, pri, flag, fmode);
7950e4506d67Smeem 	if (mctl == NULL)
7951e4506d67Smeem 		return (EINVAL);
79527c478bd9Sstevel@tonic-gate 
79539acbbeafSnn35248 	mutex_enter(&stp->sd_lock);
79549acbbeafSnn35248 
79559acbbeafSnn35248 	if ((error = i_straccess(stp, JCWRITE)) != 0) {
79569acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
79577c478bd9Sstevel@tonic-gate 		freemsg(mctl);
79587c478bd9Sstevel@tonic-gate 		return (error);
79597c478bd9Sstevel@tonic-gate 	}
79607c478bd9Sstevel@tonic-gate 
79617c478bd9Sstevel@tonic-gate 	if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) {
79627c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
79637c478bd9Sstevel@tonic-gate 			error = strwriteable(stp, B_FALSE, B_TRUE);
79647c478bd9Sstevel@tonic-gate 			if (error != 0) {
79659acbbeafSnn35248 				mutex_exit(&stp->sd_lock);
79667c478bd9Sstevel@tonic-gate 				freemsg(mctl);
79677c478bd9Sstevel@tonic-gate 				return (error);
79687c478bd9Sstevel@tonic-gate 			}
79697c478bd9Sstevel@tonic-gate 		}
79707c478bd9Sstevel@tonic-gate 	}
79717c478bd9Sstevel@tonic-gate 
79729acbbeafSnn35248 	mutex_exit(&stp->sd_lock);
79739acbbeafSnn35248 
79747c478bd9Sstevel@tonic-gate 	/*
79757c478bd9Sstevel@tonic-gate 	 * Check for legal flag value.
79767c478bd9Sstevel@tonic-gate 	 */
79777c478bd9Sstevel@tonic-gate 	switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) {
79787c478bd9Sstevel@tonic-gate 	case MSG_HIPRI:
7979e4506d67Smeem 		if (pri != 0) {
79807c478bd9Sstevel@tonic-gate 			freemsg(mctl);
79817c478bd9Sstevel@tonic-gate 			return (EINVAL);
79827c478bd9Sstevel@tonic-gate 		}
79837c478bd9Sstevel@tonic-gate 		break;
79847c478bd9Sstevel@tonic-gate 	case MSG_BAND:
79857c478bd9Sstevel@tonic-gate 		break;
79867c478bd9Sstevel@tonic-gate 	default:
79877c478bd9Sstevel@tonic-gate 		freemsg(mctl);
79887c478bd9Sstevel@tonic-gate 		return (EINVAL);
79897c478bd9Sstevel@tonic-gate 	}
79907c478bd9Sstevel@tonic-gate 
79917c478bd9Sstevel@tonic-gate 	TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN,
79927c478bd9Sstevel@tonic-gate 	    "kstrputmsg in:stp %p", stp);
79937c478bd9Sstevel@tonic-gate 
79947c478bd9Sstevel@tonic-gate 	/* get these values from those cached in the stream head */
79957c478bd9Sstevel@tonic-gate 	rmin = stp->sd_qn_minpsz;
79967c478bd9Sstevel@tonic-gate 	rmax = stp->sd_qn_maxpsz;
79977c478bd9Sstevel@tonic-gate 
79987c478bd9Sstevel@tonic-gate 	/*
79997c478bd9Sstevel@tonic-gate 	 * Make sure ctl and data sizes together fall within the
80007c478bd9Sstevel@tonic-gate 	 * limits of the max and min receive packet sizes and do
80017c478bd9Sstevel@tonic-gate 	 * not exceed system limit.
80027c478bd9Sstevel@tonic-gate 	 */
80037c478bd9Sstevel@tonic-gate 	ASSERT((rmax >= 0) || (rmax == INFPSZ));
80047c478bd9Sstevel@tonic-gate 	if (rmax == 0) {
80057c478bd9Sstevel@tonic-gate 		freemsg(mctl);
80067c478bd9Sstevel@tonic-gate 		return (ERANGE);
80077c478bd9Sstevel@tonic-gate 	}
80087c478bd9Sstevel@tonic-gate 	/*
80097c478bd9Sstevel@tonic-gate 	 * Use the MAXIMUM of sd_maxblk and q_maxpsz.
80107c478bd9Sstevel@tonic-gate 	 * Needed to prevent partial failures in the strmakedata loop.
80117c478bd9Sstevel@tonic-gate 	 */
80127c478bd9Sstevel@tonic-gate 	if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
80137c478bd9Sstevel@tonic-gate 		rmax = stp->sd_maxblk;
80147c478bd9Sstevel@tonic-gate 
80157c478bd9Sstevel@tonic-gate 	if (uiop == NULL) {
80167c478bd9Sstevel@tonic-gate 		msgsize = -1;
80177c478bd9Sstevel@tonic-gate 		rmin = -1;	/* no range check for NULL data part */
80187c478bd9Sstevel@tonic-gate 	} else {
80197c478bd9Sstevel@tonic-gate 		/* Use uio flags as well as the fmode parameter flags */
80207c478bd9Sstevel@tonic-gate 		fmode |= uiop->uio_fmode;
80217c478bd9Sstevel@tonic-gate 
80227c478bd9Sstevel@tonic-gate 		if ((msgsize < rmin) ||
80237c478bd9Sstevel@tonic-gate 		    ((msgsize > rmax) && (rmax != INFPSZ))) {
80247c478bd9Sstevel@tonic-gate 			freemsg(mctl);
80257c478bd9Sstevel@tonic-gate 			return (ERANGE);
80267c478bd9Sstevel@tonic-gate 		}
80277c478bd9Sstevel@tonic-gate 	}
80287c478bd9Sstevel@tonic-gate 
80297c478bd9Sstevel@tonic-gate 	/* Ignore flow control in strput for HIPRI */
80307c478bd9Sstevel@tonic-gate 	if (flag & MSG_HIPRI)
80317c478bd9Sstevel@tonic-gate 		flag |= MSG_IGNFLOW;
80327c478bd9Sstevel@tonic-gate 
80337c478bd9Sstevel@tonic-gate 	for (;;) {
80347c478bd9Sstevel@tonic-gate 		int done = 0;
80357c478bd9Sstevel@tonic-gate 		int waitflag;
80367c478bd9Sstevel@tonic-gate 		mblk_t *mp;
80377c478bd9Sstevel@tonic-gate 
80387c478bd9Sstevel@tonic-gate 		/*
80397c478bd9Sstevel@tonic-gate 		 * strput will always free the ctl mblk - even when strput
80407c478bd9Sstevel@tonic-gate 		 * fails. If MSG_IGNFLOW is set then any error returned
80417c478bd9Sstevel@tonic-gate 		 * will cause us to break the loop, so we don't need a copy
80427c478bd9Sstevel@tonic-gate 		 * of the message. If MSG_IGNFLOW is not set, then we can
80437c478bd9Sstevel@tonic-gate 		 * get hit by flow control and be forced to try again. In
80447c478bd9Sstevel@tonic-gate 		 * this case we need to have a copy of the message. We
80457c478bd9Sstevel@tonic-gate 		 * do this using copymsg since the message may get modified
80467c478bd9Sstevel@tonic-gate 		 * by something below us.
80477c478bd9Sstevel@tonic-gate 		 *
80487c478bd9Sstevel@tonic-gate 		 * We've observed that many TPI providers do not check db_ref
80497c478bd9Sstevel@tonic-gate 		 * on the control messages but blindly reuse them for the
80507c478bd9Sstevel@tonic-gate 		 * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more
80517c478bd9Sstevel@tonic-gate 		 * friendly to such providers than using dupmsg. Also, note
80527c478bd9Sstevel@tonic-gate 		 * that sockfs uses MSG_IGNFLOW for all TPI control messages.
80537c478bd9Sstevel@tonic-gate 		 * Only data messages are subject to flow control, hence
80547c478bd9Sstevel@tonic-gate 		 * subject to this copymsg.
80557c478bd9Sstevel@tonic-gate 		 */
80567c478bd9Sstevel@tonic-gate 		if (flag & MSG_IGNFLOW) {
80577c478bd9Sstevel@tonic-gate 			mp = mctl;
80587c478bd9Sstevel@tonic-gate 			mctl = NULL;
80597c478bd9Sstevel@tonic-gate 		} else {
80607c478bd9Sstevel@tonic-gate 			do {
80617c478bd9Sstevel@tonic-gate 				/*
80627c478bd9Sstevel@tonic-gate 				 * If a message has a free pointer, the message
80637c478bd9Sstevel@tonic-gate 				 * must be dupmsg to maintain this pointer.
80647c478bd9Sstevel@tonic-gate 				 * Code using this facility must be sure
80657c478bd9Sstevel@tonic-gate 				 * that modules below will not change the
80667c478bd9Sstevel@tonic-gate 				 * contents of the dblk without checking db_ref
80677c478bd9Sstevel@tonic-gate 				 * first. If db_ref is > 1, then the module
80687c478bd9Sstevel@tonic-gate 				 * needs to do a copymsg first. Otherwise,
80697c478bd9Sstevel@tonic-gate 				 * the contents of the dblk may become
80707c478bd9Sstevel@tonic-gate 				 * inconsistent because the freesmg/freeb below
80717c478bd9Sstevel@tonic-gate 				 * may end up calling atomic_add_32_nv.
80727c478bd9Sstevel@tonic-gate 				 * The atomic_add_32_nv in freeb (accessing
80737c478bd9Sstevel@tonic-gate 				 * all of db_ref, db_type, db_flags, and
80747c478bd9Sstevel@tonic-gate 				 * db_struioflag) does not prevent other threads
80757c478bd9Sstevel@tonic-gate 				 * from concurrently trying to modify e.g.
80767c478bd9Sstevel@tonic-gate 				 * db_type.
80777c478bd9Sstevel@tonic-gate 				 */
80787c478bd9Sstevel@tonic-gate 				if (mctl->b_datap->db_frtnp != NULL)
80797c478bd9Sstevel@tonic-gate 					mp = dupmsg(mctl);
80807c478bd9Sstevel@tonic-gate 				else
80817c478bd9Sstevel@tonic-gate 					mp = copymsg(mctl);
80827c478bd9Sstevel@tonic-gate 
8083e4506d67Smeem 				if (mp != NULL)
80847c478bd9Sstevel@tonic-gate 					break;
80857c478bd9Sstevel@tonic-gate 
80867c478bd9Sstevel@tonic-gate 				error = strwaitbuf(msgdsize(mctl), BPRI_MED);
80877c478bd9Sstevel@tonic-gate 				if (error) {
80887c478bd9Sstevel@tonic-gate 					freemsg(mctl);
80897c478bd9Sstevel@tonic-gate 					return (error);
80907c478bd9Sstevel@tonic-gate 				}
80917c478bd9Sstevel@tonic-gate 			} while (mp == NULL);
80927c478bd9Sstevel@tonic-gate 		}
80937c478bd9Sstevel@tonic-gate 		/*
80947c478bd9Sstevel@tonic-gate 		 * Verify that all of msgsize can be transferred by
80957c478bd9Sstevel@tonic-gate 		 * strput.
80967c478bd9Sstevel@tonic-gate 		 */
8097e4506d67Smeem 		ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize);
80987c478bd9Sstevel@tonic-gate 		error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
80997c478bd9Sstevel@tonic-gate 		if (error == 0)
81007c478bd9Sstevel@tonic-gate 			break;
81017c478bd9Sstevel@tonic-gate 
81027c478bd9Sstevel@tonic-gate 		if (error != EWOULDBLOCK)
81037c478bd9Sstevel@tonic-gate 			goto out;
81047c478bd9Sstevel@tonic-gate 
81057c478bd9Sstevel@tonic-gate 		/*
81067c478bd9Sstevel@tonic-gate 		 * IF MSG_IGNFLOW is set we should have broken out of loop
81077c478bd9Sstevel@tonic-gate 		 * above.
81087c478bd9Sstevel@tonic-gate 		 */
81097c478bd9Sstevel@tonic-gate 		ASSERT(!(flag & MSG_IGNFLOW));
81107c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
81117c478bd9Sstevel@tonic-gate 		/*
81127c478bd9Sstevel@tonic-gate 		 * Check for a missed wakeup.
81137c478bd9Sstevel@tonic-gate 		 * Needed since strput did not hold sd_lock across
81147c478bd9Sstevel@tonic-gate 		 * the canputnext.
81157c478bd9Sstevel@tonic-gate 		 */
81167c478bd9Sstevel@tonic-gate 		if (bcanputnext(wqp, pri)) {
81177c478bd9Sstevel@tonic-gate 			/* Try again */
81187c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
81197c478bd9Sstevel@tonic-gate 			continue;
81207c478bd9Sstevel@tonic-gate 		}
81217c478bd9Sstevel@tonic-gate 		TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT,
81227c478bd9Sstevel@tonic-gate 		    "kstrputmsg wait:stp %p waits pri %d", stp, pri);
81237c478bd9Sstevel@tonic-gate 
81247c478bd9Sstevel@tonic-gate 		waitflag = WRITEWAIT;
81257c478bd9Sstevel@tonic-gate 		if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) {
81267c478bd9Sstevel@tonic-gate 			if (flag & MSG_HOLDSIG)
81277c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOSIG;
81287c478bd9Sstevel@tonic-gate 			if (flag & MSG_IGNERROR)
81297c478bd9Sstevel@tonic-gate 				waitflag |= STR_NOERROR;
81307c478bd9Sstevel@tonic-gate 		}
81317c478bd9Sstevel@tonic-gate 		if (((error = strwaitq(stp, waitflag,
81327c478bd9Sstevel@tonic-gate 		    (ssize_t)0, fmode, -1, &done)) != 0) || done) {
81337c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
81347c478bd9Sstevel@tonic-gate 			TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
81357c478bd9Sstevel@tonic-gate 			    "kstrputmsg out:stp %p out %d error %d",
81367c478bd9Sstevel@tonic-gate 			    stp, 0, error);
81377c478bd9Sstevel@tonic-gate 			freemsg(mctl);
81387c478bd9Sstevel@tonic-gate 			return (error);
81397c478bd9Sstevel@tonic-gate 		}
81407c478bd9Sstevel@tonic-gate 		TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE,
81417c478bd9Sstevel@tonic-gate 		    "kstrputmsg wake:stp %p wakes", stp);
81429acbbeafSnn35248 		if ((error = i_straccess(stp, JCWRITE)) != 0) {
81437c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
81447c478bd9Sstevel@tonic-gate 			freemsg(mctl);
81457c478bd9Sstevel@tonic-gate 			return (error);
81467c478bd9Sstevel@tonic-gate 		}
81479acbbeafSnn35248 		mutex_exit(&stp->sd_lock);
81487c478bd9Sstevel@tonic-gate 	}
81497c478bd9Sstevel@tonic-gate out:
81507c478bd9Sstevel@tonic-gate 	freemsg(mctl);
81517c478bd9Sstevel@tonic-gate 	/*
81527c478bd9Sstevel@tonic-gate 	 * For historic reasons, applications expect EAGAIN
81537c478bd9Sstevel@tonic-gate 	 * when data mblk could not be allocated. so change
81547c478bd9Sstevel@tonic-gate 	 * ENOMEM back to EAGAIN
81557c478bd9Sstevel@tonic-gate 	 */
81567c478bd9Sstevel@tonic-gate 	if (error == ENOMEM)
81577c478bd9Sstevel@tonic-gate 		error = EAGAIN;
81587c478bd9Sstevel@tonic-gate 	TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
81597c478bd9Sstevel@tonic-gate 	    "kstrputmsg out:stp %p out %d error %d", stp, 2, error);
81607c478bd9Sstevel@tonic-gate 	return (error);
81617c478bd9Sstevel@tonic-gate }
81627c478bd9Sstevel@tonic-gate 
81637c478bd9Sstevel@tonic-gate /*
81647c478bd9Sstevel@tonic-gate  * Determines whether the necessary conditions are set on a stream
81657c478bd9Sstevel@tonic-gate  * for it to be readable, writeable, or have exceptions.
81667c478bd9Sstevel@tonic-gate  *
81677c478bd9Sstevel@tonic-gate  * strpoll handles the consolidation private events:
81687c478bd9Sstevel@tonic-gate  *	POLLNOERR	Do not return POLLERR even if there are stream
81697c478bd9Sstevel@tonic-gate  *			head errors.
81707c478bd9Sstevel@tonic-gate  *			Used by sockfs.
81717c478bd9Sstevel@tonic-gate  *	POLLRDDATA	Do not return POLLIN unless at least one message on
81727c478bd9Sstevel@tonic-gate  *			the queue contains one or more M_DATA mblks. Thus
81737c478bd9Sstevel@tonic-gate  *			when this flag is set a queue with only
81747c478bd9Sstevel@tonic-gate  *			M_PROTO/M_PCPROTO mblks does not return POLLIN.
81757c478bd9Sstevel@tonic-gate  *			Used by sockfs to ignore T_EXDATA_IND messages.
81767c478bd9Sstevel@tonic-gate  *
81777c478bd9Sstevel@tonic-gate  * Note: POLLRDDATA assumes that synch streams only return messages with
81787c478bd9Sstevel@tonic-gate  * an M_DATA attached (i.e. not messages consisting of only
81797c478bd9Sstevel@tonic-gate  * an M_PROTO/M_PCPROTO part).
81807c478bd9Sstevel@tonic-gate  */
81817c478bd9Sstevel@tonic-gate int
81827c478bd9Sstevel@tonic-gate strpoll(
81837c478bd9Sstevel@tonic-gate 	struct stdata *stp,
81847c478bd9Sstevel@tonic-gate 	short events_arg,
81857c478bd9Sstevel@tonic-gate 	int anyyet,
81867c478bd9Sstevel@tonic-gate 	short *reventsp,
81877c478bd9Sstevel@tonic-gate 	struct pollhead **phpp)
81887c478bd9Sstevel@tonic-gate {
81897c478bd9Sstevel@tonic-gate 	int events = (ushort_t)events_arg;
81907c478bd9Sstevel@tonic-gate 	int retevents = 0;
81917c478bd9Sstevel@tonic-gate 	mblk_t *mp;
81927c478bd9Sstevel@tonic-gate 	qband_t *qbp;
81937c478bd9Sstevel@tonic-gate 	long sd_flags = stp->sd_flag;
81947c478bd9Sstevel@tonic-gate 	int headlocked = 0;
81957c478bd9Sstevel@tonic-gate 
81967c478bd9Sstevel@tonic-gate 	/*
81977c478bd9Sstevel@tonic-gate 	 * For performance, a single 'if' tests for most possible edge
81987c478bd9Sstevel@tonic-gate 	 * conditions in one shot
81997c478bd9Sstevel@tonic-gate 	 */
82007c478bd9Sstevel@tonic-gate 	if (sd_flags & (STPLEX | STRDERR | STWRERR)) {
82017c478bd9Sstevel@tonic-gate 		if (sd_flags & STPLEX) {
82027c478bd9Sstevel@tonic-gate 			*reventsp = POLLNVAL;
82037c478bd9Sstevel@tonic-gate 			return (EINVAL);
82047c478bd9Sstevel@tonic-gate 		}
82057c478bd9Sstevel@tonic-gate 		if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) &&
82067c478bd9Sstevel@tonic-gate 		    (sd_flags & STRDERR)) ||
82077c478bd9Sstevel@tonic-gate 		    ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
82087c478bd9Sstevel@tonic-gate 		    (sd_flags & STWRERR))) {
82097c478bd9Sstevel@tonic-gate 			if (!(events & POLLNOERR)) {
82107c478bd9Sstevel@tonic-gate 				*reventsp = POLLERR;
82117c478bd9Sstevel@tonic-gate 				return (0);
82127c478bd9Sstevel@tonic-gate 			}
82137c478bd9Sstevel@tonic-gate 		}
82147c478bd9Sstevel@tonic-gate 	}
82157c478bd9Sstevel@tonic-gate 	if (sd_flags & STRHUP) {
82167c478bd9Sstevel@tonic-gate 		retevents |= POLLHUP;
82177c478bd9Sstevel@tonic-gate 	} else if (events & (POLLWRNORM | POLLWRBAND)) {
82187c478bd9Sstevel@tonic-gate 		queue_t *tq;
82197c478bd9Sstevel@tonic-gate 		queue_t	*qp = stp->sd_wrq;
82207c478bd9Sstevel@tonic-gate 
82217c478bd9Sstevel@tonic-gate 		claimstr(qp);
82227c478bd9Sstevel@tonic-gate 		/* Find next module forward that has a service procedure */
82237c478bd9Sstevel@tonic-gate 		tq = qp->q_next->q_nfsrv;
82247c478bd9Sstevel@tonic-gate 		ASSERT(tq != NULL);
82257c478bd9Sstevel@tonic-gate 
82267c478bd9Sstevel@tonic-gate 		polllock(&stp->sd_pollist, QLOCK(tq));
82277c478bd9Sstevel@tonic-gate 		if (events & POLLWRNORM) {
82287c478bd9Sstevel@tonic-gate 			queue_t *sqp;
82297c478bd9Sstevel@tonic-gate 
82307c478bd9Sstevel@tonic-gate 			if (tq->q_flag & QFULL)
82317c478bd9Sstevel@tonic-gate 				/* ensure backq svc procedure runs */
82327c478bd9Sstevel@tonic-gate 				tq->q_flag |= QWANTW;
82337c478bd9Sstevel@tonic-gate 			else if ((sqp = stp->sd_struiowrq) != NULL) {
82347c478bd9Sstevel@tonic-gate 				/* Check sync stream barrier write q */
82357c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(tq));
82367c478bd9Sstevel@tonic-gate 				polllock(&stp->sd_pollist, QLOCK(sqp));
82377c478bd9Sstevel@tonic-gate 				if (sqp->q_flag & QFULL)
82387c478bd9Sstevel@tonic-gate 					/* ensure pollwakeup() is done */
82397c478bd9Sstevel@tonic-gate 					sqp->q_flag |= QWANTWSYNC;
82407c478bd9Sstevel@tonic-gate 				else
82417c478bd9Sstevel@tonic-gate 					retevents |= POLLOUT;
82427c478bd9Sstevel@tonic-gate 				/* More write events to process ??? */
82437c478bd9Sstevel@tonic-gate 				if (! (events & POLLWRBAND)) {
82447c478bd9Sstevel@tonic-gate 					mutex_exit(QLOCK(sqp));
82457c478bd9Sstevel@tonic-gate 					releasestr(qp);
82467c478bd9Sstevel@tonic-gate 					goto chkrd;
82477c478bd9Sstevel@tonic-gate 				}
82487c478bd9Sstevel@tonic-gate 				mutex_exit(QLOCK(sqp));
82497c478bd9Sstevel@tonic-gate 				polllock(&stp->sd_pollist, QLOCK(tq));
82507c478bd9Sstevel@tonic-gate 			} else
82517c478bd9Sstevel@tonic-gate 				retevents |= POLLOUT;
82527c478bd9Sstevel@tonic-gate 		}
82537c478bd9Sstevel@tonic-gate 		if (events & POLLWRBAND) {
82547c478bd9Sstevel@tonic-gate 			qbp = tq->q_bandp;
82557c478bd9Sstevel@tonic-gate 			if (qbp) {
82567c478bd9Sstevel@tonic-gate 				while (qbp) {
82577c478bd9Sstevel@tonic-gate 					if (qbp->qb_flag & QB_FULL)
82587c478bd9Sstevel@tonic-gate 						qbp->qb_flag |= QB_WANTW;
82597c478bd9Sstevel@tonic-gate 					else
82607c478bd9Sstevel@tonic-gate 						retevents |= POLLWRBAND;
82617c478bd9Sstevel@tonic-gate 					qbp = qbp->qb_next;
82627c478bd9Sstevel@tonic-gate 				}
82637c478bd9Sstevel@tonic-gate 			} else {
82647c478bd9Sstevel@tonic-gate 				retevents |= POLLWRBAND;
82657c478bd9Sstevel@tonic-gate 			}
82667c478bd9Sstevel@tonic-gate 		}
82677c478bd9Sstevel@tonic-gate 		mutex_exit(QLOCK(tq));
82687c478bd9Sstevel@tonic-gate 		releasestr(qp);
82697c478bd9Sstevel@tonic-gate 	}
82707c478bd9Sstevel@tonic-gate chkrd:
82717c478bd9Sstevel@tonic-gate 	if (sd_flags & STRPRI) {
82727c478bd9Sstevel@tonic-gate 		retevents |= (events & POLLPRI);
82737c478bd9Sstevel@tonic-gate 	} else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) {
82747c478bd9Sstevel@tonic-gate 		queue_t	*qp = _RD(stp->sd_wrq);
82757c478bd9Sstevel@tonic-gate 		int normevents = (events & (POLLIN | POLLRDNORM));
82767c478bd9Sstevel@tonic-gate 
82777c478bd9Sstevel@tonic-gate 		/*
82787c478bd9Sstevel@tonic-gate 		 * Note: Need to do polllock() here since ps_lock may be
82797c478bd9Sstevel@tonic-gate 		 * held. See bug 4191544.
82807c478bd9Sstevel@tonic-gate 		 */
82817c478bd9Sstevel@tonic-gate 		polllock(&stp->sd_pollist, &stp->sd_lock);
82827c478bd9Sstevel@tonic-gate 		headlocked = 1;
82837c478bd9Sstevel@tonic-gate 		mp = qp->q_first;
82847c478bd9Sstevel@tonic-gate 		while (mp) {
82857c478bd9Sstevel@tonic-gate 			/*
82867c478bd9Sstevel@tonic-gate 			 * For POLLRDDATA we scan b_cont and b_next until we
82877c478bd9Sstevel@tonic-gate 			 * find an M_DATA.
82887c478bd9Sstevel@tonic-gate 			 */
82897c478bd9Sstevel@tonic-gate 			if ((events & POLLRDDATA) &&
82907c478bd9Sstevel@tonic-gate 			    mp->b_datap->db_type != M_DATA) {
82917c478bd9Sstevel@tonic-gate 				mblk_t *nmp = mp->b_cont;
82927c478bd9Sstevel@tonic-gate 
82937c478bd9Sstevel@tonic-gate 				while (nmp != NULL &&
82947c478bd9Sstevel@tonic-gate 				    nmp->b_datap->db_type != M_DATA)
82957c478bd9Sstevel@tonic-gate 					nmp = nmp->b_cont;
82967c478bd9Sstevel@tonic-gate 				if (nmp == NULL) {
82977c478bd9Sstevel@tonic-gate 					mp = mp->b_next;
82987c478bd9Sstevel@tonic-gate 					continue;
82997c478bd9Sstevel@tonic-gate 				}
83007c478bd9Sstevel@tonic-gate 			}
83017c478bd9Sstevel@tonic-gate 			if (mp->b_band == 0)
83027c478bd9Sstevel@tonic-gate 				retevents |= normevents;
83037c478bd9Sstevel@tonic-gate 			else
83047c478bd9Sstevel@tonic-gate 				retevents |= (events & (POLLIN | POLLRDBAND));
83057c478bd9Sstevel@tonic-gate 			break;
83067c478bd9Sstevel@tonic-gate 		}
83077c478bd9Sstevel@tonic-gate 		if (! (retevents & normevents) &&
83087c478bd9Sstevel@tonic-gate 		    (stp->sd_wakeq & RSLEEP)) {
83097c478bd9Sstevel@tonic-gate 			/*
83107c478bd9Sstevel@tonic-gate 			 * Sync stream barrier read queue has data.
83117c478bd9Sstevel@tonic-gate 			 */
83127c478bd9Sstevel@tonic-gate 			retevents |= normevents;
83137c478bd9Sstevel@tonic-gate 		}
83147c478bd9Sstevel@tonic-gate 		/* Treat eof as normal data */
83157c478bd9Sstevel@tonic-gate 		if (sd_flags & STREOF)
83167c478bd9Sstevel@tonic-gate 			retevents |= normevents;
83177c478bd9Sstevel@tonic-gate 	}
83187c478bd9Sstevel@tonic-gate 
83197c478bd9Sstevel@tonic-gate 	*reventsp = (short)retevents;
83207c478bd9Sstevel@tonic-gate 	if (retevents) {
83217c478bd9Sstevel@tonic-gate 		if (headlocked)
83227c478bd9Sstevel@tonic-gate 			mutex_exit(&stp->sd_lock);
83237c478bd9Sstevel@tonic-gate 		return (0);
83247c478bd9Sstevel@tonic-gate 	}
83257c478bd9Sstevel@tonic-gate 
83267c478bd9Sstevel@tonic-gate 	/*
83277c478bd9Sstevel@tonic-gate 	 * If poll() has not found any events yet, set up event cell
83287c478bd9Sstevel@tonic-gate 	 * to wake up the poll if a requested event occurs on this
83297c478bd9Sstevel@tonic-gate 	 * stream.  Check for collisions with outstanding poll requests.
83307c478bd9Sstevel@tonic-gate 	 */
83317c478bd9Sstevel@tonic-gate 	if (!anyyet) {
83327c478bd9Sstevel@tonic-gate 		*phpp = &stp->sd_pollist;
83337c478bd9Sstevel@tonic-gate 		if (headlocked == 0) {
83347c478bd9Sstevel@tonic-gate 			polllock(&stp->sd_pollist, &stp->sd_lock);
83357c478bd9Sstevel@tonic-gate 			headlocked = 1;
83367c478bd9Sstevel@tonic-gate 		}
83377c478bd9Sstevel@tonic-gate 		stp->sd_rput_opt |= SR_POLLIN;
83387c478bd9Sstevel@tonic-gate 	}
83397c478bd9Sstevel@tonic-gate 	if (headlocked)
83407c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
83417c478bd9Sstevel@tonic-gate 	return (0);
83427c478bd9Sstevel@tonic-gate }
83437c478bd9Sstevel@tonic-gate 
83447c478bd9Sstevel@tonic-gate /*
83457c478bd9Sstevel@tonic-gate  * The purpose of putback() is to assure sleeping polls/reads
83467c478bd9Sstevel@tonic-gate  * are awakened when there are no new messages arriving at the,
83477c478bd9Sstevel@tonic-gate  * stream head, and a message is placed back on the read queue.
83487c478bd9Sstevel@tonic-gate  *
83497c478bd9Sstevel@tonic-gate  * sd_lock must be held when messages are placed back on stream
83507c478bd9Sstevel@tonic-gate  * head.  (getq() holds sd_lock when it removes messages from
83517c478bd9Sstevel@tonic-gate  * the queue)
83527c478bd9Sstevel@tonic-gate  */
83537c478bd9Sstevel@tonic-gate 
83547c478bd9Sstevel@tonic-gate static void
83557c478bd9Sstevel@tonic-gate putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band)
83567c478bd9Sstevel@tonic-gate {
8357301ce41fSja97890 	mblk_t	*qfirst;
83587c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&stp->sd_lock));
83593584396bSja97890 
8360301ce41fSja97890 	/*
8361301ce41fSja97890 	 * As a result of lock-step ordering around q_lock and sd_lock,
8362301ce41fSja97890 	 * it's possible for function calls like putnext() and
8363301ce41fSja97890 	 * canputnext() to get an inaccurate picture of how much
8364301ce41fSja97890 	 * data is really being processed at the stream head.
8365301ce41fSja97890 	 * We only consolidate with existing messages on the queue
8366301ce41fSja97890 	 * if the length of the message we want to put back is smaller
8367301ce41fSja97890 	 * than the queue hiwater mark.
8368301ce41fSja97890 	 */
83693584396bSja97890 	if ((stp->sd_rput_opt & SR_CONSOL_DATA) &&
8370301ce41fSja97890 	    (DB_TYPE(bp) == M_DATA) && ((qfirst = q->q_first) != NULL) &&
8371301ce41fSja97890 	    (DB_TYPE(qfirst) == M_DATA) &&
8372301ce41fSja97890 	    ((qfirst->b_flag & (MSGMARK|MSGDELIM)) == 0) &&
8373301ce41fSja97890 	    ((bp->b_flag & (MSGMARK|MSGDELIM|MSGMARKNEXT)) == 0) &&
8374301ce41fSja97890 	    (mp_cont_len(bp, NULL) < q->q_hiwat)) {
83753584396bSja97890 		/*
83763584396bSja97890 		 * We use the same logic as defined in strrput()
83773584396bSja97890 		 * but in reverse as we are putting back onto the
83783584396bSja97890 		 * queue and want to retain byte ordering.
8379301ce41fSja97890 		 * Consolidate M_DATA messages with M_DATA ONLY.
8380301ce41fSja97890 		 * strrput() allows the consolidation of M_DATA onto
8381301ce41fSja97890 		 * M_PROTO | M_PCPROTO but not the other way round.
8382301ce41fSja97890 		 *
83833584396bSja97890 		 * The consolidation does not take place if the message
83843584396bSja97890 		 * we are returning to the queue is marked with either
83853584396bSja97890 		 * of the marks or the delim flag or if q_first
83863584396bSja97890 		 * is marked with MSGMARK. The MSGMARK check is needed to
83873584396bSja97890 		 * handle the odd semantics of MSGMARK where essentially
83883584396bSja97890 		 * the whole message is to be treated as marked.
83893584396bSja97890 		 * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from q_first
83903584396bSja97890 		 * to the front of the b_cont chain.
83913584396bSja97890 		 */
83923584396bSja97890 		rmvq_noenab(q, qfirst);
8393301ce41fSja97890 
83943584396bSja97890 		/*
83953584396bSja97890 		 * The first message in the b_cont list
83963584396bSja97890 		 * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
83973584396bSja97890 		 * We need to handle the case where we
83983584396bSja97890 		 * are appending:
83993584396bSja97890 		 *
84003584396bSja97890 		 * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
84013584396bSja97890 		 * 2) a MSGMARKNEXT to a plain message.
84023584396bSja97890 		 * 3) a MSGNOTMARKNEXT to a plain message
84033584396bSja97890 		 * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
84043584396bSja97890 		 *    message.
84053584396bSja97890 		 *
84063584396bSja97890 		 * Thus we never append a MSGMARKNEXT or
84073584396bSja97890 		 * MSGNOTMARKNEXT to a MSGMARKNEXT message.
84083584396bSja97890 		 */
84093584396bSja97890 		if (qfirst->b_flag & MSGMARKNEXT) {
84103584396bSja97890 			bp->b_flag |= MSGMARKNEXT;
84113584396bSja97890 			bp->b_flag &= ~MSGNOTMARKNEXT;
84123584396bSja97890 			qfirst->b_flag &= ~MSGMARKNEXT;
84133584396bSja97890 		} else if (qfirst->b_flag & MSGNOTMARKNEXT) {
84143584396bSja97890 			bp->b_flag |= MSGNOTMARKNEXT;
84153584396bSja97890 			qfirst->b_flag &= ~MSGNOTMARKNEXT;
84163584396bSja97890 		}
84173584396bSja97890 
84183584396bSja97890 		linkb(bp, qfirst);
84193584396bSja97890 	}
84207c478bd9Sstevel@tonic-gate 	(void) putbq(q, bp);
84213584396bSja97890 
84227c478bd9Sstevel@tonic-gate 	/*
84237c478bd9Sstevel@tonic-gate 	 * A message may have come in when the sd_lock was dropped in the
84247c478bd9Sstevel@tonic-gate 	 * calling routine. If this is the case and STR*ATMARK info was
84257c478bd9Sstevel@tonic-gate 	 * received, need to move that from the stream head to the q_last
84267c478bd9Sstevel@tonic-gate 	 * so that SIOCATMARK can return the proper value.
84277c478bd9Sstevel@tonic-gate 	 */
84287c478bd9Sstevel@tonic-gate 	if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) {
84297c478bd9Sstevel@tonic-gate 		unsigned short *flagp = &q->q_last->b_flag;
84307c478bd9Sstevel@tonic-gate 		uint_t b_flag = (uint_t)*flagp;
84317c478bd9Sstevel@tonic-gate 
84327c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRATMARK) {
84337c478bd9Sstevel@tonic-gate 			b_flag &= ~MSGNOTMARKNEXT;
84347c478bd9Sstevel@tonic-gate 			b_flag |= MSGMARKNEXT;
84357c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRATMARK;
84367c478bd9Sstevel@tonic-gate 		} else {
84377c478bd9Sstevel@tonic-gate 			b_flag &= ~MSGMARKNEXT;
84387c478bd9Sstevel@tonic-gate 			b_flag |= MSGNOTMARKNEXT;
84397c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~STRNOTATMARK;
84407c478bd9Sstevel@tonic-gate 		}
84417c478bd9Sstevel@tonic-gate 		*flagp = (unsigned short) b_flag;
84427c478bd9Sstevel@tonic-gate 	}
84437c478bd9Sstevel@tonic-gate 
84447c478bd9Sstevel@tonic-gate #ifdef	DEBUG
84457c478bd9Sstevel@tonic-gate 	/*
84467c478bd9Sstevel@tonic-gate 	 * Make sure that the flags are not messed up.
84477c478bd9Sstevel@tonic-gate 	 */
84487c478bd9Sstevel@tonic-gate 	{
84497c478bd9Sstevel@tonic-gate 		mblk_t *mp;
84507c478bd9Sstevel@tonic-gate 		mp = q->q_last;
84517c478bd9Sstevel@tonic-gate 		while (mp != NULL) {
84527c478bd9Sstevel@tonic-gate 			ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
84537c478bd9Sstevel@tonic-gate 			    (MSGMARKNEXT|MSGNOTMARKNEXT));
84547c478bd9Sstevel@tonic-gate 			mp = mp->b_cont;
84557c478bd9Sstevel@tonic-gate 		}
84567c478bd9Sstevel@tonic-gate 	}
84577c478bd9Sstevel@tonic-gate #endif
84587c478bd9Sstevel@tonic-gate 	if (q->q_first == bp) {
84597c478bd9Sstevel@tonic-gate 		short pollevents;
84607c478bd9Sstevel@tonic-gate 
84617c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & RSLEEP) {
84627c478bd9Sstevel@tonic-gate 			stp->sd_flag &= ~RSLEEP;
84637c478bd9Sstevel@tonic-gate 			cv_broadcast(&q->q_wait);
84647c478bd9Sstevel@tonic-gate 		}
84657c478bd9Sstevel@tonic-gate 		if (stp->sd_flag & STRPRI) {
84667c478bd9Sstevel@tonic-gate 			pollevents = POLLPRI;
84677c478bd9Sstevel@tonic-gate 		} else {
84687c478bd9Sstevel@tonic-gate 			if (band == 0) {
84697c478bd9Sstevel@tonic-gate 				if (!(stp->sd_rput_opt & SR_POLLIN))
84707c478bd9Sstevel@tonic-gate 					return;
84717c478bd9Sstevel@tonic-gate 				stp->sd_rput_opt &= ~SR_POLLIN;
84727c478bd9Sstevel@tonic-gate 				pollevents = POLLIN | POLLRDNORM;
84737c478bd9Sstevel@tonic-gate 			} else {
84747c478bd9Sstevel@tonic-gate 				pollevents = POLLIN | POLLRDBAND;
84757c478bd9Sstevel@tonic-gate 			}
84767c478bd9Sstevel@tonic-gate 		}
84777c478bd9Sstevel@tonic-gate 		mutex_exit(&stp->sd_lock);
84787c478bd9Sstevel@tonic-gate 		pollwakeup(&stp->sd_pollist, pollevents);
84797c478bd9Sstevel@tonic-gate 		mutex_enter(&stp->sd_lock);
84807c478bd9Sstevel@tonic-gate 	}
84817c478bd9Sstevel@tonic-gate }
84827c478bd9Sstevel@tonic-gate 
84837c478bd9Sstevel@tonic-gate /*
84847c478bd9Sstevel@tonic-gate  * Return the held vnode attached to the stream head of a
84857c478bd9Sstevel@tonic-gate  * given queue
84867c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
84877c478bd9Sstevel@tonic-gate  * that the queue does not go away (e.g. pop).
84887c478bd9Sstevel@tonic-gate  */
84897c478bd9Sstevel@tonic-gate vnode_t *
84907c478bd9Sstevel@tonic-gate strq2vp(queue_t *qp)
84917c478bd9Sstevel@tonic-gate {
84927c478bd9Sstevel@tonic-gate 	vnode_t *vp;
84937c478bd9Sstevel@tonic-gate 	vp = STREAM(qp)->sd_vnode;
84947c478bd9Sstevel@tonic-gate 	ASSERT(vp != NULL);
84957c478bd9Sstevel@tonic-gate 	VN_HOLD(vp);
84967c478bd9Sstevel@tonic-gate 	return (vp);
84977c478bd9Sstevel@tonic-gate }
84987c478bd9Sstevel@tonic-gate 
84997c478bd9Sstevel@tonic-gate /*
85007c478bd9Sstevel@tonic-gate  * return the stream head write queue for the given vp
85017c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
85027c478bd9Sstevel@tonic-gate  * that the stream or vnode do not close.
85037c478bd9Sstevel@tonic-gate  */
85047c478bd9Sstevel@tonic-gate queue_t *
85057c478bd9Sstevel@tonic-gate strvp2wq(vnode_t *vp)
85067c478bd9Sstevel@tonic-gate {
85077c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream != NULL);
85087c478bd9Sstevel@tonic-gate 	return (vp->v_stream->sd_wrq);
85097c478bd9Sstevel@tonic-gate }
85107c478bd9Sstevel@tonic-gate 
85117c478bd9Sstevel@tonic-gate /*
85127c478bd9Sstevel@tonic-gate  * pollwakeup stream head
85137c478bd9Sstevel@tonic-gate  * It is the responsibility of the calling routine to ensure
85147c478bd9Sstevel@tonic-gate  * that the stream or vnode do not close.
85157c478bd9Sstevel@tonic-gate  */
85167c478bd9Sstevel@tonic-gate void
85177c478bd9Sstevel@tonic-gate strpollwakeup(vnode_t *vp, short event)
85187c478bd9Sstevel@tonic-gate {
85197c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
85207c478bd9Sstevel@tonic-gate 	pollwakeup(&vp->v_stream->sd_pollist, event);
85217c478bd9Sstevel@tonic-gate }
85227c478bd9Sstevel@tonic-gate 
85237c478bd9Sstevel@tonic-gate /*
85247c478bd9Sstevel@tonic-gate  * Mate the stream heads of two vnodes together. If the two vnodes are the
85257c478bd9Sstevel@tonic-gate  * same, we just make the write-side point at the read-side -- otherwise,
85267c478bd9Sstevel@tonic-gate  * we do a full mate.  Only works on vnodes associated with streams that are
85277c478bd9Sstevel@tonic-gate  * still being built and thus have only a stream head.
85287c478bd9Sstevel@tonic-gate  */
85297c478bd9Sstevel@tonic-gate void
85307c478bd9Sstevel@tonic-gate strmate(vnode_t *vp1, vnode_t *vp2)
85317c478bd9Sstevel@tonic-gate {
85327c478bd9Sstevel@tonic-gate 	queue_t *wrq1 = strvp2wq(vp1);
85337c478bd9Sstevel@tonic-gate 	queue_t *wrq2 = strvp2wq(vp2);
85347c478bd9Sstevel@tonic-gate 
85357c478bd9Sstevel@tonic-gate 	/*
85367c478bd9Sstevel@tonic-gate 	 * Verify that there are no modules on the stream yet.  We also
85377c478bd9Sstevel@tonic-gate 	 * rely on the stream head always having a service procedure to
85387c478bd9Sstevel@tonic-gate 	 * avoid tweaking q_nfsrv.
85397c478bd9Sstevel@tonic-gate 	 */
85407c478bd9Sstevel@tonic-gate 	ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL);
85417c478bd9Sstevel@tonic-gate 	ASSERT(wrq1->q_qinfo->qi_srvp != NULL);
85427c478bd9Sstevel@tonic-gate 	ASSERT(wrq2->q_qinfo->qi_srvp != NULL);
85437c478bd9Sstevel@tonic-gate 
85447c478bd9Sstevel@tonic-gate 	/*
85457c478bd9Sstevel@tonic-gate 	 * If the queues are the same, just twist; otherwise do a full mate.
85467c478bd9Sstevel@tonic-gate 	 */
85477c478bd9Sstevel@tonic-gate 	if (wrq1 == wrq2) {
85487c478bd9Sstevel@tonic-gate 		wrq1->q_next = _RD(wrq1);
85497c478bd9Sstevel@tonic-gate 	} else {
85507c478bd9Sstevel@tonic-gate 		wrq1->q_next = _RD(wrq2);
85517c478bd9Sstevel@tonic-gate 		wrq2->q_next = _RD(wrq1);
85527c478bd9Sstevel@tonic-gate 		STREAM(wrq1)->sd_mate = STREAM(wrq2);
85537c478bd9Sstevel@tonic-gate 		STREAM(wrq1)->sd_flag |= STRMATE;
85547c478bd9Sstevel@tonic-gate 		STREAM(wrq2)->sd_mate = STREAM(wrq1);
85557c478bd9Sstevel@tonic-gate 		STREAM(wrq2)->sd_flag |= STRMATE;
85567c478bd9Sstevel@tonic-gate 	}
85577c478bd9Sstevel@tonic-gate }
85587c478bd9Sstevel@tonic-gate 
85597c478bd9Sstevel@tonic-gate /*
85607c478bd9Sstevel@tonic-gate  * XXX will go away when console is correctly fixed.
85617c478bd9Sstevel@tonic-gate  * Clean up the console PIDS, from previous I_SETSIG,
85627c478bd9Sstevel@tonic-gate  * called only for cnopen which never calls strclean().
85637c478bd9Sstevel@tonic-gate  */
85647c478bd9Sstevel@tonic-gate void
85657c478bd9Sstevel@tonic-gate str_cn_clean(struct vnode *vp)
85667c478bd9Sstevel@tonic-gate {
85677c478bd9Sstevel@tonic-gate 	strsig_t *ssp, *pssp, *tssp;
85687c478bd9Sstevel@tonic-gate 	struct stdata *stp;
85697c478bd9Sstevel@tonic-gate 	struct pid  *pidp;
85707c478bd9Sstevel@tonic-gate 	int update = 0;
85717c478bd9Sstevel@tonic-gate 
85727c478bd9Sstevel@tonic-gate 	ASSERT(vp->v_stream);
85737c478bd9Sstevel@tonic-gate 	stp = vp->v_stream;
85747c478bd9Sstevel@tonic-gate 	pssp = NULL;
85757c478bd9Sstevel@tonic-gate 	mutex_enter(&stp->sd_lock);
85767c478bd9Sstevel@tonic-gate 	ssp = stp->sd_siglist;
85777c478bd9Sstevel@tonic-gate 	while (ssp) {
85787c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
85797c478bd9Sstevel@tonic-gate 		pidp = ssp->ss_pidp;
85807c478bd9Sstevel@tonic-gate 		/*
85817c478bd9Sstevel@tonic-gate 		 * Get rid of PID if the proc is gone.
85827c478bd9Sstevel@tonic-gate 		 */
85837c478bd9Sstevel@tonic-gate 		if (pidp->pid_prinactive) {
85847c478bd9Sstevel@tonic-gate 			tssp = ssp->ss_next;
85857c478bd9Sstevel@tonic-gate 			if (pssp)
85867c478bd9Sstevel@tonic-gate 				pssp->ss_next = tssp;
85877c478bd9Sstevel@tonic-gate 			else
85887c478bd9Sstevel@tonic-gate 				stp->sd_siglist = tssp;
85897c478bd9Sstevel@tonic-gate 			ASSERT(pidp->pid_ref <= 1);
85907c478bd9Sstevel@tonic-gate 			PID_RELE(ssp->ss_pidp);
85917c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
85927c478bd9Sstevel@tonic-gate 			kmem_free(ssp, sizeof (strsig_t));
85937c478bd9Sstevel@tonic-gate 			update = 1;
85947c478bd9Sstevel@tonic-gate 			ssp = tssp;
85957c478bd9Sstevel@tonic-gate 			continue;
85967c478bd9Sstevel@tonic-gate 		} else
85977c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
85987c478bd9Sstevel@tonic-gate 		pssp = ssp;
85997c478bd9Sstevel@tonic-gate 		ssp = ssp->ss_next;
86007c478bd9Sstevel@tonic-gate 	}
86017c478bd9Sstevel@tonic-gate 	if (update) {
86027c478bd9Sstevel@tonic-gate 		stp->sd_sigflags = 0;
86037c478bd9Sstevel@tonic-gate 		for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
86047c478bd9Sstevel@tonic-gate 			stp->sd_sigflags |= ssp->ss_events;
86057c478bd9Sstevel@tonic-gate 	}
86067c478bd9Sstevel@tonic-gate 	mutex_exit(&stp->sd_lock);
86077c478bd9Sstevel@tonic-gate }
86087c478bd9Sstevel@tonic-gate 
86097c478bd9Sstevel@tonic-gate /*
86107c478bd9Sstevel@tonic-gate  * Return B_TRUE if there is data in the message, B_FALSE otherwise.
86117c478bd9Sstevel@tonic-gate  */
86127c478bd9Sstevel@tonic-gate static boolean_t
86137c478bd9Sstevel@tonic-gate msghasdata(mblk_t *bp)
86147c478bd9Sstevel@tonic-gate {
86157c478bd9Sstevel@tonic-gate 	for (; bp; bp = bp->b_cont)
86167c478bd9Sstevel@tonic-gate 		if (bp->b_datap->db_type == M_DATA) {
86177c478bd9Sstevel@tonic-gate 			ASSERT(bp->b_wptr >= bp->b_rptr);
86187c478bd9Sstevel@tonic-gate 			if (bp->b_wptr > bp->b_rptr)
86197c478bd9Sstevel@tonic-gate 				return (B_TRUE);
86207c478bd9Sstevel@tonic-gate 		}
86217c478bd9Sstevel@tonic-gate 	return (B_FALSE);
86227c478bd9Sstevel@tonic-gate }
8623