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 */
22c0423dd8SToomas Soome /* All Rights Reserved */
237c478bd9Sstevel@tonic-gate
247c478bd9Sstevel@tonic-gate
257c478bd9Sstevel@tonic-gate /*
2686c7bc49SAnil udupa * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
2780d5689fSPatrick Mooney * Copyright 2017 Joyent, Inc.
287d8deab2SAndy Fiddaman * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
297c478bd9Sstevel@tonic-gate */
307c478bd9Sstevel@tonic-gate
317c478bd9Sstevel@tonic-gate #include <sys/types.h>
327c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
337c478bd9Sstevel@tonic-gate #include <sys/param.h>
347c478bd9Sstevel@tonic-gate #include <sys/errno.h>
357c478bd9Sstevel@tonic-gate #include <sys/signal.h>
367c478bd9Sstevel@tonic-gate #include <sys/stat.h>
377c478bd9Sstevel@tonic-gate #include <sys/proc.h>
387c478bd9Sstevel@tonic-gate #include <sys/cred.h>
397c478bd9Sstevel@tonic-gate #include <sys/user.h>
407c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
417c478bd9Sstevel@tonic-gate #include <sys/file.h>
427c478bd9Sstevel@tonic-gate #include <sys/stream.h>
437c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
447c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
457c478bd9Sstevel@tonic-gate #include <sys/tihdr.h>
467c478bd9Sstevel@tonic-gate #include <sys/var.h>
477c478bd9Sstevel@tonic-gate #include <sys/poll.h>
487c478bd9Sstevel@tonic-gate #include <sys/termio.h>
497c478bd9Sstevel@tonic-gate #include <sys/ttold.h>
507c478bd9Sstevel@tonic-gate #include <sys/systm.h>
517c478bd9Sstevel@tonic-gate #include <sys/uio.h>
527c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
537c478bd9Sstevel@tonic-gate #include <sys/sad.h>
54f4b3ec61Sdh #include <sys/netstack.h>
557c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
567c478bd9Sstevel@tonic-gate #include <sys/jioctl.h>
577c478bd9Sstevel@tonic-gate #include <sys/procset.h>
587c478bd9Sstevel@tonic-gate #include <sys/session.h>
597c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
607c478bd9Sstevel@tonic-gate #include <sys/filio.h>
617c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
627c478bd9Sstevel@tonic-gate #include <sys/debug.h>
637c478bd9Sstevel@tonic-gate #include <sys/strredir.h>
647c478bd9Sstevel@tonic-gate #include <sys/fs/fifonode.h>
657c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
667c478bd9Sstevel@tonic-gate #include <sys/strlog.h>
677c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
687c478bd9Sstevel@tonic-gate #include <sys/project.h>
697c478bd9Sstevel@tonic-gate #include <sys/kbio.h>
707c478bd9Sstevel@tonic-gate #include <sys/msio.h>
717c478bd9Sstevel@tonic-gate #include <sys/tty.h>
727c478bd9Sstevel@tonic-gate #include <sys/ptyvar.h>
737c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h>
747c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
757c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
767c478bd9Sstevel@tonic-gate #include <sys/sunldi_impl.h>
777c478bd9Sstevel@tonic-gate #include <sys/autoconf.h>
787c478bd9Sstevel@tonic-gate #include <sys/policy.h>
79d62bc4baSyz #include <sys/dld.h>
80f4b3ec61Sdh #include <sys/zone.h>
817d8deab2SAndy Fiddaman #include <sys/ptms.h>
828e935259SBryan Cantrill #include <sys/limits.h>
83005d3febSMarek Pospisil #include <c2/audit.h>
847c478bd9Sstevel@tonic-gate
859acbbeafSnn /*
869acbbeafSnn * This define helps improve the readability of streams code while
879acbbeafSnn * still maintaining a very old streams performance enhancement. The
889acbbeafSnn * performance enhancement basically involved having all callers
899acbbeafSnn * of straccess() perform the first check that straccess() will do
909acbbeafSnn * locally before actually calling straccess(). (There by reducing
919acbbeafSnn * the number of unnecessary calls to straccess().)
929acbbeafSnn */
939acbbeafSnn #define i_straccess(x, y) ((stp->sd_sidp == NULL) ? 0 : \
949acbbeafSnn (stp->sd_vnode->v_type == VFIFO) ? 0 : \
959acbbeafSnn straccess((x), (y)))
969acbbeafSnn
977c478bd9Sstevel@tonic-gate /*
987c478bd9Sstevel@tonic-gate * what is mblk_pull_len?
997c478bd9Sstevel@tonic-gate *
1007c478bd9Sstevel@tonic-gate * If a streams message consists of many short messages,
1017c478bd9Sstevel@tonic-gate * a performance degradation occurs from copyout overhead.
1027c478bd9Sstevel@tonic-gate * To decrease the per mblk overhead, messages that are
1037c478bd9Sstevel@tonic-gate * likely to consist of many small mblks are pulled up into
1047c478bd9Sstevel@tonic-gate * one continuous chunk of memory.
1057c478bd9Sstevel@tonic-gate *
1067c478bd9Sstevel@tonic-gate * To avoid the processing overhead of examining every
1077c478bd9Sstevel@tonic-gate * mblk, a quick heuristic is used. If the first mblk in
1087c478bd9Sstevel@tonic-gate * the message is shorter than mblk_pull_len, it is likely
1097c478bd9Sstevel@tonic-gate * that the rest of the mblk will be short.
1107c478bd9Sstevel@tonic-gate *
1117c478bd9Sstevel@tonic-gate * This heuristic was decided upon after performance tests
1127c478bd9Sstevel@tonic-gate * indicated that anything more complex slowed down the main
1137c478bd9Sstevel@tonic-gate * code path.
1147c478bd9Sstevel@tonic-gate */
1157c478bd9Sstevel@tonic-gate #define MBLK_PULL_LEN 64
1167c478bd9Sstevel@tonic-gate uint32_t mblk_pull_len = MBLK_PULL_LEN;
1177c478bd9Sstevel@tonic-gate
1187c478bd9Sstevel@tonic-gate /*
1197c478bd9Sstevel@tonic-gate * The sgttyb_handling flag controls the handling of the old BSD
1207c478bd9Sstevel@tonic-gate * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:
1217c478bd9Sstevel@tonic-gate *
1227c478bd9Sstevel@tonic-gate * 0 - Emit no warnings at all and retain old, broken behavior.
1237c478bd9Sstevel@tonic-gate * 1 - Emit no warnings and silently handle new semantics.
1247c478bd9Sstevel@tonic-gate * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used
1257c478bd9Sstevel@tonic-gate * (once per system invocation). Handle with new semantics.
1267c478bd9Sstevel@tonic-gate * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is
1277c478bd9Sstevel@tonic-gate * made (so that offenders drop core and are easy to debug).
1287c478bd9Sstevel@tonic-gate *
1297c478bd9Sstevel@tonic-gate * The "new semantics" are that TIOCGETP returns B38400 for
1307c478bd9Sstevel@tonic-gate * sg_[io]speed if the corresponding value is over B38400, and that
1317c478bd9Sstevel@tonic-gate * TIOCSET[PN] accept B38400 in these cases to mean "retain current
1327c478bd9Sstevel@tonic-gate * bit rate."
1337c478bd9Sstevel@tonic-gate */
1347c478bd9Sstevel@tonic-gate int sgttyb_handling = 1;
1357c478bd9Sstevel@tonic-gate static boolean_t sgttyb_complaint;
1367c478bd9Sstevel@tonic-gate
1377c478bd9Sstevel@tonic-gate /* don't push drcompat module by default on Style-2 streams */
1387c478bd9Sstevel@tonic-gate static int push_drcompat = 0;
1397c478bd9Sstevel@tonic-gate
1407c478bd9Sstevel@tonic-gate /*
1417c478bd9Sstevel@tonic-gate * id value used to distinguish between different ioctl messages
1427c478bd9Sstevel@tonic-gate */
1437c478bd9Sstevel@tonic-gate static uint32_t ioc_id;
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate static void putback(struct stdata *, queue_t *, mblk_t *, int);
1467c478bd9Sstevel@tonic-gate static void strcleanall(struct vnode *);
1477c478bd9Sstevel@tonic-gate static int strwsrv(queue_t *);
148ca9327a6Smeem static int strdocmd(struct stdata *, struct strcmd *, cred_t *);
1497c478bd9Sstevel@tonic-gate
1507c478bd9Sstevel@tonic-gate /*
1517c478bd9Sstevel@tonic-gate * qinit and module_info structures for stream head read and write queues
1527c478bd9Sstevel@tonic-gate */
1537c478bd9Sstevel@tonic-gate struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };
1547c478bd9Sstevel@tonic-gate struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };
1557c478bd9Sstevel@tonic-gate struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };
1567c478bd9Sstevel@tonic-gate struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };
1577c478bd9Sstevel@tonic-gate struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,
1587c478bd9Sstevel@tonic-gate FIFOLOWAT };
1597c478bd9Sstevel@tonic-gate struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };
1607c478bd9Sstevel@tonic-gate struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };
1617c478bd9Sstevel@tonic-gate struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };
1627c478bd9Sstevel@tonic-gate
1637c478bd9Sstevel@tonic-gate extern kmutex_t strresources; /* protects global resources */
1647c478bd9Sstevel@tonic-gate extern kmutex_t muxifier; /* single-threads multiplexor creation */
1657c478bd9Sstevel@tonic-gate
1667c478bd9Sstevel@tonic-gate static boolean_t msghasdata(mblk_t *bp);
1677c478bd9Sstevel@tonic-gate #define msgnodata(bp) (!msghasdata(bp))
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate /*
1707c478bd9Sstevel@tonic-gate * Stream head locking notes:
1717c478bd9Sstevel@tonic-gate * There are four monitors associated with the stream head:
1727c478bd9Sstevel@tonic-gate * 1. v_stream monitor: in stropen() and strclose() v_lock
1737c478bd9Sstevel@tonic-gate * is held while the association of vnode and stream
1747c478bd9Sstevel@tonic-gate * head is established or tested for.
1757c478bd9Sstevel@tonic-gate * 2. open/close/push/pop monitor: sd_lock is held while each
1767c478bd9Sstevel@tonic-gate * thread bids for exclusive access to this monitor
1777c478bd9Sstevel@tonic-gate * for opening or closing a stream. In addition, this
1787c478bd9Sstevel@tonic-gate * monitor is entered during pushes and pops. This
1797c478bd9Sstevel@tonic-gate * guarantees that during plumbing operations there
1807c478bd9Sstevel@tonic-gate * is only one thread trying to change the plumbing.
1817c478bd9Sstevel@tonic-gate * Any other threads present in the stream are only
1827c478bd9Sstevel@tonic-gate * using the plumbing.
1837c478bd9Sstevel@tonic-gate * 3. read/write monitor: in the case of read, a thread holds
1847c478bd9Sstevel@tonic-gate * sd_lock while trying to get data from the stream
1857c478bd9Sstevel@tonic-gate * head queue. if there is none to fulfill a read
1867c478bd9Sstevel@tonic-gate * request, it sets RSLEEP and calls cv_wait_sig() down
1877c478bd9Sstevel@tonic-gate * in strwaitq() to await the arrival of new data.
1887c478bd9Sstevel@tonic-gate * when new data arrives in strrput(), sd_lock is acquired
1897c478bd9Sstevel@tonic-gate * before testing for RSLEEP and calling cv_broadcast().
1907c478bd9Sstevel@tonic-gate * the behavior of strwrite(), strwsrv(), and WSLEEP
1917c478bd9Sstevel@tonic-gate * mirror this.
1927c478bd9Sstevel@tonic-gate * 4. ioctl monitor: sd_lock is gotten to ensure that only one
1937c478bd9Sstevel@tonic-gate * thread is doing an ioctl at a time.
1947c478bd9Sstevel@tonic-gate */
1957c478bd9Sstevel@tonic-gate
1967c478bd9Sstevel@tonic-gate static int
push_mod(queue_t * qp,dev_t * devp,struct stdata * stp,const char * name,int anchor,cred_t * crp,uint_t anchor_zoneid)1977c478bd9Sstevel@tonic-gate push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,
198f4b3ec61Sdh int anchor, cred_t *crp, uint_t anchor_zoneid)
1997c478bd9Sstevel@tonic-gate {
2007c478bd9Sstevel@tonic-gate int error;
2017c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp;
2027c478bd9Sstevel@tonic-gate
2037c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {
2047c478bd9Sstevel@tonic-gate error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;
2057c478bd9Sstevel@tonic-gate return (error);
2067c478bd9Sstevel@tonic-gate }
2077c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush) {
2087c478bd9Sstevel@tonic-gate return (EINVAL);
2097c478bd9Sstevel@tonic-gate }
2107c478bd9Sstevel@tonic-gate
2117c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {
2127c478bd9Sstevel@tonic-gate stp->sd_flag |= STREOPENFAIL;
2137c478bd9Sstevel@tonic-gate return (EINVAL);
2147c478bd9Sstevel@tonic-gate }
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate /*
2177c478bd9Sstevel@tonic-gate * push new module and call its open routine via qattach
2187c478bd9Sstevel@tonic-gate */
2197c478bd9Sstevel@tonic-gate if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)
2207c478bd9Sstevel@tonic-gate return (error);
2217c478bd9Sstevel@tonic-gate
2227c478bd9Sstevel@tonic-gate /*
2237c478bd9Sstevel@tonic-gate * Check to see if caller wants a STREAMS anchor
2247c478bd9Sstevel@tonic-gate * put at this place in the stream, and add if so.
2257c478bd9Sstevel@tonic-gate */
2267c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
227f4b3ec61Sdh if (anchor == stp->sd_pushcnt) {
2287c478bd9Sstevel@tonic-gate stp->sd_anchor = stp->sd_pushcnt;
229f4b3ec61Sdh stp->sd_anchorzone = anchor_zoneid;
230f4b3ec61Sdh }
2317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
2327c478bd9Sstevel@tonic-gate
2337c478bd9Sstevel@tonic-gate return (0);
2347c478bd9Sstevel@tonic-gate }
2357c478bd9Sstevel@tonic-gate
2367d8deab2SAndy Fiddaman static int
xpg4_fixup(queue_t * qp,dev_t * devp,struct stdata * stp,cred_t * crp)2377d8deab2SAndy Fiddaman xpg4_fixup(queue_t *qp, dev_t *devp, struct stdata *stp, cred_t *crp)
2387d8deab2SAndy Fiddaman {
2397d8deab2SAndy Fiddaman static const char *ptsmods[] = {
2407d8deab2SAndy Fiddaman "ptem", "ldterm", "ttcompat"
2417d8deab2SAndy Fiddaman };
2427d8deab2SAndy Fiddaman dev_t dummydev = *devp;
2437d8deab2SAndy Fiddaman struct strioctl strioc;
2447d8deab2SAndy Fiddaman zoneid_t zoneid;
2457d8deab2SAndy Fiddaman int32_t rval;
2467d8deab2SAndy Fiddaman uint_t i;
2477d8deab2SAndy Fiddaman
2487d8deab2SAndy Fiddaman /*
2497d8deab2SAndy Fiddaman * Push modules required for the slave PTY to have terminal
2507d8deab2SAndy Fiddaman * semantics out of the box; this is required by XPG4v2.
2517d8deab2SAndy Fiddaman * These three modules are flagged as single-instance so that
2527d8deab2SAndy Fiddaman * the system will never end up with duplicate copies pushed
2537d8deab2SAndy Fiddaman * onto a stream.
2547d8deab2SAndy Fiddaman */
2557d8deab2SAndy Fiddaman
2567d8deab2SAndy Fiddaman zoneid = crgetzoneid(crp);
2577d8deab2SAndy Fiddaman for (i = 0; i < ARRAY_SIZE(ptsmods); i++) {
2587d8deab2SAndy Fiddaman int error;
2597d8deab2SAndy Fiddaman
2607d8deab2SAndy Fiddaman error = push_mod(qp, &dummydev, stp, ptsmods[i], 0,
2617d8deab2SAndy Fiddaman crp, zoneid);
2627d8deab2SAndy Fiddaman if (error != 0)
2637d8deab2SAndy Fiddaman return (error);
2647d8deab2SAndy Fiddaman }
2657d8deab2SAndy Fiddaman
2667d8deab2SAndy Fiddaman /*
2677d8deab2SAndy Fiddaman * Send PTSSTTY down the stream
2687d8deab2SAndy Fiddaman */
2697d8deab2SAndy Fiddaman
2707d8deab2SAndy Fiddaman strioc.ic_cmd = PTSSTTY;
2717d8deab2SAndy Fiddaman strioc.ic_timout = 0;
2727d8deab2SAndy Fiddaman strioc.ic_len = 0;
2737d8deab2SAndy Fiddaman strioc.ic_dp = NULL;
2747d8deab2SAndy Fiddaman
2757d8deab2SAndy Fiddaman (void) strdoioctl(stp, &strioc, FNATIVE, K_TO_K, crp, &rval);
2767d8deab2SAndy Fiddaman
2777d8deab2SAndy Fiddaman return (0);
2787d8deab2SAndy Fiddaman }
2797d8deab2SAndy Fiddaman
2807c478bd9Sstevel@tonic-gate /*
2817c478bd9Sstevel@tonic-gate * Open a stream device.
2827c478bd9Sstevel@tonic-gate */
2837c478bd9Sstevel@tonic-gate int
stropen(vnode_t * vp,dev_t * devp,int flag,cred_t * crp)2847c478bd9Sstevel@tonic-gate stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)
2857c478bd9Sstevel@tonic-gate {
2867c478bd9Sstevel@tonic-gate struct stdata *stp;
2877c478bd9Sstevel@tonic-gate queue_t *qp;
2887c478bd9Sstevel@tonic-gate int s;
289d62bc4baSyz dev_t dummydev, savedev;
2907c478bd9Sstevel@tonic-gate struct autopush *ap;
291d62bc4baSyz struct dlautopush dlap;
2927c478bd9Sstevel@tonic-gate int error = 0;
2937c478bd9Sstevel@tonic-gate ssize_t rmin, rmax;
2947c478bd9Sstevel@tonic-gate int cloneopen;
2957c478bd9Sstevel@tonic-gate queue_t *brq;
2967c478bd9Sstevel@tonic-gate major_t major;
297f4b3ec61Sdh str_stack_t *ss;
298f4b3ec61Sdh zoneid_t zoneid;
299f4b3ec61Sdh uint_t anchor;
3007c478bd9Sstevel@tonic-gate
3017c478bd9Sstevel@tonic-gate /*
3027c478bd9Sstevel@tonic-gate * If the stream already exists, wait for any open in progress
3037c478bd9Sstevel@tonic-gate * to complete, then call the open function of each module and
3047c478bd9Sstevel@tonic-gate * driver in the stream. Otherwise create the stream.
3057c478bd9Sstevel@tonic-gate */
3067c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);
3077c478bd9Sstevel@tonic-gate retry:
3087c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock);
3097c478bd9Sstevel@tonic-gate if ((stp = vp->v_stream) != NULL) {
3107c478bd9Sstevel@tonic-gate
3117c478bd9Sstevel@tonic-gate /*
3127c478bd9Sstevel@tonic-gate * Waiting for stream to be created to device
3137c478bd9Sstevel@tonic-gate * due to another open.
3147c478bd9Sstevel@tonic-gate */
315d3e55dcdSgww mutex_exit(&vp->v_lock);
3167c478bd9Sstevel@tonic-gate
317d3e55dcdSgww if (STRMATED(stp)) {
318d3e55dcdSgww struct stdata *strmatep = stp->sd_mate;
3197c478bd9Sstevel@tonic-gate
320d3e55dcdSgww STRLOCKMATES(stp);
321d3e55dcdSgww if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
322d3e55dcdSgww if (flag & (FNDELAY|FNONBLOCK)) {
323d3e55dcdSgww error = EAGAIN;
324d3e55dcdSgww mutex_exit(&strmatep->sd_lock);
325d3e55dcdSgww goto ckreturn;
326d3e55dcdSgww }
327d3e55dcdSgww mutex_exit(&stp->sd_lock);
328d3e55dcdSgww if (!cv_wait_sig(&strmatep->sd_monitor,
329d3e55dcdSgww &strmatep->sd_lock)) {
330d3e55dcdSgww error = EINTR;
331d3e55dcdSgww mutex_exit(&strmatep->sd_lock);
332d3e55dcdSgww mutex_enter(&stp->sd_lock);
333d3e55dcdSgww goto ckreturn;
334d3e55dcdSgww }
3357c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock);
336d3e55dcdSgww goto retry;
3377c478bd9Sstevel@tonic-gate }
338d3e55dcdSgww if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
339d3e55dcdSgww if (flag & (FNDELAY|FNONBLOCK)) {
340d3e55dcdSgww error = EAGAIN;
341d3e55dcdSgww mutex_exit(&strmatep->sd_lock);
342d3e55dcdSgww goto ckreturn;
343d3e55dcdSgww }
3447c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock);
345d3e55dcdSgww if (!cv_wait_sig(&stp->sd_monitor,
346d3e55dcdSgww &stp->sd_lock)) {
347d3e55dcdSgww error = EINTR;
348d3e55dcdSgww goto ckreturn;
349d3e55dcdSgww }
350d3e55dcdSgww mutex_exit(&stp->sd_lock);
351d3e55dcdSgww goto retry;
3527c478bd9Sstevel@tonic-gate }
353d3e55dcdSgww
354d3e55dcdSgww if (stp->sd_flag & (STRDERR|STWRERR)) {
355d3e55dcdSgww error = EIO;
3567c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock);
3577c478bd9Sstevel@tonic-gate goto ckreturn;
3587c478bd9Sstevel@tonic-gate }
3597c478bd9Sstevel@tonic-gate
360d3e55dcdSgww stp->sd_flag |= STWOPEN;
361d3e55dcdSgww STRUNLOCKMATES(stp);
362d3e55dcdSgww } else {
363d3e55dcdSgww mutex_enter(&stp->sd_lock);
364d3e55dcdSgww if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
365d3e55dcdSgww if (flag & (FNDELAY|FNONBLOCK)) {
366d3e55dcdSgww error = EAGAIN;
367d3e55dcdSgww goto ckreturn;
368d3e55dcdSgww }
369d3e55dcdSgww if (!cv_wait_sig(&stp->sd_monitor,
370d3e55dcdSgww &stp->sd_lock)) {
371d3e55dcdSgww error = EINTR;
372d3e55dcdSgww goto ckreturn;
373d3e55dcdSgww }
374d3e55dcdSgww mutex_exit(&stp->sd_lock);
375d3e55dcdSgww goto retry; /* could be clone! */
3767c478bd9Sstevel@tonic-gate }
377d3e55dcdSgww
378d3e55dcdSgww if (stp->sd_flag & (STRDERR|STWRERR)) {
379d3e55dcdSgww error = EIO;
3807c478bd9Sstevel@tonic-gate goto ckreturn;
3817c478bd9Sstevel@tonic-gate }
3827c478bd9Sstevel@tonic-gate
383d3e55dcdSgww stp->sd_flag |= STWOPEN;
384d3e55dcdSgww mutex_exit(&stp->sd_lock);
3857c478bd9Sstevel@tonic-gate }
3867c478bd9Sstevel@tonic-gate
3877c478bd9Sstevel@tonic-gate /*
3887c478bd9Sstevel@tonic-gate * Open all modules and devices down stream to notify
3897c478bd9Sstevel@tonic-gate * that another user is streaming. For modules, set the
3907c478bd9Sstevel@tonic-gate * last argument to MODOPEN and do not pass any open flags.
3917c478bd9Sstevel@tonic-gate * Ignore dummydev since this is not the first open.
3927c478bd9Sstevel@tonic-gate */
393d3e55dcdSgww claimstr(stp->sd_wrq);
394d3e55dcdSgww qp = stp->sd_wrq;
395d3e55dcdSgww while (_SAMESTR(qp)) {
396d3e55dcdSgww qp = qp->q_next;
397d3e55dcdSgww if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0)
398d3e55dcdSgww break;
399d3e55dcdSgww }
400d3e55dcdSgww releasestr(stp->sd_wrq);
401d3e55dcdSgww mutex_enter(&stp->sd_lock);
402d3e55dcdSgww stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR);
403d3e55dcdSgww stp->sd_rerror = 0;
404d3e55dcdSgww stp->sd_werror = 0;
4057c478bd9Sstevel@tonic-gate ckreturn:
406d3e55dcdSgww cv_broadcast(&stp->sd_monitor);
407d3e55dcdSgww mutex_exit(&stp->sd_lock);
408d3e55dcdSgww return (error);
4097c478bd9Sstevel@tonic-gate }
4107c478bd9Sstevel@tonic-gate
4117c478bd9Sstevel@tonic-gate /*
4127c478bd9Sstevel@tonic-gate * This vnode isn't streaming. SPECFS already
4137c478bd9Sstevel@tonic-gate * checked for multiple vnodes pointing to the
4147c478bd9Sstevel@tonic-gate * same stream, so create a stream to the driver.
4157c478bd9Sstevel@tonic-gate */
4167c478bd9Sstevel@tonic-gate qp = allocq();
4177c478bd9Sstevel@tonic-gate stp = shalloc(qp);
4187c478bd9Sstevel@tonic-gate
4197c478bd9Sstevel@tonic-gate /*
4207c478bd9Sstevel@tonic-gate * Initialize stream head. shalloc() has given us
4217c478bd9Sstevel@tonic-gate * exclusive access, and we have the vnode locked;
4227c478bd9Sstevel@tonic-gate * we can do whatever we want with stp.
4237c478bd9Sstevel@tonic-gate */
4247c478bd9Sstevel@tonic-gate stp->sd_flag = STWOPEN;
4257c478bd9Sstevel@tonic-gate stp->sd_siglist = NULL;
4267c478bd9Sstevel@tonic-gate stp->sd_pollist.ph_list = NULL;
4277c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
4287c478bd9Sstevel@tonic-gate stp->sd_mark = NULL;
4297c478bd9Sstevel@tonic-gate stp->sd_closetime = STRTIMOUT;
4307c478bd9Sstevel@tonic-gate stp->sd_sidp = NULL;
4317c478bd9Sstevel@tonic-gate stp->sd_pgidp = NULL;
4327c478bd9Sstevel@tonic-gate stp->sd_vnode = vp;
43378a2e113SAndy Fiddaman stp->sd_pvnode = NULL;
4347c478bd9Sstevel@tonic-gate stp->sd_rerror = 0;
4357c478bd9Sstevel@tonic-gate stp->sd_werror = 0;
4367c478bd9Sstevel@tonic-gate stp->sd_wroff = 0;
437c28749e9Skais stp->sd_tail = 0;
4387c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL;
439ca9327a6Smeem stp->sd_cmdblk = NULL;
4407c478bd9Sstevel@tonic-gate stp->sd_pushcnt = 0;
4417c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = 0;
4427c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = INFPSZ - 1; /* used to check for initialization */
4437c478bd9Sstevel@tonic-gate stp->sd_maxblk = INFPSZ;
4447c478bd9Sstevel@tonic-gate qp->q_ptr = _WR(qp)->q_ptr = stp;
4457c478bd9Sstevel@tonic-gate STREAM(qp) = STREAM(_WR(qp)) = stp;
4467c478bd9Sstevel@tonic-gate vp->v_stream = stp;
4477c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock);
4487c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) {
4497c478bd9Sstevel@tonic-gate stp->sd_flag |= OLDNDELAY;
4507c478bd9Sstevel@tonic-gate /*
4517c478bd9Sstevel@tonic-gate * This means, both for pipes and fifos
4527c478bd9Sstevel@tonic-gate * strwrite will send SIGPIPE if the other
4537c478bd9Sstevel@tonic-gate * end is closed. For putmsg it depends
4547c478bd9Sstevel@tonic-gate * on whether it is a XPG4_2 application
4557c478bd9Sstevel@tonic-gate * or not
4567c478bd9Sstevel@tonic-gate */
4577c478bd9Sstevel@tonic-gate stp->sd_wput_opt = SW_SIGPIPE;
4587c478bd9Sstevel@tonic-gate
4597c478bd9Sstevel@tonic-gate /* setq might sleep in kmem_alloc - avoid holding locks. */
4607c478bd9Sstevel@tonic-gate setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,
4617c478bd9Sstevel@tonic-gate SQ_CI|SQ_CO, B_FALSE);
4627c478bd9Sstevel@tonic-gate
4637c478bd9Sstevel@tonic-gate set_qend(qp);
464ad1660d0Smeem stp->sd_strtab = fifo_getinfo();
4657c478bd9Sstevel@tonic-gate _WR(qp)->q_nfsrv = _WR(qp);
4667c478bd9Sstevel@tonic-gate qp->q_nfsrv = qp;
4677c478bd9Sstevel@tonic-gate /*
4687c478bd9Sstevel@tonic-gate * Wake up others that are waiting for stream to be created.
4697c478bd9Sstevel@tonic-gate */
4707c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
4717c478bd9Sstevel@tonic-gate /*
4727c478bd9Sstevel@tonic-gate * nothing is be pushed on stream yet, so
4737c478bd9Sstevel@tonic-gate * optimized stream head packetsizes are just that
4747c478bd9Sstevel@tonic-gate * of the read queue
4757c478bd9Sstevel@tonic-gate */
4767c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = qp->q_minpsz;
4777c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = qp->q_maxpsz;
4787c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWOPEN;
4797c478bd9Sstevel@tonic-gate goto fifo_opendone;
4807c478bd9Sstevel@tonic-gate }
4817c478bd9Sstevel@tonic-gate /* setq might sleep in kmem_alloc - avoid holding locks. */
4827c478bd9Sstevel@tonic-gate setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);
4837c478bd9Sstevel@tonic-gate
4847c478bd9Sstevel@tonic-gate set_qend(qp);
4857c478bd9Sstevel@tonic-gate
4867c478bd9Sstevel@tonic-gate /*
4877c478bd9Sstevel@tonic-gate * Open driver and create stream to it (via qattach).
4887c478bd9Sstevel@tonic-gate */
489d62bc4baSyz savedev = *devp;
4907c478bd9Sstevel@tonic-gate cloneopen = (getmajor(*devp) == clone_major);
4917c478bd9Sstevel@tonic-gate if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {
4927c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock);
4937c478bd9Sstevel@tonic-gate vp->v_stream = NULL;
4947c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock);
4957c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
4967c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
4977c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
4987c478bd9Sstevel@tonic-gate freeq(_RD(qp));
4997c478bd9Sstevel@tonic-gate shfree(stp);
5007c478bd9Sstevel@tonic-gate return (error);
5017c478bd9Sstevel@tonic-gate }
5027c478bd9Sstevel@tonic-gate /*
5037c478bd9Sstevel@tonic-gate * Set sd_strtab after open in order to handle clonable drivers
5047c478bd9Sstevel@tonic-gate */
5057c478bd9Sstevel@tonic-gate stp->sd_strtab = STREAMSTAB(getmajor(*devp));
5067c478bd9Sstevel@tonic-gate
5077c478bd9Sstevel@tonic-gate /*
5087c478bd9Sstevel@tonic-gate * Historical note: dummydev used to be be prior to the initial
5097c478bd9Sstevel@tonic-gate * open (via qattach above), which made the value seen
5107c478bd9Sstevel@tonic-gate * inconsistent between an I_PUSH and an autopush of a module.
5117c478bd9Sstevel@tonic-gate */
5127c478bd9Sstevel@tonic-gate dummydev = *devp;
5137c478bd9Sstevel@tonic-gate
5147c478bd9Sstevel@tonic-gate /*
5157c478bd9Sstevel@tonic-gate * For clone open of old style (Q not associated) network driver,
5167c478bd9Sstevel@tonic-gate * push DRMODNAME module to handle DL_ATTACH/DL_DETACH
5177c478bd9Sstevel@tonic-gate */
5187c478bd9Sstevel@tonic-gate brq = _RD(_WR(qp)->q_next);
5197c478bd9Sstevel@tonic-gate major = getmajor(*devp);
5207c478bd9Sstevel@tonic-gate if (push_drcompat && cloneopen && NETWORK_DRV(major) &&
5217c478bd9Sstevel@tonic-gate ((brq->q_flag & _QASSOCIATED) == 0)) {
522f4b3ec61Sdh if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0)
5237c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "cannot push " DRMODNAME
5247c478bd9Sstevel@tonic-gate " streams module");
5257c478bd9Sstevel@tonic-gate }
5267c478bd9Sstevel@tonic-gate
527d62bc4baSyz if (!NETWORK_DRV(major)) {
528d62bc4baSyz savedev = *devp;
529d62bc4baSyz } else {
530d62bc4baSyz /*
531d62bc4baSyz * For network devices, process differently based on the
532d62bc4baSyz * return value from dld_autopush():
533d62bc4baSyz *
534d62bc4baSyz * 0: the passed-in device points to a GLDv3 datalink with
535d62bc4baSyz * per-link autopush configuration; use that configuration
536d62bc4baSyz * and ignore any per-driver autopush configuration.
537d62bc4baSyz *
538d62bc4baSyz * 1: the passed-in device points to a physical GLDv3
539d62bc4baSyz * datalink without per-link autopush configuration. The
540d62bc4baSyz * passed in device was changed to refer to the actual
541d62bc4baSyz * physical device (if it's not already); we use that new
542d62bc4baSyz * device to look up any per-driver autopush configuration.
543d62bc4baSyz *
544d62bc4baSyz * -1: neither of the above cases applied; use the initial
545d62bc4baSyz * device to look up any per-driver autopush configuration.
546d62bc4baSyz */
547d62bc4baSyz switch (dld_autopush(&savedev, &dlap)) {
548d62bc4baSyz case 0:
549d62bc4baSyz zoneid = crgetzoneid(crp);
550d62bc4baSyz for (s = 0; s < dlap.dap_npush; s++) {
551d62bc4baSyz error = push_mod(qp, &dummydev, stp,
552d62bc4baSyz dlap.dap_aplist[s], dlap.dap_anchor, crp,
553d62bc4baSyz zoneid);
554d62bc4baSyz if (error != 0)
555d62bc4baSyz break;
556d62bc4baSyz }
557d62bc4baSyz goto opendone;
558d62bc4baSyz case 1:
559d62bc4baSyz break;
560d62bc4baSyz case -1:
561d62bc4baSyz savedev = *devp;
562d62bc4baSyz break;
563d62bc4baSyz }
564d62bc4baSyz }
5657c478bd9Sstevel@tonic-gate /*
566d62bc4baSyz * Find the autopush configuration based on "savedev". Start with the
567d62bc4baSyz * global zone. If not found check in the local zone.
5687c478bd9Sstevel@tonic-gate */
569f4b3ec61Sdh zoneid = GLOBAL_ZONEID;
570f4b3ec61Sdh retryap:
571f4b3ec61Sdh ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))->
572f4b3ec61Sdh netstack_str;
573d62bc4baSyz if ((ap = sad_ap_find_by_dev(savedev, ss)) == NULL) {
574f4b3ec61Sdh netstack_rele(ss->ss_netstack);
575f4b3ec61Sdh if (zoneid == GLOBAL_ZONEID) {
576f4b3ec61Sdh /*
577f4b3ec61Sdh * None found. Also look in the zone's autopush table.
578f4b3ec61Sdh */
579f4b3ec61Sdh zoneid = crgetzoneid(crp);
580f4b3ec61Sdh if (zoneid != GLOBAL_ZONEID)
581f4b3ec61Sdh goto retryap;
582f4b3ec61Sdh }
5837c478bd9Sstevel@tonic-gate goto opendone;
584f4b3ec61Sdh }
585f4b3ec61Sdh anchor = ap->ap_anchor;
586f4b3ec61Sdh zoneid = crgetzoneid(crp);
5877c478bd9Sstevel@tonic-gate for (s = 0; s < ap->ap_npush; s++) {
5887c478bd9Sstevel@tonic-gate error = push_mod(qp, &dummydev, stp, ap->ap_list[s],
589f4b3ec61Sdh anchor, crp, zoneid);
5907c478bd9Sstevel@tonic-gate if (error != 0)
5917c478bd9Sstevel@tonic-gate break;
5927c478bd9Sstevel@tonic-gate }
593f4b3ec61Sdh sad_ap_rele(ap, ss);
594f4b3ec61Sdh netstack_rele(ss->ss_netstack);
5957c478bd9Sstevel@tonic-gate
596d62bc4baSyz opendone:
597d62bc4baSyz
5987d8deab2SAndy Fiddaman if (error == 0 &&
5997d8deab2SAndy Fiddaman (stp->sd_flag & (STRISTTY|STRXPG4TTY)) == (STRISTTY|STRXPG4TTY)) {
6007d8deab2SAndy Fiddaman error = xpg4_fixup(qp, devp, stp, crp);
6017d8deab2SAndy Fiddaman }
6027d8deab2SAndy Fiddaman
6037c478bd9Sstevel@tonic-gate /*
6047c478bd9Sstevel@tonic-gate * let specfs know that open failed part way through
6057c478bd9Sstevel@tonic-gate */
6067d8deab2SAndy Fiddaman if (error != 0) {
6077c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
6087c478bd9Sstevel@tonic-gate stp->sd_flag |= STREOPENFAIL;
6097c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
6107c478bd9Sstevel@tonic-gate }
6117c478bd9Sstevel@tonic-gate
6127c478bd9Sstevel@tonic-gate /*
6137c478bd9Sstevel@tonic-gate * Wake up others that are waiting for stream to be created.
6147c478bd9Sstevel@tonic-gate */
6157c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
6167c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWOPEN;
6177c478bd9Sstevel@tonic-gate
6187c478bd9Sstevel@tonic-gate /*
6197c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of
6207c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream
6217c478bd9Sstevel@tonic-gate * head in the stream head.
6227c478bd9Sstevel@tonic-gate */
6237c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next));
6247c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz;
6257c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz;
6267c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next));
6277c478bd9Sstevel@tonic-gate
6287c478bd9Sstevel@tonic-gate /* do this processing here as a performance concern */
6297c478bd9Sstevel@tonic-gate if (strmsgsz != 0) {
6307c478bd9Sstevel@tonic-gate if (rmax == INFPSZ)
6317c478bd9Sstevel@tonic-gate rmax = strmsgsz;
6327c478bd9Sstevel@tonic-gate else
6337c478bd9Sstevel@tonic-gate rmax = MIN(strmsgsz, rmax);
6347c478bd9Sstevel@tonic-gate }
6357c478bd9Sstevel@tonic-gate
6367c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq));
6377c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin;
6387c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax;
6397c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq));
6407c478bd9Sstevel@tonic-gate
6417c478bd9Sstevel@tonic-gate fifo_opendone:
6427c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
6437c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
6447c478bd9Sstevel@tonic-gate return (error);
6457c478bd9Sstevel@tonic-gate }
6467c478bd9Sstevel@tonic-gate
6477c478bd9Sstevel@tonic-gate static int strsink(queue_t *, mblk_t *);
6487c478bd9Sstevel@tonic-gate static struct qinit deadrend = {
6497c478bd9Sstevel@tonic-gate strsink, NULL, NULL, NULL, NULL, &strm_info, NULL
6507c478bd9Sstevel@tonic-gate };
6517c478bd9Sstevel@tonic-gate static struct qinit deadwend = {
6527c478bd9Sstevel@tonic-gate NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL
6537c478bd9Sstevel@tonic-gate };
6547c478bd9Sstevel@tonic-gate
6557c478bd9Sstevel@tonic-gate /*
6567c478bd9Sstevel@tonic-gate * Close a stream.
6577c478bd9Sstevel@tonic-gate * This is called from closef() on the last close of an open stream.
6587c478bd9Sstevel@tonic-gate * Strclean() will already have removed the siglist and pollist
6597c478bd9Sstevel@tonic-gate * information, so all that remains is to remove all multiplexor links
6607c478bd9Sstevel@tonic-gate * for the stream, pop all the modules (and the driver), and free the
6617c478bd9Sstevel@tonic-gate * stream structure.
6627c478bd9Sstevel@tonic-gate */
6637c478bd9Sstevel@tonic-gate
6647c478bd9Sstevel@tonic-gate int
strclose(struct vnode * vp,int flag,cred_t * crp)6657c478bd9Sstevel@tonic-gate strclose(struct vnode *vp, int flag, cred_t *crp)
6667c478bd9Sstevel@tonic-gate {
6677c478bd9Sstevel@tonic-gate struct stdata *stp;
6687c478bd9Sstevel@tonic-gate queue_t *qp;
6697c478bd9Sstevel@tonic-gate int rval;
6707c478bd9Sstevel@tonic-gate int freestp = 1;
6717c478bd9Sstevel@tonic-gate queue_t *rmq;
6727c478bd9Sstevel@tonic-gate
6737c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
674d3e55dcdSgww TR_STRCLOSE, "strclose:%p", vp);
6757c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
6767c478bd9Sstevel@tonic-gate
6777c478bd9Sstevel@tonic-gate stp = vp->v_stream;
6787c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX));
6797c478bd9Sstevel@tonic-gate qp = stp->sd_wrq;
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate /*
6827c478bd9Sstevel@tonic-gate * Needed so that strpoll will return non-zero for this fd.
6837c478bd9Sstevel@tonic-gate * Note that with POLLNOERR STRHUP does still cause POLLHUP.
6847c478bd9Sstevel@tonic-gate */
6857c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
6867c478bd9Sstevel@tonic-gate stp->sd_flag |= STRHUP;
6877c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate /*
6907c478bd9Sstevel@tonic-gate * If the registered process or process group did not have an
6917c478bd9Sstevel@tonic-gate * open instance of this stream then strclean would not be
6927c478bd9Sstevel@tonic-gate * called. Thus at the time of closing all remaining siglist entries
6937c478bd9Sstevel@tonic-gate * are removed.
6947c478bd9Sstevel@tonic-gate */
6957c478bd9Sstevel@tonic-gate if (stp->sd_siglist != NULL)
6967c478bd9Sstevel@tonic-gate strcleanall(vp);
6977c478bd9Sstevel@tonic-gate
6987c478bd9Sstevel@tonic-gate ASSERT(stp->sd_siglist == NULL);
6997c478bd9Sstevel@tonic-gate ASSERT(stp->sd_sigflags == 0);
7007c478bd9Sstevel@tonic-gate
7017c478bd9Sstevel@tonic-gate if (STRMATED(stp)) {
7027c478bd9Sstevel@tonic-gate struct stdata *strmatep = stp->sd_mate;
7037c478bd9Sstevel@tonic-gate int waited = 1;
7047c478bd9Sstevel@tonic-gate
7057c478bd9Sstevel@tonic-gate STRLOCKMATES(stp);
7067c478bd9Sstevel@tonic-gate while (waited) {
7077c478bd9Sstevel@tonic-gate waited = 0;
7087c478bd9Sstevel@tonic-gate while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {
7097c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock);
7107c478bd9Sstevel@tonic-gate cv_wait(&stp->sd_monitor, &stp->sd_lock);
7117c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
7127c478bd9Sstevel@tonic-gate STRLOCKMATES(stp);
7137c478bd9Sstevel@tonic-gate waited = 1;
7147c478bd9Sstevel@tonic-gate }
7157c478bd9Sstevel@tonic-gate while (strmatep->sd_flag &
7167c478bd9Sstevel@tonic-gate (STWOPEN|STRCLOSE|STRPLUMB)) {
7177c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
7187c478bd9Sstevel@tonic-gate cv_wait(&strmatep->sd_monitor,
7197c478bd9Sstevel@tonic-gate &strmatep->sd_lock);
7207c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock);
7217c478bd9Sstevel@tonic-gate STRLOCKMATES(stp);
7227c478bd9Sstevel@tonic-gate waited = 1;
7237c478bd9Sstevel@tonic-gate }
7247c478bd9Sstevel@tonic-gate }
7257c478bd9Sstevel@tonic-gate stp->sd_flag |= STRCLOSE;
7267c478bd9Sstevel@tonic-gate STRUNLOCKMATES(stp);
7277c478bd9Sstevel@tonic-gate } else {
7287c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
7297c478bd9Sstevel@tonic-gate stp->sd_flag |= STRCLOSE;
7307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
7317c478bd9Sstevel@tonic-gate }
7327c478bd9Sstevel@tonic-gate
7337c478bd9Sstevel@tonic-gate ASSERT(qp->q_first == NULL); /* No more delayed write */
7347c478bd9Sstevel@tonic-gate
7357c478bd9Sstevel@tonic-gate /* Check if an I_LINK was ever done on this stream */
7367c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHASLINKS) {
737f4b3ec61Sdh netstack_t *ns;
738f4b3ec61Sdh str_stack_t *ss;
739f4b3ec61Sdh
740f4b3ec61Sdh ns = netstack_find_by_cred(crp);
741f4b3ec61Sdh ASSERT(ns != NULL);
742f4b3ec61Sdh ss = ns->netstack_str;
743f4b3ec61Sdh ASSERT(ss != NULL);
744f4b3ec61Sdh
745f4b3ec61Sdh (void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss);
746f4b3ec61Sdh netstack_rele(ss->ss_netstack);
7477c478bd9Sstevel@tonic-gate }
7487c478bd9Sstevel@tonic-gate
7497c478bd9Sstevel@tonic-gate while (_SAMESTR(qp)) {
7507c478bd9Sstevel@tonic-gate /*
7517c478bd9Sstevel@tonic-gate * Holding sd_lock prevents q_next from changing in
7527c478bd9Sstevel@tonic-gate * this stream.
7537c478bd9Sstevel@tonic-gate */
7547c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
7557c478bd9Sstevel@tonic-gate if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) {
7567c478bd9Sstevel@tonic-gate
7577c478bd9Sstevel@tonic-gate /*
7587c478bd9Sstevel@tonic-gate * sleep until awakened by strwsrv() or timeout
7597c478bd9Sstevel@tonic-gate */
7607c478bd9Sstevel@tonic-gate for (;;) {
7617c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(qp->q_next));
7627c478bd9Sstevel@tonic-gate if (!(qp->q_next->q_mblkcnt)) {
7637c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(qp->q_next));
7647c478bd9Sstevel@tonic-gate break;
7657c478bd9Sstevel@tonic-gate }
7667c478bd9Sstevel@tonic-gate stp->sd_flag |= WSLEEP;
7677c478bd9Sstevel@tonic-gate
7687c478bd9Sstevel@tonic-gate /* ensure strwsrv gets enabled */
7697c478bd9Sstevel@tonic-gate qp->q_next->q_flag |= QWANTW;
7707c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(qp->q_next));
7717c478bd9Sstevel@tonic-gate /* get out if we timed out or recv'd a signal */
7727c478bd9Sstevel@tonic-gate if (str_cv_wait(&qp->q_wait, &stp->sd_lock,
7737c478bd9Sstevel@tonic-gate stp->sd_closetime, 0) <= 0) {
7747c478bd9Sstevel@tonic-gate break;
7757c478bd9Sstevel@tonic-gate }
7767c478bd9Sstevel@tonic-gate }
7777c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP;
7787c478bd9Sstevel@tonic-gate }
7797c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
7807c478bd9Sstevel@tonic-gate
7817c478bd9Sstevel@tonic-gate rmq = qp->q_next;
7827c478bd9Sstevel@tonic-gate if (rmq->q_flag & QISDRV) {
7837c478bd9Sstevel@tonic-gate ASSERT(!_SAMESTR(rmq));
7847c478bd9Sstevel@tonic-gate wait_sq_svc(_RD(qp)->q_syncq);
7857c478bd9Sstevel@tonic-gate }
7867c478bd9Sstevel@tonic-gate
7877c478bd9Sstevel@tonic-gate qdetach(_RD(rmq), 1, flag, crp, B_FALSE);
7887c478bd9Sstevel@tonic-gate }
7897c478bd9Sstevel@tonic-gate
7908ec5a142Sedp /*
7918ec5a142Sedp * Since we call pollwakeup in close() now, the poll list should
7928ec5a142Sedp * be empty in most cases. The only exception is the layered devices
7938ec5a142Sedp * (e.g. the console drivers with redirection modules pushed on top
7948ec5a142Sedp * of it). We have to do this after calling qdetach() because
7958ec5a142Sedp * the redirection module won't have torn down the console
7968ec5a142Sedp * redirection until after qdetach() has been invoked.
7978ec5a142Sedp */
7988ec5a142Sedp if (stp->sd_pollist.ph_list != NULL) {
7998ec5a142Sedp pollwakeup(&stp->sd_pollist, POLLERR);
8008ec5a142Sedp pollhead_clean(&stp->sd_pollist);
8018ec5a142Sedp }
8028ec5a142Sedp ASSERT(stp->sd_pollist.ph_list == NULL);
8038ec5a142Sedp ASSERT(stp->sd_sidp == NULL);
8048ec5a142Sedp ASSERT(stp->sd_pgidp == NULL);
8058ec5a142Sedp
8067c478bd9Sstevel@tonic-gate /* Prevent qenable from re-enabling the stream head queue */
8077c478bd9Sstevel@tonic-gate disable_svc(_RD(qp));
8087c478bd9Sstevel@tonic-gate
8097c478bd9Sstevel@tonic-gate /*
8107c478bd9Sstevel@tonic-gate * Wait until service procedure of each queue is
8117c478bd9Sstevel@tonic-gate * run, if QINSERVICE is set.
8127c478bd9Sstevel@tonic-gate */
8137c478bd9Sstevel@tonic-gate wait_svc(_RD(qp));
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate /*
8167c478bd9Sstevel@tonic-gate * Now, flush both queues.
8177c478bd9Sstevel@tonic-gate */
8187c478bd9Sstevel@tonic-gate flushq(_RD(qp), FLUSHALL);
8197c478bd9Sstevel@tonic-gate flushq(qp, FLUSHALL);
8207c478bd9Sstevel@tonic-gate
8217c478bd9Sstevel@tonic-gate /*
8227c478bd9Sstevel@tonic-gate * If the write queue of the stream head is pointing to a
8237c478bd9Sstevel@tonic-gate * read queue, we have a twisted stream. If the read queue
8247c478bd9Sstevel@tonic-gate * is alive, convert the stream head queues into a dead end.
8257c478bd9Sstevel@tonic-gate * If the read queue is dead, free the dead pair.
8267c478bd9Sstevel@tonic-gate */
8277c478bd9Sstevel@tonic-gate if (qp->q_next && !_SAMESTR(qp)) {
8287c478bd9Sstevel@tonic-gate if (qp->q_next->q_qinfo == &deadrend) { /* half-closed pipe */
8297c478bd9Sstevel@tonic-gate flushq(qp->q_next, FLUSHALL); /* ensure no message */
8307c478bd9Sstevel@tonic-gate shfree(qp->q_next->q_stream);
8317c478bd9Sstevel@tonic-gate freeq(qp->q_next);
8327c478bd9Sstevel@tonic-gate freeq(_RD(qp));
8337c478bd9Sstevel@tonic-gate } else if (qp->q_next == _RD(qp)) { /* fifo */
8347c478bd9Sstevel@tonic-gate freeq(_RD(qp));
8357c478bd9Sstevel@tonic-gate } else { /* pipe */
8367c478bd9Sstevel@tonic-gate freestp = 0;
8377c478bd9Sstevel@tonic-gate /*
8387c478bd9Sstevel@tonic-gate * The q_info pointers are never accessed when
8397c478bd9Sstevel@tonic-gate * SQLOCK is held.
8407c478bd9Sstevel@tonic-gate */
8417c478bd9Sstevel@tonic-gate ASSERT(qp->q_syncq == _RD(qp)->q_syncq);
8427c478bd9Sstevel@tonic-gate mutex_enter(SQLOCK(qp->q_syncq));
8437c478bd9Sstevel@tonic-gate qp->q_qinfo = &deadwend;
8447c478bd9Sstevel@tonic-gate _RD(qp)->q_qinfo = &deadrend;
8457c478bd9Sstevel@tonic-gate mutex_exit(SQLOCK(qp->q_syncq));
8467c478bd9Sstevel@tonic-gate }
8477c478bd9Sstevel@tonic-gate } else {
8487c478bd9Sstevel@tonic-gate freeq(_RD(qp)); /* free stream head queue pair */
8497c478bd9Sstevel@tonic-gate }
8507c478bd9Sstevel@tonic-gate
8517c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock);
8527c478bd9Sstevel@tonic-gate if (stp->sd_iocblk) {
8537c478bd9Sstevel@tonic-gate if (stp->sd_iocblk != (mblk_t *)-1) {
8547c478bd9Sstevel@tonic-gate freemsg(stp->sd_iocblk);
8557c478bd9Sstevel@tonic-gate }
8567c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL;
8577c478bd9Sstevel@tonic-gate }
85878a2e113SAndy Fiddaman stp->sd_vnode = stp->sd_pvnode = NULL;
8597c478bd9Sstevel@tonic-gate vp->v_stream = NULL;
8607c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock);
8617c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
862ca9327a6Smeem freemsg(stp->sd_cmdblk);
863ca9327a6Smeem stp->sd_cmdblk = NULL;
8647c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRCLOSE;
8657c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
8667c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
8677c478bd9Sstevel@tonic-gate
8687c478bd9Sstevel@tonic-gate if (freestp)
8697c478bd9Sstevel@tonic-gate shfree(stp);
8707c478bd9Sstevel@tonic-gate return (0);
8717c478bd9Sstevel@tonic-gate }
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate static int
strsink(queue_t * q,mblk_t * bp)8747c478bd9Sstevel@tonic-gate strsink(queue_t *q, mblk_t *bp)
8757c478bd9Sstevel@tonic-gate {
8767c478bd9Sstevel@tonic-gate struct copyresp *resp;
8777c478bd9Sstevel@tonic-gate
8787c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
8797c478bd9Sstevel@tonic-gate case M_FLUSH:
8807c478bd9Sstevel@tonic-gate if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
8817c478bd9Sstevel@tonic-gate *bp->b_rptr &= ~FLUSHR;
8827c478bd9Sstevel@tonic-gate bp->b_flag |= MSGNOLOOP;
8837c478bd9Sstevel@tonic-gate /*
8847c478bd9Sstevel@tonic-gate * Protect against the driver passing up
8857c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
8867c478bd9Sstevel@tonic-gate */
8877c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
8887c478bd9Sstevel@tonic-gate freemsg(bp);
8897c478bd9Sstevel@tonic-gate else
8907c478bd9Sstevel@tonic-gate qreply(q, bp);
8917c478bd9Sstevel@tonic-gate } else {
8927c478bd9Sstevel@tonic-gate freemsg(bp);
8937c478bd9Sstevel@tonic-gate }
8947c478bd9Sstevel@tonic-gate break;
8957c478bd9Sstevel@tonic-gate
8967c478bd9Sstevel@tonic-gate case M_COPYIN:
8977c478bd9Sstevel@tonic-gate case M_COPYOUT:
8987c478bd9Sstevel@tonic-gate if (bp->b_cont) {
8997c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
9007c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
9017c478bd9Sstevel@tonic-gate }
9027c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA;
9037c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
9047c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr;
9057c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)1; /* failure */
9067c478bd9Sstevel@tonic-gate /*
9077c478bd9Sstevel@tonic-gate * Protect against the driver passing up
9087c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
9097c478bd9Sstevel@tonic-gate */
9107c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
9117c478bd9Sstevel@tonic-gate freemsg(bp);
9127c478bd9Sstevel@tonic-gate else
9137c478bd9Sstevel@tonic-gate qreply(q, bp);
9147c478bd9Sstevel@tonic-gate break;
9157c478bd9Sstevel@tonic-gate
9167c478bd9Sstevel@tonic-gate case M_IOCTL:
9177c478bd9Sstevel@tonic-gate if (bp->b_cont) {
9187c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
9197c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
9207c478bd9Sstevel@tonic-gate }
9217c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK;
9227c478bd9Sstevel@tonic-gate /*
9237c478bd9Sstevel@tonic-gate * Protect against the driver passing up
9247c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
9257c478bd9Sstevel@tonic-gate */
9267c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
9277c478bd9Sstevel@tonic-gate freemsg(bp);
9287c478bd9Sstevel@tonic-gate else
9297c478bd9Sstevel@tonic-gate qreply(q, bp);
9307c478bd9Sstevel@tonic-gate break;
9317c478bd9Sstevel@tonic-gate
9327c478bd9Sstevel@tonic-gate default:
9337c478bd9Sstevel@tonic-gate freemsg(bp);
9347c478bd9Sstevel@tonic-gate break;
9357c478bd9Sstevel@tonic-gate }
9367c478bd9Sstevel@tonic-gate
9377c478bd9Sstevel@tonic-gate return (0);
9387c478bd9Sstevel@tonic-gate }
9397c478bd9Sstevel@tonic-gate
9407c478bd9Sstevel@tonic-gate /*
9417c478bd9Sstevel@tonic-gate * Clean up after a process when it closes a stream. This is called
9427c478bd9Sstevel@tonic-gate * from closef for all closes, whereas strclose is called only for the
9437c478bd9Sstevel@tonic-gate * last close on a stream. The siglist is scanned for entries for the
9447c478bd9Sstevel@tonic-gate * current process, and these are removed.
9457c478bd9Sstevel@tonic-gate */
9467c478bd9Sstevel@tonic-gate void
strclean(struct vnode * vp)9477c478bd9Sstevel@tonic-gate strclean(struct vnode *vp)
9487c478bd9Sstevel@tonic-gate {
9497c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp, *tssp;
9507c478bd9Sstevel@tonic-gate stdata_t *stp;
9517c478bd9Sstevel@tonic-gate int update = 0;
9527c478bd9Sstevel@tonic-gate
9537c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
954d3e55dcdSgww TR_STRCLEAN, "strclean:%p", vp);
9557c478bd9Sstevel@tonic-gate stp = vp->v_stream;
9567c478bd9Sstevel@tonic-gate pssp = NULL;
9577c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
9587c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist;
9597c478bd9Sstevel@tonic-gate while (ssp) {
9607c478bd9Sstevel@tonic-gate if (ssp->ss_pidp == curproc->p_pidp) {
9617c478bd9Sstevel@tonic-gate tssp = ssp->ss_next;
9627c478bd9Sstevel@tonic-gate if (pssp)
9637c478bd9Sstevel@tonic-gate pssp->ss_next = tssp;
9647c478bd9Sstevel@tonic-gate else
9657c478bd9Sstevel@tonic-gate stp->sd_siglist = tssp;
9667c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
9677c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp);
9687c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
9697c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t));
9707c478bd9Sstevel@tonic-gate update = 1;
9717c478bd9Sstevel@tonic-gate ssp = tssp;
9727c478bd9Sstevel@tonic-gate } else {
9737c478bd9Sstevel@tonic-gate pssp = ssp;
9747c478bd9Sstevel@tonic-gate ssp = ssp->ss_next;
9757c478bd9Sstevel@tonic-gate }
9767c478bd9Sstevel@tonic-gate }
9777c478bd9Sstevel@tonic-gate if (update) {
9787c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
9797c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
9807c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events;
9817c478bd9Sstevel@tonic-gate }
9827c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
9837c478bd9Sstevel@tonic-gate }
9847c478bd9Sstevel@tonic-gate
9857c478bd9Sstevel@tonic-gate /*
9867c478bd9Sstevel@tonic-gate * Used on the last close to remove any remaining items on the siglist.
9877c478bd9Sstevel@tonic-gate * These could be present on the siglist due to I_ESETSIG calls that
9887c478bd9Sstevel@tonic-gate * use process groups or processed that do not have an open file descriptor
9897c478bd9Sstevel@tonic-gate * for this stream (Such entries would not be removed by strclean).
9907c478bd9Sstevel@tonic-gate */
9917c478bd9Sstevel@tonic-gate static void
strcleanall(struct vnode * vp)9927c478bd9Sstevel@tonic-gate strcleanall(struct vnode *vp)
9937c478bd9Sstevel@tonic-gate {
9947c478bd9Sstevel@tonic-gate strsig_t *ssp, *nssp;
9957c478bd9Sstevel@tonic-gate stdata_t *stp;
9967c478bd9Sstevel@tonic-gate
9977c478bd9Sstevel@tonic-gate stp = vp->v_stream;
9987c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
9997c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist;
10007c478bd9Sstevel@tonic-gate stp->sd_siglist = NULL;
10017c478bd9Sstevel@tonic-gate while (ssp) {
10027c478bd9Sstevel@tonic-gate nssp = ssp->ss_next;
10037c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
10047c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp);
10057c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
10067c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t));
10077c478bd9Sstevel@tonic-gate ssp = nssp;
10087c478bd9Sstevel@tonic-gate }
10097c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
10107c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
10117c478bd9Sstevel@tonic-gate }
10127c478bd9Sstevel@tonic-gate
10137c478bd9Sstevel@tonic-gate /*
10147c478bd9Sstevel@tonic-gate * Retrieve the next message from the logical stream head read queue
10157c478bd9Sstevel@tonic-gate * using either rwnext (if sync stream) or getq_noenab.
10167c478bd9Sstevel@tonic-gate * It is the callers responsibility to call qbackenable after
10177c478bd9Sstevel@tonic-gate * it is finished with the message. The caller should not call
10187c478bd9Sstevel@tonic-gate * qbackenable until after any putback calls to avoid spurious backenabling.
10197c478bd9Sstevel@tonic-gate */
10207c478bd9Sstevel@tonic-gate mblk_t *
strget(struct stdata * stp,queue_t * q,struct uio * uiop,int first,int * errorp)10217c478bd9Sstevel@tonic-gate strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first,
10227c478bd9Sstevel@tonic-gate int *errorp)
10237c478bd9Sstevel@tonic-gate {
10247c478bd9Sstevel@tonic-gate mblk_t *bp;
10257c478bd9Sstevel@tonic-gate int error;
1026301ce41fSja ssize_t rbytes = 0;
10277c478bd9Sstevel@tonic-gate
10287c478bd9Sstevel@tonic-gate /* Holding sd_lock prevents the read queue from changing */
1029301ce41fSja ASSERT(MUTEX_HELD(&stp->sd_lock));
10307c478bd9Sstevel@tonic-gate
10317c478bd9Sstevel@tonic-gate if (uiop != NULL && stp->sd_struiordq != NULL &&
10327c478bd9Sstevel@tonic-gate q->q_first == NULL &&
10337c478bd9Sstevel@tonic-gate (!first || (stp->sd_wakeq & RSLEEP))) {
10347c478bd9Sstevel@tonic-gate /*
10357c478bd9Sstevel@tonic-gate * Stream supports rwnext() for the read side.
10367c478bd9Sstevel@tonic-gate * If this is the first time we're called by e.g. strread
10377c478bd9Sstevel@tonic-gate * only do the downcall if there is a deferred wakeup
10387c478bd9Sstevel@tonic-gate * (registered in sd_wakeq).
10397c478bd9Sstevel@tonic-gate */
10407c478bd9Sstevel@tonic-gate struiod_t uiod;
10418e935259SBryan Cantrill struct iovec buf[IOV_MAX_STACK];
10428e935259SBryan Cantrill int iovlen = 0;
10437c478bd9Sstevel@tonic-gate
10447c478bd9Sstevel@tonic-gate if (first)
10457c478bd9Sstevel@tonic-gate stp->sd_wakeq &= ~RSLEEP;
10467c478bd9Sstevel@tonic-gate
10478e935259SBryan Cantrill if (uiop->uio_iovcnt > IOV_MAX_STACK) {
10488e935259SBryan Cantrill iovlen = uiop->uio_iovcnt * sizeof (iovec_t);
10498e935259SBryan Cantrill uiod.d_iov = kmem_alloc(iovlen, KM_SLEEP);
10508e935259SBryan Cantrill } else {
10518e935259SBryan Cantrill uiod.d_iov = buf;
10528e935259SBryan Cantrill }
10538e935259SBryan Cantrill
10548e935259SBryan Cantrill (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov, uiop->uio_iovcnt);
10557c478bd9Sstevel@tonic-gate uiod.d_mp = 0;
10567c478bd9Sstevel@tonic-gate /*
10577c478bd9Sstevel@tonic-gate * Mark that a thread is in rwnext on the read side
10587c478bd9Sstevel@tonic-gate * to prevent strrput from nacking ioctls immediately.
10597c478bd9Sstevel@tonic-gate * When the last concurrent rwnext returns
10607c478bd9Sstevel@tonic-gate * the ioctls are nack'ed.
10617c478bd9Sstevel@tonic-gate */
10627c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
10637c478bd9Sstevel@tonic-gate stp->sd_struiodnak++;
10647c478bd9Sstevel@tonic-gate /*
10657c478bd9Sstevel@tonic-gate * Note: rwnext will drop sd_lock.
10667c478bd9Sstevel@tonic-gate */
10677c478bd9Sstevel@tonic-gate error = rwnext(q, &uiod);
10687c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
10697c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
10707c478bd9Sstevel@tonic-gate stp->sd_struiodnak--;
10717c478bd9Sstevel@tonic-gate while (stp->sd_struiodnak == 0 &&
10727c478bd9Sstevel@tonic-gate ((bp = stp->sd_struionak) != NULL)) {
10737c478bd9Sstevel@tonic-gate stp->sd_struionak = bp->b_next;
10747c478bd9Sstevel@tonic-gate bp->b_next = NULL;
10757c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK;
10767c478bd9Sstevel@tonic-gate /*
10777c478bd9Sstevel@tonic-gate * Protect against the driver passing up
10787c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
10797c478bd9Sstevel@tonic-gate */
10807c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
10817c478bd9Sstevel@tonic-gate freemsg(bp);
10827c478bd9Sstevel@tonic-gate else {
10837c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
10847c478bd9Sstevel@tonic-gate qreply(q, bp);
10857c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate }
10887c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
10897c478bd9Sstevel@tonic-gate if (error == 0 || error == EWOULDBLOCK) {
10907c478bd9Sstevel@tonic-gate if ((bp = uiod.d_mp) != NULL) {
10917c478bd9Sstevel@tonic-gate *errorp = 0;
10927c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
10938e935259SBryan Cantrill if (iovlen != 0)
10948e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
10957c478bd9Sstevel@tonic-gate return (bp);
10967c478bd9Sstevel@tonic-gate }
10977c478bd9Sstevel@tonic-gate error = 0;
10987c478bd9Sstevel@tonic-gate } else if (error == EINVAL) {
10997c478bd9Sstevel@tonic-gate /*
11007c478bd9Sstevel@tonic-gate * The stream plumbing must have
11017c478bd9Sstevel@tonic-gate * changed while we were away, so
11027c478bd9Sstevel@tonic-gate * just turn off rwnext()s.
11037c478bd9Sstevel@tonic-gate */
11047c478bd9Sstevel@tonic-gate error = 0;
11057c478bd9Sstevel@tonic-gate } else if (error == EBUSY) {
11067c478bd9Sstevel@tonic-gate /*
11077c478bd9Sstevel@tonic-gate * The module might have data in transit using putnext
11087c478bd9Sstevel@tonic-gate * Fall back on waiting + getq.
11097c478bd9Sstevel@tonic-gate */
11107c478bd9Sstevel@tonic-gate error = 0;
11117c478bd9Sstevel@tonic-gate } else {
11127c478bd9Sstevel@tonic-gate *errorp = error;
11137c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
11148e935259SBryan Cantrill if (iovlen != 0)
11158e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
11167c478bd9Sstevel@tonic-gate return (NULL);
11177c478bd9Sstevel@tonic-gate }
11188e935259SBryan Cantrill
11198e935259SBryan Cantrill if (iovlen != 0)
11208e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
11218e935259SBryan Cantrill
11227c478bd9Sstevel@tonic-gate /*
11237c478bd9Sstevel@tonic-gate * Try a getq in case a rwnext() generated mblk
11247c478bd9Sstevel@tonic-gate * has bubbled up via strrput().
11257c478bd9Sstevel@tonic-gate */
11267c478bd9Sstevel@tonic-gate }
11277c478bd9Sstevel@tonic-gate *errorp = 0;
11287c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
1129301ce41fSja
1130bbc000e5SAnders Persson /*
1131bbc000e5SAnders Persson * If we have a valid uio, try and use this as a guide for how
1132bbc000e5SAnders Persson * many bytes to retrieve from the queue via getq_noenab().
1133bbc000e5SAnders Persson * Doing this can avoid unneccesary counting of overlong
1134bbc000e5SAnders Persson * messages in putback(). We currently only do this for sockets
1135bbc000e5SAnders Persson * and only if there is no sd_rputdatafunc hook.
1136bbc000e5SAnders Persson *
1137bbc000e5SAnders Persson * The sd_rputdatafunc hook transforms the entire message
1138bbc000e5SAnders Persson * before any bytes in it can be given to a client. So, rbytes
1139bbc000e5SAnders Persson * must be 0 if there is a hook.
1140bbc000e5SAnders Persson */
1141bbc000e5SAnders Persson if ((uiop != NULL) && (stp->sd_vnode->v_type == VSOCK) &&
1142bbc000e5SAnders Persson (stp->sd_rputdatafunc == NULL))
1143bbc000e5SAnders Persson rbytes = uiop->uio_resid;
114417169044Sbrutus
1145bbc000e5SAnders Persson return (getq_noenab(q, rbytes));
11467c478bd9Sstevel@tonic-gate }
11477c478bd9Sstevel@tonic-gate
11487c478bd9Sstevel@tonic-gate /*
11497c478bd9Sstevel@tonic-gate * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'.
11507c478bd9Sstevel@tonic-gate * If the message does not fit in the uio the remainder of it is returned;
11517c478bd9Sstevel@tonic-gate * otherwise NULL is returned. Any embedded zero-length mblk_t's are
11527c478bd9Sstevel@tonic-gate * consumed, even if uio_resid reaches zero. On error, `*errorp' is set to
11537c478bd9Sstevel@tonic-gate * the error code, the message is consumed, and NULL is returned.
11547c478bd9Sstevel@tonic-gate */
11557c478bd9Sstevel@tonic-gate static mblk_t *
struiocopyout(mblk_t * bp,struct uio * uiop,int * errorp)11567c478bd9Sstevel@tonic-gate struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp)
11577c478bd9Sstevel@tonic-gate {
11587c478bd9Sstevel@tonic-gate int error;
11597c478bd9Sstevel@tonic-gate ptrdiff_t n;
11607c478bd9Sstevel@tonic-gate mblk_t *nbp;
11617c478bd9Sstevel@tonic-gate
11627c478bd9Sstevel@tonic-gate ASSERT(bp->b_wptr >= bp->b_rptr);
11637c478bd9Sstevel@tonic-gate
11647c478bd9Sstevel@tonic-gate do {
11657c478bd9Sstevel@tonic-gate if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) {
11667c478bd9Sstevel@tonic-gate ASSERT(n > 0);
11677c478bd9Sstevel@tonic-gate
11687c478bd9Sstevel@tonic-gate error = uiomove(bp->b_rptr, n, UIO_READ, uiop);
11697c478bd9Sstevel@tonic-gate if (error != 0) {
11707c478bd9Sstevel@tonic-gate freemsg(bp);
11717c478bd9Sstevel@tonic-gate *errorp = error;
11727c478bd9Sstevel@tonic-gate return (NULL);
11737c478bd9Sstevel@tonic-gate }
11747c478bd9Sstevel@tonic-gate }
11757c478bd9Sstevel@tonic-gate
11767c478bd9Sstevel@tonic-gate bp->b_rptr += n;
11777c478bd9Sstevel@tonic-gate while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) {
11787c478bd9Sstevel@tonic-gate nbp = bp;
11797c478bd9Sstevel@tonic-gate bp = bp->b_cont;
11807c478bd9Sstevel@tonic-gate freeb(nbp);
11817c478bd9Sstevel@tonic-gate }
11827c478bd9Sstevel@tonic-gate } while (bp != NULL && uiop->uio_resid > 0);
11837c478bd9Sstevel@tonic-gate
11847c478bd9Sstevel@tonic-gate *errorp = 0;
11857c478bd9Sstevel@tonic-gate return (bp);
11867c478bd9Sstevel@tonic-gate }
11877c478bd9Sstevel@tonic-gate
11887c478bd9Sstevel@tonic-gate /*
11897c478bd9Sstevel@tonic-gate * Read a stream according to the mode flags in sd_flag:
11907c478bd9Sstevel@tonic-gate *
11917c478bd9Sstevel@tonic-gate * (default mode) - Byte stream, msg boundaries are ignored
11927c478bd9Sstevel@tonic-gate * RD_MSGDIS (msg discard) - Read on msg boundaries and throw away
11937c478bd9Sstevel@tonic-gate * any data remaining in msg
11947c478bd9Sstevel@tonic-gate * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back
11957c478bd9Sstevel@tonic-gate * any remaining data on head of read queue
11967c478bd9Sstevel@tonic-gate *
11977c478bd9Sstevel@tonic-gate * Consume readable messages on the front of the queue until
11987c478bd9Sstevel@tonic-gate * ttolwp(curthread)->lwp_count
11997c478bd9Sstevel@tonic-gate * is satisfied, the readable messages are exhausted, or a message
12007c478bd9Sstevel@tonic-gate * boundary is reached in a message mode. If no data was read and
12017c478bd9Sstevel@tonic-gate * the stream was not opened with the NDELAY flag, block until data arrives.
12027c478bd9Sstevel@tonic-gate * Otherwise return the data read and update the count.
12037c478bd9Sstevel@tonic-gate *
12047c478bd9Sstevel@tonic-gate * In default mode a 0 length message signifies end-of-file and terminates
12057c478bd9Sstevel@tonic-gate * a read in progress. The 0 length message is removed from the queue
12067c478bd9Sstevel@tonic-gate * only if it is the only message read (no data is read).
12077c478bd9Sstevel@tonic-gate *
12087c478bd9Sstevel@tonic-gate * An attempt to read an M_PROTO or M_PCPROTO message results in an
12097c478bd9Sstevel@tonic-gate * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set.
12107c478bd9Sstevel@tonic-gate * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data.
12117c478bd9Sstevel@tonic-gate * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message
12127c478bd9Sstevel@tonic-gate * are unlinked from and M_DATA blocks in the message, the protos are
12137c478bd9Sstevel@tonic-gate * thrown away, and the data is read.
12147c478bd9Sstevel@tonic-gate */
12157c478bd9Sstevel@tonic-gate /* ARGSUSED */
12167c478bd9Sstevel@tonic-gate int
strread(struct vnode * vp,struct uio * uiop,cred_t * crp)12177c478bd9Sstevel@tonic-gate strread(struct vnode *vp, struct uio *uiop, cred_t *crp)
12187c478bd9Sstevel@tonic-gate {
12197c478bd9Sstevel@tonic-gate struct stdata *stp;
12207c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp;
12217c478bd9Sstevel@tonic-gate queue_t *q;
12227c478bd9Sstevel@tonic-gate int error = 0;
12237c478bd9Sstevel@tonic-gate uint_t old_sd_flag;
12247c478bd9Sstevel@tonic-gate int first;
12257c478bd9Sstevel@tonic-gate char rflg;
12267c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */
12277c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
12287c478bd9Sstevel@tonic-gate short delim;
12297c478bd9Sstevel@tonic-gate unsigned char pri = 0;
12307c478bd9Sstevel@tonic-gate char waitflag;
12317c478bd9Sstevel@tonic-gate unsigned char type;
12327c478bd9Sstevel@tonic-gate
12337c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
1234d3e55dcdSgww TR_STRREAD_ENTER, "strread:%p", vp);
12357c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
12367c478bd9Sstevel@tonic-gate stp = vp->v_stream;
12377c478bd9Sstevel@tonic-gate
12387c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
12399acbbeafSnn
12409acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
12419acbbeafSnn mutex_exit(&stp->sd_lock);
12429acbbeafSnn return (error);
12439acbbeafSnn }
12449acbbeafSnn
12457c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) {
12467c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 0);
12477c478bd9Sstevel@tonic-gate if (error != 0) {
12487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
12497c478bd9Sstevel@tonic-gate return (error);
12507c478bd9Sstevel@tonic-gate }
12517c478bd9Sstevel@tonic-gate }
12527c478bd9Sstevel@tonic-gate
12537c478bd9Sstevel@tonic-gate /*
12547c478bd9Sstevel@tonic-gate * Loop terminates when uiop->uio_resid == 0.
12557c478bd9Sstevel@tonic-gate */
12567c478bd9Sstevel@tonic-gate rflg = 0;
12577c478bd9Sstevel@tonic-gate waitflag = READWAIT;
12587c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
12597c478bd9Sstevel@tonic-gate for (;;) {
12607c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
12617c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag;
12627c478bd9Sstevel@tonic-gate mark = 0;
12637c478bd9Sstevel@tonic-gate delim = 0;
12647c478bd9Sstevel@tonic-gate first = 1;
12657c478bd9Sstevel@tonic-gate while ((bp = strget(stp, q, uiop, first, &error)) == NULL) {
12667c478bd9Sstevel@tonic-gate int done = 0;
12677c478bd9Sstevel@tonic-gate
12687c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
12697c478bd9Sstevel@tonic-gate
12707c478bd9Sstevel@tonic-gate if (error != 0)
12717c478bd9Sstevel@tonic-gate goto oops;
12727c478bd9Sstevel@tonic-gate
12737c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STREOF)) {
12747c478bd9Sstevel@tonic-gate goto oops;
12757c478bd9Sstevel@tonic-gate }
12767c478bd9Sstevel@tonic-gate if (rflg && !(stp->sd_flag & STRDELIM)) {
12777c478bd9Sstevel@tonic-gate goto oops;
12787c478bd9Sstevel@tonic-gate }
12797c478bd9Sstevel@tonic-gate /*
12807c478bd9Sstevel@tonic-gate * If a read(fd,buf,0) has been done, there is no
12817c478bd9Sstevel@tonic-gate * need to sleep. We always have zero bytes to
12827c478bd9Sstevel@tonic-gate * return.
12837c478bd9Sstevel@tonic-gate */
12847c478bd9Sstevel@tonic-gate if (uiop->uio_resid == 0) {
12857c478bd9Sstevel@tonic-gate goto oops;
12867c478bd9Sstevel@tonic-gate }
12877c478bd9Sstevel@tonic-gate
12887c478bd9Sstevel@tonic-gate qbackenable(q, 0);
12897c478bd9Sstevel@tonic-gate
12907c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT,
1291d3e55dcdSgww "strread calls strwaitq:%p, %p, %p",
1292d3e55dcdSgww vp, uiop, crp);
12937c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, waitflag, uiop->uio_resid,
12947c478bd9Sstevel@tonic-gate uiop->uio_fmode, -1, &done)) != 0 || done) {
12957c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE,
1296d3e55dcdSgww "strread error or done:%p, %p, %p",
1297d3e55dcdSgww vp, uiop, crp);
12987c478bd9Sstevel@tonic-gate if ((uiop->uio_fmode & FNDELAY) &&
12997c478bd9Sstevel@tonic-gate (stp->sd_flag & OLDNDELAY) &&
13007c478bd9Sstevel@tonic-gate (error == EAGAIN))
13017c478bd9Sstevel@tonic-gate error = 0;
13027c478bd9Sstevel@tonic-gate goto oops;
13037c478bd9Sstevel@tonic-gate }
13047c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE,
1305d3e55dcdSgww "strread awakes:%p, %p, %p", vp, uiop, crp);
13069acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
13079acbbeafSnn goto oops;
13087c478bd9Sstevel@tonic-gate }
13097c478bd9Sstevel@tonic-gate first = 0;
13107c478bd9Sstevel@tonic-gate }
131117169044Sbrutus
13127c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
13137c478bd9Sstevel@tonic-gate ASSERT(bp);
13147c478bd9Sstevel@tonic-gate pri = bp->b_band;
13157c478bd9Sstevel@tonic-gate /*
13167c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not
13177c478bd9Sstevel@tonic-gate * completely consumed this information will be put in the mblk
13187c478bd9Sstevel@tonic-gate * that is putback.
13197c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed
13207c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if
13217c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is
13227c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set.
13237c478bd9Sstevel@tonic-gate *
13247c478bd9Sstevel@tonic-gate * For some unknown reason strread only breaks the read at the
13257c478bd9Sstevel@tonic-gate * last mark.
13267c478bd9Sstevel@tonic-gate */
13277c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
13287c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
1329d3e55dcdSgww (MSGMARKNEXT|MSGNOTMARKNEXT));
13307c478bd9Sstevel@tonic-gate if (mark != 0 && bp == stp->sd_mark) {
13317c478bd9Sstevel@tonic-gate if (rflg) {
13327c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
13337c478bd9Sstevel@tonic-gate goto oops;
13347c478bd9Sstevel@tonic-gate }
13357c478bd9Sstevel@tonic-gate mark |= _LASTMARK;
13367c478bd9Sstevel@tonic-gate stp->sd_mark = NULL;
13377c478bd9Sstevel@tonic-gate }
13387c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM))
13397c478bd9Sstevel@tonic-gate delim = 1;
13407c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
13417c478bd9Sstevel@tonic-gate
13427c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
13437c478bd9Sstevel@tonic-gate stream_runservice(stp);
13447c478bd9Sstevel@tonic-gate
13457c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type;
13467c478bd9Sstevel@tonic-gate
13477c478bd9Sstevel@tonic-gate switch (type) {
13487c478bd9Sstevel@tonic-gate
13497c478bd9Sstevel@tonic-gate case M_DATA:
13507c478bd9Sstevel@tonic-gate ismdata:
13517c478bd9Sstevel@tonic-gate if (msgnodata(bp)) {
13527c478bd9Sstevel@tonic-gate if (mark || delim) {
13537c478bd9Sstevel@tonic-gate freemsg(bp);
13547c478bd9Sstevel@tonic-gate } else if (rflg) {
13557c478bd9Sstevel@tonic-gate
13567c478bd9Sstevel@tonic-gate /*
13577c478bd9Sstevel@tonic-gate * If already read data put zero
13587c478bd9Sstevel@tonic-gate * length message back on queue else
13597c478bd9Sstevel@tonic-gate * free msg and return 0.
13607c478bd9Sstevel@tonic-gate */
13617c478bd9Sstevel@tonic-gate bp->b_band = pri;
13627c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
13637c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
13647c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
13657c478bd9Sstevel@tonic-gate } else {
13667c478bd9Sstevel@tonic-gate freemsg(bp);
13677c478bd9Sstevel@tonic-gate }
13687c478bd9Sstevel@tonic-gate error = 0;
13697c478bd9Sstevel@tonic-gate goto oops1;
13707c478bd9Sstevel@tonic-gate }
13717c478bd9Sstevel@tonic-gate
13727c478bd9Sstevel@tonic-gate rflg = 1;
13737c478bd9Sstevel@tonic-gate waitflag |= NOINTR;
13747c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error);
13757c478bd9Sstevel@tonic-gate if (error != 0)
13767c478bd9Sstevel@tonic-gate goto oops1;
13777c478bd9Sstevel@tonic-gate
13787c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
13797c478bd9Sstevel@tonic-gate if (bp) {
13807c478bd9Sstevel@tonic-gate /*
13817c478bd9Sstevel@tonic-gate * Have remaining data in message.
13827c478bd9Sstevel@tonic-gate * Free msg if in discard mode.
13837c478bd9Sstevel@tonic-gate */
13847c478bd9Sstevel@tonic-gate if (stp->sd_read_opt & RD_MSGDIS) {
13857c478bd9Sstevel@tonic-gate freemsg(bp);
13867c478bd9Sstevel@tonic-gate } else {
13877c478bd9Sstevel@tonic-gate bp->b_band = pri;
13887c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) &&
13897c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL))
13907c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
13917c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK;
13927c478bd9Sstevel@tonic-gate if (delim)
13937c478bd9Sstevel@tonic-gate bp->b_flag |= MSGDELIM;
13947c478bd9Sstevel@tonic-gate if (msgnodata(bp))
13957c478bd9Sstevel@tonic-gate freemsg(bp);
13967c478bd9Sstevel@tonic-gate else
13977c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
13987c478bd9Sstevel@tonic-gate }
13997c478bd9Sstevel@tonic-gate } else {
14007c478bd9Sstevel@tonic-gate /*
14017c478bd9Sstevel@tonic-gate * Consumed the complete message.
14027c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information
14037c478bd9Sstevel@tonic-gate * to the stream head just in case
14047c478bd9Sstevel@tonic-gate * the read queue becomes empty.
14057c478bd9Sstevel@tonic-gate *
14067c478bd9Sstevel@tonic-gate * If the stream head was at the mark
14077c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above
14087c478bd9Sstevel@tonic-gate * and some data was consumed then we have
14097c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is
14107c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in
14117c478bd9Sstevel@tonic-gate * strrput during the copyout above causing
14127c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that
14137c478bd9Sstevel@tonic-gate * flag.
14147c478bd9Sstevel@tonic-gate */
14157c478bd9Sstevel@tonic-gate if (mark &
14167c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
14177c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) {
14187c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK;
14197c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK;
14207c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) {
14217c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
14227c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK;
14237c478bd9Sstevel@tonic-gate } else {
14247c478bd9Sstevel@tonic-gate stp->sd_flag &=
14257c478bd9Sstevel@tonic-gate ~(STRATMARK|STRNOTATMARK);
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate } else if (rflg && (old_sd_flag & STRATMARK)) {
14287c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
14297c478bd9Sstevel@tonic-gate }
14307c478bd9Sstevel@tonic-gate }
14317c478bd9Sstevel@tonic-gate
14327c478bd9Sstevel@tonic-gate /*
14337c478bd9Sstevel@tonic-gate * Check for signal messages at the front of the read
14347c478bd9Sstevel@tonic-gate * queue and generate the signal(s) if appropriate.
14357c478bd9Sstevel@tonic-gate * The only signal that can be on queue is M_SIG at
14367c478bd9Sstevel@tonic-gate * this point.
14377c478bd9Sstevel@tonic-gate */
14387c478bd9Sstevel@tonic-gate while ((((bp = q->q_first)) != NULL) &&
1439d3e55dcdSgww (bp->b_datap->db_type == M_SIG)) {
1440301ce41fSja bp = getq_noenab(q, 0);
14417c478bd9Sstevel@tonic-gate /*
14427c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the
14437c478bd9Sstevel@tonic-gate * read queue can not change.
14447c478bd9Sstevel@tonic-gate */
1445a45f3f93Smeem ASSERT(bp != NULL && DB_TYPE(bp) == M_SIG);
1446a45f3f93Smeem strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
14477c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
14487c478bd9Sstevel@tonic-gate freemsg(bp);
14497c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
14507c478bd9Sstevel@tonic-gate stream_runservice(stp);
14517c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
14527c478bd9Sstevel@tonic-gate }
14537c478bd9Sstevel@tonic-gate
14547c478bd9Sstevel@tonic-gate if ((uiop->uio_resid == 0) || (mark & _LASTMARK) ||
14557c478bd9Sstevel@tonic-gate delim ||
14567c478bd9Sstevel@tonic-gate (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) {
14577c478bd9Sstevel@tonic-gate goto oops;
14587c478bd9Sstevel@tonic-gate }
14597c478bd9Sstevel@tonic-gate continue;
14607c478bd9Sstevel@tonic-gate
14617c478bd9Sstevel@tonic-gate case M_SIG:
14627c478bd9Sstevel@tonic-gate strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band);
14637c478bd9Sstevel@tonic-gate freemsg(bp);
14647c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
14657c478bd9Sstevel@tonic-gate continue;
14667c478bd9Sstevel@tonic-gate
14677c478bd9Sstevel@tonic-gate case M_PROTO:
14687c478bd9Sstevel@tonic-gate case M_PCPROTO:
14697c478bd9Sstevel@tonic-gate /*
14707c478bd9Sstevel@tonic-gate * Only data messages are readable.
14717c478bd9Sstevel@tonic-gate * Any others generate an error, unless
14727c478bd9Sstevel@tonic-gate * RD_PROTDIS or RD_PROTDAT is set.
14737c478bd9Sstevel@tonic-gate */
14747c478bd9Sstevel@tonic-gate if (stp->sd_read_opt & RD_PROTDAT) {
14757c478bd9Sstevel@tonic-gate for (nbp = bp; nbp; nbp = nbp->b_next) {
1476d3e55dcdSgww if ((nbp->b_datap->db_type ==
1477d3e55dcdSgww M_PROTO) ||
1478d3e55dcdSgww (nbp->b_datap->db_type ==
1479d3e55dcdSgww M_PCPROTO)) {
1480d3e55dcdSgww nbp->b_datap->db_type = M_DATA;
1481d3e55dcdSgww } else {
1482d3e55dcdSgww break;
1483d3e55dcdSgww }
14847c478bd9Sstevel@tonic-gate }
14857c478bd9Sstevel@tonic-gate /*
14867c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
14877c478bd9Sstevel@tonic-gate * first message
14887c478bd9Sstevel@tonic-gate */
14897c478bd9Sstevel@tonic-gate if (type == M_PCPROTO) {
14907c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
14917c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
14927c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
14937c478bd9Sstevel@tonic-gate }
14947c478bd9Sstevel@tonic-gate goto ismdata;
14957c478bd9Sstevel@tonic-gate } else if (stp->sd_read_opt & RD_PROTDIS) {
14967c478bd9Sstevel@tonic-gate /*
14977c478bd9Sstevel@tonic-gate * discard non-data messages
14987c478bd9Sstevel@tonic-gate */
14997c478bd9Sstevel@tonic-gate while (bp &&
15007c478bd9Sstevel@tonic-gate ((bp->b_datap->db_type == M_PROTO) ||
15017c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_PCPROTO))) {
15027c478bd9Sstevel@tonic-gate nbp = unlinkb(bp);
15037c478bd9Sstevel@tonic-gate freeb(bp);
15047c478bd9Sstevel@tonic-gate bp = nbp;
15057c478bd9Sstevel@tonic-gate }
15067c478bd9Sstevel@tonic-gate /*
15077c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
15087c478bd9Sstevel@tonic-gate * first message
15097c478bd9Sstevel@tonic-gate */
15107c478bd9Sstevel@tonic-gate if (type == M_PCPROTO) {
15117c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
15127c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
15137c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
15147c478bd9Sstevel@tonic-gate }
15157c478bd9Sstevel@tonic-gate if (bp) {
15167c478bd9Sstevel@tonic-gate bp->b_band = pri;
15177c478bd9Sstevel@tonic-gate goto ismdata;
15187c478bd9Sstevel@tonic-gate } else {
15197c478bd9Sstevel@tonic-gate break;
15207c478bd9Sstevel@tonic-gate }
15217c478bd9Sstevel@tonic-gate }
15227c478bd9Sstevel@tonic-gate /* FALLTHRU */
15237c478bd9Sstevel@tonic-gate case M_PASSFP:
15247c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_PASSFP) &&
15257c478bd9Sstevel@tonic-gate (stp->sd_read_opt & RD_PROTDIS)) {
15267c478bd9Sstevel@tonic-gate freemsg(bp);
15277c478bd9Sstevel@tonic-gate break;
15287c478bd9Sstevel@tonic-gate }
15297c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
15307c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
15317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
15327c478bd9Sstevel@tonic-gate if (rflg == 0)
15337c478bd9Sstevel@tonic-gate error = EBADMSG;
15347c478bd9Sstevel@tonic-gate goto oops1;
15357c478bd9Sstevel@tonic-gate
15367c478bd9Sstevel@tonic-gate default:
15377c478bd9Sstevel@tonic-gate /*
15387c478bd9Sstevel@tonic-gate * Garbage on stream head read queue.
15397c478bd9Sstevel@tonic-gate */
15407c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "bad %x found at stream head\n",
1541d3e55dcdSgww bp->b_datap->db_type);
15427c478bd9Sstevel@tonic-gate freemsg(bp);
15437c478bd9Sstevel@tonic-gate goto oops1;
15447c478bd9Sstevel@tonic-gate }
15457c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
15467c478bd9Sstevel@tonic-gate }
15477c478bd9Sstevel@tonic-gate oops:
15487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
15497c478bd9Sstevel@tonic-gate oops1:
15507c478bd9Sstevel@tonic-gate qbackenable(q, pri);
15517c478bd9Sstevel@tonic-gate return (error);
15527c478bd9Sstevel@tonic-gate #undef _LASTMARK
15537c478bd9Sstevel@tonic-gate }
15547c478bd9Sstevel@tonic-gate
15557c478bd9Sstevel@tonic-gate /*
15567c478bd9Sstevel@tonic-gate * Default processing of M_PROTO/M_PCPROTO messages.
15577c478bd9Sstevel@tonic-gate * Determine which wakeups and signals are needed.
15587c478bd9Sstevel@tonic-gate * This can be replaced by a user-specified procedure for kernel users
15597c478bd9Sstevel@tonic-gate * of STREAMS.
15607c478bd9Sstevel@tonic-gate */
15617c478bd9Sstevel@tonic-gate /* ARGSUSED */
15627c478bd9Sstevel@tonic-gate mblk_t *
strrput_proto(vnode_t * vp,mblk_t * mp,strwakeup_t * wakeups,strsigset_t * firstmsgsigs,strsigset_t * allmsgsigs,strpollset_t * pollwakeups)15637c478bd9Sstevel@tonic-gate strrput_proto(vnode_t *vp, mblk_t *mp,
15647c478bd9Sstevel@tonic-gate strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
15657c478bd9Sstevel@tonic-gate strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
15667c478bd9Sstevel@tonic-gate {
15677c478bd9Sstevel@tonic-gate *wakeups = RSLEEP;
15687c478bd9Sstevel@tonic-gate *allmsgsigs = 0;
15697c478bd9Sstevel@tonic-gate
15707c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
15717c478bd9Sstevel@tonic-gate case M_PROTO:
15727c478bd9Sstevel@tonic-gate if (mp->b_band == 0) {
15737c478bd9Sstevel@tonic-gate *firstmsgsigs = S_INPUT | S_RDNORM;
15747c478bd9Sstevel@tonic-gate *pollwakeups = POLLIN | POLLRDNORM;
15757c478bd9Sstevel@tonic-gate } else {
15767c478bd9Sstevel@tonic-gate *firstmsgsigs = S_INPUT | S_RDBAND;
15777c478bd9Sstevel@tonic-gate *pollwakeups = POLLIN | POLLRDBAND;
15787c478bd9Sstevel@tonic-gate }
15797c478bd9Sstevel@tonic-gate break;
15807c478bd9Sstevel@tonic-gate case M_PCPROTO:
15817c478bd9Sstevel@tonic-gate *firstmsgsigs = S_HIPRI;
15827c478bd9Sstevel@tonic-gate *pollwakeups = POLLPRI;
15837c478bd9Sstevel@tonic-gate break;
15847c478bd9Sstevel@tonic-gate }
15857c478bd9Sstevel@tonic-gate return (mp);
15867c478bd9Sstevel@tonic-gate }
15877c478bd9Sstevel@tonic-gate
15887c478bd9Sstevel@tonic-gate /*
15897c478bd9Sstevel@tonic-gate * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and
15907c478bd9Sstevel@tonic-gate * M_PASSFP messages.
15917c478bd9Sstevel@tonic-gate * Determine which wakeups and signals are needed.
15927c478bd9Sstevel@tonic-gate * This can be replaced by a user-specified procedure for kernel users
15937c478bd9Sstevel@tonic-gate * of STREAMS.
15947c478bd9Sstevel@tonic-gate */
15957c478bd9Sstevel@tonic-gate /* ARGSUSED */
15967c478bd9Sstevel@tonic-gate mblk_t *
strrput_misc(vnode_t * vp,mblk_t * mp,strwakeup_t * wakeups,strsigset_t * firstmsgsigs,strsigset_t * allmsgsigs,strpollset_t * pollwakeups)15977c478bd9Sstevel@tonic-gate strrput_misc(vnode_t *vp, mblk_t *mp,
15987c478bd9Sstevel@tonic-gate strwakeup_t *wakeups, strsigset_t *firstmsgsigs,
15997c478bd9Sstevel@tonic-gate strsigset_t *allmsgsigs, strpollset_t *pollwakeups)
16007c478bd9Sstevel@tonic-gate {
16017c478bd9Sstevel@tonic-gate *wakeups = 0;
16027c478bd9Sstevel@tonic-gate *firstmsgsigs = 0;
16037c478bd9Sstevel@tonic-gate *allmsgsigs = 0;
16047c478bd9Sstevel@tonic-gate *pollwakeups = 0;
16057c478bd9Sstevel@tonic-gate return (mp);
16067c478bd9Sstevel@tonic-gate }
16077c478bd9Sstevel@tonic-gate
16087c478bd9Sstevel@tonic-gate /*
16097c478bd9Sstevel@tonic-gate * Stream read put procedure. Called from downstream driver/module
16107c478bd9Sstevel@tonic-gate * with messages for the stream head. Data, protocol, and in-stream
16117c478bd9Sstevel@tonic-gate * signal messages are placed on the queue, others are handled directly.
16127c478bd9Sstevel@tonic-gate */
16137c478bd9Sstevel@tonic-gate int
strrput(queue_t * q,mblk_t * bp)16147c478bd9Sstevel@tonic-gate strrput(queue_t *q, mblk_t *bp)
16157c478bd9Sstevel@tonic-gate {
16167c478bd9Sstevel@tonic-gate struct stdata *stp;
16177c478bd9Sstevel@tonic-gate ulong_t rput_opt;
16187c478bd9Sstevel@tonic-gate strwakeup_t wakeups;
16197c478bd9Sstevel@tonic-gate strsigset_t firstmsgsigs; /* Signals if first message on queue */
16207c478bd9Sstevel@tonic-gate strsigset_t allmsgsigs; /* Signals for all messages */
16217c478bd9Sstevel@tonic-gate strsigset_t signals; /* Signals events to generate */
16227c478bd9Sstevel@tonic-gate strpollset_t pollwakeups;
16237c478bd9Sstevel@tonic-gate mblk_t *nextbp;
16247c478bd9Sstevel@tonic-gate uchar_t band = 0;
16257c478bd9Sstevel@tonic-gate int hipri_sig;
16267c478bd9Sstevel@tonic-gate
16277c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr;
16287c478bd9Sstevel@tonic-gate /*
16297c478bd9Sstevel@tonic-gate * Use rput_opt for optimized access to the SR_ flags except
16307c478bd9Sstevel@tonic-gate * SR_POLLIN. That flag has to be checked under sd_lock since it
16317c478bd9Sstevel@tonic-gate * is modified by strpoll().
16327c478bd9Sstevel@tonic-gate */
16337c478bd9Sstevel@tonic-gate rput_opt = stp->sd_rput_opt;
16347c478bd9Sstevel@tonic-gate
16357c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q));
16367c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER,
1637d3e55dcdSgww "strrput called with message type:q %p bp %p", q, bp);
16387c478bd9Sstevel@tonic-gate
16397c478bd9Sstevel@tonic-gate /*
16407c478bd9Sstevel@tonic-gate * Perform initial processing and pass to the parameterized functions.
16417c478bd9Sstevel@tonic-gate */
16427c478bd9Sstevel@tonic-gate ASSERT(bp->b_next == NULL);
16437c478bd9Sstevel@tonic-gate
16447c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
16457c478bd9Sstevel@tonic-gate case M_DATA:
16467c478bd9Sstevel@tonic-gate /*
16477c478bd9Sstevel@tonic-gate * sockfs is the only consumer of STREOF and when it is set,
16487c478bd9Sstevel@tonic-gate * it implies that the receiver is not interested in receiving
16497c478bd9Sstevel@tonic-gate * any more data, hence the mblk is freed to prevent unnecessary
16507c478bd9Sstevel@tonic-gate * message queueing at the stream head.
16517c478bd9Sstevel@tonic-gate */
16527c478bd9Sstevel@tonic-gate if (stp->sd_flag == STREOF) {
16537c478bd9Sstevel@tonic-gate freemsg(bp);
16547c478bd9Sstevel@tonic-gate return (0);
16557c478bd9Sstevel@tonic-gate }
16567c478bd9Sstevel@tonic-gate if ((rput_opt & SR_IGN_ZEROLEN) &&
16577c478bd9Sstevel@tonic-gate bp->b_rptr == bp->b_wptr && msgnodata(bp)) {
16587c478bd9Sstevel@tonic-gate /*
16597c478bd9Sstevel@tonic-gate * Ignore zero-length M_DATA messages. These might be
16607c478bd9Sstevel@tonic-gate * generated by some transports.
16617c478bd9Sstevel@tonic-gate * The zero-length M_DATA messages, even if they
16627c478bd9Sstevel@tonic-gate * are ignored, should effect the atmark tracking and
16637c478bd9Sstevel@tonic-gate * should wake up a thread sleeping in strwaitmark.
16647c478bd9Sstevel@tonic-gate */
16657c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
16667c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARKNEXT) {
16677c478bd9Sstevel@tonic-gate /*
16687c478bd9Sstevel@tonic-gate * Record the position of the mark either
16697c478bd9Sstevel@tonic-gate * in q_last or in STRATMARK.
16707c478bd9Sstevel@tonic-gate */
16717c478bd9Sstevel@tonic-gate if (q->q_last != NULL) {
16727c478bd9Sstevel@tonic-gate q->q_last->b_flag &= ~MSGNOTMARKNEXT;
16737c478bd9Sstevel@tonic-gate q->q_last->b_flag |= MSGMARKNEXT;
16747c478bd9Sstevel@tonic-gate } else {
16757c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK;
16767c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK;
16777c478bd9Sstevel@tonic-gate }
16787c478bd9Sstevel@tonic-gate } else if (bp->b_flag & MSGNOTMARKNEXT) {
16797c478bd9Sstevel@tonic-gate /*
16807c478bd9Sstevel@tonic-gate * Record that this is not the position of
16817c478bd9Sstevel@tonic-gate * the mark either in q_last or in
16827c478bd9Sstevel@tonic-gate * STRNOTATMARK.
16837c478bd9Sstevel@tonic-gate */
16847c478bd9Sstevel@tonic-gate if (q->q_last != NULL) {
16857c478bd9Sstevel@tonic-gate q->q_last->b_flag &= ~MSGMARKNEXT;
16867c478bd9Sstevel@tonic-gate q->q_last->b_flag |= MSGNOTMARKNEXT;
16877c478bd9Sstevel@tonic-gate } else {
16887c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
16897c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK;
16907c478bd9Sstevel@tonic-gate }
16917c478bd9Sstevel@tonic-gate }
16927c478bd9Sstevel@tonic-gate if (stp->sd_flag & RSLEEP) {
16937c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP;
16947c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait);
16957c478bd9Sstevel@tonic-gate }
16967c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
16977c478bd9Sstevel@tonic-gate freemsg(bp);
16987c478bd9Sstevel@tonic-gate return (0);
16997c478bd9Sstevel@tonic-gate }
17007c478bd9Sstevel@tonic-gate wakeups = RSLEEP;
17017c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
17027c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDNORM;
17037c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
17047c478bd9Sstevel@tonic-gate } else {
17057c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDBAND;
17067c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
17077c478bd9Sstevel@tonic-gate }
17087c478bd9Sstevel@tonic-gate if (rput_opt & SR_SIGALLDATA)
17097c478bd9Sstevel@tonic-gate allmsgsigs = firstmsgsigs;
17107c478bd9Sstevel@tonic-gate else
17117c478bd9Sstevel@tonic-gate allmsgsigs = 0;
17127c478bd9Sstevel@tonic-gate
17137c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
17147c478bd9Sstevel@tonic-gate if ((rput_opt & SR_CONSOL_DATA) &&
17153584396bSja (q->q_last != NULL) &&
17167c478bd9Sstevel@tonic-gate (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) {
17177c478bd9Sstevel@tonic-gate /*
17183584396bSja * Consolidate an M_DATA message onto an M_DATA,
17197c478bd9Sstevel@tonic-gate * M_PROTO, or M_PCPROTO by merging it with q_last.
17207c478bd9Sstevel@tonic-gate * The consolidation does not take place if
17217c478bd9Sstevel@tonic-gate * the old message is marked with either of the
17227c478bd9Sstevel@tonic-gate * marks or the delim flag or if the new
17237c478bd9Sstevel@tonic-gate * message is marked with MSGMARK. The MSGMARK
17247c478bd9Sstevel@tonic-gate * check is needed to handle the odd semantics of
17257c478bd9Sstevel@tonic-gate * MSGMARK where essentially the whole message
17267c478bd9Sstevel@tonic-gate * is to be treated as marked.
17277c478bd9Sstevel@tonic-gate * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from the
17287c478bd9Sstevel@tonic-gate * new message to the front of the b_cont chain.
17297c478bd9Sstevel@tonic-gate */
17303584396bSja mblk_t *lbp = q->q_last;
17313584396bSja unsigned char db_type = lbp->b_datap->db_type;
17323584396bSja
17333584396bSja if ((db_type == M_DATA || db_type == M_PROTO ||
17343584396bSja db_type == M_PCPROTO) &&
17353584396bSja !(lbp->b_flag & (MSGDELIM|MSGMARK|MSGMARKNEXT))) {
17367c478bd9Sstevel@tonic-gate rmvq_noenab(q, lbp);
17377c478bd9Sstevel@tonic-gate /*
17387c478bd9Sstevel@tonic-gate * The first message in the b_cont list
17397c478bd9Sstevel@tonic-gate * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
17407c478bd9Sstevel@tonic-gate * We need to handle the case where we
17413584396bSja * are appending:
17427c478bd9Sstevel@tonic-gate *
17437c478bd9Sstevel@tonic-gate * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
17447c478bd9Sstevel@tonic-gate * 2) a MSGMARKNEXT to a plain message.
17457c478bd9Sstevel@tonic-gate * 3) a MSGNOTMARKNEXT to a plain message
17467c478bd9Sstevel@tonic-gate * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
17477c478bd9Sstevel@tonic-gate * message.
17487c478bd9Sstevel@tonic-gate *
17497c478bd9Sstevel@tonic-gate * Thus we never append a MSGMARKNEXT or
17507c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT to a MSGMARKNEXT message.
17517c478bd9Sstevel@tonic-gate */
17527c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARKNEXT) {
17537c478bd9Sstevel@tonic-gate lbp->b_flag |= MSGMARKNEXT;
17547c478bd9Sstevel@tonic-gate lbp->b_flag &= ~MSGNOTMARKNEXT;
17557c478bd9Sstevel@tonic-gate bp->b_flag &= ~MSGMARKNEXT;
17567c478bd9Sstevel@tonic-gate } else if (bp->b_flag & MSGNOTMARKNEXT) {
17577c478bd9Sstevel@tonic-gate lbp->b_flag |= MSGNOTMARKNEXT;
17587c478bd9Sstevel@tonic-gate bp->b_flag &= ~MSGNOTMARKNEXT;
17597c478bd9Sstevel@tonic-gate }
17607c478bd9Sstevel@tonic-gate
17617c478bd9Sstevel@tonic-gate linkb(lbp, bp);
17627c478bd9Sstevel@tonic-gate bp = lbp;
17637c478bd9Sstevel@tonic-gate /*
17647c478bd9Sstevel@tonic-gate * The new message logically isn't the first
17657c478bd9Sstevel@tonic-gate * even though the q_first check below thinks
17667c478bd9Sstevel@tonic-gate * it is. Clear the firstmsgsigs to make it
17677c478bd9Sstevel@tonic-gate * not appear to be first.
17687c478bd9Sstevel@tonic-gate */
17697c478bd9Sstevel@tonic-gate firstmsgsigs = 0;
17707c478bd9Sstevel@tonic-gate }
17717c478bd9Sstevel@tonic-gate }
17727c478bd9Sstevel@tonic-gate break;
17737c478bd9Sstevel@tonic-gate
17747c478bd9Sstevel@tonic-gate case M_PASSFP:
17757c478bd9Sstevel@tonic-gate wakeups = RSLEEP;
17767c478bd9Sstevel@tonic-gate allmsgsigs = 0;
17777c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
17787c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDNORM;
17797c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
17807c478bd9Sstevel@tonic-gate } else {
17817c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDBAND;
17827c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
17837c478bd9Sstevel@tonic-gate }
17847c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
17857c478bd9Sstevel@tonic-gate break;
17867c478bd9Sstevel@tonic-gate
17877c478bd9Sstevel@tonic-gate case M_PROTO:
17887c478bd9Sstevel@tonic-gate case M_PCPROTO:
17897c478bd9Sstevel@tonic-gate ASSERT(stp->sd_rprotofunc != NULL);
17907c478bd9Sstevel@tonic-gate bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp,
1791d3e55dcdSgww &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
17927c478bd9Sstevel@tonic-gate #define ALLSIG (S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\
17937c478bd9Sstevel@tonic-gate S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)
17947c478bd9Sstevel@tonic-gate #define ALLPOLL (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\
17957c478bd9Sstevel@tonic-gate POLLWRBAND)
17967c478bd9Sstevel@tonic-gate
17977c478bd9Sstevel@tonic-gate ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
17987c478bd9Sstevel@tonic-gate ASSERT((firstmsgsigs & ~ALLSIG) == 0);
17997c478bd9Sstevel@tonic-gate ASSERT((allmsgsigs & ~ALLSIG) == 0);
18007c478bd9Sstevel@tonic-gate ASSERT((pollwakeups & ~ALLPOLL) == 0);
18017c478bd9Sstevel@tonic-gate
18027c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
18037c478bd9Sstevel@tonic-gate break;
18047c478bd9Sstevel@tonic-gate
18057c478bd9Sstevel@tonic-gate default:
18067c478bd9Sstevel@tonic-gate ASSERT(stp->sd_rmiscfunc != NULL);
18077c478bd9Sstevel@tonic-gate bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp,
1808d3e55dcdSgww &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups);
18097c478bd9Sstevel@tonic-gate ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0);
18107c478bd9Sstevel@tonic-gate ASSERT((firstmsgsigs & ~ALLSIG) == 0);
18117c478bd9Sstevel@tonic-gate ASSERT((allmsgsigs & ~ALLSIG) == 0);
18127c478bd9Sstevel@tonic-gate ASSERT((pollwakeups & ~ALLPOLL) == 0);
18137c478bd9Sstevel@tonic-gate #undef ALLSIG
18147c478bd9Sstevel@tonic-gate #undef ALLPOLL
18157c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
18167c478bd9Sstevel@tonic-gate break;
18177c478bd9Sstevel@tonic-gate }
18187c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
18197c478bd9Sstevel@tonic-gate
18207c478bd9Sstevel@tonic-gate /* By default generate superset of signals */
18217c478bd9Sstevel@tonic-gate signals = (firstmsgsigs | allmsgsigs);
18227c478bd9Sstevel@tonic-gate
18237c478bd9Sstevel@tonic-gate /*
18247c478bd9Sstevel@tonic-gate * The proto and misc functions can return multiple messages
18257c478bd9Sstevel@tonic-gate * as a b_next chain. Such messages are processed separately.
18267c478bd9Sstevel@tonic-gate */
18277c478bd9Sstevel@tonic-gate one_more:
18287c478bd9Sstevel@tonic-gate hipri_sig = 0;
18297c478bd9Sstevel@tonic-gate if (bp == NULL) {
18307c478bd9Sstevel@tonic-gate nextbp = NULL;
18317c478bd9Sstevel@tonic-gate } else {
18327c478bd9Sstevel@tonic-gate nextbp = bp->b_next;
18337c478bd9Sstevel@tonic-gate bp->b_next = NULL;
18347c478bd9Sstevel@tonic-gate
18357c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
18367c478bd9Sstevel@tonic-gate case M_PCPROTO:
18377c478bd9Sstevel@tonic-gate /*
18387c478bd9Sstevel@tonic-gate * Only one priority protocol message is allowed at the
18397c478bd9Sstevel@tonic-gate * stream head at a time.
18407c478bd9Sstevel@tonic-gate */
18417c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRPRI) {
18427c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR,
18437c478bd9Sstevel@tonic-gate "M_PCPROTO already at head");
18447c478bd9Sstevel@tonic-gate freemsg(bp);
18457c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
18467c478bd9Sstevel@tonic-gate goto done;
18477c478bd9Sstevel@tonic-gate }
18487c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI;
18497c478bd9Sstevel@tonic-gate hipri_sig = 1;
18507c478bd9Sstevel@tonic-gate /* FALLTHRU */
18517c478bd9Sstevel@tonic-gate case M_DATA:
18527c478bd9Sstevel@tonic-gate case M_PROTO:
18537c478bd9Sstevel@tonic-gate case M_PASSFP:
18547c478bd9Sstevel@tonic-gate band = bp->b_band;
18557c478bd9Sstevel@tonic-gate /*
18567c478bd9Sstevel@tonic-gate * Marking doesn't work well when messages
18577c478bd9Sstevel@tonic-gate * are marked in more than one band. We only
18587c478bd9Sstevel@tonic-gate * remember the last message received, even if
18597c478bd9Sstevel@tonic-gate * it is placed on the queue ahead of other
18607c478bd9Sstevel@tonic-gate * marked messages.
18617c478bd9Sstevel@tonic-gate */
18627c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARK)
18637c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
18647c478bd9Sstevel@tonic-gate (void) putq(q, bp);
18657c478bd9Sstevel@tonic-gate
18667c478bd9Sstevel@tonic-gate /*
18677c478bd9Sstevel@tonic-gate * If message is a PCPROTO message, always use
18687c478bd9Sstevel@tonic-gate * firstmsgsigs to determine if a signal should be
18697c478bd9Sstevel@tonic-gate * sent as strrput is the only place to send
18707c478bd9Sstevel@tonic-gate * signals for PCPROTO. Other messages are based on
18717c478bd9Sstevel@tonic-gate * the STRGETINPROG flag. The flag determines if
18727c478bd9Sstevel@tonic-gate * strrput or (k)strgetmsg will be responsible for
18737c478bd9Sstevel@tonic-gate * sending the signals, in the firstmsgsigs case.
18747c478bd9Sstevel@tonic-gate */
18757c478bd9Sstevel@tonic-gate if ((hipri_sig == 1) ||
18767c478bd9Sstevel@tonic-gate (((stp->sd_flag & STRGETINPROG) == 0) &&
18777c478bd9Sstevel@tonic-gate (q->q_first == bp)))
18787c478bd9Sstevel@tonic-gate signals = (firstmsgsigs | allmsgsigs);
18797c478bd9Sstevel@tonic-gate else
18807c478bd9Sstevel@tonic-gate signals = allmsgsigs;
18817c478bd9Sstevel@tonic-gate break;
18827c478bd9Sstevel@tonic-gate
18837c478bd9Sstevel@tonic-gate default:
18847c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
18857c478bd9Sstevel@tonic-gate (void) strrput_nondata(q, bp);
18867c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
18877c478bd9Sstevel@tonic-gate break;
18887c478bd9Sstevel@tonic-gate }
18897c478bd9Sstevel@tonic-gate }
18907c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
18917c478bd9Sstevel@tonic-gate /*
18927c478bd9Sstevel@tonic-gate * Wake sleeping read/getmsg and cancel deferred wakeup
18937c478bd9Sstevel@tonic-gate */
18947c478bd9Sstevel@tonic-gate if (wakeups & RSLEEP)
18957c478bd9Sstevel@tonic-gate stp->sd_wakeq &= ~RSLEEP;
18967c478bd9Sstevel@tonic-gate
18977c478bd9Sstevel@tonic-gate wakeups &= stp->sd_flag;
18987c478bd9Sstevel@tonic-gate if (wakeups & RSLEEP) {
18997c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP;
19007c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait);
19017c478bd9Sstevel@tonic-gate }
19027c478bd9Sstevel@tonic-gate if (wakeups & WSLEEP) {
19037c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP;
19047c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait);
19057c478bd9Sstevel@tonic-gate }
19067c478bd9Sstevel@tonic-gate
19077c478bd9Sstevel@tonic-gate if (pollwakeups != 0) {
19087c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) {
19097c478bd9Sstevel@tonic-gate /*
19107c478bd9Sstevel@tonic-gate * Can't use rput_opt since it was not
19117c478bd9Sstevel@tonic-gate * read when sd_lock was held and SR_POLLIN is changed
19127c478bd9Sstevel@tonic-gate * by strpoll() under sd_lock.
19137c478bd9Sstevel@tonic-gate */
19147c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN))
19157c478bd9Sstevel@tonic-gate goto no_pollwake;
19167c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN;
19177c478bd9Sstevel@tonic-gate }
19187c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
19197c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups);
19207c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
19217c478bd9Sstevel@tonic-gate }
19227c478bd9Sstevel@tonic-gate no_pollwake:
19237c478bd9Sstevel@tonic-gate
19247c478bd9Sstevel@tonic-gate /*
19257c478bd9Sstevel@tonic-gate * strsendsig can handle multiple signals with a
19267c478bd9Sstevel@tonic-gate * single call.
19277c478bd9Sstevel@tonic-gate */
19287c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals)
19297c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, band, 0);
19307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
19317c478bd9Sstevel@tonic-gate
19327c478bd9Sstevel@tonic-gate
19337c478bd9Sstevel@tonic-gate done:
19347c478bd9Sstevel@tonic-gate if (nextbp == NULL)
19357c478bd9Sstevel@tonic-gate return (0);
19367c478bd9Sstevel@tonic-gate
19377c478bd9Sstevel@tonic-gate /*
19387c478bd9Sstevel@tonic-gate * Any signals were handled the first time.
19397c478bd9Sstevel@tonic-gate * Wakeups and pollwakeups are redone to avoid any race
19407c478bd9Sstevel@tonic-gate * conditions - all the messages are not queued until the
19417c478bd9Sstevel@tonic-gate * last message has been processed by strrput.
19427c478bd9Sstevel@tonic-gate */
19437c478bd9Sstevel@tonic-gate bp = nextbp;
19447c478bd9Sstevel@tonic-gate signals = firstmsgsigs = allmsgsigs = 0;
19457c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
19467c478bd9Sstevel@tonic-gate goto one_more;
19477c478bd9Sstevel@tonic-gate }
19487c478bd9Sstevel@tonic-gate
19497c478bd9Sstevel@tonic-gate static void
log_dupioc(queue_t * rq,mblk_t * bp)19507c478bd9Sstevel@tonic-gate log_dupioc(queue_t *rq, mblk_t *bp)
19517c478bd9Sstevel@tonic-gate {
19527c478bd9Sstevel@tonic-gate queue_t *wq, *qp;
19537c478bd9Sstevel@tonic-gate char *modnames, *mnp, *dname;
19547c478bd9Sstevel@tonic-gate size_t maxmodstr;
19557c478bd9Sstevel@tonic-gate boolean_t islast;
19567c478bd9Sstevel@tonic-gate
19577c478bd9Sstevel@tonic-gate /*
19587c478bd9Sstevel@tonic-gate * Allocate a buffer large enough to hold the names of nstrpush modules
19597c478bd9Sstevel@tonic-gate * and one driver, with spaces between and NUL terminator. If we can't
19607c478bd9Sstevel@tonic-gate * get memory, then we'll just log the driver name.
19617c478bd9Sstevel@tonic-gate */
19627c478bd9Sstevel@tonic-gate maxmodstr = nstrpush * (FMNAMESZ + 1);
19637c478bd9Sstevel@tonic-gate mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP);
19647c478bd9Sstevel@tonic-gate
19657c478bd9Sstevel@tonic-gate /* march down write side to print log message down to the driver */
19667c478bd9Sstevel@tonic-gate wq = WR(rq);
19677c478bd9Sstevel@tonic-gate
19687c478bd9Sstevel@tonic-gate /* make sure q_next doesn't shift around while we're grabbing data */
19697c478bd9Sstevel@tonic-gate claimstr(wq);
19707c478bd9Sstevel@tonic-gate qp = wq->q_next;
19717c478bd9Sstevel@tonic-gate do {
1972a45f3f93Smeem dname = Q2NAME(qp);
19737c478bd9Sstevel@tonic-gate islast = !SAMESTR(qp) || qp->q_next == NULL;
19747c478bd9Sstevel@tonic-gate if (modnames == NULL) {
19757c478bd9Sstevel@tonic-gate /*
19767c478bd9Sstevel@tonic-gate * If we don't have memory, then get the driver name in
19777c478bd9Sstevel@tonic-gate * the log where we can see it. Note that memory
19787c478bd9Sstevel@tonic-gate * pressure is a possible cause of these sorts of bugs.
19797c478bd9Sstevel@tonic-gate */
19807c478bd9Sstevel@tonic-gate if (islast) {
19817c478bd9Sstevel@tonic-gate modnames = dname;
19827c478bd9Sstevel@tonic-gate maxmodstr = 0;
19837c478bd9Sstevel@tonic-gate }
19847c478bd9Sstevel@tonic-gate } else {
19857c478bd9Sstevel@tonic-gate mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname);
19867c478bd9Sstevel@tonic-gate if (!islast)
19877c478bd9Sstevel@tonic-gate *mnp++ = ' ';
19887c478bd9Sstevel@tonic-gate }
19897c478bd9Sstevel@tonic-gate qp = qp->q_next;
19907c478bd9Sstevel@tonic-gate } while (!islast);
19917c478bd9Sstevel@tonic-gate releasestr(wq);
19927c478bd9Sstevel@tonic-gate /* Cannot happen unless stream head is corrupt. */
19937c478bd9Sstevel@tonic-gate ASSERT(modnames != NULL);
19947c478bd9Sstevel@tonic-gate (void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1,
19957c478bd9Sstevel@tonic-gate SL_CONSOLE|SL_TRACE|SL_ERROR,
19967c478bd9Sstevel@tonic-gate "Warning: stream %p received duplicate %X M_IOC%s; module list: %s",
19977c478bd9Sstevel@tonic-gate rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd,
19987c478bd9Sstevel@tonic-gate (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames);
19997c478bd9Sstevel@tonic-gate if (maxmodstr != 0)
20007c478bd9Sstevel@tonic-gate kmem_free(modnames, maxmodstr);
20017c478bd9Sstevel@tonic-gate }
20027c478bd9Sstevel@tonic-gate
20037c478bd9Sstevel@tonic-gate int
strrput_nondata(queue_t * q,mblk_t * bp)20047c478bd9Sstevel@tonic-gate strrput_nondata(queue_t *q, mblk_t *bp)
20057c478bd9Sstevel@tonic-gate {
20067c478bd9Sstevel@tonic-gate struct stdata *stp;
20077c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
20087c478bd9Sstevel@tonic-gate struct stroptions *sop;
20097c478bd9Sstevel@tonic-gate struct copyreq *reqp;
20107c478bd9Sstevel@tonic-gate struct copyresp *resp;
20117c478bd9Sstevel@tonic-gate unsigned char bpri;
20127c478bd9Sstevel@tonic-gate unsigned char flushed_already = 0;
20137c478bd9Sstevel@tonic-gate
20147c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr;
20157c478bd9Sstevel@tonic-gate
20167c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX));
20177c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q));
20187c478bd9Sstevel@tonic-gate
20197c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
20207c478bd9Sstevel@tonic-gate case M_ERROR:
20217c478bd9Sstevel@tonic-gate /*
20227c478bd9Sstevel@tonic-gate * An error has occurred downstream, the errno is in the first
20237c478bd9Sstevel@tonic-gate * bytes of the message.
20247c478bd9Sstevel@tonic-gate */
20257c478bd9Sstevel@tonic-gate if ((bp->b_wptr - bp->b_rptr) == 2) { /* New flavor */
20267c478bd9Sstevel@tonic-gate unsigned char rw = 0;
20277c478bd9Sstevel@tonic-gate
20287c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
20297c478bd9Sstevel@tonic-gate if (*bp->b_rptr != NOERROR) { /* read error */
20307c478bd9Sstevel@tonic-gate if (*bp->b_rptr != 0) {
20317c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRDERR)
20327c478bd9Sstevel@tonic-gate flushed_already |= FLUSHR;
20337c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERR;
20347c478bd9Sstevel@tonic-gate rw |= FLUSHR;
20357c478bd9Sstevel@tonic-gate } else {
20367c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERR;
20377c478bd9Sstevel@tonic-gate }
20387c478bd9Sstevel@tonic-gate stp->sd_rerror = *bp->b_rptr;
20397c478bd9Sstevel@tonic-gate }
20407c478bd9Sstevel@tonic-gate bp->b_rptr++;
20417c478bd9Sstevel@tonic-gate if (*bp->b_rptr != NOERROR) { /* write error */
20427c478bd9Sstevel@tonic-gate if (*bp->b_rptr != 0) {
20437c478bd9Sstevel@tonic-gate if (stp->sd_flag & STWRERR)
20447c478bd9Sstevel@tonic-gate flushed_already |= FLUSHW;
20457c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERR;
20467c478bd9Sstevel@tonic-gate rw |= FLUSHW;
20477c478bd9Sstevel@tonic-gate } else {
20487c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERR;
20497c478bd9Sstevel@tonic-gate }
20507c478bd9Sstevel@tonic-gate stp->sd_werror = *bp->b_rptr;
20517c478bd9Sstevel@tonic-gate }
20527c478bd9Sstevel@tonic-gate if (rw) {
20537c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE,
2054d3e55dcdSgww "strrput cv_broadcast:q %p, bp %p",
2055d3e55dcdSgww q, bp);
20567c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* readers */
20577c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* writers */
20587c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* ioctllers */
20597c478bd9Sstevel@tonic-gate
20607c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
20617c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLERR);
20627c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
20637c478bd9Sstevel@tonic-gate
20647c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_ERROR)
20657c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_ERROR, 0,
20667c478bd9Sstevel@tonic-gate ((rw & FLUSHR) ? stp->sd_rerror :
20677c478bd9Sstevel@tonic-gate stp->sd_werror));
20687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
20697c478bd9Sstevel@tonic-gate /*
20707c478bd9Sstevel@tonic-gate * Send the M_FLUSH only
20717c478bd9Sstevel@tonic-gate * for the first M_ERROR
20727c478bd9Sstevel@tonic-gate * message on the stream
20737c478bd9Sstevel@tonic-gate */
20747c478bd9Sstevel@tonic-gate if (flushed_already == rw) {
20757c478bd9Sstevel@tonic-gate freemsg(bp);
20767c478bd9Sstevel@tonic-gate return (0);
20777c478bd9Sstevel@tonic-gate }
20787c478bd9Sstevel@tonic-gate
20797c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_FLUSH;
20807c478bd9Sstevel@tonic-gate *bp->b_rptr = rw;
20817c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + 1;
20827c478bd9Sstevel@tonic-gate /*
20837c478bd9Sstevel@tonic-gate * Protect against the driver
20847c478bd9Sstevel@tonic-gate * passing up messages after
20857c478bd9Sstevel@tonic-gate * it has done a qprocsoff
20867c478bd9Sstevel@tonic-gate */
20877c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
20887c478bd9Sstevel@tonic-gate freemsg(bp);
20897c478bd9Sstevel@tonic-gate else
20907c478bd9Sstevel@tonic-gate qreply(q, bp);
20917c478bd9Sstevel@tonic-gate return (0);
20927c478bd9Sstevel@tonic-gate } else
20937c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
20947c478bd9Sstevel@tonic-gate } else if (*bp->b_rptr != 0) { /* Old flavor */
20957c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR))
20967c478bd9Sstevel@tonic-gate flushed_already = FLUSHRW;
20977c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
20987c478bd9Sstevel@tonic-gate stp->sd_flag |= (STRDERR|STWRERR);
20997c478bd9Sstevel@tonic-gate stp->sd_rerror = *bp->b_rptr;
21007c478bd9Sstevel@tonic-gate stp->sd_werror = *bp->b_rptr;
21017c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR,
2102d3e55dcdSgww TR_STRRPUT_WAKE2,
2103d3e55dcdSgww "strrput wakeup #2:q %p, bp %p", q, bp);
21047c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* the readers */
21057c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* the writers */
21067c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* ioctllers */
21077c478bd9Sstevel@tonic-gate
21087c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
21097c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLERR);
21107c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
21117c478bd9Sstevel@tonic-gate
21127c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_ERROR)
21137c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_ERROR, 0,
21147c478bd9Sstevel@tonic-gate (stp->sd_werror ? stp->sd_werror :
21157c478bd9Sstevel@tonic-gate stp->sd_rerror));
21167c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
21177c478bd9Sstevel@tonic-gate
21187c478bd9Sstevel@tonic-gate /*
21197c478bd9Sstevel@tonic-gate * Send the M_FLUSH only
21207c478bd9Sstevel@tonic-gate * for the first M_ERROR
21217c478bd9Sstevel@tonic-gate * message on the stream
21227c478bd9Sstevel@tonic-gate */
21237c478bd9Sstevel@tonic-gate if (flushed_already != FLUSHRW) {
21247c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_FLUSH;
21257c478bd9Sstevel@tonic-gate *bp->b_rptr = FLUSHRW;
21267c478bd9Sstevel@tonic-gate /*
21277c478bd9Sstevel@tonic-gate * Protect against the driver passing up
21287c478bd9Sstevel@tonic-gate * messages after it has done a
21297c478bd9Sstevel@tonic-gate * qprocsoff.
21307c478bd9Sstevel@tonic-gate */
213115c07adcSJohn Levon if (_OTHERQ(q)->q_next == NULL)
213215c07adcSJohn Levon freemsg(bp);
213315c07adcSJohn Levon else
213415c07adcSJohn Levon qreply(q, bp);
213515c07adcSJohn Levon return (0);
21367c478bd9Sstevel@tonic-gate }
21377c478bd9Sstevel@tonic-gate }
21387c478bd9Sstevel@tonic-gate freemsg(bp);
21397c478bd9Sstevel@tonic-gate return (0);
21407c478bd9Sstevel@tonic-gate
21417c478bd9Sstevel@tonic-gate case M_HANGUP:
21427c478bd9Sstevel@tonic-gate
21437c478bd9Sstevel@tonic-gate freemsg(bp);
21447c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
21457c478bd9Sstevel@tonic-gate stp->sd_werror = ENXIO;
21467c478bd9Sstevel@tonic-gate stp->sd_flag |= STRHUP;
21477c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(WSLEEP|RSLEEP);
21487c478bd9Sstevel@tonic-gate
21497c478bd9Sstevel@tonic-gate /*
21507c478bd9Sstevel@tonic-gate * send signal if controlling tty
21517c478bd9Sstevel@tonic-gate */
21527c478bd9Sstevel@tonic-gate
21537c478bd9Sstevel@tonic-gate if (stp->sd_sidp) {
21547c478bd9Sstevel@tonic-gate prsignal(stp->sd_sidp, SIGHUP);
21557c478bd9Sstevel@tonic-gate if (stp->sd_sidp != stp->sd_pgidp)
21567c478bd9Sstevel@tonic-gate pgsignal(stp->sd_pgidp, SIGTSTP);
21577c478bd9Sstevel@tonic-gate }
21587c478bd9Sstevel@tonic-gate
21597c478bd9Sstevel@tonic-gate /*
21607c478bd9Sstevel@tonic-gate * wake up read, write, and exception pollers and
21617c478bd9Sstevel@tonic-gate * reset wakeup mechanism.
21627c478bd9Sstevel@tonic-gate */
21637c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* the readers */
21647c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* the writers */
21657c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* the ioctllers */
21667c478bd9Sstevel@tonic-gate strhup(stp);
21679acbbeafSnn mutex_exit(&stp->sd_lock);
21687c478bd9Sstevel@tonic-gate return (0);
21697c478bd9Sstevel@tonic-gate
21707c478bd9Sstevel@tonic-gate case M_UNHANGUP:
21717c478bd9Sstevel@tonic-gate freemsg(bp);
21727c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
21737c478bd9Sstevel@tonic-gate stp->sd_werror = 0;
21747c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRHUP;
21757c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
21767c478bd9Sstevel@tonic-gate return (0);
21777c478bd9Sstevel@tonic-gate
21787c478bd9Sstevel@tonic-gate case M_SIG:
21797c478bd9Sstevel@tonic-gate /*
21807c478bd9Sstevel@tonic-gate * Someone downstream wants to post a signal. The
21817c478bd9Sstevel@tonic-gate * signal to post is contained in the first byte of the
21827c478bd9Sstevel@tonic-gate * message. If the message would go on the front of
21837c478bd9Sstevel@tonic-gate * the queue, send a signal to the process group
21847c478bd9Sstevel@tonic-gate * (if not SIGPOLL) or to the siglist processes
21857c478bd9Sstevel@tonic-gate * (SIGPOLL). If something is already on the queue,
21867c478bd9Sstevel@tonic-gate * OR if we are delivering a delayed suspend (*sigh*
21877c478bd9Sstevel@tonic-gate * another "tty" hack) and there's no one sleeping already,
21887c478bd9Sstevel@tonic-gate * just enqueue the message.
21897c478bd9Sstevel@tonic-gate */
21907c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
21917c478bd9Sstevel@tonic-gate if (q->q_first || (*bp->b_rptr == SIGTSTP &&
21927c478bd9Sstevel@tonic-gate !(stp->sd_flag & RSLEEP))) {
21937c478bd9Sstevel@tonic-gate (void) putq(q, bp);
21947c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
21957c478bd9Sstevel@tonic-gate return (0);
21967c478bd9Sstevel@tonic-gate }
21977c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
21987c478bd9Sstevel@tonic-gate /* FALLTHRU */
21997c478bd9Sstevel@tonic-gate
22007c478bd9Sstevel@tonic-gate case M_PCSIG:
22017c478bd9Sstevel@tonic-gate /*
22027c478bd9Sstevel@tonic-gate * Don't enqueue, just post the signal.
22037c478bd9Sstevel@tonic-gate */
22047c478bd9Sstevel@tonic-gate strsignal(stp, *bp->b_rptr, 0L);
22057c478bd9Sstevel@tonic-gate freemsg(bp);
22067c478bd9Sstevel@tonic-gate return (0);
22077c478bd9Sstevel@tonic-gate
2208ca9327a6Smeem case M_CMD:
2209ca9327a6Smeem if (MBLKL(bp) != sizeof (cmdblk_t)) {
2210ca9327a6Smeem freemsg(bp);
2211ca9327a6Smeem return (0);
2212ca9327a6Smeem }
2213ca9327a6Smeem
2214ca9327a6Smeem mutex_enter(&stp->sd_lock);
2215ca9327a6Smeem if (stp->sd_flag & STRCMDWAIT) {
2216ca9327a6Smeem ASSERT(stp->sd_cmdblk == NULL);
2217ca9327a6Smeem stp->sd_cmdblk = bp;
2218ca9327a6Smeem cv_broadcast(&stp->sd_monitor);
2219ca9327a6Smeem mutex_exit(&stp->sd_lock);
2220ca9327a6Smeem } else {
2221ca9327a6Smeem mutex_exit(&stp->sd_lock);
2222ca9327a6Smeem freemsg(bp);
2223ca9327a6Smeem }
2224ca9327a6Smeem return (0);
2225ca9327a6Smeem
22267c478bd9Sstevel@tonic-gate case M_FLUSH:
22277c478bd9Sstevel@tonic-gate /*
22287c478bd9Sstevel@tonic-gate * Flush queues. The indication of which queues to flush
22297c478bd9Sstevel@tonic-gate * is in the first byte of the message. If the read queue
22307c478bd9Sstevel@tonic-gate * is specified, then flush it. If FLUSHBAND is set, just
22317c478bd9Sstevel@tonic-gate * flush the band specified by the second byte of the message.
22327c478bd9Sstevel@tonic-gate *
22337c478bd9Sstevel@tonic-gate * If a module has issued a M_SETOPT to not flush hi
22347c478bd9Sstevel@tonic-gate * priority messages off of the stream head, then pass this
22357c478bd9Sstevel@tonic-gate * flag into the flushq code to preserve such messages.
22367c478bd9Sstevel@tonic-gate */
22377c478bd9Sstevel@tonic-gate
22387c478bd9Sstevel@tonic-gate if (*bp->b_rptr & FLUSHR) {
22397c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
22407c478bd9Sstevel@tonic-gate if (*bp->b_rptr & FLUSHBAND) {
22417c478bd9Sstevel@tonic-gate ASSERT((bp->b_wptr - bp->b_rptr) >= 2);
22427c478bd9Sstevel@tonic-gate flushband(q, *(bp->b_rptr + 1), FLUSHALL);
22437c478bd9Sstevel@tonic-gate } else
22447c478bd9Sstevel@tonic-gate flushq_common(q, FLUSHALL,
22457c478bd9Sstevel@tonic-gate stp->sd_read_opt & RFLUSHPCPROT);
22467c478bd9Sstevel@tonic-gate if ((q->q_first == NULL) ||
22477c478bd9Sstevel@tonic-gate (q->q_first->b_datap->db_type < QPCTL))
22487c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
22497c478bd9Sstevel@tonic-gate else {
22507c478bd9Sstevel@tonic-gate ASSERT(stp->sd_flag & STRPRI);
22517c478bd9Sstevel@tonic-gate }
22527c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
22537c478bd9Sstevel@tonic-gate }
22547c478bd9Sstevel@tonic-gate if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) {
22557c478bd9Sstevel@tonic-gate *bp->b_rptr &= ~FLUSHR;
22567c478bd9Sstevel@tonic-gate bp->b_flag |= MSGNOLOOP;
22577c478bd9Sstevel@tonic-gate /*
22587c478bd9Sstevel@tonic-gate * Protect against the driver passing up
22597c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
22607c478bd9Sstevel@tonic-gate */
22617c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
22627c478bd9Sstevel@tonic-gate freemsg(bp);
22637c478bd9Sstevel@tonic-gate else
22647c478bd9Sstevel@tonic-gate qreply(q, bp);
22657c478bd9Sstevel@tonic-gate return (0);
22667c478bd9Sstevel@tonic-gate }
22677c478bd9Sstevel@tonic-gate freemsg(bp);
22687c478bd9Sstevel@tonic-gate return (0);
22697c478bd9Sstevel@tonic-gate
22707c478bd9Sstevel@tonic-gate case M_IOCACK:
22717c478bd9Sstevel@tonic-gate case M_IOCNAK:
22727c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr;
22737c478bd9Sstevel@tonic-gate /*
22747c478bd9Sstevel@tonic-gate * If not waiting for ACK or NAK then just free msg.
22757c478bd9Sstevel@tonic-gate * If incorrect id sequence number then just free msg.
22767c478bd9Sstevel@tonic-gate * If already have ACK or NAK for user then this is a
22777c478bd9Sstevel@tonic-gate * duplicate, display a warning and free the msg.
22787c478bd9Sstevel@tonic-gate */
22797c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
22807c478bd9Sstevel@tonic-gate if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
22817c478bd9Sstevel@tonic-gate (stp->sd_iocid != iocbp->ioc_id)) {
22827c478bd9Sstevel@tonic-gate /*
22837c478bd9Sstevel@tonic-gate * If the ACK/NAK is a dup, display a message
22847c478bd9Sstevel@tonic-gate * Dup is when sd_iocid == ioc_id, and
22857c478bd9Sstevel@tonic-gate * sd_iocblk == <valid ptr> or -1 (the former
22867c478bd9Sstevel@tonic-gate * is when an ioctl has been put on the stream
22877c478bd9Sstevel@tonic-gate * head, but has not yet been consumed, the
22887c478bd9Sstevel@tonic-gate * later is when it has been consumed).
22897c478bd9Sstevel@tonic-gate */
22907c478bd9Sstevel@tonic-gate if ((stp->sd_iocid == iocbp->ioc_id) &&
22917c478bd9Sstevel@tonic-gate (stp->sd_iocblk != NULL)) {
22927c478bd9Sstevel@tonic-gate log_dupioc(q, bp);
22937c478bd9Sstevel@tonic-gate }
22947c478bd9Sstevel@tonic-gate freemsg(bp);
22957c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
22967c478bd9Sstevel@tonic-gate return (0);
22977c478bd9Sstevel@tonic-gate }
22987c478bd9Sstevel@tonic-gate
22997c478bd9Sstevel@tonic-gate /*
23007c478bd9Sstevel@tonic-gate * Assign ACK or NAK to user and wake up.
23017c478bd9Sstevel@tonic-gate */
23027c478bd9Sstevel@tonic-gate stp->sd_iocblk = bp;
23037c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
23047c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
23057c478bd9Sstevel@tonic-gate return (0);
23067c478bd9Sstevel@tonic-gate
23077c478bd9Sstevel@tonic-gate case M_COPYIN:
23087c478bd9Sstevel@tonic-gate case M_COPYOUT:
23097c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr;
23107c478bd9Sstevel@tonic-gate
23117c478bd9Sstevel@tonic-gate /*
23127c478bd9Sstevel@tonic-gate * If not waiting for ACK or NAK then just fail request.
23137c478bd9Sstevel@tonic-gate * If already have ACK, NAK, or copy request, then just
23147c478bd9Sstevel@tonic-gate * fail request.
23157c478bd9Sstevel@tonic-gate * If incorrect id sequence number then just fail request.
23167c478bd9Sstevel@tonic-gate */
23177c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
23187c478bd9Sstevel@tonic-gate if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk ||
23197c478bd9Sstevel@tonic-gate (stp->sd_iocid != reqp->cq_id)) {
23207c478bd9Sstevel@tonic-gate if (bp->b_cont) {
23217c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
23227c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
23237c478bd9Sstevel@tonic-gate }
23247c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA;
23257c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
23267c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr;
23277c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)1; /* failure */
23287c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
23297c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp);
23307c478bd9Sstevel@tonic-gate return (0);
23317c478bd9Sstevel@tonic-gate }
23327c478bd9Sstevel@tonic-gate
23337c478bd9Sstevel@tonic-gate /*
23347c478bd9Sstevel@tonic-gate * Assign copy request to user and wake up.
23357c478bd9Sstevel@tonic-gate */
23367c478bd9Sstevel@tonic-gate stp->sd_iocblk = bp;
23377c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
23387c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
23397c478bd9Sstevel@tonic-gate return (0);
23407c478bd9Sstevel@tonic-gate
23417c478bd9Sstevel@tonic-gate case M_SETOPTS:
23427c478bd9Sstevel@tonic-gate /*
23437c478bd9Sstevel@tonic-gate * Set stream head options (read option, write offset,
23447c478bd9Sstevel@tonic-gate * min/max packet size, and/or high/low water marks for
23457c478bd9Sstevel@tonic-gate * the read side only).
23467c478bd9Sstevel@tonic-gate */
23477c478bd9Sstevel@tonic-gate
23487c478bd9Sstevel@tonic-gate bpri = 0;
23497c478bd9Sstevel@tonic-gate sop = (struct stroptions *)bp->b_rptr;
23507c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
23517c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_READOPT) {
23527c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RMODEMASK) {
23537c478bd9Sstevel@tonic-gate case RNORM:
23547c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
23557c478bd9Sstevel@tonic-gate break;
23567c478bd9Sstevel@tonic-gate
23577c478bd9Sstevel@tonic-gate case RMSGD:
23587c478bd9Sstevel@tonic-gate stp->sd_read_opt =
23597c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_MSGNODIS) |
23607c478bd9Sstevel@tonic-gate RD_MSGDIS);
23617c478bd9Sstevel@tonic-gate break;
23627c478bd9Sstevel@tonic-gate
23637c478bd9Sstevel@tonic-gate case RMSGN:
23647c478bd9Sstevel@tonic-gate stp->sd_read_opt =
23657c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_MSGDIS) |
23667c478bd9Sstevel@tonic-gate RD_MSGNODIS);
23677c478bd9Sstevel@tonic-gate break;
23687c478bd9Sstevel@tonic-gate }
23697c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RPROTMASK) {
23707c478bd9Sstevel@tonic-gate case RPROTNORM:
23717c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
23727c478bd9Sstevel@tonic-gate break;
23737c478bd9Sstevel@tonic-gate
23747c478bd9Sstevel@tonic-gate case RPROTDAT:
23757c478bd9Sstevel@tonic-gate stp->sd_read_opt =
23767c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_PROTDIS) |
23777c478bd9Sstevel@tonic-gate RD_PROTDAT);
23787c478bd9Sstevel@tonic-gate break;
23797c478bd9Sstevel@tonic-gate
23807c478bd9Sstevel@tonic-gate case RPROTDIS:
23817c478bd9Sstevel@tonic-gate stp->sd_read_opt =
23827c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_PROTDAT) |
23837c478bd9Sstevel@tonic-gate RD_PROTDIS);
23847c478bd9Sstevel@tonic-gate break;
23857c478bd9Sstevel@tonic-gate }
23867c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RFLUSHMASK) {
23877c478bd9Sstevel@tonic-gate case RFLUSHPCPROT:
23887c478bd9Sstevel@tonic-gate /*
23897c478bd9Sstevel@tonic-gate * This sets the stream head to NOT flush
23907c478bd9Sstevel@tonic-gate * M_PCPROTO messages.
23917c478bd9Sstevel@tonic-gate */
23927c478bd9Sstevel@tonic-gate stp->sd_read_opt |= RFLUSHPCPROT;
23937c478bd9Sstevel@tonic-gate break;
23947c478bd9Sstevel@tonic-gate }
23957c478bd9Sstevel@tonic-gate }
23967c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ERROPT) {
23977c478bd9Sstevel@tonic-gate switch (sop->so_erropt & RERRMASK) {
23987c478bd9Sstevel@tonic-gate case RERRNORM:
23997c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERRNONPERSIST;
24007c478bd9Sstevel@tonic-gate break;
24017c478bd9Sstevel@tonic-gate case RERRNONPERSIST:
24027c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERRNONPERSIST;
24037c478bd9Sstevel@tonic-gate break;
24047c478bd9Sstevel@tonic-gate }
24057c478bd9Sstevel@tonic-gate switch (sop->so_erropt & WERRMASK) {
24067c478bd9Sstevel@tonic-gate case WERRNORM:
24077c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERRNONPERSIST;
24087c478bd9Sstevel@tonic-gate break;
24097c478bd9Sstevel@tonic-gate case WERRNONPERSIST:
24107c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERRNONPERSIST;
24117c478bd9Sstevel@tonic-gate break;
24127c478bd9Sstevel@tonic-gate }
24137c478bd9Sstevel@tonic-gate }
24147c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_COPYOPT) {
24157c478bd9Sstevel@tonic-gate if (sop->so_copyopt & ZCVMSAFE) {
24167c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STZCVMSAFE;
24177c478bd9Sstevel@tonic-gate stp->sd_copyflag &= ~STZCVMUNSAFE;
24187c478bd9Sstevel@tonic-gate } else if (sop->so_copyopt & ZCVMUNSAFE) {
24197c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STZCVMUNSAFE;
24207c478bd9Sstevel@tonic-gate stp->sd_copyflag &= ~STZCVMSAFE;
24217c478bd9Sstevel@tonic-gate }
24227c478bd9Sstevel@tonic-gate
24237c478bd9Sstevel@tonic-gate if (sop->so_copyopt & COPYCACHED) {
24247c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STRCOPYCACHED;
24257c478bd9Sstevel@tonic-gate }
24267c478bd9Sstevel@tonic-gate }
24277c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_WROFF)
24287c478bd9Sstevel@tonic-gate stp->sd_wroff = sop->so_wroff;
2429c28749e9Skais if (sop->so_flags & SO_TAIL)
2430c28749e9Skais stp->sd_tail = sop->so_tail;
24317c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MINPSZ)
24327c478bd9Sstevel@tonic-gate q->q_minpsz = sop->so_minpsz;
24337c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MAXPSZ)
24347c478bd9Sstevel@tonic-gate q->q_maxpsz = sop->so_maxpsz;
24357c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MAXBLK)
24367c478bd9Sstevel@tonic-gate stp->sd_maxblk = sop->so_maxblk;
24377c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_HIWAT) {
2438d3e55dcdSgww if (sop->so_flags & SO_BAND) {
2439d3e55dcdSgww if (strqset(q, QHIWAT,
2440d3e55dcdSgww sop->so_band, sop->so_hiwat)) {
2441d3e55dcdSgww cmn_err(CE_WARN, "strrput: could not "
2442d3e55dcdSgww "allocate qband\n");
2443d3e55dcdSgww } else {
2444d3e55dcdSgww bpri = sop->so_band;
2445d3e55dcdSgww }
2446d3e55dcdSgww } else {
2447d3e55dcdSgww q->q_hiwat = sop->so_hiwat;
2448d3e55dcdSgww }
24497c478bd9Sstevel@tonic-gate }
24507c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_LOWAT) {
2451d3e55dcdSgww if (sop->so_flags & SO_BAND) {
2452d3e55dcdSgww if (strqset(q, QLOWAT,
2453d3e55dcdSgww sop->so_band, sop->so_lowat)) {
2454d3e55dcdSgww cmn_err(CE_WARN, "strrput: could not "
2455d3e55dcdSgww "allocate qband\n");
2456d3e55dcdSgww } else {
2457d3e55dcdSgww bpri = sop->so_band;
2458d3e55dcdSgww }
2459d3e55dcdSgww } else {
2460d3e55dcdSgww q->q_lowat = sop->so_lowat;
2461d3e55dcdSgww }
24627c478bd9Sstevel@tonic-gate }
24637c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MREADON)
24647c478bd9Sstevel@tonic-gate stp->sd_flag |= SNDMREAD;
24657c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MREADOFF)
24667c478bd9Sstevel@tonic-gate stp->sd_flag &= ~SNDMREAD;
24677c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NDELON)
24687c478bd9Sstevel@tonic-gate stp->sd_flag |= OLDNDELAY;
24697c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NDELOFF)
24707c478bd9Sstevel@tonic-gate stp->sd_flag &= ~OLDNDELAY;
24717c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ISTTY)
24727c478bd9Sstevel@tonic-gate stp->sd_flag |= STRISTTY;
24737c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ISNTTY)
24747c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRISTTY;
24757c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_TOSTOP)
24767c478bd9Sstevel@tonic-gate stp->sd_flag |= STRTOSTOP;
24777c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_TONSTOP)
24787c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRTOSTOP;
24797c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_DELIM)
24807c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDELIM;
24817c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NODELIM)
24827c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDELIM;
24837c478bd9Sstevel@tonic-gate
24847c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
24857c478bd9Sstevel@tonic-gate freemsg(bp);
24867c478bd9Sstevel@tonic-gate
24877c478bd9Sstevel@tonic-gate /* Check backenable in case the water marks changed */
24887c478bd9Sstevel@tonic-gate qbackenable(q, bpri);
24897c478bd9Sstevel@tonic-gate return (0);
24907c478bd9Sstevel@tonic-gate
24917c478bd9Sstevel@tonic-gate /*
24927c478bd9Sstevel@tonic-gate * The following set of cases deal with situations where two stream
24937c478bd9Sstevel@tonic-gate * heads are connected to each other (twisted streams). These messages
24947c478bd9Sstevel@tonic-gate * have no meaning at the stream head.
24957c478bd9Sstevel@tonic-gate */
24967c478bd9Sstevel@tonic-gate case M_BREAK:
24977c478bd9Sstevel@tonic-gate case M_CTL:
24987c478bd9Sstevel@tonic-gate case M_DELAY:
24997c478bd9Sstevel@tonic-gate case M_START:
25007c478bd9Sstevel@tonic-gate case M_STOP:
25017c478bd9Sstevel@tonic-gate case M_IOCDATA:
25027c478bd9Sstevel@tonic-gate case M_STARTI:
25037c478bd9Sstevel@tonic-gate case M_STOPI:
25047c478bd9Sstevel@tonic-gate freemsg(bp);
25057c478bd9Sstevel@tonic-gate return (0);
25067c478bd9Sstevel@tonic-gate
25077c478bd9Sstevel@tonic-gate case M_IOCTL:
25087c478bd9Sstevel@tonic-gate /*
25097c478bd9Sstevel@tonic-gate * Always NAK this condition
25107c478bd9Sstevel@tonic-gate * (makes no sense)
25117c478bd9Sstevel@tonic-gate * If there is one or more threads in the read side
25127c478bd9Sstevel@tonic-gate * rwnext we have to defer the nacking until that thread
25137c478bd9Sstevel@tonic-gate * returns (in strget).
25147c478bd9Sstevel@tonic-gate */
25157c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
25167c478bd9Sstevel@tonic-gate if (stp->sd_struiodnak != 0) {
25177c478bd9Sstevel@tonic-gate /*
25187c478bd9Sstevel@tonic-gate * Defer NAK to the streamhead. Queue at the end
25197c478bd9Sstevel@tonic-gate * the list.
25207c478bd9Sstevel@tonic-gate */
25217c478bd9Sstevel@tonic-gate mblk_t *mp = stp->sd_struionak;
25227c478bd9Sstevel@tonic-gate
25237c478bd9Sstevel@tonic-gate while (mp && mp->b_next)
25247c478bd9Sstevel@tonic-gate mp = mp->b_next;
25257c478bd9Sstevel@tonic-gate if (mp)
25267c478bd9Sstevel@tonic-gate mp->b_next = bp;
25277c478bd9Sstevel@tonic-gate else
25287c478bd9Sstevel@tonic-gate stp->sd_struionak = bp;
25297c478bd9Sstevel@tonic-gate bp->b_next = NULL;
25307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
25317c478bd9Sstevel@tonic-gate return (0);
25327c478bd9Sstevel@tonic-gate }
25337c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
25347c478bd9Sstevel@tonic-gate
25357c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK;
25367c478bd9Sstevel@tonic-gate /*
25377c478bd9Sstevel@tonic-gate * Protect against the driver passing up
25387c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff.
25397c478bd9Sstevel@tonic-gate */
25407c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL)
25417c478bd9Sstevel@tonic-gate freemsg(bp);
25427c478bd9Sstevel@tonic-gate else
25437c478bd9Sstevel@tonic-gate qreply(q, bp);
25447c478bd9Sstevel@tonic-gate return (0);
25457c478bd9Sstevel@tonic-gate
25467c478bd9Sstevel@tonic-gate default:
25477c478bd9Sstevel@tonic-gate #ifdef DEBUG
25487c478bd9Sstevel@tonic-gate cmn_err(CE_WARN,
2549d3e55dcdSgww "bad message type %x received at stream head\n",
2550d3e55dcdSgww bp->b_datap->db_type);
25517c478bd9Sstevel@tonic-gate #endif
25527c478bd9Sstevel@tonic-gate freemsg(bp);
25537c478bd9Sstevel@tonic-gate return (0);
25547c478bd9Sstevel@tonic-gate }
25557c478bd9Sstevel@tonic-gate
25567c478bd9Sstevel@tonic-gate /* NOTREACHED */
25577c478bd9Sstevel@tonic-gate }
25587c478bd9Sstevel@tonic-gate
25597c478bd9Sstevel@tonic-gate /*
25607c478bd9Sstevel@tonic-gate * Check if the stream pointed to by `stp' can be written to, and return an
25617c478bd9Sstevel@tonic-gate * error code if not. If `eiohup' is set, then return EIO if STRHUP is set.
25627c478bd9Sstevel@tonic-gate * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream,
25637c478bd9Sstevel@tonic-gate * then always return EPIPE and send a SIGPIPE to the invoking thread.
25647c478bd9Sstevel@tonic-gate */
25657c478bd9Sstevel@tonic-gate static int
strwriteable(struct stdata * stp,boolean_t eiohup,boolean_t sigpipeok)25667c478bd9Sstevel@tonic-gate strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok)
25677c478bd9Sstevel@tonic-gate {
25687c478bd9Sstevel@tonic-gate int error;
25697c478bd9Sstevel@tonic-gate
25707c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
25717c478bd9Sstevel@tonic-gate
25727c478bd9Sstevel@tonic-gate /*
25737c478bd9Sstevel@tonic-gate * For modem support, POSIX states that on writes, EIO should
25747c478bd9Sstevel@tonic-gate * be returned if the stream has been hung up.
25757c478bd9Sstevel@tonic-gate */
25767c478bd9Sstevel@tonic-gate if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP)
25777c478bd9Sstevel@tonic-gate error = EIO;
25787c478bd9Sstevel@tonic-gate else
25797c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0);
25807c478bd9Sstevel@tonic-gate
25817c478bd9Sstevel@tonic-gate if (error != 0) {
25827c478bd9Sstevel@tonic-gate if (!(stp->sd_flag & STPLEX) &&
25837c478bd9Sstevel@tonic-gate (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) {
25847c478bd9Sstevel@tonic-gate tsignal(curthread, SIGPIPE);
25857c478bd9Sstevel@tonic-gate error = EPIPE;
25867c478bd9Sstevel@tonic-gate }
25877c478bd9Sstevel@tonic-gate }
25887c478bd9Sstevel@tonic-gate
25897c478bd9Sstevel@tonic-gate return (error);
25907c478bd9Sstevel@tonic-gate }
25917c478bd9Sstevel@tonic-gate
25927c478bd9Sstevel@tonic-gate /*
25937c478bd9Sstevel@tonic-gate * Copyin and send data down a stream.
25947c478bd9Sstevel@tonic-gate * The caller will allocate and copyin any control part that precedes the
2595de8c4a14SErik Nordmark * message and pass that in as mctl.
25967c478bd9Sstevel@tonic-gate *
25977c478bd9Sstevel@tonic-gate * Caller should *not* hold sd_lock.
25987c478bd9Sstevel@tonic-gate * When EWOULDBLOCK is returned the caller has to redo the canputnext
25997c478bd9Sstevel@tonic-gate * under sd_lock in order to avoid missing a backenabling wakeup.
26007c478bd9Sstevel@tonic-gate *
26017c478bd9Sstevel@tonic-gate * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA.
26027c478bd9Sstevel@tonic-gate *
26037c478bd9Sstevel@tonic-gate * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages.
26047c478bd9Sstevel@tonic-gate * For sync streams we can only ignore flow control by reverting to using
26057c478bd9Sstevel@tonic-gate * putnext.
26067c478bd9Sstevel@tonic-gate *
26077c478bd9Sstevel@tonic-gate * If sd_maxblk is less than *iosize this routine might return without
26087c478bd9Sstevel@tonic-gate * transferring all of *iosize. In all cases, on return *iosize will contain
26097c478bd9Sstevel@tonic-gate * the amount of data that was transferred.
26107c478bd9Sstevel@tonic-gate */
26117c478bd9Sstevel@tonic-gate static int
strput(struct stdata * stp,mblk_t * mctl,struct uio * uiop,ssize_t * iosize,int b_flag,int pri,int flags)26127c478bd9Sstevel@tonic-gate strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize,
26137c478bd9Sstevel@tonic-gate int b_flag, int pri, int flags)
26147c478bd9Sstevel@tonic-gate {
26157c478bd9Sstevel@tonic-gate struiod_t uiod;
26168e935259SBryan Cantrill struct iovec buf[IOV_MAX_STACK];
26178e935259SBryan Cantrill int iovlen = 0;
26187c478bd9Sstevel@tonic-gate mblk_t *mp;
26197c478bd9Sstevel@tonic-gate queue_t *wqp = stp->sd_wrq;
26207c478bd9Sstevel@tonic-gate int error = 0;
26217c478bd9Sstevel@tonic-gate ssize_t count = *iosize;
26227c478bd9Sstevel@tonic-gate
26237c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&stp->sd_lock));
26247c478bd9Sstevel@tonic-gate
26257c478bd9Sstevel@tonic-gate if (uiop != NULL && count >= 0)
26267c478bd9Sstevel@tonic-gate flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0;
26277c478bd9Sstevel@tonic-gate
26287c478bd9Sstevel@tonic-gate if (!(flags & STRUIO_POSTPONE)) {
26297c478bd9Sstevel@tonic-gate /*
26307c478bd9Sstevel@tonic-gate * Use regular canputnext, strmakedata, putnext sequence.
26317c478bd9Sstevel@tonic-gate */
26327c478bd9Sstevel@tonic-gate if (pri == 0) {
26337c478bd9Sstevel@tonic-gate if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
26347c478bd9Sstevel@tonic-gate freemsg(mctl);
26357c478bd9Sstevel@tonic-gate return (EWOULDBLOCK);
26367c478bd9Sstevel@tonic-gate }
26377c478bd9Sstevel@tonic-gate } else {
26387c478bd9Sstevel@tonic-gate if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) {
26397c478bd9Sstevel@tonic-gate freemsg(mctl);
26407c478bd9Sstevel@tonic-gate return (EWOULDBLOCK);
26417c478bd9Sstevel@tonic-gate }
26427c478bd9Sstevel@tonic-gate }
26437c478bd9Sstevel@tonic-gate
26447c478bd9Sstevel@tonic-gate if ((error = strmakedata(iosize, uiop, stp, flags,
2645d3e55dcdSgww &mp)) != 0) {
26467c478bd9Sstevel@tonic-gate freemsg(mctl);
26477c478bd9Sstevel@tonic-gate /*
26487c478bd9Sstevel@tonic-gate * need to change return code to ENOMEM
26497c478bd9Sstevel@tonic-gate * so that this is not confused with
26507c478bd9Sstevel@tonic-gate * flow control, EAGAIN.
26517c478bd9Sstevel@tonic-gate */
26527c478bd9Sstevel@tonic-gate
26537c478bd9Sstevel@tonic-gate if (error == EAGAIN)
26547c478bd9Sstevel@tonic-gate return (ENOMEM);
26557c478bd9Sstevel@tonic-gate else
26567c478bd9Sstevel@tonic-gate return (error);
26577c478bd9Sstevel@tonic-gate }
26587c478bd9Sstevel@tonic-gate if (mctl != NULL) {
26597c478bd9Sstevel@tonic-gate if (mctl->b_cont == NULL)
26607c478bd9Sstevel@tonic-gate mctl->b_cont = mp;
26617c478bd9Sstevel@tonic-gate else if (mp != NULL)
26627c478bd9Sstevel@tonic-gate linkb(mctl, mp);
26637c478bd9Sstevel@tonic-gate mp = mctl;
26647c478bd9Sstevel@tonic-gate } else if (mp == NULL)
26657c478bd9Sstevel@tonic-gate return (0);
26667c478bd9Sstevel@tonic-gate
26677c478bd9Sstevel@tonic-gate mp->b_flag |= b_flag;
26687c478bd9Sstevel@tonic-gate mp->b_band = (uchar_t)pri;
26697c478bd9Sstevel@tonic-gate
26707c478bd9Sstevel@tonic-gate if (flags & MSG_IGNFLOW) {
26717c478bd9Sstevel@tonic-gate /*
26727c478bd9Sstevel@tonic-gate * XXX Hack: Don't get stuck running service
26737c478bd9Sstevel@tonic-gate * procedures. This is needed for sockfs when
26747c478bd9Sstevel@tonic-gate * sending the unbind message out of the rput
26757c478bd9Sstevel@tonic-gate * procedure - we don't want a put procedure
26767c478bd9Sstevel@tonic-gate * to run service procedures.
26777c478bd9Sstevel@tonic-gate */
26787c478bd9Sstevel@tonic-gate putnext(wqp, mp);
26797c478bd9Sstevel@tonic-gate } else {
26807c478bd9Sstevel@tonic-gate stream_willservice(stp);
26817c478bd9Sstevel@tonic-gate putnext(wqp, mp);
26827c478bd9Sstevel@tonic-gate stream_runservice(stp);
26837c478bd9Sstevel@tonic-gate }
26847c478bd9Sstevel@tonic-gate return (0);
26857c478bd9Sstevel@tonic-gate }
26867c478bd9Sstevel@tonic-gate /*
26877c478bd9Sstevel@tonic-gate * Stream supports rwnext() for the write side.
26887c478bd9Sstevel@tonic-gate */
26897c478bd9Sstevel@tonic-gate if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) {
26907c478bd9Sstevel@tonic-gate freemsg(mctl);
26917c478bd9Sstevel@tonic-gate /*
26927c478bd9Sstevel@tonic-gate * map EAGAIN to ENOMEM since EAGAIN means "flow controlled".
26937c478bd9Sstevel@tonic-gate */
26947c478bd9Sstevel@tonic-gate return (error == EAGAIN ? ENOMEM : error);
26957c478bd9Sstevel@tonic-gate }
26967c478bd9Sstevel@tonic-gate if (mctl != NULL) {
26977c478bd9Sstevel@tonic-gate if (mctl->b_cont == NULL)
26987c478bd9Sstevel@tonic-gate mctl->b_cont = mp;
26997c478bd9Sstevel@tonic-gate else if (mp != NULL)
27007c478bd9Sstevel@tonic-gate linkb(mctl, mp);
27017c478bd9Sstevel@tonic-gate mp = mctl;
27027c478bd9Sstevel@tonic-gate } else if (mp == NULL) {
27037c478bd9Sstevel@tonic-gate return (0);
27047c478bd9Sstevel@tonic-gate }
27057c478bd9Sstevel@tonic-gate
27067c478bd9Sstevel@tonic-gate mp->b_flag |= b_flag;
27077c478bd9Sstevel@tonic-gate mp->b_band = (uchar_t)pri;
27087c478bd9Sstevel@tonic-gate
27098e935259SBryan Cantrill if (uiop->uio_iovcnt > IOV_MAX_STACK) {
27108e935259SBryan Cantrill iovlen = uiop->uio_iovcnt * sizeof (iovec_t);
27118e935259SBryan Cantrill uiod.d_iov = (struct iovec *)kmem_alloc(iovlen, KM_SLEEP);
27128e935259SBryan Cantrill } else {
27138e935259SBryan Cantrill uiod.d_iov = buf;
27148e935259SBryan Cantrill }
27158e935259SBryan Cantrill
27168e935259SBryan Cantrill (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov, uiop->uio_iovcnt);
27177c478bd9Sstevel@tonic-gate uiod.d_uio.uio_offset = 0;
27187c478bd9Sstevel@tonic-gate uiod.d_mp = mp;
27197c478bd9Sstevel@tonic-gate error = rwnext(wqp, &uiod);
27207c478bd9Sstevel@tonic-gate if (! uiod.d_mp) {
27217c478bd9Sstevel@tonic-gate uioskip(uiop, *iosize);
27228e935259SBryan Cantrill if (iovlen != 0)
27238e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27247c478bd9Sstevel@tonic-gate return (error);
27257c478bd9Sstevel@tonic-gate }
27267c478bd9Sstevel@tonic-gate ASSERT(mp == uiod.d_mp);
27277c478bd9Sstevel@tonic-gate if (error == EINVAL) {
27287c478bd9Sstevel@tonic-gate /*
27297c478bd9Sstevel@tonic-gate * The stream plumbing must have changed while
27307c478bd9Sstevel@tonic-gate * we were away, so just turn off rwnext()s.
27317c478bd9Sstevel@tonic-gate */
27327c478bd9Sstevel@tonic-gate error = 0;
27337c478bd9Sstevel@tonic-gate } else if (error == EBUSY || error == EWOULDBLOCK) {
27347c478bd9Sstevel@tonic-gate /*
27357c478bd9Sstevel@tonic-gate * Couldn't enter a perimeter or took a page fault,
27367c478bd9Sstevel@tonic-gate * so fall-back to putnext().
27377c478bd9Sstevel@tonic-gate */
27387c478bd9Sstevel@tonic-gate error = 0;
27397c478bd9Sstevel@tonic-gate } else {
27407c478bd9Sstevel@tonic-gate freemsg(mp);
27418e935259SBryan Cantrill if (iovlen != 0)
27428e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27437c478bd9Sstevel@tonic-gate return (error);
27447c478bd9Sstevel@tonic-gate }
27457c478bd9Sstevel@tonic-gate /* Have to check canput before consuming data from the uio */
27467c478bd9Sstevel@tonic-gate if (pri == 0) {
27477c478bd9Sstevel@tonic-gate if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) {
27487c478bd9Sstevel@tonic-gate freemsg(mp);
27498e935259SBryan Cantrill if (iovlen != 0)
27508e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27517c478bd9Sstevel@tonic-gate return (EWOULDBLOCK);
27527c478bd9Sstevel@tonic-gate }
27537c478bd9Sstevel@tonic-gate } else {
27547c478bd9Sstevel@tonic-gate if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) {
27557c478bd9Sstevel@tonic-gate freemsg(mp);
27568e935259SBryan Cantrill if (iovlen != 0)
27578e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27587c478bd9Sstevel@tonic-gate return (EWOULDBLOCK);
27597c478bd9Sstevel@tonic-gate }
27607c478bd9Sstevel@tonic-gate }
27617c478bd9Sstevel@tonic-gate ASSERT(mp == uiod.d_mp);
27627c478bd9Sstevel@tonic-gate /* Copyin data from the uio */
27637c478bd9Sstevel@tonic-gate if ((error = struioget(wqp, mp, &uiod, 0)) != 0) {
27647c478bd9Sstevel@tonic-gate freemsg(mp);
27658e935259SBryan Cantrill if (iovlen != 0)
27668e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27677c478bd9Sstevel@tonic-gate return (error);
27687c478bd9Sstevel@tonic-gate }
27697c478bd9Sstevel@tonic-gate uioskip(uiop, *iosize);
27707c478bd9Sstevel@tonic-gate if (flags & MSG_IGNFLOW) {
27717c478bd9Sstevel@tonic-gate /*
27727c478bd9Sstevel@tonic-gate * XXX Hack: Don't get stuck running service procedures.
27737c478bd9Sstevel@tonic-gate * This is needed for sockfs when sending the unbind message
27747c478bd9Sstevel@tonic-gate * out of the rput procedure - we don't want a put procedure
27757c478bd9Sstevel@tonic-gate * to run service procedures.
27767c478bd9Sstevel@tonic-gate */
27777c478bd9Sstevel@tonic-gate putnext(wqp, mp);
27787c478bd9Sstevel@tonic-gate } else {
27797c478bd9Sstevel@tonic-gate stream_willservice(stp);
27807c478bd9Sstevel@tonic-gate putnext(wqp, mp);
27817c478bd9Sstevel@tonic-gate stream_runservice(stp);
27827c478bd9Sstevel@tonic-gate }
27838e935259SBryan Cantrill if (iovlen != 0)
27848e935259SBryan Cantrill kmem_free(uiod.d_iov, iovlen);
27857c478bd9Sstevel@tonic-gate return (0);
27867c478bd9Sstevel@tonic-gate }
27877c478bd9Sstevel@tonic-gate
27887c478bd9Sstevel@tonic-gate /*
27897c478bd9Sstevel@tonic-gate * Write attempts to break the write request into messages conforming
27907c478bd9Sstevel@tonic-gate * with the minimum and maximum packet sizes set downstream.
27917c478bd9Sstevel@tonic-gate *
27927c478bd9Sstevel@tonic-gate * Write will not block if downstream queue is full and
27937c478bd9Sstevel@tonic-gate * O_NDELAY is set, otherwise it will block waiting for the queue to get room.
27947c478bd9Sstevel@tonic-gate *
27957c478bd9Sstevel@tonic-gate * A write of zero bytes gets packaged into a zero length message and sent
27967c478bd9Sstevel@tonic-gate * downstream like any other message.
27977c478bd9Sstevel@tonic-gate *
27987c478bd9Sstevel@tonic-gate * If buffers of the requested sizes are not available, the write will
27997c478bd9Sstevel@tonic-gate * sleep until the buffers become available.
28007c478bd9Sstevel@tonic-gate *
28017c478bd9Sstevel@tonic-gate * Write (if specified) will supply a write offset in a message if it
28027c478bd9Sstevel@tonic-gate * makes sense. This can be specified by downstream modules as part of
28037c478bd9Sstevel@tonic-gate * a M_SETOPTS message. Write will not supply the write offset if it
28047c478bd9Sstevel@tonic-gate * cannot supply any data in a buffer. In other words, write will never
28057c478bd9Sstevel@tonic-gate * send down an empty packet due to a write offset.
28067c478bd9Sstevel@tonic-gate */
28077c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
28087c478bd9Sstevel@tonic-gate int
strwrite(struct vnode * vp,struct uio * uiop,cred_t * crp)28097c478bd9Sstevel@tonic-gate strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp)
2810ff550d0eSmasputra {
2811ff550d0eSmasputra return (strwrite_common(vp, uiop, crp, 0));
2812ff550d0eSmasputra }
2813ff550d0eSmasputra
2814ff550d0eSmasputra /* ARGSUSED2 */
2815ff550d0eSmasputra int
strwrite_common(struct vnode * vp,struct uio * uiop,cred_t * crp,int wflag)2816ff550d0eSmasputra strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag)
28177c478bd9Sstevel@tonic-gate {
28187c478bd9Sstevel@tonic-gate struct stdata *stp;
28197c478bd9Sstevel@tonic-gate struct queue *wqp;
28207c478bd9Sstevel@tonic-gate ssize_t rmin, rmax;
28217c478bd9Sstevel@tonic-gate ssize_t iosize;
2822ff550d0eSmasputra int waitflag;
28237c478bd9Sstevel@tonic-gate int tempmode;
28247c478bd9Sstevel@tonic-gate int error = 0;
28257c478bd9Sstevel@tonic-gate int b_flag;
28267c478bd9Sstevel@tonic-gate
28277c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
28287c478bd9Sstevel@tonic-gate stp = vp->v_stream;
28297c478bd9Sstevel@tonic-gate
28309acbbeafSnn mutex_enter(&stp->sd_lock);
28319acbbeafSnn
28329acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
28339acbbeafSnn mutex_exit(&stp->sd_lock);
28349acbbeafSnn return (error);
28359acbbeafSnn }
28367c478bd9Sstevel@tonic-gate
28377c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
28387c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_TRUE, B_TRUE);
28399acbbeafSnn if (error != 0) {
28409acbbeafSnn mutex_exit(&stp->sd_lock);
28417c478bd9Sstevel@tonic-gate return (error);
28429acbbeafSnn }
28437c478bd9Sstevel@tonic-gate }
28447c478bd9Sstevel@tonic-gate
28459acbbeafSnn mutex_exit(&stp->sd_lock);
28469acbbeafSnn
28477c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq;
28487c478bd9Sstevel@tonic-gate
28497c478bd9Sstevel@tonic-gate /* get these values from them cached in the stream head */
28507c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz;
28517c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz;
28527c478bd9Sstevel@tonic-gate
28537c478bd9Sstevel@tonic-gate /*
28547c478bd9Sstevel@tonic-gate * Check the min/max packet size constraints. If min packet size
28557c478bd9Sstevel@tonic-gate * is non-zero, the write cannot be split into multiple messages
28567c478bd9Sstevel@tonic-gate * and still guarantee the size constraints.
28577c478bd9Sstevel@tonic-gate */
28587c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp);
28597c478bd9Sstevel@tonic-gate
28607c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ));
28617c478bd9Sstevel@tonic-gate if (rmax == 0) {
28627c478bd9Sstevel@tonic-gate return (0);
28637c478bd9Sstevel@tonic-gate }
28647c478bd9Sstevel@tonic-gate if (rmin > 0) {
28657c478bd9Sstevel@tonic-gate if (uiop->uio_resid < rmin) {
28667c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2867d3e55dcdSgww "strwrite out:q %p out %d error %d",
2868d3e55dcdSgww wqp, 0, ERANGE);
28697c478bd9Sstevel@tonic-gate return (ERANGE);
28707c478bd9Sstevel@tonic-gate }
28717c478bd9Sstevel@tonic-gate if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) {
28727c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2873d3e55dcdSgww "strwrite out:q %p out %d error %d",
2874d3e55dcdSgww wqp, 1, ERANGE);
28757c478bd9Sstevel@tonic-gate return (ERANGE);
28767c478bd9Sstevel@tonic-gate }
28777c478bd9Sstevel@tonic-gate }
28787c478bd9Sstevel@tonic-gate
28797c478bd9Sstevel@tonic-gate /*
28807c478bd9Sstevel@tonic-gate * Do until count satisfied or error.
28817c478bd9Sstevel@tonic-gate */
2882ff550d0eSmasputra waitflag = WRITEWAIT | wflag;
28837c478bd9Sstevel@tonic-gate if (stp->sd_flag & OLDNDELAY)
28847c478bd9Sstevel@tonic-gate tempmode = uiop->uio_fmode & ~FNDELAY;
28857c478bd9Sstevel@tonic-gate else
28867c478bd9Sstevel@tonic-gate tempmode = uiop->uio_fmode;
28877c478bd9Sstevel@tonic-gate
28887c478bd9Sstevel@tonic-gate if (rmax == INFPSZ)
28897c478bd9Sstevel@tonic-gate rmax = uiop->uio_resid;
28907c478bd9Sstevel@tonic-gate
28917c478bd9Sstevel@tonic-gate /*
28927c478bd9Sstevel@tonic-gate * Note that tempmode does not get used in strput/strmakedata
28937c478bd9Sstevel@tonic-gate * but only in strwaitq. The other routines use uio_fmode
28947c478bd9Sstevel@tonic-gate * unmodified.
28957c478bd9Sstevel@tonic-gate */
28967c478bd9Sstevel@tonic-gate
28977c478bd9Sstevel@tonic-gate /* LINTED: constant in conditional context */
28987c478bd9Sstevel@tonic-gate while (1) { /* breaks when uio_resid reaches zero */
28997c478bd9Sstevel@tonic-gate /*
29007c478bd9Sstevel@tonic-gate * Determine the size of the next message to be
29017c478bd9Sstevel@tonic-gate * packaged. May have to break write into several
29027c478bd9Sstevel@tonic-gate * messages based on max packet size.
29037c478bd9Sstevel@tonic-gate */
29047c478bd9Sstevel@tonic-gate iosize = MIN(uiop->uio_resid, rmax);
29057c478bd9Sstevel@tonic-gate
29067c478bd9Sstevel@tonic-gate /*
29077c478bd9Sstevel@tonic-gate * Put block downstream when flow control allows it.
29087c478bd9Sstevel@tonic-gate */
29097c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize))
29107c478bd9Sstevel@tonic-gate b_flag = MSGDELIM;
29117c478bd9Sstevel@tonic-gate else
29127c478bd9Sstevel@tonic-gate b_flag = 0;
29137c478bd9Sstevel@tonic-gate
29147c478bd9Sstevel@tonic-gate for (;;) {
29157c478bd9Sstevel@tonic-gate int done = 0;
29167c478bd9Sstevel@tonic-gate
2917d3e55dcdSgww error = strput(stp, NULL, uiop, &iosize, b_flag, 0, 0);
29187c478bd9Sstevel@tonic-gate if (error == 0)
29197c478bd9Sstevel@tonic-gate break;
29207c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK)
29217c478bd9Sstevel@tonic-gate goto out;
29227c478bd9Sstevel@tonic-gate
29237c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
29247c478bd9Sstevel@tonic-gate /*
29257c478bd9Sstevel@tonic-gate * Check for a missed wakeup.
29267c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across
29277c478bd9Sstevel@tonic-gate * the canputnext.
29287c478bd9Sstevel@tonic-gate */
29297c478bd9Sstevel@tonic-gate if (canputnext(wqp)) {
29307c478bd9Sstevel@tonic-gate /* Try again */
29317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
29327c478bd9Sstevel@tonic-gate continue;
29337c478bd9Sstevel@tonic-gate }
29347c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT,
2935d3e55dcdSgww "strwrite wait:q %p wait", wqp);
29367c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, waitflag, (ssize_t)0,
29377c478bd9Sstevel@tonic-gate tempmode, -1, &done)) != 0 || done) {
29387c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
29397c478bd9Sstevel@tonic-gate if ((vp->v_type == VFIFO) &&
29407c478bd9Sstevel@tonic-gate (uiop->uio_fmode & FNDELAY) &&
29417c478bd9Sstevel@tonic-gate (error == EAGAIN))
29427c478bd9Sstevel@tonic-gate error = 0;
29437c478bd9Sstevel@tonic-gate goto out;
29447c478bd9Sstevel@tonic-gate }
29457c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE,
2946d3e55dcdSgww "strwrite wake:q %p awakes", wqp);
29479acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
29489acbbeafSnn mutex_exit(&stp->sd_lock);
29499acbbeafSnn goto out;
29509acbbeafSnn }
29517c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
29527c478bd9Sstevel@tonic-gate }
29537c478bd9Sstevel@tonic-gate waitflag |= NOINTR;
29547c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID,
2955d3e55dcdSgww "strwrite resid:q %p uiop %p", wqp, uiop);
29567c478bd9Sstevel@tonic-gate if (uiop->uio_resid) {
29577c478bd9Sstevel@tonic-gate /* Recheck for errors - needed for sockets */
29587c478bd9Sstevel@tonic-gate if ((stp->sd_wput_opt & SW_RECHECK_ERR) &&
29597c478bd9Sstevel@tonic-gate (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) {
29607c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
29617c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_FALSE, B_TRUE);
29627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
29637c478bd9Sstevel@tonic-gate if (error != 0)
29647c478bd9Sstevel@tonic-gate return (error);
29657c478bd9Sstevel@tonic-gate }
29667c478bd9Sstevel@tonic-gate continue;
29677c478bd9Sstevel@tonic-gate }
29687c478bd9Sstevel@tonic-gate break;
29697c478bd9Sstevel@tonic-gate }
29707c478bd9Sstevel@tonic-gate out:
29717c478bd9Sstevel@tonic-gate /*
29727c478bd9Sstevel@tonic-gate * For historical reasons, applications expect EAGAIN when a data
29737c478bd9Sstevel@tonic-gate * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN.
29747c478bd9Sstevel@tonic-gate */
29757c478bd9Sstevel@tonic-gate if (error == ENOMEM)
29767c478bd9Sstevel@tonic-gate error = EAGAIN;
29777c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT,
2978d3e55dcdSgww "strwrite out:q %p out %d error %d", wqp, 2, error);
29797c478bd9Sstevel@tonic-gate return (error);
29807c478bd9Sstevel@tonic-gate }
29817c478bd9Sstevel@tonic-gate
29827c478bd9Sstevel@tonic-gate /*
29837c478bd9Sstevel@tonic-gate * Stream head write service routine.
29847c478bd9Sstevel@tonic-gate * Its job is to wake up any sleeping writers when a queue
29857c478bd9Sstevel@tonic-gate * downstream needs data (part of the flow control in putq and getq).
29867c478bd9Sstevel@tonic-gate * It also must wake anyone sleeping on a poll().
29877c478bd9Sstevel@tonic-gate * For stream head right below mux module, it must also invoke put procedure
29887c478bd9Sstevel@tonic-gate * of next downstream module.
29897c478bd9Sstevel@tonic-gate */
29907c478bd9Sstevel@tonic-gate int
strwsrv(queue_t * q)29917c478bd9Sstevel@tonic-gate strwsrv(queue_t *q)
29927c478bd9Sstevel@tonic-gate {
29937c478bd9Sstevel@tonic-gate struct stdata *stp;
29947c478bd9Sstevel@tonic-gate queue_t *tq;
29957c478bd9Sstevel@tonic-gate qband_t *qbp;
29967c478bd9Sstevel@tonic-gate int i;
29977c478bd9Sstevel@tonic-gate qband_t *myqbp;
29987c478bd9Sstevel@tonic-gate int isevent;
29997c478bd9Sstevel@tonic-gate unsigned char qbf[NBAND]; /* band flushing backenable flags */
30007c478bd9Sstevel@tonic-gate
30017c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
3002d3e55dcdSgww TR_STRWSRV, "strwsrv:q %p", q);
30037c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr;
30047c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q));
30057c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
30067c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX));
30077c478bd9Sstevel@tonic-gate
30087c478bd9Sstevel@tonic-gate if (stp->sd_flag & WSLEEP) {
30097c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP;
30107c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait);
30117c478bd9Sstevel@tonic-gate }
30127c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
30137c478bd9Sstevel@tonic-gate
30147c478bd9Sstevel@tonic-gate /* The other end of a stream pipe went away. */
30157c478bd9Sstevel@tonic-gate if ((tq = q->q_next) == NULL) {
30167c478bd9Sstevel@tonic-gate return (0);
30177c478bd9Sstevel@tonic-gate }
30187c478bd9Sstevel@tonic-gate
30197c478bd9Sstevel@tonic-gate /* Find the next module forward that has a service procedure */
30207c478bd9Sstevel@tonic-gate claimstr(q);
30217c478bd9Sstevel@tonic-gate tq = q->q_nfsrv;
30227c478bd9Sstevel@tonic-gate ASSERT(tq != NULL);
30237c478bd9Sstevel@tonic-gate
30247c478bd9Sstevel@tonic-gate if ((q->q_flag & QBACK)) {
30257c478bd9Sstevel@tonic-gate if ((tq->q_flag & QFULL)) {
30267c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(tq));
30277c478bd9Sstevel@tonic-gate if (!(tq->q_flag & QFULL)) {
30287c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq));
30297c478bd9Sstevel@tonic-gate goto wakeup;
30307c478bd9Sstevel@tonic-gate }
30317c478bd9Sstevel@tonic-gate /*
30327c478bd9Sstevel@tonic-gate * The queue must have become full again. Set QWANTW
30337c478bd9Sstevel@tonic-gate * again so strwsrv will be back enabled when
30347c478bd9Sstevel@tonic-gate * the queue becomes non-full next time.
30357c478bd9Sstevel@tonic-gate */
30367c478bd9Sstevel@tonic-gate tq->q_flag |= QWANTW;
30377c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq));
30387c478bd9Sstevel@tonic-gate } else {
30397c478bd9Sstevel@tonic-gate wakeup:
30407c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLWRNORM);
30417c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
30427c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_WRNORM)
30437c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_WRNORM, 0, 0);
30447c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
30457c478bd9Sstevel@tonic-gate }
30467c478bd9Sstevel@tonic-gate }
30477c478bd9Sstevel@tonic-gate
30487c478bd9Sstevel@tonic-gate isevent = 0;
30497c478bd9Sstevel@tonic-gate i = 1;
30507c478bd9Sstevel@tonic-gate bzero((caddr_t)qbf, NBAND);
30517c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(tq));
30527c478bd9Sstevel@tonic-gate if ((myqbp = q->q_bandp) != NULL)
30537c478bd9Sstevel@tonic-gate for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) {
30547c478bd9Sstevel@tonic-gate ASSERT(myqbp);
30557c478bd9Sstevel@tonic-gate if ((myqbp->qb_flag & QB_BACK)) {
30567c478bd9Sstevel@tonic-gate if (qbp->qb_flag & QB_FULL) {
30577c478bd9Sstevel@tonic-gate /*
30587c478bd9Sstevel@tonic-gate * The band must have become full again.
30597c478bd9Sstevel@tonic-gate * Set QB_WANTW again so strwsrv will
30607c478bd9Sstevel@tonic-gate * be back enabled when the band becomes
30617c478bd9Sstevel@tonic-gate * non-full next time.
30627c478bd9Sstevel@tonic-gate */
30637c478bd9Sstevel@tonic-gate qbp->qb_flag |= QB_WANTW;
30647c478bd9Sstevel@tonic-gate } else {
30657c478bd9Sstevel@tonic-gate isevent = 1;
30667c478bd9Sstevel@tonic-gate qbf[i] = 1;
30677c478bd9Sstevel@tonic-gate }
30687c478bd9Sstevel@tonic-gate }
30697c478bd9Sstevel@tonic-gate myqbp = myqbp->qb_next;
30707c478bd9Sstevel@tonic-gate i++;
30717c478bd9Sstevel@tonic-gate }
30727c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq));
30737c478bd9Sstevel@tonic-gate
30747c478bd9Sstevel@tonic-gate if (isevent) {
3075d3e55dcdSgww for (i = tq->q_nband; i; i--) {
3076d3e55dcdSgww if (qbf[i]) {
3077d3e55dcdSgww pollwakeup(&stp->sd_pollist, POLLWRBAND);
3078d3e55dcdSgww mutex_enter(&stp->sd_lock);
3079d3e55dcdSgww if (stp->sd_sigflags & S_WRBAND)
3080d3e55dcdSgww strsendsig(stp->sd_siglist, S_WRBAND,
3081d3e55dcdSgww (uchar_t)i, 0);
3082d3e55dcdSgww mutex_exit(&stp->sd_lock);
3083d3e55dcdSgww }
30847c478bd9Sstevel@tonic-gate }
30857c478bd9Sstevel@tonic-gate }
30867c478bd9Sstevel@tonic-gate
30877c478bd9Sstevel@tonic-gate releasestr(q);
30887c478bd9Sstevel@tonic-gate return (0);
30897c478bd9Sstevel@tonic-gate }
30907c478bd9Sstevel@tonic-gate
30917c478bd9Sstevel@tonic-gate /*
30927c478bd9Sstevel@tonic-gate * Special case of strcopyin/strcopyout for copying
30937c478bd9Sstevel@tonic-gate * struct strioctl that can deal with both data
30947c478bd9Sstevel@tonic-gate * models.
30957c478bd9Sstevel@tonic-gate */
30967c478bd9Sstevel@tonic-gate
30977c478bd9Sstevel@tonic-gate #ifdef _LP64
30987c478bd9Sstevel@tonic-gate
30997c478bd9Sstevel@tonic-gate static int
strcopyin_strioctl(void * from,void * to,int flag,int copyflag)31007c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
31017c478bd9Sstevel@tonic-gate {
31027c478bd9Sstevel@tonic-gate struct strioctl32 strioc32;
31037c478bd9Sstevel@tonic-gate struct strioctl *striocp;
31047c478bd9Sstevel@tonic-gate
31057c478bd9Sstevel@tonic-gate if (copyflag & U_TO_K) {
31067c478bd9Sstevel@tonic-gate ASSERT((copyflag & K_TO_K) == 0);
31077c478bd9Sstevel@tonic-gate
31087c478bd9Sstevel@tonic-gate if ((flag & FMODELS) == DATAMODEL_ILP32) {
31097c478bd9Sstevel@tonic-gate if (copyin(from, &strioc32, sizeof (strioc32)))
31107c478bd9Sstevel@tonic-gate return (EFAULT);
31117c478bd9Sstevel@tonic-gate
31127c478bd9Sstevel@tonic-gate striocp = (struct strioctl *)to;
31137c478bd9Sstevel@tonic-gate striocp->ic_cmd = strioc32.ic_cmd;
31147c478bd9Sstevel@tonic-gate striocp->ic_timout = strioc32.ic_timout;
31157c478bd9Sstevel@tonic-gate striocp->ic_len = strioc32.ic_len;
31167c478bd9Sstevel@tonic-gate striocp->ic_dp = (char *)(uintptr_t)strioc32.ic_dp;
31177c478bd9Sstevel@tonic-gate
31187c478bd9Sstevel@tonic-gate } else { /* NATIVE data model */
31197c478bd9Sstevel@tonic-gate if (copyin(from, to, sizeof (struct strioctl))) {
31207c478bd9Sstevel@tonic-gate return (EFAULT);
31217c478bd9Sstevel@tonic-gate } else {
31227c478bd9Sstevel@tonic-gate return (0);
31237c478bd9Sstevel@tonic-gate }
31247c478bd9Sstevel@tonic-gate }
31257c478bd9Sstevel@tonic-gate } else {
31267c478bd9Sstevel@tonic-gate ASSERT(copyflag & K_TO_K);
31277c478bd9Sstevel@tonic-gate bcopy(from, to, sizeof (struct strioctl));
31287c478bd9Sstevel@tonic-gate }
31297c478bd9Sstevel@tonic-gate return (0);
31307c478bd9Sstevel@tonic-gate }
31317c478bd9Sstevel@tonic-gate
31327c478bd9Sstevel@tonic-gate static int
strcopyout_strioctl(void * from,void * to,int flag,int copyflag)31337c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
31347c478bd9Sstevel@tonic-gate {
31357c478bd9Sstevel@tonic-gate struct strioctl32 strioc32;
31367c478bd9Sstevel@tonic-gate struct strioctl *striocp;
31377c478bd9Sstevel@tonic-gate
31387c478bd9Sstevel@tonic-gate if (copyflag & U_TO_K) {
31397c478bd9Sstevel@tonic-gate ASSERT((copyflag & K_TO_K) == 0);
31407c478bd9Sstevel@tonic-gate
31417c478bd9Sstevel@tonic-gate if ((flag & FMODELS) == DATAMODEL_ILP32) {
31427c478bd9Sstevel@tonic-gate striocp = (struct strioctl *)from;
31437c478bd9Sstevel@tonic-gate strioc32.ic_cmd = striocp->ic_cmd;
31447c478bd9Sstevel@tonic-gate strioc32.ic_timout = striocp->ic_timout;
31457c478bd9Sstevel@tonic-gate strioc32.ic_len = striocp->ic_len;
31467c478bd9Sstevel@tonic-gate strioc32.ic_dp = (caddr32_t)(uintptr_t)striocp->ic_dp;
31477c478bd9Sstevel@tonic-gate ASSERT((char *)(uintptr_t)strioc32.ic_dp ==
31487c478bd9Sstevel@tonic-gate striocp->ic_dp);
31497c478bd9Sstevel@tonic-gate
31507c478bd9Sstevel@tonic-gate if (copyout(&strioc32, to, sizeof (strioc32)))
31517c478bd9Sstevel@tonic-gate return (EFAULT);
31527c478bd9Sstevel@tonic-gate
31537c478bd9Sstevel@tonic-gate } else { /* NATIVE data model */
31547c478bd9Sstevel@tonic-gate if (copyout(from, to, sizeof (struct strioctl))) {
31557c478bd9Sstevel@tonic-gate return (EFAULT);
31567c478bd9Sstevel@tonic-gate } else {
31577c478bd9Sstevel@tonic-gate return (0);
31587c478bd9Sstevel@tonic-gate }
31597c478bd9Sstevel@tonic-gate }
31607c478bd9Sstevel@tonic-gate } else {
31617c478bd9Sstevel@tonic-gate ASSERT(copyflag & K_TO_K);
31627c478bd9Sstevel@tonic-gate bcopy(from, to, sizeof (struct strioctl));
31637c478bd9Sstevel@tonic-gate }
31647c478bd9Sstevel@tonic-gate return (0);
31657c478bd9Sstevel@tonic-gate }
31667c478bd9Sstevel@tonic-gate
31677c478bd9Sstevel@tonic-gate #else /* ! _LP64 */
31687c478bd9Sstevel@tonic-gate
31697c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
31707c478bd9Sstevel@tonic-gate static int
strcopyin_strioctl(void * from,void * to,int flag,int copyflag)31717c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag)
31727c478bd9Sstevel@tonic-gate {
31737c478bd9Sstevel@tonic-gate return (strcopyin(from, to, sizeof (struct strioctl), copyflag));
31747c478bd9Sstevel@tonic-gate }
31757c478bd9Sstevel@tonic-gate
31767c478bd9Sstevel@tonic-gate /* ARGSUSED2 */
31777c478bd9Sstevel@tonic-gate static int
strcopyout_strioctl(void * from,void * to,int flag,int copyflag)31787c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag)
31797c478bd9Sstevel@tonic-gate {
31807c478bd9Sstevel@tonic-gate return (strcopyout(from, to, sizeof (struct strioctl), copyflag));
31817c478bd9Sstevel@tonic-gate }
31827c478bd9Sstevel@tonic-gate
31837c478bd9Sstevel@tonic-gate #endif /* _LP64 */
31847c478bd9Sstevel@tonic-gate
31857c478bd9Sstevel@tonic-gate /*
31867c478bd9Sstevel@tonic-gate * Determine type of job control semantics expected by user. The
31877c478bd9Sstevel@tonic-gate * possibilities are:
31887c478bd9Sstevel@tonic-gate * JCREAD - Behaves like read() on fd; send SIGTTIN
31897c478bd9Sstevel@tonic-gate * JCWRITE - Behaves like write() on fd; send SIGTTOU if TOSTOP set
31907c478bd9Sstevel@tonic-gate * JCSETP - Sets a value in the stream; send SIGTTOU, ignore TOSTOP
31917c478bd9Sstevel@tonic-gate * JCGETP - Gets a value in the stream; no signals.
31927c478bd9Sstevel@tonic-gate * See straccess in strsubr.c for usage of these values.
31937c478bd9Sstevel@tonic-gate *
31947c478bd9Sstevel@tonic-gate * This routine also returns -1 for I_STR as a special case; the
31957c478bd9Sstevel@tonic-gate * caller must call again with the real ioctl number for
31967c478bd9Sstevel@tonic-gate * classification.
31977c478bd9Sstevel@tonic-gate */
31987c478bd9Sstevel@tonic-gate static int
job_control_type(int cmd)31997c478bd9Sstevel@tonic-gate job_control_type(int cmd)
32007c478bd9Sstevel@tonic-gate {
32017c478bd9Sstevel@tonic-gate switch (cmd) {
32027c478bd9Sstevel@tonic-gate case I_STR:
32037c478bd9Sstevel@tonic-gate return (-1);
32047c478bd9Sstevel@tonic-gate
32057c478bd9Sstevel@tonic-gate case I_RECVFD:
32067c478bd9Sstevel@tonic-gate case I_E_RECVFD:
32077c478bd9Sstevel@tonic-gate return (JCREAD);
32087c478bd9Sstevel@tonic-gate
32097c478bd9Sstevel@tonic-gate case I_FDINSERT:
32107c478bd9Sstevel@tonic-gate case I_SENDFD:
32117c478bd9Sstevel@tonic-gate return (JCWRITE);
32127c478bd9Sstevel@tonic-gate
32137c478bd9Sstevel@tonic-gate case TCSETA:
32147c478bd9Sstevel@tonic-gate case TCSETAW:
32157c478bd9Sstevel@tonic-gate case TCSETAF:
32167c478bd9Sstevel@tonic-gate case TCSBRK:
32177c478bd9Sstevel@tonic-gate case TCXONC:
32187c478bd9Sstevel@tonic-gate case TCFLSH:
32197c478bd9Sstevel@tonic-gate case TCDSET: /* Obsolete */
32207c478bd9Sstevel@tonic-gate case TIOCSWINSZ:
32217c478bd9Sstevel@tonic-gate case TCSETS:
32227c478bd9Sstevel@tonic-gate case TCSETSW:
32237c478bd9Sstevel@tonic-gate case TCSETSF:
32247c478bd9Sstevel@tonic-gate case TIOCSETD:
32257c478bd9Sstevel@tonic-gate case TIOCHPCL:
32267c478bd9Sstevel@tonic-gate case TIOCSETP:
32277c478bd9Sstevel@tonic-gate case TIOCSETN:
32287c478bd9Sstevel@tonic-gate case TIOCEXCL:
32297c478bd9Sstevel@tonic-gate case TIOCNXCL:
32307c478bd9Sstevel@tonic-gate case TIOCFLUSH:
32317c478bd9Sstevel@tonic-gate case TIOCSETC:
32327c478bd9Sstevel@tonic-gate case TIOCLBIS:
32337c478bd9Sstevel@tonic-gate case TIOCLBIC:
32347c478bd9Sstevel@tonic-gate case TIOCLSET:
32357c478bd9Sstevel@tonic-gate case TIOCSBRK:
32367c478bd9Sstevel@tonic-gate case TIOCCBRK:
32377c478bd9Sstevel@tonic-gate case TIOCSDTR:
32387c478bd9Sstevel@tonic-gate case TIOCCDTR:
32397c478bd9Sstevel@tonic-gate case TIOCSLTC:
32407c478bd9Sstevel@tonic-gate case TIOCSTOP:
32417c478bd9Sstevel@tonic-gate case TIOCSTART:
32427c478bd9Sstevel@tonic-gate case TIOCSTI:
32437c478bd9Sstevel@tonic-gate case TIOCSPGRP:
32447c478bd9Sstevel@tonic-gate case TIOCMSET:
32457c478bd9Sstevel@tonic-gate case TIOCMBIS:
32467c478bd9Sstevel@tonic-gate case TIOCMBIC:
32477c478bd9Sstevel@tonic-gate case TIOCREMOTE:
32487c478bd9Sstevel@tonic-gate case TIOCSIGNAL:
32497c478bd9Sstevel@tonic-gate case LDSETT:
32507c478bd9Sstevel@tonic-gate case LDSMAP: /* Obsolete */
32517c478bd9Sstevel@tonic-gate case DIOCSETP:
32527c478bd9Sstevel@tonic-gate case I_FLUSH:
32537c478bd9Sstevel@tonic-gate case I_SRDOPT:
32547c478bd9Sstevel@tonic-gate case I_SETSIG:
32557c478bd9Sstevel@tonic-gate case I_SWROPT:
32567c478bd9Sstevel@tonic-gate case I_FLUSHBAND:
32577c478bd9Sstevel@tonic-gate case I_SETCLTIME:
32587c478bd9Sstevel@tonic-gate case I_SERROPT:
32597c478bd9Sstevel@tonic-gate case I_ESETSIG:
32607c478bd9Sstevel@tonic-gate case FIONBIO:
32617c478bd9Sstevel@tonic-gate case FIOASYNC:
32627c478bd9Sstevel@tonic-gate case FIOSETOWN:
32637c478bd9Sstevel@tonic-gate case JBOOT: /* Obsolete */
32647c478bd9Sstevel@tonic-gate case JTERM: /* Obsolete */
32657c478bd9Sstevel@tonic-gate case JTIMOM: /* Obsolete */
32667c478bd9Sstevel@tonic-gate case JZOMBOOT: /* Obsolete */
32677c478bd9Sstevel@tonic-gate case JAGENT: /* Obsolete */
32687c478bd9Sstevel@tonic-gate case JTRUN: /* Obsolete */
32697c478bd9Sstevel@tonic-gate case JXTPROTO: /* Obsolete */
32707c478bd9Sstevel@tonic-gate return (JCSETP);
32717c478bd9Sstevel@tonic-gate }
32727c478bd9Sstevel@tonic-gate
32737c478bd9Sstevel@tonic-gate return (JCGETP);
32747c478bd9Sstevel@tonic-gate }
32757c478bd9Sstevel@tonic-gate
32767c478bd9Sstevel@tonic-gate /*
32777c478bd9Sstevel@tonic-gate * ioctl for streams
32787c478bd9Sstevel@tonic-gate */
32797c478bd9Sstevel@tonic-gate int
strioctl(struct vnode * vp,int cmd,intptr_t arg,int flag,int copyflag,cred_t * crp,int * rvalp)32807c478bd9Sstevel@tonic-gate strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag,
32817c478bd9Sstevel@tonic-gate cred_t *crp, int *rvalp)
32827c478bd9Sstevel@tonic-gate {
32837c478bd9Sstevel@tonic-gate struct stdata *stp;
3284ca9327a6Smeem struct strcmd *scp;
32857c478bd9Sstevel@tonic-gate struct strioctl strioc;
32867c478bd9Sstevel@tonic-gate struct uio uio;
32877c478bd9Sstevel@tonic-gate struct iovec iov;
32887c478bd9Sstevel@tonic-gate int access;
32897c478bd9Sstevel@tonic-gate mblk_t *mp;
32907c478bd9Sstevel@tonic-gate int error = 0;
32917c478bd9Sstevel@tonic-gate int done = 0;
32927c478bd9Sstevel@tonic-gate ssize_t rmin, rmax;
32937c478bd9Sstevel@tonic-gate queue_t *wrq;
32947c478bd9Sstevel@tonic-gate queue_t *rdq;
32957c478bd9Sstevel@tonic-gate boolean_t kioctl = B_FALSE;
3296005d3febSMarek Pospisil uint32_t auditing = AU_AUDITING();
32977c478bd9Sstevel@tonic-gate
32987c478bd9Sstevel@tonic-gate if (flag & FKIOCTL) {
32997c478bd9Sstevel@tonic-gate copyflag = K_TO_K;
33007c478bd9Sstevel@tonic-gate kioctl = B_TRUE;
33017c478bd9Sstevel@tonic-gate }
33027c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
33037c478bd9Sstevel@tonic-gate ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
33047c478bd9Sstevel@tonic-gate stp = vp->v_stream;
33057c478bd9Sstevel@tonic-gate
33067c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER,
3307d3e55dcdSgww "strioctl:stp %p cmd %X arg %lX", stp, cmd, arg);
33087c478bd9Sstevel@tonic-gate
33097c478bd9Sstevel@tonic-gate /*
33107c478bd9Sstevel@tonic-gate * If the copy is kernel to kernel, make sure that the FNATIVE
33117c478bd9Sstevel@tonic-gate * flag is set. After this it would be a serious error to have
33127c478bd9Sstevel@tonic-gate * no model flag.
33137c478bd9Sstevel@tonic-gate */
33147c478bd9Sstevel@tonic-gate if (copyflag == K_TO_K)
33157c478bd9Sstevel@tonic-gate flag = (flag & ~FMODELS) | FNATIVE;
33167c478bd9Sstevel@tonic-gate
33177c478bd9Sstevel@tonic-gate ASSERT((flag & FMODELS) != 0);
33187c478bd9Sstevel@tonic-gate
33197c478bd9Sstevel@tonic-gate wrq = stp->sd_wrq;
33207c478bd9Sstevel@tonic-gate rdq = _RD(wrq);
33217c478bd9Sstevel@tonic-gate
33227c478bd9Sstevel@tonic-gate access = job_control_type(cmd);
33237c478bd9Sstevel@tonic-gate
33247c478bd9Sstevel@tonic-gate /* We should never see these here, should be handled by iwscn */
33257c478bd9Sstevel@tonic-gate if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR)
33267c478bd9Sstevel@tonic-gate return (EINVAL);
33277c478bd9Sstevel@tonic-gate
33289acbbeafSnn mutex_enter(&stp->sd_lock);
33299acbbeafSnn if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) {
33309acbbeafSnn mutex_exit(&stp->sd_lock);
33319acbbeafSnn return (error);
33329acbbeafSnn }
33339acbbeafSnn mutex_exit(&stp->sd_lock);
33347c478bd9Sstevel@tonic-gate
33357c478bd9Sstevel@tonic-gate /*
33367c478bd9Sstevel@tonic-gate * Check for sgttyb-related ioctls first, and complain as
33377c478bd9Sstevel@tonic-gate * necessary.
33387c478bd9Sstevel@tonic-gate */
33397c478bd9Sstevel@tonic-gate switch (cmd) {
33407c478bd9Sstevel@tonic-gate case TIOCGETP:
33417c478bd9Sstevel@tonic-gate case TIOCSETP:
33427c478bd9Sstevel@tonic-gate case TIOCSETN:
33437c478bd9Sstevel@tonic-gate if (sgttyb_handling >= 2 && !sgttyb_complaint) {
33447c478bd9Sstevel@tonic-gate sgttyb_complaint = B_TRUE;
33457c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE,
33467c478bd9Sstevel@tonic-gate "application used obsolete TIOC[GS]ET");
33477c478bd9Sstevel@tonic-gate }
33487c478bd9Sstevel@tonic-gate if (sgttyb_handling >= 3) {
33497c478bd9Sstevel@tonic-gate tsignal(curthread, SIGSYS);
33507c478bd9Sstevel@tonic-gate return (EIO);
33517c478bd9Sstevel@tonic-gate }
33527c478bd9Sstevel@tonic-gate break;
33537c478bd9Sstevel@tonic-gate }
33547c478bd9Sstevel@tonic-gate
33557c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
33567c478bd9Sstevel@tonic-gate
33577c478bd9Sstevel@tonic-gate switch (cmd) {
33587c478bd9Sstevel@tonic-gate case I_RECVFD:
33597c478bd9Sstevel@tonic-gate case I_E_RECVFD:
33607c478bd9Sstevel@tonic-gate case I_PEEK:
33617c478bd9Sstevel@tonic-gate case I_NREAD:
33627c478bd9Sstevel@tonic-gate case FIONREAD:
33637c478bd9Sstevel@tonic-gate case FIORDCHK:
33647c478bd9Sstevel@tonic-gate case I_ATMARK:
33657c478bd9Sstevel@tonic-gate case FIONBIO:
33667c478bd9Sstevel@tonic-gate case FIOASYNC:
33677c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) {
33687c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 0);
33697c478bd9Sstevel@tonic-gate if (error != 0) {
33707c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
33717c478bd9Sstevel@tonic-gate return (error);
33727c478bd9Sstevel@tonic-gate }
33737c478bd9Sstevel@tonic-gate }
33747c478bd9Sstevel@tonic-gate break;
33757c478bd9Sstevel@tonic-gate
33767c478bd9Sstevel@tonic-gate default:
33777c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) {
33787c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0);
33797c478bd9Sstevel@tonic-gate if (error != 0) {
33807c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
33817c478bd9Sstevel@tonic-gate return (error);
33827c478bd9Sstevel@tonic-gate }
33837c478bd9Sstevel@tonic-gate }
33847c478bd9Sstevel@tonic-gate }
33857c478bd9Sstevel@tonic-gate
33867c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
33877c478bd9Sstevel@tonic-gate
33887c478bd9Sstevel@tonic-gate switch (cmd) {
33897c478bd9Sstevel@tonic-gate default:
33907c478bd9Sstevel@tonic-gate /*
33917c478bd9Sstevel@tonic-gate * The stream head has hardcoded knowledge of a
33927c478bd9Sstevel@tonic-gate * miscellaneous collection of terminal-, keyboard- and
33937c478bd9Sstevel@tonic-gate * mouse-related ioctls, enumerated below. This hardcoded
33947c478bd9Sstevel@tonic-gate * knowledge allows the stream head to automatically
33957c478bd9Sstevel@tonic-gate * convert transparent ioctl requests made by userland
33967c478bd9Sstevel@tonic-gate * programs into I_STR ioctls which many old STREAMS
33977c478bd9Sstevel@tonic-gate * modules and drivers require.
33987c478bd9Sstevel@tonic-gate *
33997c478bd9Sstevel@tonic-gate * No new ioctls should ever be added to this list.
34007c478bd9Sstevel@tonic-gate * Instead, the STREAMS module or driver should be written
34017c478bd9Sstevel@tonic-gate * to either handle transparent ioctls or require any
34027c478bd9Sstevel@tonic-gate * userland programs to use I_STR ioctls (by returning
34037c478bd9Sstevel@tonic-gate * EINVAL to any transparent ioctl requests).
34047c478bd9Sstevel@tonic-gate *
34057c478bd9Sstevel@tonic-gate * More importantly, removing ioctls from this list should
34067c478bd9Sstevel@tonic-gate * be done with the utmost care, since our STREAMS modules
34077c478bd9Sstevel@tonic-gate * and drivers *count* on the stream head performing this
34087c478bd9Sstevel@tonic-gate * conversion, and thus may panic while processing
34097c478bd9Sstevel@tonic-gate * transparent ioctl request for one of these ioctls (keep
34107c478bd9Sstevel@tonic-gate * in mind that third party modules and drivers may have
34117c478bd9Sstevel@tonic-gate * similar problems).
34127c478bd9Sstevel@tonic-gate */
34137c478bd9Sstevel@tonic-gate if (((cmd & IOCTYPE) == LDIOC) ||
34147c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == tIOC) ||
34157c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == TIOC) ||
34167c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == KIOC) ||
34177c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == MSIOC) ||
34187c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == VUIOC)) {
34197c478bd9Sstevel@tonic-gate /*
34207c478bd9Sstevel@tonic-gate * The ioctl is a tty ioctl - set up strioc buffer
34217c478bd9Sstevel@tonic-gate * and call strdoioctl() to do the work.
34227c478bd9Sstevel@tonic-gate */
34237c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
34247c478bd9Sstevel@tonic-gate return (ENXIO);
34257c478bd9Sstevel@tonic-gate strioc.ic_cmd = cmd;
34267c478bd9Sstevel@tonic-gate strioc.ic_timout = INFTIM;
34277c478bd9Sstevel@tonic-gate
34287c478bd9Sstevel@tonic-gate switch (cmd) {
34297c478bd9Sstevel@tonic-gate
34307c478bd9Sstevel@tonic-gate case TCXONC:
34317c478bd9Sstevel@tonic-gate case TCSBRK:
34327c478bd9Sstevel@tonic-gate case TCFLSH:
34337c478bd9Sstevel@tonic-gate case TCDSET:
34347c478bd9Sstevel@tonic-gate {
34357c478bd9Sstevel@tonic-gate int native_arg = (int)arg;
34367c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (int);
34377c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)&native_arg;
34387c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
34397c478bd9Sstevel@tonic-gate K_TO_K, crp, rvalp));
34407c478bd9Sstevel@tonic-gate }
34417c478bd9Sstevel@tonic-gate
34427c478bd9Sstevel@tonic-gate case TCSETA:
34437c478bd9Sstevel@tonic-gate case TCSETAW:
34447c478bd9Sstevel@tonic-gate case TCSETAF:
34457c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termio);
34467c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34477c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3448d3e55dcdSgww copyflag, crp, rvalp));
34497c478bd9Sstevel@tonic-gate
34507c478bd9Sstevel@tonic-gate case TCSETS:
34517c478bd9Sstevel@tonic-gate case TCSETSW:
34527c478bd9Sstevel@tonic-gate case TCSETSF:
34537c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termios);
34547c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34557c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3456d3e55dcdSgww copyflag, crp, rvalp));
34577c478bd9Sstevel@tonic-gate
34587c478bd9Sstevel@tonic-gate case LDSETT:
34597c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termcb);
34607c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34617c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3462d3e55dcdSgww copyflag, crp, rvalp));
34637c478bd9Sstevel@tonic-gate
34647c478bd9Sstevel@tonic-gate case TIOCSETP:
34657c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct sgttyb);
34667c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34677c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3468d3e55dcdSgww copyflag, crp, rvalp));
34697c478bd9Sstevel@tonic-gate
34707c478bd9Sstevel@tonic-gate case TIOCSTI:
34717c478bd9Sstevel@tonic-gate if ((flag & FREAD) == 0 &&
34727c478bd9Sstevel@tonic-gate secpolicy_sti(crp) != 0) {
34737c478bd9Sstevel@tonic-gate return (EPERM);
34747c478bd9Sstevel@tonic-gate }
34759acbbeafSnn mutex_enter(&stp->sd_lock);
34769acbbeafSnn mutex_enter(&curproc->p_splock);
34779acbbeafSnn if (stp->sd_sidp != curproc->p_sessp->s_sidp &&
34787c478bd9Sstevel@tonic-gate secpolicy_sti(crp) != 0) {
34799acbbeafSnn mutex_exit(&curproc->p_splock);
34809acbbeafSnn mutex_exit(&stp->sd_lock);
34817c478bd9Sstevel@tonic-gate return (EACCES);
34827c478bd9Sstevel@tonic-gate }
34839acbbeafSnn mutex_exit(&curproc->p_splock);
34849acbbeafSnn mutex_exit(&stp->sd_lock);
34857c478bd9Sstevel@tonic-gate
34867c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (char);
34877c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34887c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3489d3e55dcdSgww copyflag, crp, rvalp));
34907c478bd9Sstevel@tonic-gate
34917c478bd9Sstevel@tonic-gate case TIOCSWINSZ:
34927c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct winsize);
34937c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
34947c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3495d3e55dcdSgww copyflag, crp, rvalp));
34967c478bd9Sstevel@tonic-gate
34977c478bd9Sstevel@tonic-gate case TIOCSSIZE:
34987c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct ttysize);
34997c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35007c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3501d3e55dcdSgww copyflag, crp, rvalp));
35027c478bd9Sstevel@tonic-gate
35037c478bd9Sstevel@tonic-gate case TIOCSSOFTCAR:
35047c478bd9Sstevel@tonic-gate case KIOCTRANS:
35057c478bd9Sstevel@tonic-gate case KIOCTRANSABLE:
35067c478bd9Sstevel@tonic-gate case KIOCCMD:
35077c478bd9Sstevel@tonic-gate case KIOCSDIRECT:
35087c478bd9Sstevel@tonic-gate case KIOCSCOMPAT:
35097c478bd9Sstevel@tonic-gate case KIOCSKABORTEN:
3510c0423dd8SToomas Soome case KIOCSRPTCOUNT:
35117c478bd9Sstevel@tonic-gate case KIOCSRPTDELAY:
35127c478bd9Sstevel@tonic-gate case KIOCSRPTRATE:
35137c478bd9Sstevel@tonic-gate case VUIDSFORMAT:
35147c478bd9Sstevel@tonic-gate case TIOCSPPS:
35157c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (int);
35167c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35177c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3518d3e55dcdSgww copyflag, crp, rvalp));
35197c478bd9Sstevel@tonic-gate
35207c478bd9Sstevel@tonic-gate case KIOCSETKEY:
35217c478bd9Sstevel@tonic-gate case KIOCGETKEY:
35227c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct kiockey);
35237c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35247c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3525d3e55dcdSgww copyflag, crp, rvalp));
35267c478bd9Sstevel@tonic-gate
35277c478bd9Sstevel@tonic-gate case KIOCSKEY:
35287c478bd9Sstevel@tonic-gate case KIOCGKEY:
35297c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct kiockeymap);
35307c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35317c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3532d3e55dcdSgww copyflag, crp, rvalp));
35337c478bd9Sstevel@tonic-gate
35347c478bd9Sstevel@tonic-gate case KIOCSLED:
35357c478bd9Sstevel@tonic-gate /* arg is a pointer to char */
35367c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (char);
35377c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35387c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3539d3e55dcdSgww copyflag, crp, rvalp));
35407c478bd9Sstevel@tonic-gate
35417c478bd9Sstevel@tonic-gate case MSIOSETPARMS:
35427c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (Ms_parms);
35437c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35447c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3545d3e55dcdSgww copyflag, crp, rvalp));
35467c478bd9Sstevel@tonic-gate
35477c478bd9Sstevel@tonic-gate case VUIDSADDR:
35487c478bd9Sstevel@tonic-gate case VUIDGADDR:
35497c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct vuid_addr_probe);
35507c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35517c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3552d3e55dcdSgww copyflag, crp, rvalp));
35537c478bd9Sstevel@tonic-gate
35547c478bd9Sstevel@tonic-gate /*
35557c478bd9Sstevel@tonic-gate * These M_IOCTL's don't require any data to be sent
35567c478bd9Sstevel@tonic-gate * downstream, and the driver will allocate and link
35577c478bd9Sstevel@tonic-gate * on its own mblk_t upon M_IOCACK -- thus we set
35587c478bd9Sstevel@tonic-gate * ic_len to zero and set ic_dp to arg so we know
35597c478bd9Sstevel@tonic-gate * where to copyout to later.
35607c478bd9Sstevel@tonic-gate */
35617c478bd9Sstevel@tonic-gate case TIOCGSOFTCAR:
35627c478bd9Sstevel@tonic-gate case TIOCGWINSZ:
35637c478bd9Sstevel@tonic-gate case TIOCGSIZE:
35647c478bd9Sstevel@tonic-gate case KIOCGTRANS:
35657c478bd9Sstevel@tonic-gate case KIOCGTRANSABLE:
35667c478bd9Sstevel@tonic-gate case KIOCTYPE:
35677c478bd9Sstevel@tonic-gate case KIOCGDIRECT:
35687c478bd9Sstevel@tonic-gate case KIOCGCOMPAT:
35697c478bd9Sstevel@tonic-gate case KIOCLAYOUT:
35707c478bd9Sstevel@tonic-gate case KIOCGLED:
35717c478bd9Sstevel@tonic-gate case MSIOGETPARMS:
35727c478bd9Sstevel@tonic-gate case MSIOBUTTONS:
35737c478bd9Sstevel@tonic-gate case VUIDGFORMAT:
35747c478bd9Sstevel@tonic-gate case TIOCGPPS:
35757c478bd9Sstevel@tonic-gate case TIOCGPPSEV:
35767c478bd9Sstevel@tonic-gate case TCGETA:
35777c478bd9Sstevel@tonic-gate case TCGETS:
35787c478bd9Sstevel@tonic-gate case LDGETT:
35797c478bd9Sstevel@tonic-gate case TIOCGETP:
3580c0423dd8SToomas Soome case KIOCGRPTCOUNT:
35817c478bd9Sstevel@tonic-gate case KIOCGRPTDELAY:
35827c478bd9Sstevel@tonic-gate case KIOCGRPTRATE:
35837c478bd9Sstevel@tonic-gate strioc.ic_len = 0;
35847c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg;
35857c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag,
3586d3e55dcdSgww copyflag, crp, rvalp));
35877c478bd9Sstevel@tonic-gate }
35887c478bd9Sstevel@tonic-gate }
35897c478bd9Sstevel@tonic-gate
35907c478bd9Sstevel@tonic-gate /*
35917c478bd9Sstevel@tonic-gate * Unknown cmd - send it down as a transparent ioctl.
35927c478bd9Sstevel@tonic-gate */
35937c478bd9Sstevel@tonic-gate strioc.ic_cmd = cmd;
35947c478bd9Sstevel@tonic-gate strioc.ic_timout = INFTIM;
35957c478bd9Sstevel@tonic-gate strioc.ic_len = TRANSPARENT;
35967c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)&arg;
35977c478bd9Sstevel@tonic-gate
35987c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp));
35997c478bd9Sstevel@tonic-gate
36007c478bd9Sstevel@tonic-gate case I_STR:
36017c478bd9Sstevel@tonic-gate /*
36027c478bd9Sstevel@tonic-gate * Stream ioctl. Read in an strioctl buffer from the user
36037c478bd9Sstevel@tonic-gate * along with any data specified and send it downstream.
36047c478bd9Sstevel@tonic-gate * Strdoioctl will wait allow only one ioctl message at
36057c478bd9Sstevel@tonic-gate * a time, and waits for the acknowledgement.
36067c478bd9Sstevel@tonic-gate */
36077c478bd9Sstevel@tonic-gate
36087c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
36097c478bd9Sstevel@tonic-gate return (ENXIO);
36107c478bd9Sstevel@tonic-gate
36117c478bd9Sstevel@tonic-gate error = strcopyin_strioctl((void *)arg, &strioc, flag,
36127c478bd9Sstevel@tonic-gate copyflag);
36137c478bd9Sstevel@tonic-gate if (error != 0)
36147c478bd9Sstevel@tonic-gate return (error);
36157c478bd9Sstevel@tonic-gate
36167c478bd9Sstevel@tonic-gate if ((strioc.ic_len < 0) || (strioc.ic_timout < -1))
36177c478bd9Sstevel@tonic-gate return (EINVAL);
36187c478bd9Sstevel@tonic-gate
36197c478bd9Sstevel@tonic-gate access = job_control_type(strioc.ic_cmd);
36209acbbeafSnn mutex_enter(&stp->sd_lock);
36219acbbeafSnn if ((access != -1) &&
36229acbbeafSnn ((error = i_straccess(stp, access)) != 0)) {
36239acbbeafSnn mutex_exit(&stp->sd_lock);
36247c478bd9Sstevel@tonic-gate return (error);
36259acbbeafSnn }
36269acbbeafSnn mutex_exit(&stp->sd_lock);
36277c478bd9Sstevel@tonic-gate
36287c478bd9Sstevel@tonic-gate /*
36297c478bd9Sstevel@tonic-gate * The I_STR facility provides a trap door for malicious
3630*bbf21555SRichard Lowe * code to send down bogus streamio(4I) ioctl commands to
36317c478bd9Sstevel@tonic-gate * unsuspecting STREAMS modules and drivers which expect to
36327c478bd9Sstevel@tonic-gate * only get these messages from the stream head.
36337c478bd9Sstevel@tonic-gate * Explicitly prohibit any streamio ioctls which can be
36347c478bd9Sstevel@tonic-gate * passed downstream by the stream head. Note that we do
36357c478bd9Sstevel@tonic-gate * not block all streamio ioctls because the ioctl
36367c478bd9Sstevel@tonic-gate * numberspace is not well managed and thus it's possible
36377c478bd9Sstevel@tonic-gate * that a module or driver's ioctl numbers may accidentally
36387c478bd9Sstevel@tonic-gate * collide with them.
36397c478bd9Sstevel@tonic-gate */
36407c478bd9Sstevel@tonic-gate switch (strioc.ic_cmd) {
36417c478bd9Sstevel@tonic-gate case I_LINK:
36427c478bd9Sstevel@tonic-gate case I_PLINK:
36437c478bd9Sstevel@tonic-gate case I_UNLINK:
36447c478bd9Sstevel@tonic-gate case I_PUNLINK:
36457c478bd9Sstevel@tonic-gate case _I_GETPEERCRED:
36467c478bd9Sstevel@tonic-gate case _I_PLINK_LH:
36477c478bd9Sstevel@tonic-gate return (EINVAL);
36487c478bd9Sstevel@tonic-gate }
36497c478bd9Sstevel@tonic-gate
36507c478bd9Sstevel@tonic-gate error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp);
36517c478bd9Sstevel@tonic-gate if (error == 0) {
36527c478bd9Sstevel@tonic-gate error = strcopyout_strioctl(&strioc, (void *)arg,
36537c478bd9Sstevel@tonic-gate flag, copyflag);
36547c478bd9Sstevel@tonic-gate }
36557c478bd9Sstevel@tonic-gate return (error);
36567c478bd9Sstevel@tonic-gate
3657ca9327a6Smeem case _I_CMD:
3658ca9327a6Smeem /*
3659ca9327a6Smeem * Like I_STR, but without using M_IOC* messages and without
3660ca9327a6Smeem * copyins/copyouts beyond the passed-in argument.
3661ca9327a6Smeem */
3662ca9327a6Smeem if (stp->sd_flag & STRHUP)
3663ca9327a6Smeem return (ENXIO);
3664ca9327a6Smeem
3665e63ea1f9SAndy Fiddaman if (copyflag == U_TO_K) {
3666e63ea1f9SAndy Fiddaman if ((scp = kmem_alloc(sizeof (strcmd_t),
3667e63ea1f9SAndy Fiddaman KM_NOSLEEP)) == NULL) {
3668e63ea1f9SAndy Fiddaman return (ENOMEM);
3669e63ea1f9SAndy Fiddaman }
3670ca9327a6Smeem
3671e63ea1f9SAndy Fiddaman if (copyin((void *)arg, scp, sizeof (strcmd_t))) {
3672e63ea1f9SAndy Fiddaman kmem_free(scp, sizeof (strcmd_t));
3673e63ea1f9SAndy Fiddaman return (EFAULT);
3674e63ea1f9SAndy Fiddaman }
3675e63ea1f9SAndy Fiddaman } else {
3676e63ea1f9SAndy Fiddaman scp = (strcmd_t *)arg;
3677ca9327a6Smeem }
3678ca9327a6Smeem
3679ca9327a6Smeem access = job_control_type(scp->sc_cmd);
3680ca9327a6Smeem mutex_enter(&stp->sd_lock);
3681ca9327a6Smeem if (access != -1 && (error = i_straccess(stp, access)) != 0) {
3682ca9327a6Smeem mutex_exit(&stp->sd_lock);
3683e63ea1f9SAndy Fiddaman if (copyflag == U_TO_K)
3684e63ea1f9SAndy Fiddaman kmem_free(scp, sizeof (strcmd_t));
3685ca9327a6Smeem return (error);
3686ca9327a6Smeem }
3687ca9327a6Smeem mutex_exit(&stp->sd_lock);
3688ca9327a6Smeem
3689ca9327a6Smeem *rvalp = 0;
3690ca9327a6Smeem if ((error = strdocmd(stp, scp, crp)) == 0) {
3691e63ea1f9SAndy Fiddaman if (copyflag == U_TO_K &&
3692e63ea1f9SAndy Fiddaman copyout(scp, (void *)arg, sizeof (strcmd_t))) {
3693ca9327a6Smeem error = EFAULT;
3694e63ea1f9SAndy Fiddaman }
3695ca9327a6Smeem }
3696e63ea1f9SAndy Fiddaman if (copyflag == U_TO_K)
3697e63ea1f9SAndy Fiddaman kmem_free(scp, sizeof (strcmd_t));
3698ca9327a6Smeem return (error);
3699ca9327a6Smeem
37007c478bd9Sstevel@tonic-gate case I_NREAD:
37017c478bd9Sstevel@tonic-gate /*
37027c478bd9Sstevel@tonic-gate * Return number of bytes of data in first message
37037c478bd9Sstevel@tonic-gate * in queue in "arg" and return the number of messages
37047c478bd9Sstevel@tonic-gate * in queue in return value.
37057c478bd9Sstevel@tonic-gate */
3706d3e55dcdSgww {
37077c478bd9Sstevel@tonic-gate size_t size;
37087c478bd9Sstevel@tonic-gate int retval;
37097c478bd9Sstevel@tonic-gate int count = 0;
37107c478bd9Sstevel@tonic-gate
37117c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq));
37127c478bd9Sstevel@tonic-gate
37137c478bd9Sstevel@tonic-gate size = msgdsize(rdq->q_first);
37147c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
37157c478bd9Sstevel@tonic-gate count++;
37167c478bd9Sstevel@tonic-gate
37177c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
37187c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) {
37197c478bd9Sstevel@tonic-gate infod_t infod;
37207c478bd9Sstevel@tonic-gate
37217c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_COUNT;
37227c478bd9Sstevel@tonic-gate infod.d_count = 0;
37237c478bd9Sstevel@tonic-gate if (count == 0) {
37247c478bd9Sstevel@tonic-gate infod.d_cmd |= INFOD_FIRSTBYTES;
37257c478bd9Sstevel@tonic-gate infod.d_bytes = 0;
37267c478bd9Sstevel@tonic-gate }
37277c478bd9Sstevel@tonic-gate infod.d_res = 0;
37287c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod);
37297c478bd9Sstevel@tonic-gate count += infod.d_count;
37307c478bd9Sstevel@tonic-gate if (infod.d_res & INFOD_FIRSTBYTES)
37317c478bd9Sstevel@tonic-gate size = infod.d_bytes;
37327c478bd9Sstevel@tonic-gate }
37337c478bd9Sstevel@tonic-gate
37347c478bd9Sstevel@tonic-gate /*
37357c478bd9Sstevel@tonic-gate * Drop down from size_t to the "int" required by the
37367c478bd9Sstevel@tonic-gate * interface. Cap at INT_MAX.
37377c478bd9Sstevel@tonic-gate */
37387c478bd9Sstevel@tonic-gate retval = MIN(size, INT_MAX);
37397c478bd9Sstevel@tonic-gate error = strcopyout(&retval, (void *)arg, sizeof (retval),
37407c478bd9Sstevel@tonic-gate copyflag);
37417c478bd9Sstevel@tonic-gate if (!error)
37427c478bd9Sstevel@tonic-gate *rvalp = count;
37437c478bd9Sstevel@tonic-gate return (error);
3744d3e55dcdSgww }
37457c478bd9Sstevel@tonic-gate
37467c478bd9Sstevel@tonic-gate case FIONREAD:
37477c478bd9Sstevel@tonic-gate /*
37487c478bd9Sstevel@tonic-gate * Return number of bytes of data in all data messages
37497c478bd9Sstevel@tonic-gate * in queue in "arg".
37507c478bd9Sstevel@tonic-gate */
3751d3e55dcdSgww {
37527c478bd9Sstevel@tonic-gate size_t size = 0;
37537c478bd9Sstevel@tonic-gate int retval;
37547c478bd9Sstevel@tonic-gate
37557c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq));
37567c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
37577c478bd9Sstevel@tonic-gate size += msgdsize(mp);
37587c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
37597c478bd9Sstevel@tonic-gate
37607c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) {
37617c478bd9Sstevel@tonic-gate infod_t infod;
37627c478bd9Sstevel@tonic-gate
37637c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_BYTES;
37647c478bd9Sstevel@tonic-gate infod.d_res = 0;
37657c478bd9Sstevel@tonic-gate infod.d_bytes = 0;
37667c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod);
37677c478bd9Sstevel@tonic-gate size += infod.d_bytes;
37687c478bd9Sstevel@tonic-gate }
37697c478bd9Sstevel@tonic-gate
37707c478bd9Sstevel@tonic-gate /*
37717c478bd9Sstevel@tonic-gate * Drop down from size_t to the "int" required by the
37727c478bd9Sstevel@tonic-gate * interface. Cap at INT_MAX.
37737c478bd9Sstevel@tonic-gate */
37747c478bd9Sstevel@tonic-gate retval = MIN(size, INT_MAX);
37757c478bd9Sstevel@tonic-gate error = strcopyout(&retval, (void *)arg, sizeof (retval),
37767c478bd9Sstevel@tonic-gate copyflag);
37777c478bd9Sstevel@tonic-gate
37787c478bd9Sstevel@tonic-gate *rvalp = 0;
37797c478bd9Sstevel@tonic-gate return (error);
3780d3e55dcdSgww }
37817c478bd9Sstevel@tonic-gate case FIORDCHK:
37827c478bd9Sstevel@tonic-gate /*
37837c478bd9Sstevel@tonic-gate * FIORDCHK does not use arg value (like FIONREAD),
37847c478bd9Sstevel@tonic-gate * instead a count is returned. I_NREAD value may
37857c478bd9Sstevel@tonic-gate * not be accurate but safe. The real thing to do is
37867c478bd9Sstevel@tonic-gate * to add the msgdsizes of all data messages until
37877c478bd9Sstevel@tonic-gate * a non-data message.
37887c478bd9Sstevel@tonic-gate */
3789d3e55dcdSgww {
37907c478bd9Sstevel@tonic-gate size_t size = 0;
37917c478bd9Sstevel@tonic-gate
37927c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq));
37937c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
37947c478bd9Sstevel@tonic-gate size += msgdsize(mp);
37957c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
37967c478bd9Sstevel@tonic-gate
37977c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) {
37987c478bd9Sstevel@tonic-gate infod_t infod;
37997c478bd9Sstevel@tonic-gate
38007c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_BYTES;
38017c478bd9Sstevel@tonic-gate infod.d_res = 0;
38027c478bd9Sstevel@tonic-gate infod.d_bytes = 0;
38037c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod);
38047c478bd9Sstevel@tonic-gate size += infod.d_bytes;
38057c478bd9Sstevel@tonic-gate }
38067c478bd9Sstevel@tonic-gate
38077c478bd9Sstevel@tonic-gate /*
38087c478bd9Sstevel@tonic-gate * Since ioctl returns an int, and memory sizes under
38097c478bd9Sstevel@tonic-gate * LP64 may not fit, we return INT_MAX if the count was
38107c478bd9Sstevel@tonic-gate * actually greater.
38117c478bd9Sstevel@tonic-gate */
38127c478bd9Sstevel@tonic-gate *rvalp = MIN(size, INT_MAX);
38137c478bd9Sstevel@tonic-gate return (0);
3814d3e55dcdSgww }
38157c478bd9Sstevel@tonic-gate
38167c478bd9Sstevel@tonic-gate case I_FIND:
38177c478bd9Sstevel@tonic-gate /*
38187c478bd9Sstevel@tonic-gate * Get module name.
38197c478bd9Sstevel@tonic-gate */
3820d3e55dcdSgww {
38217c478bd9Sstevel@tonic-gate char mname[FMNAMESZ + 1];
38227c478bd9Sstevel@tonic-gate queue_t *q;
38237c478bd9Sstevel@tonic-gate
38247c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
38257c478bd9Sstevel@tonic-gate mname, FMNAMESZ + 1, NULL);
38267c478bd9Sstevel@tonic-gate if (error)
38277c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
38287c478bd9Sstevel@tonic-gate
38297c478bd9Sstevel@tonic-gate /*
38307c478bd9Sstevel@tonic-gate * Return EINVAL if we're handed a bogus module name.
38317c478bd9Sstevel@tonic-gate */
38327c478bd9Sstevel@tonic-gate if (fmodsw_find(mname, FMODSW_LOAD) == NULL) {
38337c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR,
3834d3e55dcdSgww TR_I_CANT_FIND, "couldn't I_FIND");
38357c478bd9Sstevel@tonic-gate return (EINVAL);
38367c478bd9Sstevel@tonic-gate }
38377c478bd9Sstevel@tonic-gate
38387c478bd9Sstevel@tonic-gate *rvalp = 0;
38397c478bd9Sstevel@tonic-gate
38407c478bd9Sstevel@tonic-gate /* Look downstream to see if module is there. */
38417c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq);
38427c478bd9Sstevel@tonic-gate for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
3843a45f3f93Smeem if (q->q_flag & QREADR) {
38447c478bd9Sstevel@tonic-gate q = NULL;
38457c478bd9Sstevel@tonic-gate break;
38467c478bd9Sstevel@tonic-gate }
3847a45f3f93Smeem if (strcmp(mname, Q2NAME(q)) == 0)
38487c478bd9Sstevel@tonic-gate break;
38497c478bd9Sstevel@tonic-gate }
38507c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq);
38517c478bd9Sstevel@tonic-gate
38527c478bd9Sstevel@tonic-gate *rvalp = (q ? 1 : 0);
38537c478bd9Sstevel@tonic-gate return (error);
3854d3e55dcdSgww }
38557c478bd9Sstevel@tonic-gate
38567c478bd9Sstevel@tonic-gate case I_PUSH:
38577c478bd9Sstevel@tonic-gate case __I_PUSH_NOCTTY:
38587c478bd9Sstevel@tonic-gate /*
38597c478bd9Sstevel@tonic-gate * Push a module.
38607c478bd9Sstevel@tonic-gate * For the case __I_PUSH_NOCTTY push a module but
38617c478bd9Sstevel@tonic-gate * do not allocate controlling tty. See bugid 4025044
38627c478bd9Sstevel@tonic-gate */
38637c478bd9Sstevel@tonic-gate
3864d3e55dcdSgww {
38657c478bd9Sstevel@tonic-gate char mname[FMNAMESZ + 1];
38667c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp;
38677c478bd9Sstevel@tonic-gate dev_t dummydev;
38687c478bd9Sstevel@tonic-gate
38697c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
38707c478bd9Sstevel@tonic-gate return (ENXIO);
38717c478bd9Sstevel@tonic-gate
38727c478bd9Sstevel@tonic-gate /*
38737c478bd9Sstevel@tonic-gate * Get module name and look up in fmodsw.
38747c478bd9Sstevel@tonic-gate */
38757c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg,
38767c478bd9Sstevel@tonic-gate mname, FMNAMESZ + 1, NULL);
38777c478bd9Sstevel@tonic-gate if (error)
38787c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
38797c478bd9Sstevel@tonic-gate
38807c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) ==
38817c478bd9Sstevel@tonic-gate NULL)
38827c478bd9Sstevel@tonic-gate return (EINVAL);
38837c478bd9Sstevel@tonic-gate
38847c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH,
38857c478bd9Sstevel@tonic-gate "I_PUSH:fp %p stp %p", fp, stp);
38867c478bd9Sstevel@tonic-gate
38876cfa0a70SAndy Fiddaman /*
38886cfa0a70SAndy Fiddaman * If the module is flagged as single-instance, then check
38896cfa0a70SAndy Fiddaman * to see if the module is already pushed. If it is, return
38906cfa0a70SAndy Fiddaman * as if the push was successful.
38916cfa0a70SAndy Fiddaman */
38926cfa0a70SAndy Fiddaman if (fp->f_qflag & _QSINGLE_INSTANCE) {
38936cfa0a70SAndy Fiddaman queue_t *q;
38946cfa0a70SAndy Fiddaman
38956cfa0a70SAndy Fiddaman claimstr(stp->sd_wrq);
38966cfa0a70SAndy Fiddaman for (q = stp->sd_wrq->q_next; q; q = q->q_next) {
38976cfa0a70SAndy Fiddaman if (q->q_flag & QREADR) {
38986cfa0a70SAndy Fiddaman q = NULL;
38996cfa0a70SAndy Fiddaman break;
39006cfa0a70SAndy Fiddaman }
39016cfa0a70SAndy Fiddaman if (strcmp(mname, Q2NAME(q)) == 0)
39026cfa0a70SAndy Fiddaman break;
39036cfa0a70SAndy Fiddaman }
39046cfa0a70SAndy Fiddaman releasestr(stp->sd_wrq);
39056cfa0a70SAndy Fiddaman if (q != NULL) {
39066cfa0a70SAndy Fiddaman fmodsw_rele(fp);
39076cfa0a70SAndy Fiddaman return (0);
39086cfa0a70SAndy Fiddaman }
39096cfa0a70SAndy Fiddaman }
39106cfa0a70SAndy Fiddaman
39117c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd)) {
39127c478bd9Sstevel@tonic-gate fmodsw_rele(fp);
39137c478bd9Sstevel@tonic-gate return (error);
39147c478bd9Sstevel@tonic-gate }
39157c478bd9Sstevel@tonic-gate
39167c478bd9Sstevel@tonic-gate /*
39177c478bd9Sstevel@tonic-gate * See if any more modules can be pushed on this stream.
39187c478bd9Sstevel@tonic-gate * Note that this check must be done after strstartplumb()
39197c478bd9Sstevel@tonic-gate * since otherwise multiple threads issuing I_PUSHes on
39207c478bd9Sstevel@tonic-gate * the same stream will be able to exceed nstrpush.
39217c478bd9Sstevel@tonic-gate */
39227c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
39237c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush) {
39247c478bd9Sstevel@tonic-gate fmodsw_rele(fp);
39257c478bd9Sstevel@tonic-gate strendplumb(stp);
39267c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
39277c478bd9Sstevel@tonic-gate return (EINVAL);
39287c478bd9Sstevel@tonic-gate }
39297c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
39307c478bd9Sstevel@tonic-gate
39317c478bd9Sstevel@tonic-gate /*
39327c478bd9Sstevel@tonic-gate * Push new module and call its open routine
39337c478bd9Sstevel@tonic-gate * via qattach(). Modules don't change device
39347c478bd9Sstevel@tonic-gate * numbers, so just ignore dummydev here.
39357c478bd9Sstevel@tonic-gate */
39367c478bd9Sstevel@tonic-gate dummydev = vp->v_rdev;
39377c478bd9Sstevel@tonic-gate if ((error = qattach(rdq, &dummydev, 0, crp, fp,
39387c478bd9Sstevel@tonic-gate B_FALSE)) == 0) {
39397c478bd9Sstevel@tonic-gate if (vp->v_type == VCHR && /* sorry, no pipes allowed */
39407c478bd9Sstevel@tonic-gate (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) {
39417c478bd9Sstevel@tonic-gate /*
39427c478bd9Sstevel@tonic-gate * try to allocate it as a controlling terminal
39437c478bd9Sstevel@tonic-gate */
39449acbbeafSnn (void) strctty(stp);
39457c478bd9Sstevel@tonic-gate }
39467c478bd9Sstevel@tonic-gate }
39477c478bd9Sstevel@tonic-gate
39487c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
39497c478bd9Sstevel@tonic-gate
39507c478bd9Sstevel@tonic-gate /*
39517c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of
39527c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream
39537c478bd9Sstevel@tonic-gate * head in the stream head.
39547c478bd9Sstevel@tonic-gate */
39557c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next));
39567c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz;
39577c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz;
39587c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next));
39597c478bd9Sstevel@tonic-gate
39607c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */
39617c478bd9Sstevel@tonic-gate if (strmsgsz != 0) {
39627c478bd9Sstevel@tonic-gate if (rmax == INFPSZ)
39637c478bd9Sstevel@tonic-gate rmax = strmsgsz;
39647c478bd9Sstevel@tonic-gate else {
39657c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO)
39667c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax);
39677c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax);
39687c478bd9Sstevel@tonic-gate }
39697c478bd9Sstevel@tonic-gate }
39707c478bd9Sstevel@tonic-gate
39717c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq));
39727c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin;
39737c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax;
39747c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq));
39757c478bd9Sstevel@tonic-gate
39767c478bd9Sstevel@tonic-gate strendplumb(stp);
39777c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
39787c478bd9Sstevel@tonic-gate return (error);
3979d3e55dcdSgww }
39807c478bd9Sstevel@tonic-gate
39817c478bd9Sstevel@tonic-gate case I_POP:
3982d3e55dcdSgww {
39837c478bd9Sstevel@tonic-gate queue_t *q;
39847c478bd9Sstevel@tonic-gate
39857c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
39867c478bd9Sstevel@tonic-gate return (ENXIO);
39877c478bd9Sstevel@tonic-gate if (!wrq->q_next) /* for broken pipes */
39887c478bd9Sstevel@tonic-gate return (EINVAL);
39897c478bd9Sstevel@tonic-gate
39907c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd))
39917c478bd9Sstevel@tonic-gate return (error);
39927c478bd9Sstevel@tonic-gate
39937c478bd9Sstevel@tonic-gate /*
39947c478bd9Sstevel@tonic-gate * If there is an anchor on this stream and popping
39957c478bd9Sstevel@tonic-gate * the current module would attempt to pop through the
39967c478bd9Sstevel@tonic-gate * anchor, then disallow the pop unless we have sufficient
39977c478bd9Sstevel@tonic-gate * privileges; take the cheapest (non-locking) check
39987c478bd9Sstevel@tonic-gate * first.
39997c478bd9Sstevel@tonic-gate */
4000f4b3ec61Sdh if (secpolicy_ip_config(crp, B_TRUE) != 0 ||
4001f4b3ec61Sdh (stp->sd_anchorzone != crgetzoneid(crp))) {
40027c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
40037c478bd9Sstevel@tonic-gate /*
40047c478bd9Sstevel@tonic-gate * Anchors only apply if there's at least one
40057c478bd9Sstevel@tonic-gate * module on the stream (sd_pushcnt > 0).
40067c478bd9Sstevel@tonic-gate */
40077c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt > 0 &&
40087c478bd9Sstevel@tonic-gate stp->sd_pushcnt == stp->sd_anchor &&
40097c478bd9Sstevel@tonic-gate stp->sd_vnode->v_type != VFIFO) {
40107c478bd9Sstevel@tonic-gate strendplumb(stp);
40117c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
4012f4b3ec61Sdh if (stp->sd_anchorzone != crgetzoneid(crp))
4013f4b3ec61Sdh return (EINVAL);
40147c478bd9Sstevel@tonic-gate /* Audit and report error */
4015f4b3ec61Sdh return (secpolicy_ip_config(crp, B_FALSE));
40167c478bd9Sstevel@tonic-gate }
40177c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
40187c478bd9Sstevel@tonic-gate }
40197c478bd9Sstevel@tonic-gate
40207c478bd9Sstevel@tonic-gate q = wrq->q_next;
40217c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP,
4022d3e55dcdSgww "I_POP:%p from %p", q, stp);
40237c478bd9Sstevel@tonic-gate if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) {
40247c478bd9Sstevel@tonic-gate error = EINVAL;
40257c478bd9Sstevel@tonic-gate } else {
40267c478bd9Sstevel@tonic-gate qdetach(_RD(q), 1, flag, crp, B_FALSE);
40277c478bd9Sstevel@tonic-gate error = 0;
40287c478bd9Sstevel@tonic-gate }
40297c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
40307c478bd9Sstevel@tonic-gate
40317c478bd9Sstevel@tonic-gate /*
40327c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of
40337c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream
40347c478bd9Sstevel@tonic-gate * head in the stream head.
40357c478bd9Sstevel@tonic-gate */
40367c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq->q_next));
40377c478bd9Sstevel@tonic-gate rmin = wrq->q_next->q_minpsz;
40387c478bd9Sstevel@tonic-gate rmax = wrq->q_next->q_maxpsz;
40397c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq->q_next));
40407c478bd9Sstevel@tonic-gate
40417c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */
40427c478bd9Sstevel@tonic-gate if (strmsgsz != 0) {
40437c478bd9Sstevel@tonic-gate if (rmax == INFPSZ)
40447c478bd9Sstevel@tonic-gate rmax = strmsgsz;
40457c478bd9Sstevel@tonic-gate else {
40467c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO)
40477c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax);
40487c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax);
40497c478bd9Sstevel@tonic-gate }
40507c478bd9Sstevel@tonic-gate }
40517c478bd9Sstevel@tonic-gate
40527c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq));
40537c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin;
40547c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax;
40557c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq));
40567c478bd9Sstevel@tonic-gate
40577c478bd9Sstevel@tonic-gate /* If we popped through the anchor, then reset the anchor. */
4058f4b3ec61Sdh if (stp->sd_pushcnt < stp->sd_anchor) {
40597c478bd9Sstevel@tonic-gate stp->sd_anchor = 0;
4060f4b3ec61Sdh stp->sd_anchorzone = 0;
4061f4b3ec61Sdh }
40627c478bd9Sstevel@tonic-gate strendplumb(stp);
40637c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
40647c478bd9Sstevel@tonic-gate return (error);
4065d3e55dcdSgww }
40667c478bd9Sstevel@tonic-gate
40677c478bd9Sstevel@tonic-gate case _I_MUXID2FD:
40687c478bd9Sstevel@tonic-gate {
40697c478bd9Sstevel@tonic-gate /*
40707c478bd9Sstevel@tonic-gate * Create a fd for a I_PLINK'ed lower stream with a given
40717c478bd9Sstevel@tonic-gate * muxid. With the fd, application can send down ioctls,
40727c478bd9Sstevel@tonic-gate * like I_LIST, to the previously I_PLINK'ed stream. Note
40737c478bd9Sstevel@tonic-gate * that after getting the fd, the application has to do an
40747c478bd9Sstevel@tonic-gate * I_PUNLINK on the muxid before it can do any operation
40757c478bd9Sstevel@tonic-gate * on the lower stream. This is required by spec1170.
40767c478bd9Sstevel@tonic-gate *
40777c478bd9Sstevel@tonic-gate * The fd used to do this ioctl should point to the same
40787c478bd9Sstevel@tonic-gate * controlling device used to do the I_PLINK. If it uses
40797c478bd9Sstevel@tonic-gate * a different stream or an invalid muxid, I_MUXID2FD will
40807c478bd9Sstevel@tonic-gate * fail. The error code is set to EINVAL.
40817c478bd9Sstevel@tonic-gate *
40827c478bd9Sstevel@tonic-gate * The intended use of this interface is the following.
40837c478bd9Sstevel@tonic-gate * An application I_PLINK'ed a stream and exits. The fd
40847c478bd9Sstevel@tonic-gate * to the lower stream is gone. Another application
40857c478bd9Sstevel@tonic-gate * wants to get a fd to the lower stream, it uses I_MUXID2FD.
40867c478bd9Sstevel@tonic-gate */
40877c478bd9Sstevel@tonic-gate int muxid = (int)arg;
40887c478bd9Sstevel@tonic-gate int fd;
40897c478bd9Sstevel@tonic-gate linkinfo_t *linkp;
40907c478bd9Sstevel@tonic-gate struct file *fp;
4091f4b3ec61Sdh netstack_t *ns;
4092f4b3ec61Sdh str_stack_t *ss;
40937c478bd9Sstevel@tonic-gate
40947c478bd9Sstevel@tonic-gate /*
40957c478bd9Sstevel@tonic-gate * Do not allow the wildcard muxid. This ioctl is not
40967c478bd9Sstevel@tonic-gate * intended to find arbitrary link.
40977c478bd9Sstevel@tonic-gate */
40987c478bd9Sstevel@tonic-gate if (muxid == 0) {
40997c478bd9Sstevel@tonic-gate return (EINVAL);
41007c478bd9Sstevel@tonic-gate }
41017c478bd9Sstevel@tonic-gate
4102f4b3ec61Sdh ns = netstack_find_by_cred(crp);
4103f4b3ec61Sdh ASSERT(ns != NULL);
4104f4b3ec61Sdh ss = ns->netstack_str;
4105f4b3ec61Sdh ASSERT(ss != NULL);
4106f4b3ec61Sdh
41077c478bd9Sstevel@tonic-gate mutex_enter(&muxifier);
4108f4b3ec61Sdh linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss);
41097c478bd9Sstevel@tonic-gate if (linkp == NULL) {
41107c478bd9Sstevel@tonic-gate mutex_exit(&muxifier);
4111f4b3ec61Sdh netstack_rele(ss->ss_netstack);
41127c478bd9Sstevel@tonic-gate return (EINVAL);
41137c478bd9Sstevel@tonic-gate }
41147c478bd9Sstevel@tonic-gate
41157c478bd9Sstevel@tonic-gate if ((fd = ufalloc(0)) == -1) {
41167c478bd9Sstevel@tonic-gate mutex_exit(&muxifier);
4117f4b3ec61Sdh netstack_rele(ss->ss_netstack);
41187c478bd9Sstevel@tonic-gate return (EMFILE);
41197c478bd9Sstevel@tonic-gate }
41207c478bd9Sstevel@tonic-gate fp = linkp->li_fpdown;
41217c478bd9Sstevel@tonic-gate mutex_enter(&fp->f_tlock);
41227c478bd9Sstevel@tonic-gate fp->f_count++;
41237c478bd9Sstevel@tonic-gate mutex_exit(&fp->f_tlock);
41247c478bd9Sstevel@tonic-gate mutex_exit(&muxifier);
41257c478bd9Sstevel@tonic-gate setf(fd, fp);
41267c478bd9Sstevel@tonic-gate *rvalp = fd;
4127f4b3ec61Sdh netstack_rele(ss->ss_netstack);
41287c478bd9Sstevel@tonic-gate return (0);
41297c478bd9Sstevel@tonic-gate }
41307c478bd9Sstevel@tonic-gate
41317c478bd9Sstevel@tonic-gate case _I_INSERT:
41327c478bd9Sstevel@tonic-gate {
41337c478bd9Sstevel@tonic-gate /*
41347c478bd9Sstevel@tonic-gate * To insert a module to a given position in a stream.
41357c478bd9Sstevel@tonic-gate * In the first release, only allow privileged user
4136f4b3ec61Sdh * to use this ioctl. Furthermore, the insert is only allowed
4137f4b3ec61Sdh * below an anchor if the zoneid is the same as the zoneid
4138f4b3ec61Sdh * which created the anchor.
41397c478bd9Sstevel@tonic-gate *
41407c478bd9Sstevel@tonic-gate * Note that we do not plan to support this ioctl
41417c478bd9Sstevel@tonic-gate * on pipes in the first release. We want to learn more
41427c478bd9Sstevel@tonic-gate * about the implications of these ioctls before extending
41437c478bd9Sstevel@tonic-gate * their support. And we do not think these features are
41447c478bd9Sstevel@tonic-gate * valuable for pipes.
41457c478bd9Sstevel@tonic-gate */
41467c478bd9Sstevel@tonic-gate STRUCT_DECL(strmodconf, strmodinsert);
41477c478bd9Sstevel@tonic-gate char mod_name[FMNAMESZ + 1];
41487c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp;
41497c478bd9Sstevel@tonic-gate dev_t dummydev;
41507c478bd9Sstevel@tonic-gate queue_t *tmp_wrq;
41517c478bd9Sstevel@tonic-gate int pos;
41527c478bd9Sstevel@tonic-gate boolean_t is_insert;
41537c478bd9Sstevel@tonic-gate
41547c478bd9Sstevel@tonic-gate STRUCT_INIT(strmodinsert, flag);
41557c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
41567c478bd9Sstevel@tonic-gate return (ENXIO);
41577c478bd9Sstevel@tonic-gate if (STRMATED(stp))
41587c478bd9Sstevel@tonic-gate return (EINVAL);
41597c478bd9Sstevel@tonic-gate if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
41607c478bd9Sstevel@tonic-gate return (error);
4161f4b3ec61Sdh if (stp->sd_anchor != 0 &&
4162f4b3ec61Sdh stp->sd_anchorzone != crgetzoneid(crp))
4163f4b3ec61Sdh return (EINVAL);
41647c478bd9Sstevel@tonic-gate
41657c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert),
41667c478bd9Sstevel@tonic-gate STRUCT_SIZE(strmodinsert), copyflag);
41677c478bd9Sstevel@tonic-gate if (error)
41687c478bd9Sstevel@tonic-gate return (error);
41697c478bd9Sstevel@tonic-gate
41707c478bd9Sstevel@tonic-gate /*
41717c478bd9Sstevel@tonic-gate * Get module name and look up in fmodsw.
41727c478bd9Sstevel@tonic-gate */
41737c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr :
41747c478bd9Sstevel@tonic-gate copystr)(STRUCT_FGETP(strmodinsert, mod_name),
41757c478bd9Sstevel@tonic-gate mod_name, FMNAMESZ + 1, NULL);
41767c478bd9Sstevel@tonic-gate if (error)
41777c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
41787c478bd9Sstevel@tonic-gate
41797c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) ==
41807c478bd9Sstevel@tonic-gate NULL)
41817c478bd9Sstevel@tonic-gate return (EINVAL);
41827c478bd9Sstevel@tonic-gate
41837c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd)) {
41847c478bd9Sstevel@tonic-gate fmodsw_rele(fp);
41857c478bd9Sstevel@tonic-gate return (error);
41867c478bd9Sstevel@tonic-gate }
41877c478bd9Sstevel@tonic-gate
41887c478bd9Sstevel@tonic-gate /*
41897c478bd9Sstevel@tonic-gate * Is this _I_INSERT just like an I_PUSH? We need to know
41907c478bd9Sstevel@tonic-gate * this because we do some optimizations if this is a
41917c478bd9Sstevel@tonic-gate * module being pushed.
41927c478bd9Sstevel@tonic-gate */
41937c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodinsert, pos);
41947c478bd9Sstevel@tonic-gate is_insert = (pos != 0);
41957c478bd9Sstevel@tonic-gate
41967c478bd9Sstevel@tonic-gate /*
41977c478bd9Sstevel@tonic-gate * Make sure pos is valid. Even though it is not an I_PUSH,
41987c478bd9Sstevel@tonic-gate * we impose the same limit on the number of modules in a
41997c478bd9Sstevel@tonic-gate * stream.
42007c478bd9Sstevel@tonic-gate */
42017c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
42027c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush || pos < 0 ||
42037c478bd9Sstevel@tonic-gate pos > stp->sd_pushcnt) {
42047c478bd9Sstevel@tonic-gate fmodsw_rele(fp);
42057c478bd9Sstevel@tonic-gate strendplumb(stp);
42067c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
42077c478bd9Sstevel@tonic-gate return (EINVAL);
42087c478bd9Sstevel@tonic-gate }
4209f4b3ec61Sdh if (stp->sd_anchor != 0) {
4210f4b3ec61Sdh /*
4211f4b3ec61Sdh * Is this insert below the anchor?
4212f4b3ec61Sdh * Pushcnt hasn't been increased yet hence
4213f4b3ec61Sdh * we test for greater than here, and greater or
4214f4b3ec61Sdh * equal after qattach.
4215f4b3ec61Sdh */
4216f4b3ec61Sdh if (pos > (stp->sd_pushcnt - stp->sd_anchor) &&
4217f4b3ec61Sdh stp->sd_anchorzone != crgetzoneid(crp)) {
4218f4b3ec61Sdh fmodsw_rele(fp);
4219f4b3ec61Sdh strendplumb(stp);
4220f4b3ec61Sdh mutex_exit(&stp->sd_lock);
4221f4b3ec61Sdh return (EPERM);
4222f4b3ec61Sdh }
4223f4b3ec61Sdh }
4224f4b3ec61Sdh
42257c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
42267c478bd9Sstevel@tonic-gate
42277c478bd9Sstevel@tonic-gate /*
42287c478bd9Sstevel@tonic-gate * First find the correct position this module to
42297c478bd9Sstevel@tonic-gate * be inserted. We don't need to call claimstr()
42307c478bd9Sstevel@tonic-gate * as the stream should not be changing at this point.
42317c478bd9Sstevel@tonic-gate *
42327c478bd9Sstevel@tonic-gate * Insert new module and call its open routine
42337c478bd9Sstevel@tonic-gate * via qattach(). Modules don't change device
42347c478bd9Sstevel@tonic-gate * numbers, so just ignore dummydev here.
42357c478bd9Sstevel@tonic-gate */
42367c478bd9Sstevel@tonic-gate for (tmp_wrq = stp->sd_wrq; pos > 0;
42377c478bd9Sstevel@tonic-gate tmp_wrq = tmp_wrq->q_next, pos--) {
42387c478bd9Sstevel@tonic-gate ASSERT(SAMESTR(tmp_wrq));
42397c478bd9Sstevel@tonic-gate }
42407c478bd9Sstevel@tonic-gate dummydev = vp->v_rdev;
42417c478bd9Sstevel@tonic-gate if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp,
42427c478bd9Sstevel@tonic-gate fp, is_insert)) != 0) {
42437c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
42447c478bd9Sstevel@tonic-gate strendplumb(stp);
42457c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
42467c478bd9Sstevel@tonic-gate return (error);
42477c478bd9Sstevel@tonic-gate }
42487c478bd9Sstevel@tonic-gate
42497c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
42507c478bd9Sstevel@tonic-gate
42517c478bd9Sstevel@tonic-gate /*
42527c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of
42537c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream
42547c478bd9Sstevel@tonic-gate * head in the stream head.
42557c478bd9Sstevel@tonic-gate */
42567c478bd9Sstevel@tonic-gate if (!is_insert) {
42577c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next));
42587c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz;
42597c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz;
42607c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next));
42617c478bd9Sstevel@tonic-gate
42627c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */
42637c478bd9Sstevel@tonic-gate if (strmsgsz != 0) {
42647c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) {
42657c478bd9Sstevel@tonic-gate rmax = strmsgsz;
42667c478bd9Sstevel@tonic-gate } else {
42677c478bd9Sstevel@tonic-gate rmax = MIN(strmsgsz, rmax);
42687c478bd9Sstevel@tonic-gate }
42697c478bd9Sstevel@tonic-gate }
42707c478bd9Sstevel@tonic-gate
42717c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq));
42727c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin;
42737c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax;
42747c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq));
42757c478bd9Sstevel@tonic-gate }
42767c478bd9Sstevel@tonic-gate
42777c478bd9Sstevel@tonic-gate /*
42787c478bd9Sstevel@tonic-gate * Need to update the anchor value if this module is
42797c478bd9Sstevel@tonic-gate * inserted below the anchor point.
42807c478bd9Sstevel@tonic-gate */
42817c478bd9Sstevel@tonic-gate if (stp->sd_anchor != 0) {
42827c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodinsert, pos);
42837c478bd9Sstevel@tonic-gate if (pos >= (stp->sd_pushcnt - stp->sd_anchor))
42847c478bd9Sstevel@tonic-gate stp->sd_anchor++;
42857c478bd9Sstevel@tonic-gate }
42867c478bd9Sstevel@tonic-gate
42877c478bd9Sstevel@tonic-gate strendplumb(stp);
42887c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
42897c478bd9Sstevel@tonic-gate return (0);
42907c478bd9Sstevel@tonic-gate }
42917c478bd9Sstevel@tonic-gate
42927c478bd9Sstevel@tonic-gate case _I_REMOVE:
42937c478bd9Sstevel@tonic-gate {
42947c478bd9Sstevel@tonic-gate /*
42957c478bd9Sstevel@tonic-gate * To remove a module with a given name in a stream. The
42967c478bd9Sstevel@tonic-gate * caller of this ioctl needs to provide both the name and
42977c478bd9Sstevel@tonic-gate * the position of the module to be removed. This eliminates
42987c478bd9Sstevel@tonic-gate * the ambiguity of removal if a module is inserted/pushed
42997c478bd9Sstevel@tonic-gate * multiple times in a stream. In the first release, only
43007c478bd9Sstevel@tonic-gate * allow privileged user to use this ioctl.
4301f4b3ec61Sdh * Furthermore, the remove is only allowed
4302f4b3ec61Sdh * below an anchor if the zoneid is the same as the zoneid
4303f4b3ec61Sdh * which created the anchor.
43047c478bd9Sstevel@tonic-gate *
43057c478bd9Sstevel@tonic-gate * Note that we do not plan to support this ioctl
43067c478bd9Sstevel@tonic-gate * on pipes in the first release. We want to learn more
43077c478bd9Sstevel@tonic-gate * about the implications of these ioctls before extending
43087c478bd9Sstevel@tonic-gate * their support. And we do not think these features are
43097c478bd9Sstevel@tonic-gate * valuable for pipes.
43107c478bd9Sstevel@tonic-gate *
43117c478bd9Sstevel@tonic-gate * Also note that _I_REMOVE cannot be used to remove a
43127c478bd9Sstevel@tonic-gate * driver or the stream head.
43137c478bd9Sstevel@tonic-gate */
43147c478bd9Sstevel@tonic-gate STRUCT_DECL(strmodconf, strmodremove);
43157c478bd9Sstevel@tonic-gate queue_t *q;
43167c478bd9Sstevel@tonic-gate int pos;
43177c478bd9Sstevel@tonic-gate char mod_name[FMNAMESZ + 1];
43187c478bd9Sstevel@tonic-gate boolean_t is_remove;
43197c478bd9Sstevel@tonic-gate
43207c478bd9Sstevel@tonic-gate STRUCT_INIT(strmodremove, flag);
43217c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
43227c478bd9Sstevel@tonic-gate return (ENXIO);
43237c478bd9Sstevel@tonic-gate if (STRMATED(stp))
43247c478bd9Sstevel@tonic-gate return (EINVAL);
43257c478bd9Sstevel@tonic-gate if ((error = secpolicy_net_config(crp, B_FALSE)) != 0)
43267c478bd9Sstevel@tonic-gate return (error);
4327f4b3ec61Sdh if (stp->sd_anchor != 0 &&
4328f4b3ec61Sdh stp->sd_anchorzone != crgetzoneid(crp))
4329f4b3ec61Sdh return (EINVAL);
43307c478bd9Sstevel@tonic-gate
43317c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strmodremove),
43327c478bd9Sstevel@tonic-gate STRUCT_SIZE(strmodremove), copyflag);
43337c478bd9Sstevel@tonic-gate if (error)
43347c478bd9Sstevel@tonic-gate return (error);
43357c478bd9Sstevel@tonic-gate
43367c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr :
43377c478bd9Sstevel@tonic-gate copystr)(STRUCT_FGETP(strmodremove, mod_name),
43387c478bd9Sstevel@tonic-gate mod_name, FMNAMESZ + 1, NULL);
43397c478bd9Sstevel@tonic-gate if (error)
43407c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT);
43417c478bd9Sstevel@tonic-gate
43427c478bd9Sstevel@tonic-gate if ((error = strstartplumb(stp, flag, cmd)) != 0)
43437c478bd9Sstevel@tonic-gate return (error);
43447c478bd9Sstevel@tonic-gate
43457c478bd9Sstevel@tonic-gate /*
43467c478bd9Sstevel@tonic-gate * Match the name of given module to the name of module at
43477c478bd9Sstevel@tonic-gate * the given position.
43487c478bd9Sstevel@tonic-gate */
43497c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodremove, pos);
43507c478bd9Sstevel@tonic-gate
43517c478bd9Sstevel@tonic-gate is_remove = (pos != 0);
43527c478bd9Sstevel@tonic-gate for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0;
43537c478bd9Sstevel@tonic-gate q = q->q_next, pos--)
43547c478bd9Sstevel@tonic-gate ;
4355a45f3f93Smeem if (pos > 0 || !SAMESTR(q) ||
4356a45f3f93Smeem strcmp(Q2NAME(q), mod_name) != 0) {
43577c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
43587c478bd9Sstevel@tonic-gate strendplumb(stp);
43597c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
43607c478bd9Sstevel@tonic-gate return (EINVAL);
43617c478bd9Sstevel@tonic-gate }
43627c478bd9Sstevel@tonic-gate
4363f4b3ec61Sdh /*
4364f4b3ec61Sdh * If the position is at or below an anchor, then the zoneid
4365f4b3ec61Sdh * must match the zoneid that created the anchor.
4366f4b3ec61Sdh */
4367f4b3ec61Sdh if (stp->sd_anchor != 0) {
4368f4b3ec61Sdh pos = STRUCT_FGET(strmodremove, pos);
4369f4b3ec61Sdh if (pos >= (stp->sd_pushcnt - stp->sd_anchor) &&
4370f4b3ec61Sdh stp->sd_anchorzone != crgetzoneid(crp)) {
4371f4b3ec61Sdh mutex_enter(&stp->sd_lock);
4372f4b3ec61Sdh strendplumb(stp);
4373f4b3ec61Sdh mutex_exit(&stp->sd_lock);
4374f4b3ec61Sdh return (EPERM);
4375f4b3ec61Sdh }
4376f4b3ec61Sdh }
4377f4b3ec61Sdh
4378f4b3ec61Sdh
43797c478bd9Sstevel@tonic-gate ASSERT(!(q->q_flag & QREADR));
43807c478bd9Sstevel@tonic-gate qdetach(_RD(q), 1, flag, crp, is_remove);
43817c478bd9Sstevel@tonic-gate
43827c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
43837c478bd9Sstevel@tonic-gate
43847c478bd9Sstevel@tonic-gate /*
43857c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of
43867c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream
43877c478bd9Sstevel@tonic-gate * head in the stream head.
43887c478bd9Sstevel@tonic-gate */
43897c478bd9Sstevel@tonic-gate if (!is_remove) {
43907c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq->q_next));
43917c478bd9Sstevel@tonic-gate rmin = wrq->q_next->q_minpsz;
43927c478bd9Sstevel@tonic-gate rmax = wrq->q_next->q_maxpsz;
43937c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq->q_next));
43947c478bd9Sstevel@tonic-gate
43957c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */
43967c478bd9Sstevel@tonic-gate if (strmsgsz != 0) {
43977c478bd9Sstevel@tonic-gate if (rmax == INFPSZ)
43987c478bd9Sstevel@tonic-gate rmax = strmsgsz;
43997c478bd9Sstevel@tonic-gate else {
44007c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO)
44017c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax);
44027c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax);
44037c478bd9Sstevel@tonic-gate }
44047c478bd9Sstevel@tonic-gate }
44057c478bd9Sstevel@tonic-gate
44067c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq));
44077c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin;
44087c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax;
44097c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq));
44107c478bd9Sstevel@tonic-gate }
44117c478bd9Sstevel@tonic-gate
44127c478bd9Sstevel@tonic-gate /*
44137c478bd9Sstevel@tonic-gate * Need to update the anchor value if this module is removed
44147c478bd9Sstevel@tonic-gate * at or below the anchor point. If the removed module is at
44157c478bd9Sstevel@tonic-gate * the anchor point, remove the anchor for this stream if
44167c478bd9Sstevel@tonic-gate * there is no module above the anchor point. Otherwise, if
44177c478bd9Sstevel@tonic-gate * the removed module is below the anchor point, decrement the
44187c478bd9Sstevel@tonic-gate * anchor point by 1.
44197c478bd9Sstevel@tonic-gate */
44207c478bd9Sstevel@tonic-gate if (stp->sd_anchor != 0) {
44217c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodremove, pos);
4422f4b3ec61Sdh if (pos == stp->sd_pushcnt - stp->sd_anchor + 1)
44237c478bd9Sstevel@tonic-gate stp->sd_anchor = 0;
44247c478bd9Sstevel@tonic-gate else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1))
44257c478bd9Sstevel@tonic-gate stp->sd_anchor--;
44267c478bd9Sstevel@tonic-gate }
44277c478bd9Sstevel@tonic-gate
44287c478bd9Sstevel@tonic-gate strendplumb(stp);
44297c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
44307c478bd9Sstevel@tonic-gate return (0);
44317c478bd9Sstevel@tonic-gate }
44327c478bd9Sstevel@tonic-gate
44337c478bd9Sstevel@tonic-gate case I_ANCHOR:
44347c478bd9Sstevel@tonic-gate /*
44357c478bd9Sstevel@tonic-gate * Set the anchor position on the stream to reside at
44367c478bd9Sstevel@tonic-gate * the top module (in other words, the top module
44377c478bd9Sstevel@tonic-gate * cannot be popped). Anchors with a FIFO make no
44387c478bd9Sstevel@tonic-gate * obvious sense, so they're not allowed.
44397c478bd9Sstevel@tonic-gate */
44407c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
44417c478bd9Sstevel@tonic-gate
44427c478bd9Sstevel@tonic-gate if (stp->sd_vnode->v_type == VFIFO) {
44437c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
44447c478bd9Sstevel@tonic-gate return (EINVAL);
44457c478bd9Sstevel@tonic-gate }
4446f4b3ec61Sdh /* Only allow the same zoneid to update the anchor */
4447f4b3ec61Sdh if (stp->sd_anchor != 0 &&
4448f4b3ec61Sdh stp->sd_anchorzone != crgetzoneid(crp)) {
4449f4b3ec61Sdh mutex_exit(&stp->sd_lock);
4450f4b3ec61Sdh return (EINVAL);
4451f4b3ec61Sdh }
44527c478bd9Sstevel@tonic-gate stp->sd_anchor = stp->sd_pushcnt;
4453f4b3ec61Sdh stp->sd_anchorzone = crgetzoneid(crp);
44547c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
44557c478bd9Sstevel@tonic-gate return (0);
44567c478bd9Sstevel@tonic-gate
44577c478bd9Sstevel@tonic-gate case I_LOOK:
44587c478bd9Sstevel@tonic-gate /*
44597c478bd9Sstevel@tonic-gate * Get name of first module downstream.
44607c478bd9Sstevel@tonic-gate * If no module, return an error.
44617c478bd9Sstevel@tonic-gate */
44627c478bd9Sstevel@tonic-gate claimstr(wrq);
4463a45f3f93Smeem if (_SAMESTR(wrq) && wrq->q_next->q_next != NULL) {
4464a45f3f93Smeem char *name = Q2NAME(wrq->q_next);
4465a45f3f93Smeem
44667c478bd9Sstevel@tonic-gate error = strcopyout(name, (void *)arg, strlen(name) + 1,
44677c478bd9Sstevel@tonic-gate copyflag);
44687c478bd9Sstevel@tonic-gate releasestr(wrq);
44697c478bd9Sstevel@tonic-gate return (error);
44707c478bd9Sstevel@tonic-gate }
44717c478bd9Sstevel@tonic-gate releasestr(wrq);
44727c478bd9Sstevel@tonic-gate return (EINVAL);
44737c478bd9Sstevel@tonic-gate
44747c478bd9Sstevel@tonic-gate case I_LINK:
44757c478bd9Sstevel@tonic-gate case I_PLINK:
44767c478bd9Sstevel@tonic-gate /*
44777c478bd9Sstevel@tonic-gate * Link a multiplexor.
44787c478bd9Sstevel@tonic-gate */
4479a45f3f93Smeem return (mlink(vp, cmd, (int)arg, crp, rvalp, 0));
44807c478bd9Sstevel@tonic-gate
44817c478bd9Sstevel@tonic-gate case _I_PLINK_LH:
44827c478bd9Sstevel@tonic-gate /*
44837c478bd9Sstevel@tonic-gate * Link a multiplexor: Call must originate from kernel.
44847c478bd9Sstevel@tonic-gate */
44857c478bd9Sstevel@tonic-gate if (kioctl)
44867c478bd9Sstevel@tonic-gate return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp));
44877c478bd9Sstevel@tonic-gate
44887c478bd9Sstevel@tonic-gate return (EINVAL);
44897c478bd9Sstevel@tonic-gate case I_UNLINK:
44907c478bd9Sstevel@tonic-gate case I_PUNLINK:
44917c478bd9Sstevel@tonic-gate /*
44927c478bd9Sstevel@tonic-gate * Unlink a multiplexor.
44937c478bd9Sstevel@tonic-gate * If arg is -1, unlink all links for which this is the
44947c478bd9Sstevel@tonic-gate * controlling stream. Otherwise, arg is an index number
44957c478bd9Sstevel@tonic-gate * for a link to be removed.
44967c478bd9Sstevel@tonic-gate */
4497d3e55dcdSgww {
44987c478bd9Sstevel@tonic-gate struct linkinfo *linkp;
44997c478bd9Sstevel@tonic-gate int native_arg = (int)arg;
45007c478bd9Sstevel@tonic-gate int type;
4501f4b3ec61Sdh netstack_t *ns;
4502f4b3ec61Sdh str_stack_t *ss;
45037c478bd9Sstevel@tonic-gate
45047c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
4505d3e55dcdSgww TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp);
45067c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) {
45077c478bd9Sstevel@tonic-gate return (EINVAL);
45087c478bd9Sstevel@tonic-gate }
45097c478bd9Sstevel@tonic-gate if (cmd == I_UNLINK)
45107c478bd9Sstevel@tonic-gate type = LINKNORMAL;
45117c478bd9Sstevel@tonic-gate else /* I_PUNLINK */
45127c478bd9Sstevel@tonic-gate type = LINKPERSIST;
45137c478bd9Sstevel@tonic-gate if (native_arg == 0) {
45147c478bd9Sstevel@tonic-gate return (EINVAL);
45157c478bd9Sstevel@tonic-gate }
4516f4b3ec61Sdh ns = netstack_find_by_cred(crp);
4517f4b3ec61Sdh ASSERT(ns != NULL);
4518f4b3ec61Sdh ss = ns->netstack_str;
4519f4b3ec61Sdh ASSERT(ss != NULL);
4520f4b3ec61Sdh
45217c478bd9Sstevel@tonic-gate if (native_arg == MUXID_ALL)
4522f4b3ec61Sdh error = munlinkall(stp, type, crp, rvalp, ss);
45237c478bd9Sstevel@tonic-gate else {
45247c478bd9Sstevel@tonic-gate mutex_enter(&muxifier);
4525f4b3ec61Sdh if (!(linkp = findlinks(stp, (int)arg, type, ss))) {
45267c478bd9Sstevel@tonic-gate /* invalid user supplied index number */
45277c478bd9Sstevel@tonic-gate mutex_exit(&muxifier);
4528f4b3ec61Sdh netstack_rele(ss->ss_netstack);
45297c478bd9Sstevel@tonic-gate return (EINVAL);
45307c478bd9Sstevel@tonic-gate }
45317c478bd9Sstevel@tonic-gate /* munlink drops the muxifier lock */
4532f4b3ec61Sdh error = munlink(stp, linkp, type, crp, rvalp, ss);
45337c478bd9Sstevel@tonic-gate }
4534f4b3ec61Sdh netstack_rele(ss->ss_netstack);
45357c478bd9Sstevel@tonic-gate return (error);
4536d3e55dcdSgww }
45377c478bd9Sstevel@tonic-gate
45387c478bd9Sstevel@tonic-gate case I_FLUSH:
45397c478bd9Sstevel@tonic-gate /*
45407c478bd9Sstevel@tonic-gate * send a flush message downstream
45417c478bd9Sstevel@tonic-gate * flush message can indicate
45427c478bd9Sstevel@tonic-gate * FLUSHR - flush read queue
45437c478bd9Sstevel@tonic-gate * FLUSHW - flush write queue
45447c478bd9Sstevel@tonic-gate * FLUSHRW - flush read/write queue
45457c478bd9Sstevel@tonic-gate */
45467c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
45477c478bd9Sstevel@tonic-gate return (ENXIO);
45487c478bd9Sstevel@tonic-gate if (arg & ~FLUSHRW)
45497c478bd9Sstevel@tonic-gate return (EINVAL);
45507c478bd9Sstevel@tonic-gate
45517c478bd9Sstevel@tonic-gate for (;;) {
45527c478bd9Sstevel@tonic-gate if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) {
45537c478bd9Sstevel@tonic-gate break;
45547c478bd9Sstevel@tonic-gate }
45557c478bd9Sstevel@tonic-gate if (error = strwaitbuf(1, BPRI_HI)) {
45567c478bd9Sstevel@tonic-gate return (error);
45577c478bd9Sstevel@tonic-gate }
45587c478bd9Sstevel@tonic-gate }
45597c478bd9Sstevel@tonic-gate
45607c478bd9Sstevel@tonic-gate /*
45617c478bd9Sstevel@tonic-gate * Send down an unsupported ioctl and wait for the nack
45627c478bd9Sstevel@tonic-gate * in order to allow the M_FLUSH to propagate back
45637c478bd9Sstevel@tonic-gate * up to the stream head.
45647c478bd9Sstevel@tonic-gate * Replaces if (qready()) runqueues();
45657c478bd9Sstevel@tonic-gate */
45667c478bd9Sstevel@tonic-gate strioc.ic_cmd = -1; /* The unsupported ioctl */
45677c478bd9Sstevel@tonic-gate strioc.ic_timout = 0;
45687c478bd9Sstevel@tonic-gate strioc.ic_len = 0;
45697c478bd9Sstevel@tonic-gate strioc.ic_dp = NULL;
45707c478bd9Sstevel@tonic-gate (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
45717c478bd9Sstevel@tonic-gate *rvalp = 0;
45727c478bd9Sstevel@tonic-gate return (0);
45737c478bd9Sstevel@tonic-gate
45747c478bd9Sstevel@tonic-gate case I_FLUSHBAND:
4575d3e55dcdSgww {
45767c478bd9Sstevel@tonic-gate struct bandinfo binfo;
45777c478bd9Sstevel@tonic-gate
45787c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &binfo, sizeof (binfo),
45797c478bd9Sstevel@tonic-gate copyflag);
45807c478bd9Sstevel@tonic-gate if (error)
45817c478bd9Sstevel@tonic-gate return (error);
45827c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
45837c478bd9Sstevel@tonic-gate return (ENXIO);
45847c478bd9Sstevel@tonic-gate if (binfo.bi_flag & ~FLUSHRW)
45857c478bd9Sstevel@tonic-gate return (EINVAL);
45867c478bd9Sstevel@tonic-gate while (!(mp = allocb(2, BPRI_HI))) {
45877c478bd9Sstevel@tonic-gate if (error = strwaitbuf(2, BPRI_HI))
45887c478bd9Sstevel@tonic-gate return (error);
45897c478bd9Sstevel@tonic-gate }
45907c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_FLUSH;
45917c478bd9Sstevel@tonic-gate *mp->b_wptr++ = binfo.bi_flag | FLUSHBAND;
45927c478bd9Sstevel@tonic-gate *mp->b_wptr++ = binfo.bi_pri;
45937c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, mp);
45947c478bd9Sstevel@tonic-gate /*
45957c478bd9Sstevel@tonic-gate * Send down an unsupported ioctl and wait for the nack
45967c478bd9Sstevel@tonic-gate * in order to allow the M_FLUSH to propagate back
45977c478bd9Sstevel@tonic-gate * up to the stream head.
45987c478bd9Sstevel@tonic-gate * Replaces if (qready()) runqueues();
45997c478bd9Sstevel@tonic-gate */
46007c478bd9Sstevel@tonic-gate strioc.ic_cmd = -1; /* The unsupported ioctl */
46017c478bd9Sstevel@tonic-gate strioc.ic_timout = 0;
46027c478bd9Sstevel@tonic-gate strioc.ic_len = 0;
46037c478bd9Sstevel@tonic-gate strioc.ic_dp = NULL;
46047c478bd9Sstevel@tonic-gate (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp);
46057c478bd9Sstevel@tonic-gate *rvalp = 0;
46067c478bd9Sstevel@tonic-gate return (0);
4607d3e55dcdSgww }
46087c478bd9Sstevel@tonic-gate
46097c478bd9Sstevel@tonic-gate case I_SRDOPT:
46107c478bd9Sstevel@tonic-gate /*
46117c478bd9Sstevel@tonic-gate * Set read options
46127c478bd9Sstevel@tonic-gate *
46137c478bd9Sstevel@tonic-gate * RNORM - default stream mode
46147c478bd9Sstevel@tonic-gate * RMSGN - message no discard
46157c478bd9Sstevel@tonic-gate * RMSGD - message discard
46167c478bd9Sstevel@tonic-gate * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs
46177c478bd9Sstevel@tonic-gate * RPROTDAT - convert M_[PC]PROTOs to M_DATAs
46187c478bd9Sstevel@tonic-gate * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs
46197c478bd9Sstevel@tonic-gate */
46207c478bd9Sstevel@tonic-gate if (arg & ~(RMODEMASK | RPROTMASK))
46217c478bd9Sstevel@tonic-gate return (EINVAL);
46227c478bd9Sstevel@tonic-gate
46237c478bd9Sstevel@tonic-gate if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN))
46247c478bd9Sstevel@tonic-gate return (EINVAL);
46257c478bd9Sstevel@tonic-gate
46267c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
46277c478bd9Sstevel@tonic-gate switch (arg & RMODEMASK) {
46287c478bd9Sstevel@tonic-gate case RNORM:
46297c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS);
46307c478bd9Sstevel@tonic-gate break;
46317c478bd9Sstevel@tonic-gate case RMSGD:
46327c478bd9Sstevel@tonic-gate stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) |
46337c478bd9Sstevel@tonic-gate RD_MSGDIS;
46347c478bd9Sstevel@tonic-gate break;
46357c478bd9Sstevel@tonic-gate case RMSGN:
46367c478bd9Sstevel@tonic-gate stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) |
46377c478bd9Sstevel@tonic-gate RD_MSGNODIS;
46387c478bd9Sstevel@tonic-gate break;
46397c478bd9Sstevel@tonic-gate }
46407c478bd9Sstevel@tonic-gate
46417c478bd9Sstevel@tonic-gate switch (arg & RPROTMASK) {
46427c478bd9Sstevel@tonic-gate case RPROTNORM:
46437c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS);
46447c478bd9Sstevel@tonic-gate break;
46457c478bd9Sstevel@tonic-gate
46467c478bd9Sstevel@tonic-gate case RPROTDAT:
46477c478bd9Sstevel@tonic-gate stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) |
46487c478bd9Sstevel@tonic-gate RD_PROTDAT);
46497c478bd9Sstevel@tonic-gate break;
46507c478bd9Sstevel@tonic-gate
46517c478bd9Sstevel@tonic-gate case RPROTDIS:
46527c478bd9Sstevel@tonic-gate stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) |
46537c478bd9Sstevel@tonic-gate RD_PROTDIS);
46547c478bd9Sstevel@tonic-gate break;
46557c478bd9Sstevel@tonic-gate }
46567c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
46577c478bd9Sstevel@tonic-gate return (0);
46587c478bd9Sstevel@tonic-gate
46597c478bd9Sstevel@tonic-gate case I_GRDOPT:
46607c478bd9Sstevel@tonic-gate /*
46617c478bd9Sstevel@tonic-gate * Get read option and return the value
46627c478bd9Sstevel@tonic-gate * to spot pointed to by arg
46637c478bd9Sstevel@tonic-gate */
4664d3e55dcdSgww {
46657c478bd9Sstevel@tonic-gate int rdopt;
46667c478bd9Sstevel@tonic-gate
46677c478bd9Sstevel@tonic-gate rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD :
46687c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM));
46697c478bd9Sstevel@tonic-gate rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT :
46707c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM));
46717c478bd9Sstevel@tonic-gate
46727c478bd9Sstevel@tonic-gate return (strcopyout(&rdopt, (void *)arg, sizeof (int),
46737c478bd9Sstevel@tonic-gate copyflag));
4674d3e55dcdSgww }
46757c478bd9Sstevel@tonic-gate
46767c478bd9Sstevel@tonic-gate case I_SERROPT:
46777c478bd9Sstevel@tonic-gate /*
46787c478bd9Sstevel@tonic-gate * Set error options
46797c478bd9Sstevel@tonic-gate *
46807c478bd9Sstevel@tonic-gate * RERRNORM - persistent read errors
46817c478bd9Sstevel@tonic-gate * RERRNONPERSIST - non-persistent read errors
46827c478bd9Sstevel@tonic-gate * WERRNORM - persistent write errors
46837c478bd9Sstevel@tonic-gate * WERRNONPERSIST - non-persistent write errors
46847c478bd9Sstevel@tonic-gate */
46857c478bd9Sstevel@tonic-gate if (arg & ~(RERRMASK | WERRMASK))
46867c478bd9Sstevel@tonic-gate return (EINVAL);
46877c478bd9Sstevel@tonic-gate
46887c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
46897c478bd9Sstevel@tonic-gate switch (arg & RERRMASK) {
46907c478bd9Sstevel@tonic-gate case RERRNORM:
46917c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERRNONPERSIST;
46927c478bd9Sstevel@tonic-gate break;
46937c478bd9Sstevel@tonic-gate case RERRNONPERSIST:
46947c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERRNONPERSIST;
46957c478bd9Sstevel@tonic-gate break;
46967c478bd9Sstevel@tonic-gate }
46977c478bd9Sstevel@tonic-gate switch (arg & WERRMASK) {
46987c478bd9Sstevel@tonic-gate case WERRNORM:
46997c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERRNONPERSIST;
47007c478bd9Sstevel@tonic-gate break;
47017c478bd9Sstevel@tonic-gate case WERRNONPERSIST:
47027c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERRNONPERSIST;
47037c478bd9Sstevel@tonic-gate break;
47047c478bd9Sstevel@tonic-gate }
47057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
47067c478bd9Sstevel@tonic-gate return (0);
47077c478bd9Sstevel@tonic-gate
47087c478bd9Sstevel@tonic-gate case I_GERROPT:
47097c478bd9Sstevel@tonic-gate /*
47107c478bd9Sstevel@tonic-gate * Get error option and return the value
47117c478bd9Sstevel@tonic-gate * to spot pointed to by arg
47127c478bd9Sstevel@tonic-gate */
4713d3e55dcdSgww {
47147c478bd9Sstevel@tonic-gate int erropt = 0;
47157c478bd9Sstevel@tonic-gate
47167c478bd9Sstevel@tonic-gate erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST :
4717d3e55dcdSgww RERRNORM;
47187c478bd9Sstevel@tonic-gate erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST :
4719d3e55dcdSgww WERRNORM;
47207c478bd9Sstevel@tonic-gate return (strcopyout(&erropt, (void *)arg, sizeof (int),
47217c478bd9Sstevel@tonic-gate copyflag));
4722d3e55dcdSgww }
47237c478bd9Sstevel@tonic-gate
47247c478bd9Sstevel@tonic-gate case I_SETSIG:
47257c478bd9Sstevel@tonic-gate /*
47267c478bd9Sstevel@tonic-gate * Register the calling proc to receive the SIGPOLL
47277c478bd9Sstevel@tonic-gate * signal based on the events given in arg. If
47287c478bd9Sstevel@tonic-gate * arg is zero, remove the proc from register list.
47297c478bd9Sstevel@tonic-gate */
4730d3e55dcdSgww {
47317c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp;
47327c478bd9Sstevel@tonic-gate struct pid *pidp;
47337c478bd9Sstevel@tonic-gate
47347c478bd9Sstevel@tonic-gate pssp = NULL;
47357c478bd9Sstevel@tonic-gate pidp = curproc->p_pidp;
47367c478bd9Sstevel@tonic-gate /*
47377c478bd9Sstevel@tonic-gate * Hold sd_lock to prevent traversal of sd_siglist while
47387c478bd9Sstevel@tonic-gate * it is modified.
47397c478bd9Sstevel@tonic-gate */
47407c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
47417c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp);
4742d3e55dcdSgww pssp = ssp, ssp = ssp->ss_next)
47437c478bd9Sstevel@tonic-gate ;
47447c478bd9Sstevel@tonic-gate
47457c478bd9Sstevel@tonic-gate if (arg) {
47467c478bd9Sstevel@tonic-gate if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
47477c478bd9Sstevel@tonic-gate S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
47487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
47497c478bd9Sstevel@tonic-gate return (EINVAL);
47507c478bd9Sstevel@tonic-gate }
47517c478bd9Sstevel@tonic-gate if ((arg & S_BANDURG) && !(arg & S_RDBAND)) {
47527c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
47537c478bd9Sstevel@tonic-gate return (EINVAL);
47547c478bd9Sstevel@tonic-gate }
47557c478bd9Sstevel@tonic-gate
47567c478bd9Sstevel@tonic-gate /*
47577c478bd9Sstevel@tonic-gate * If proc not already registered, add it
47587c478bd9Sstevel@tonic-gate * to list.
47597c478bd9Sstevel@tonic-gate */
47607c478bd9Sstevel@tonic-gate if (!ssp) {
47617c478bd9Sstevel@tonic-gate ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
47627c478bd9Sstevel@tonic-gate ssp->ss_pidp = pidp;
47637c478bd9Sstevel@tonic-gate ssp->ss_pid = pidp->pid_id;
47647c478bd9Sstevel@tonic-gate ssp->ss_next = NULL;
47657c478bd9Sstevel@tonic-gate if (pssp)
47667c478bd9Sstevel@tonic-gate pssp->ss_next = ssp;
47677c478bd9Sstevel@tonic-gate else
47687c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp;
47697c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
47707c478bd9Sstevel@tonic-gate PID_HOLD(pidp);
47717c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
47727c478bd9Sstevel@tonic-gate }
47737c478bd9Sstevel@tonic-gate
47747c478bd9Sstevel@tonic-gate /*
47757c478bd9Sstevel@tonic-gate * Set events.
47767c478bd9Sstevel@tonic-gate */
47777c478bd9Sstevel@tonic-gate ssp->ss_events = (int)arg;
47787c478bd9Sstevel@tonic-gate } else {
47797c478bd9Sstevel@tonic-gate /*
47807c478bd9Sstevel@tonic-gate * Remove proc from register list.
47817c478bd9Sstevel@tonic-gate */
47827c478bd9Sstevel@tonic-gate if (ssp) {
47837c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
47847c478bd9Sstevel@tonic-gate PID_RELE(pidp);
47857c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
47867c478bd9Sstevel@tonic-gate if (pssp)
47877c478bd9Sstevel@tonic-gate pssp->ss_next = ssp->ss_next;
47887c478bd9Sstevel@tonic-gate else
47897c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp->ss_next;
47907c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t));
47917c478bd9Sstevel@tonic-gate } else {
47927c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
47937c478bd9Sstevel@tonic-gate return (EINVAL);
47947c478bd9Sstevel@tonic-gate }
47957c478bd9Sstevel@tonic-gate }
47967c478bd9Sstevel@tonic-gate
47977c478bd9Sstevel@tonic-gate /*
47987c478bd9Sstevel@tonic-gate * Recalculate OR of sig events.
47997c478bd9Sstevel@tonic-gate */
48007c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
48017c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
48027c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events;
48037c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
48047c478bd9Sstevel@tonic-gate return (0);
4805d3e55dcdSgww }
48067c478bd9Sstevel@tonic-gate
48077c478bd9Sstevel@tonic-gate case I_GETSIG:
48087c478bd9Sstevel@tonic-gate /*
48097c478bd9Sstevel@tonic-gate * Return (in arg) the current registration of events
48107c478bd9Sstevel@tonic-gate * for which the calling proc is to be signaled.
48117c478bd9Sstevel@tonic-gate */
4812d3e55dcdSgww {
48137c478bd9Sstevel@tonic-gate struct strsig *ssp;
48147c478bd9Sstevel@tonic-gate struct pid *pidp;
48157c478bd9Sstevel@tonic-gate
48167c478bd9Sstevel@tonic-gate pidp = curproc->p_pidp;
48177c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
48187c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
48197c478bd9Sstevel@tonic-gate if (ssp->ss_pidp == pidp) {
48207c478bd9Sstevel@tonic-gate error = strcopyout(&ssp->ss_events, (void *)arg,
48217c478bd9Sstevel@tonic-gate sizeof (int), copyflag);
48227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
48237c478bd9Sstevel@tonic-gate return (error);
48247c478bd9Sstevel@tonic-gate }
48257c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
48267c478bd9Sstevel@tonic-gate return (EINVAL);
4827d3e55dcdSgww }
48287c478bd9Sstevel@tonic-gate
48297c478bd9Sstevel@tonic-gate case I_ESETSIG:
48307c478bd9Sstevel@tonic-gate /*
48317c478bd9Sstevel@tonic-gate * Register the ss_pid to receive the SIGPOLL
48327c478bd9Sstevel@tonic-gate * signal based on the events is ss_events arg. If
48337c478bd9Sstevel@tonic-gate * ss_events is zero, remove the proc from register list.
48347c478bd9Sstevel@tonic-gate */
48357c478bd9Sstevel@tonic-gate {
48367c478bd9Sstevel@tonic-gate struct strsig *ssp, *pssp;
48377c478bd9Sstevel@tonic-gate struct proc *proc;
48387c478bd9Sstevel@tonic-gate struct pid *pidp;
48397c478bd9Sstevel@tonic-gate pid_t pid;
48407c478bd9Sstevel@tonic-gate struct strsigset ss;
48417c478bd9Sstevel@tonic-gate
48427c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
48437c478bd9Sstevel@tonic-gate if (error)
48447c478bd9Sstevel@tonic-gate return (error);
48457c478bd9Sstevel@tonic-gate
48467c478bd9Sstevel@tonic-gate pid = ss.ss_pid;
48477c478bd9Sstevel@tonic-gate
48487c478bd9Sstevel@tonic-gate if (ss.ss_events != 0) {
48497c478bd9Sstevel@tonic-gate /*
48507c478bd9Sstevel@tonic-gate * Permissions check by sending signal 0.
48517c478bd9Sstevel@tonic-gate * Note that when kill fails it does a set_errno
48527c478bd9Sstevel@tonic-gate * causing the system call to fail.
48537c478bd9Sstevel@tonic-gate */
48547c478bd9Sstevel@tonic-gate error = kill(pid, 0);
48557c478bd9Sstevel@tonic-gate if (error) {
48567c478bd9Sstevel@tonic-gate return (error);
48577c478bd9Sstevel@tonic-gate }
48587c478bd9Sstevel@tonic-gate }
48597c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
48607c478bd9Sstevel@tonic-gate if (pid == 0)
48617c478bd9Sstevel@tonic-gate proc = curproc;
48627c478bd9Sstevel@tonic-gate else if (pid < 0)
48637c478bd9Sstevel@tonic-gate proc = pgfind(-pid);
48647c478bd9Sstevel@tonic-gate else
48657c478bd9Sstevel@tonic-gate proc = prfind(pid);
48667c478bd9Sstevel@tonic-gate if (proc == NULL) {
48677c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
48687c478bd9Sstevel@tonic-gate return (ESRCH);
48697c478bd9Sstevel@tonic-gate }
48707c478bd9Sstevel@tonic-gate if (pid < 0)
48717c478bd9Sstevel@tonic-gate pidp = proc->p_pgidp;
48727c478bd9Sstevel@tonic-gate else
48737c478bd9Sstevel@tonic-gate pidp = proc->p_pidp;
48747c478bd9Sstevel@tonic-gate ASSERT(pidp);
48757c478bd9Sstevel@tonic-gate /*
48767c478bd9Sstevel@tonic-gate * Get a hold on the pid structure while referencing it.
48777c478bd9Sstevel@tonic-gate * There is a separate PID_HOLD should it be inserted
48787c478bd9Sstevel@tonic-gate * in the list below.
48797c478bd9Sstevel@tonic-gate */
48807c478bd9Sstevel@tonic-gate PID_HOLD(pidp);
48817c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
48827c478bd9Sstevel@tonic-gate
48837c478bd9Sstevel@tonic-gate pssp = NULL;
48847c478bd9Sstevel@tonic-gate /*
48857c478bd9Sstevel@tonic-gate * Hold sd_lock to prevent traversal of sd_siglist while
48867c478bd9Sstevel@tonic-gate * it is modified.
48877c478bd9Sstevel@tonic-gate */
48887c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
48897c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid);
4890d3e55dcdSgww pssp = ssp, ssp = ssp->ss_next)
48917c478bd9Sstevel@tonic-gate ;
48927c478bd9Sstevel@tonic-gate
48937c478bd9Sstevel@tonic-gate if (ss.ss_events) {
48947c478bd9Sstevel@tonic-gate if (ss.ss_events &
48957c478bd9Sstevel@tonic-gate ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR|
48967c478bd9Sstevel@tonic-gate S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) {
48977c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
48987c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
48997c478bd9Sstevel@tonic-gate PID_RELE(pidp);
49007c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49017c478bd9Sstevel@tonic-gate return (EINVAL);
49027c478bd9Sstevel@tonic-gate }
49037c478bd9Sstevel@tonic-gate if ((ss.ss_events & S_BANDURG) &&
49047c478bd9Sstevel@tonic-gate !(ss.ss_events & S_RDBAND)) {
49057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
49067c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49077c478bd9Sstevel@tonic-gate PID_RELE(pidp);
49087c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49097c478bd9Sstevel@tonic-gate return (EINVAL);
49107c478bd9Sstevel@tonic-gate }
49117c478bd9Sstevel@tonic-gate
49127c478bd9Sstevel@tonic-gate /*
49137c478bd9Sstevel@tonic-gate * If proc not already registered, add it
49147c478bd9Sstevel@tonic-gate * to list.
49157c478bd9Sstevel@tonic-gate */
49167c478bd9Sstevel@tonic-gate if (!ssp) {
49177c478bd9Sstevel@tonic-gate ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP);
49187c478bd9Sstevel@tonic-gate ssp->ss_pidp = pidp;
49197c478bd9Sstevel@tonic-gate ssp->ss_pid = pid;
49207c478bd9Sstevel@tonic-gate ssp->ss_next = NULL;
49217c478bd9Sstevel@tonic-gate if (pssp)
49227c478bd9Sstevel@tonic-gate pssp->ss_next = ssp;
49237c478bd9Sstevel@tonic-gate else
49247c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp;
49257c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49267c478bd9Sstevel@tonic-gate PID_HOLD(pidp);
49277c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49287c478bd9Sstevel@tonic-gate }
49297c478bd9Sstevel@tonic-gate
49307c478bd9Sstevel@tonic-gate /*
49317c478bd9Sstevel@tonic-gate * Set events.
49327c478bd9Sstevel@tonic-gate */
49337c478bd9Sstevel@tonic-gate ssp->ss_events = ss.ss_events;
49347c478bd9Sstevel@tonic-gate } else {
49357c478bd9Sstevel@tonic-gate /*
49367c478bd9Sstevel@tonic-gate * Remove proc from register list.
49377c478bd9Sstevel@tonic-gate */
49387c478bd9Sstevel@tonic-gate if (ssp) {
49397c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49407c478bd9Sstevel@tonic-gate PID_RELE(pidp);
49417c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49427c478bd9Sstevel@tonic-gate if (pssp)
49437c478bd9Sstevel@tonic-gate pssp->ss_next = ssp->ss_next;
49447c478bd9Sstevel@tonic-gate else
49457c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp->ss_next;
49467c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t));
49477c478bd9Sstevel@tonic-gate } else {
49487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
49497c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49507c478bd9Sstevel@tonic-gate PID_RELE(pidp);
49517c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49527c478bd9Sstevel@tonic-gate return (EINVAL);
49537c478bd9Sstevel@tonic-gate }
49547c478bd9Sstevel@tonic-gate }
49557c478bd9Sstevel@tonic-gate
49567c478bd9Sstevel@tonic-gate /*
49577c478bd9Sstevel@tonic-gate * Recalculate OR of sig events.
49587c478bd9Sstevel@tonic-gate */
49597c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
49607c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
49617c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events;
49627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
49637c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49647c478bd9Sstevel@tonic-gate PID_RELE(pidp);
49657c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49667c478bd9Sstevel@tonic-gate return (0);
4967d3e55dcdSgww }
49687c478bd9Sstevel@tonic-gate
49697c478bd9Sstevel@tonic-gate case I_EGETSIG:
49707c478bd9Sstevel@tonic-gate /*
49717c478bd9Sstevel@tonic-gate * Return (in arg) the current registration of events
49727c478bd9Sstevel@tonic-gate * for which the calling proc is to be signaled.
49737c478bd9Sstevel@tonic-gate */
4974d3e55dcdSgww {
49757c478bd9Sstevel@tonic-gate struct strsig *ssp;
49767c478bd9Sstevel@tonic-gate struct proc *proc;
49777c478bd9Sstevel@tonic-gate pid_t pid;
49787c478bd9Sstevel@tonic-gate struct pid *pidp;
49797c478bd9Sstevel@tonic-gate struct strsigset ss;
49807c478bd9Sstevel@tonic-gate
49817c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag);
49827c478bd9Sstevel@tonic-gate if (error)
49837c478bd9Sstevel@tonic-gate return (error);
49847c478bd9Sstevel@tonic-gate
49857c478bd9Sstevel@tonic-gate pid = ss.ss_pid;
49867c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
49877c478bd9Sstevel@tonic-gate if (pid == 0)
49887c478bd9Sstevel@tonic-gate proc = curproc;
49897c478bd9Sstevel@tonic-gate else if (pid < 0)
49907c478bd9Sstevel@tonic-gate proc = pgfind(-pid);
49917c478bd9Sstevel@tonic-gate else
49927c478bd9Sstevel@tonic-gate proc = prfind(pid);
49937c478bd9Sstevel@tonic-gate if (proc == NULL) {
49947c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
49957c478bd9Sstevel@tonic-gate return (ESRCH);
49967c478bd9Sstevel@tonic-gate }
49977c478bd9Sstevel@tonic-gate if (pid < 0)
49987c478bd9Sstevel@tonic-gate pidp = proc->p_pgidp;
49997c478bd9Sstevel@tonic-gate else
50007c478bd9Sstevel@tonic-gate pidp = proc->p_pidp;
50017c478bd9Sstevel@tonic-gate
50027c478bd9Sstevel@tonic-gate /* Prevent the pidp from being reassigned */
50037c478bd9Sstevel@tonic-gate PID_HOLD(pidp);
50047c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
50057c478bd9Sstevel@tonic-gate
50067c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
50077c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
50087c478bd9Sstevel@tonic-gate if (ssp->ss_pid == pid) {
50097c478bd9Sstevel@tonic-gate ss.ss_pid = ssp->ss_pid;
50107c478bd9Sstevel@tonic-gate ss.ss_events = ssp->ss_events;
50117c478bd9Sstevel@tonic-gate error = strcopyout(&ss, (void *)arg,
50127c478bd9Sstevel@tonic-gate sizeof (struct strsigset), copyflag);
50137c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
50147c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
50157c478bd9Sstevel@tonic-gate PID_RELE(pidp);
50167c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
50177c478bd9Sstevel@tonic-gate return (error);
50187c478bd9Sstevel@tonic-gate }
50197c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
50207c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
50217c478bd9Sstevel@tonic-gate PID_RELE(pidp);
50227c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
50237c478bd9Sstevel@tonic-gate return (EINVAL);
5024d3e55dcdSgww }
50257c478bd9Sstevel@tonic-gate
50267c478bd9Sstevel@tonic-gate case I_PEEK:
5027d3e55dcdSgww {
50287c478bd9Sstevel@tonic-gate STRUCT_DECL(strpeek, strpeek);
50297c478bd9Sstevel@tonic-gate size_t n;
50307c478bd9Sstevel@tonic-gate mblk_t *fmp, *tmp_mp = NULL;
50317c478bd9Sstevel@tonic-gate
50327c478bd9Sstevel@tonic-gate STRUCT_INIT(strpeek, flag);
50337c478bd9Sstevel@tonic-gate
50347c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strpeek),
50357c478bd9Sstevel@tonic-gate STRUCT_SIZE(strpeek), copyflag);
50367c478bd9Sstevel@tonic-gate if (error)
50377c478bd9Sstevel@tonic-gate return (error);
50387c478bd9Sstevel@tonic-gate
50397c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq));
50407c478bd9Sstevel@tonic-gate /*
50417c478bd9Sstevel@tonic-gate * Skip the invalid messages
50427c478bd9Sstevel@tonic-gate */
50437c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next)
50447c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type != M_SIG)
50457c478bd9Sstevel@tonic-gate break;
50467c478bd9Sstevel@tonic-gate
50477c478bd9Sstevel@tonic-gate /*
50487c478bd9Sstevel@tonic-gate * If user has requested to peek at a high priority message
50497c478bd9Sstevel@tonic-gate * and first message is not, return 0
50507c478bd9Sstevel@tonic-gate */
50517c478bd9Sstevel@tonic-gate if (mp != NULL) {
50527c478bd9Sstevel@tonic-gate if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) &&
50537c478bd9Sstevel@tonic-gate queclass(mp) == QNORM) {
50547c478bd9Sstevel@tonic-gate *rvalp = 0;
50557c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
50567c478bd9Sstevel@tonic-gate return (0);
50577c478bd9Sstevel@tonic-gate }
50587c478bd9Sstevel@tonic-gate } else if (stp->sd_struiordq == NULL ||
50597c478bd9Sstevel@tonic-gate (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) {
50607c478bd9Sstevel@tonic-gate /*
50617c478bd9Sstevel@tonic-gate * No mblks to look at at the streamhead and
50627c478bd9Sstevel@tonic-gate * 1). This isn't a synch stream or
50637c478bd9Sstevel@tonic-gate * 2). This is a synch stream but caller wants high
50647c478bd9Sstevel@tonic-gate * priority messages which is not supported by
50657c478bd9Sstevel@tonic-gate * the synch stream. (it only supports QNORM)
50667c478bd9Sstevel@tonic-gate */
50677c478bd9Sstevel@tonic-gate *rvalp = 0;
50687c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
50697c478bd9Sstevel@tonic-gate return (0);
50707c478bd9Sstevel@tonic-gate }
50717c478bd9Sstevel@tonic-gate
50727c478bd9Sstevel@tonic-gate fmp = mp;
50737c478bd9Sstevel@tonic-gate
50747c478bd9Sstevel@tonic-gate if (mp && mp->b_datap->db_type == M_PASSFP) {
50757c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
50767c478bd9Sstevel@tonic-gate return (EBADMSG);
50777c478bd9Sstevel@tonic-gate }
50787c478bd9Sstevel@tonic-gate
50797c478bd9Sstevel@tonic-gate ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO ||
50807c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PROTO ||
50817c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_DATA);
50827c478bd9Sstevel@tonic-gate
50837c478bd9Sstevel@tonic-gate if (mp && mp->b_datap->db_type == M_PCPROTO) {
50847c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, flags, RS_HIPRI);
50857c478bd9Sstevel@tonic-gate } else {
50867c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, flags, 0);
50877c478bd9Sstevel@tonic-gate }
50887c478bd9Sstevel@tonic-gate
50897c478bd9Sstevel@tonic-gate
50907c478bd9Sstevel@tonic-gate if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) {
50917c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
50927c478bd9Sstevel@tonic-gate return (ENOSR);
50937c478bd9Sstevel@tonic-gate }
50947c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq));
50957c478bd9Sstevel@tonic-gate
50967c478bd9Sstevel@tonic-gate /*
50977c478bd9Sstevel@tonic-gate * set mp = tmp_mp, so that I_PEEK processing can continue.
50987c478bd9Sstevel@tonic-gate * tmp_mp is used to free the dup'd message.
50997c478bd9Sstevel@tonic-gate */
51007c478bd9Sstevel@tonic-gate mp = tmp_mp;
51017c478bd9Sstevel@tonic-gate
51027c478bd9Sstevel@tonic-gate uio.uio_fmode = 0;
51037c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED;
51047c478bd9Sstevel@tonic-gate uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
51057c478bd9Sstevel@tonic-gate UIO_SYSSPACE;
51067c478bd9Sstevel@tonic-gate uio.uio_limit = 0;
51077c478bd9Sstevel@tonic-gate /*
51087c478bd9Sstevel@tonic-gate * First process PROTO blocks, if any.
51097c478bd9Sstevel@tonic-gate * If user doesn't want to get ctl info by setting maxlen <= 0,
51107c478bd9Sstevel@tonic-gate * then set len to -1/0 and skip control blocks part.
51117c478bd9Sstevel@tonic-gate */
51127c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0)
51137c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, -1);
51147c478bd9Sstevel@tonic-gate else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0)
51157c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, 0);
51167c478bd9Sstevel@tonic-gate else {
51177c478bd9Sstevel@tonic-gate int ctl_part = 0;
51187c478bd9Sstevel@tonic-gate
51197c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf);
51207c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen);
51217c478bd9Sstevel@tonic-gate uio.uio_iov = &iov;
51227c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len;
51237c478bd9Sstevel@tonic-gate uio.uio_loffset = 0;
51247c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1;
51257c478bd9Sstevel@tonic-gate while (mp && mp->b_datap->db_type != M_DATA &&
51267c478bd9Sstevel@tonic-gate uio.uio_resid >= 0) {
51277c478bd9Sstevel@tonic-gate ASSERT(STRUCT_FGET(strpeek, flags) == 0 ?
51287c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PROTO :
51297c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PCPROTO);
51307c478bd9Sstevel@tonic-gate
51317c478bd9Sstevel@tonic-gate if ((n = MIN(uio.uio_resid,
51327c478bd9Sstevel@tonic-gate mp->b_wptr - mp->b_rptr)) != 0 &&
51337c478bd9Sstevel@tonic-gate (error = uiomove((char *)mp->b_rptr, n,
51347c478bd9Sstevel@tonic-gate UIO_READ, &uio)) != 0) {
51357c478bd9Sstevel@tonic-gate freemsg(tmp_mp);
51367c478bd9Sstevel@tonic-gate return (error);
51377c478bd9Sstevel@tonic-gate }
51387c478bd9Sstevel@tonic-gate ctl_part = 1;
51397c478bd9Sstevel@tonic-gate mp = mp->b_cont;
51407c478bd9Sstevel@tonic-gate }
51417c478bd9Sstevel@tonic-gate /* No ctl message */
51427c478bd9Sstevel@tonic-gate if (ctl_part == 0)
51437c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, -1);
51447c478bd9Sstevel@tonic-gate else
51457c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len,
51467c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, ctlbuf.maxlen) -
51477c478bd9Sstevel@tonic-gate uio.uio_resid);
51487c478bd9Sstevel@tonic-gate }
51497c478bd9Sstevel@tonic-gate
51507c478bd9Sstevel@tonic-gate /*
51517c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any.
51527c478bd9Sstevel@tonic-gate * If user doesn't want to get data info by setting maxlen <= 0,
51537c478bd9Sstevel@tonic-gate * then set len to -1/0 and skip data blocks part.
51547c478bd9Sstevel@tonic-gate */
51557c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, databuf.maxlen) < 0)
51567c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1);
51577c478bd9Sstevel@tonic-gate else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0)
51587c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, 0);
51597c478bd9Sstevel@tonic-gate else {
51607c478bd9Sstevel@tonic-gate int data_part = 0;
51617c478bd9Sstevel@tonic-gate
51627c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf);
51637c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen);
51647c478bd9Sstevel@tonic-gate uio.uio_iov = &iov;
51657c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len;
51667c478bd9Sstevel@tonic-gate uio.uio_loffset = 0;
51677c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1;
51687c478bd9Sstevel@tonic-gate while (mp && uio.uio_resid) {
51697c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_DATA) {
51707c478bd9Sstevel@tonic-gate if ((n = MIN(uio.uio_resid,
51717c478bd9Sstevel@tonic-gate mp->b_wptr - mp->b_rptr)) != 0 &&
51727c478bd9Sstevel@tonic-gate (error = uiomove((char *)mp->b_rptr,
5173d3e55dcdSgww n, UIO_READ, &uio)) != 0) {
51747c478bd9Sstevel@tonic-gate freemsg(tmp_mp);
51757c478bd9Sstevel@tonic-gate return (error);
51767c478bd9Sstevel@tonic-gate }
51777c478bd9Sstevel@tonic-gate data_part = 1;
51787c478bd9Sstevel@tonic-gate }
51797c478bd9Sstevel@tonic-gate ASSERT(data_part == 0 ||
51807c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_DATA);
51817c478bd9Sstevel@tonic-gate mp = mp->b_cont;
51827c478bd9Sstevel@tonic-gate }
51837c478bd9Sstevel@tonic-gate /* No data message */
51847c478bd9Sstevel@tonic-gate if (data_part == 0)
51857c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1);
51867c478bd9Sstevel@tonic-gate else
51877c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len,
51887c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, databuf.maxlen) -
51897c478bd9Sstevel@tonic-gate uio.uio_resid);
51907c478bd9Sstevel@tonic-gate }
51917c478bd9Sstevel@tonic-gate freemsg(tmp_mp);
51927c478bd9Sstevel@tonic-gate
51937c478bd9Sstevel@tonic-gate /*
51947c478bd9Sstevel@tonic-gate * It is a synch stream and user wants to get
51957c478bd9Sstevel@tonic-gate * data (maxlen > 0).
51967c478bd9Sstevel@tonic-gate * uio setup is done by the codes that process DATA
51977c478bd9Sstevel@tonic-gate * blocks above.
51987c478bd9Sstevel@tonic-gate */
51997c478bd9Sstevel@tonic-gate if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) {
52007c478bd9Sstevel@tonic-gate infod_t infod;
52017c478bd9Sstevel@tonic-gate
52027c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_COPYOUT;
52037c478bd9Sstevel@tonic-gate infod.d_res = 0;
52047c478bd9Sstevel@tonic-gate infod.d_uiop = &uio;
52057c478bd9Sstevel@tonic-gate error = infonext(rdq, &infod);
52067c478bd9Sstevel@tonic-gate if (error == EINVAL || error == EBUSY)
52077c478bd9Sstevel@tonic-gate error = 0;
52087c478bd9Sstevel@tonic-gate if (error)
52097c478bd9Sstevel@tonic-gate return (error);
52107c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek,
52117c478bd9Sstevel@tonic-gate databuf.maxlen) - uio.uio_resid);
52127c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, databuf.len) == 0) {
52137c478bd9Sstevel@tonic-gate /*
52147c478bd9Sstevel@tonic-gate * No data found by the infonext().
52157c478bd9Sstevel@tonic-gate */
52167c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1);
52177c478bd9Sstevel@tonic-gate }
52187c478bd9Sstevel@tonic-gate }
52197c478bd9Sstevel@tonic-gate error = strcopyout(STRUCT_BUF(strpeek), (void *)arg,
52207c478bd9Sstevel@tonic-gate STRUCT_SIZE(strpeek), copyflag);
52217c478bd9Sstevel@tonic-gate if (error) {
52227c478bd9Sstevel@tonic-gate return (error);
52237c478bd9Sstevel@tonic-gate }
52247c478bd9Sstevel@tonic-gate /*
52257c478bd9Sstevel@tonic-gate * If there is no message retrieved, set return code to 0
52267c478bd9Sstevel@tonic-gate * otherwise, set it to 1.
52277c478bd9Sstevel@tonic-gate */
52287c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 &&
52297c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, databuf.len) == -1)
52307c478bd9Sstevel@tonic-gate *rvalp = 0;
52317c478bd9Sstevel@tonic-gate else
52327c478bd9Sstevel@tonic-gate *rvalp = 1;
52337c478bd9Sstevel@tonic-gate return (0);
5234d3e55dcdSgww }
52357c478bd9Sstevel@tonic-gate
52367c478bd9Sstevel@tonic-gate case I_FDINSERT:
5237d3e55dcdSgww {
52387c478bd9Sstevel@tonic-gate STRUCT_DECL(strfdinsert, strfdinsert);
52397c478bd9Sstevel@tonic-gate struct file *resftp;
52407c478bd9Sstevel@tonic-gate struct stdata *resstp;
52417c478bd9Sstevel@tonic-gate t_uscalar_t ival;
52427c478bd9Sstevel@tonic-gate ssize_t msgsize;
52437c478bd9Sstevel@tonic-gate struct strbuf mctl;
52447c478bd9Sstevel@tonic-gate
52457c478bd9Sstevel@tonic-gate STRUCT_INIT(strfdinsert, flag);
52467c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
52477c478bd9Sstevel@tonic-gate return (ENXIO);
52487c478bd9Sstevel@tonic-gate /*
52497c478bd9Sstevel@tonic-gate * STRDERR, STWRERR and STPLEX tested above.
52507c478bd9Sstevel@tonic-gate */
52517c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert),
52527c478bd9Sstevel@tonic-gate STRUCT_SIZE(strfdinsert), copyflag);
52537c478bd9Sstevel@tonic-gate if (error)
52547c478bd9Sstevel@tonic-gate return (error);
52557c478bd9Sstevel@tonic-gate
52567c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, offset) < 0 ||
52577c478bd9Sstevel@tonic-gate (STRUCT_FGET(strfdinsert, offset) %
52587c478bd9Sstevel@tonic-gate sizeof (t_uscalar_t)) != 0)
52597c478bd9Sstevel@tonic-gate return (EINVAL);
52607c478bd9Sstevel@tonic-gate if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) {
52617c478bd9Sstevel@tonic-gate if ((resstp = resftp->f_vnode->v_stream) == NULL) {
52627c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
52637c478bd9Sstevel@tonic-gate return (EINVAL);
52647c478bd9Sstevel@tonic-gate }
52657c478bd9Sstevel@tonic-gate } else
52667c478bd9Sstevel@tonic-gate return (EINVAL);
52677c478bd9Sstevel@tonic-gate
52687c478bd9Sstevel@tonic-gate mutex_enter(&resstp->sd_lock);
52697c478bd9Sstevel@tonic-gate if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) {
52707c478bd9Sstevel@tonic-gate error = strgeterr(resstp,
5271d3e55dcdSgww STRDERR|STWRERR|STRHUP|STPLEX, 0);
52727c478bd9Sstevel@tonic-gate if (error != 0) {
52737c478bd9Sstevel@tonic-gate mutex_exit(&resstp->sd_lock);
52747c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
52757c478bd9Sstevel@tonic-gate return (error);
52767c478bd9Sstevel@tonic-gate }
52777c478bd9Sstevel@tonic-gate }
52787c478bd9Sstevel@tonic-gate mutex_exit(&resstp->sd_lock);
52797c478bd9Sstevel@tonic-gate
52807c478bd9Sstevel@tonic-gate #ifdef _ILP32
52817c478bd9Sstevel@tonic-gate {
52827c478bd9Sstevel@tonic-gate queue_t *q;
52837c478bd9Sstevel@tonic-gate queue_t *mate = NULL;
52847c478bd9Sstevel@tonic-gate
52857c478bd9Sstevel@tonic-gate /* get read queue of stream terminus */
52867c478bd9Sstevel@tonic-gate claimstr(resstp->sd_wrq);
52877c478bd9Sstevel@tonic-gate for (q = resstp->sd_wrq->q_next; q->q_next != NULL;
52887c478bd9Sstevel@tonic-gate q = q->q_next)
52897c478bd9Sstevel@tonic-gate if (!STRMATED(resstp) && STREAM(q) != resstp &&
52907c478bd9Sstevel@tonic-gate mate == NULL) {
52917c478bd9Sstevel@tonic-gate ASSERT(q->q_qinfo->qi_srvp);
52927c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp);
52937c478bd9Sstevel@tonic-gate claimstr(q);
52947c478bd9Sstevel@tonic-gate mate = q;
52957c478bd9Sstevel@tonic-gate }
52967c478bd9Sstevel@tonic-gate q = _RD(q);
52977c478bd9Sstevel@tonic-gate if (mate)
52987c478bd9Sstevel@tonic-gate releasestr(mate);
52997c478bd9Sstevel@tonic-gate releasestr(resstp->sd_wrq);
53007c478bd9Sstevel@tonic-gate ival = (t_uscalar_t)q;
53017c478bd9Sstevel@tonic-gate }
53027c478bd9Sstevel@tonic-gate #else
53037c478bd9Sstevel@tonic-gate ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev);
53047c478bd9Sstevel@tonic-gate #endif /* _ILP32 */
53057c478bd9Sstevel@tonic-gate
53067c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, ctlbuf.len) <
53077c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) {
53087c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53097c478bd9Sstevel@tonic-gate return (EINVAL);
53107c478bd9Sstevel@tonic-gate }
53117c478bd9Sstevel@tonic-gate
53127c478bd9Sstevel@tonic-gate /*
53137c478bd9Sstevel@tonic-gate * Check for legal flag value.
53147c478bd9Sstevel@tonic-gate */
53157c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) {
53167c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53177c478bd9Sstevel@tonic-gate return (EINVAL);
53187c478bd9Sstevel@tonic-gate }
53197c478bd9Sstevel@tonic-gate
53207c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */
53217c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq));
53227c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz;
53237c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz;
53247c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq));
53257c478bd9Sstevel@tonic-gate
53267c478bd9Sstevel@tonic-gate /*
53277c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within
53287c478bd9Sstevel@tonic-gate * the limits of the max and min receive packet sizes
53297c478bd9Sstevel@tonic-gate * and do not exceed system limit. A negative data
53307c478bd9Sstevel@tonic-gate * length means that no data part is to be sent.
53317c478bd9Sstevel@tonic-gate */
53327c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ));
53337c478bd9Sstevel@tonic-gate if (rmax == 0) {
53347c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53357c478bd9Sstevel@tonic-gate return (ERANGE);
53367c478bd9Sstevel@tonic-gate }
53377c478bd9Sstevel@tonic-gate if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0)
53387c478bd9Sstevel@tonic-gate msgsize = 0;
53397c478bd9Sstevel@tonic-gate if ((msgsize < rmin) ||
53407c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ)) ||
53417c478bd9Sstevel@tonic-gate (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) {
53427c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53437c478bd9Sstevel@tonic-gate return (ERANGE);
53447c478bd9Sstevel@tonic-gate }
53457c478bd9Sstevel@tonic-gate
53467c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
53477c478bd9Sstevel@tonic-gate while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) &&
53487c478bd9Sstevel@tonic-gate !canputnext(stp->sd_wrq)) {
53497c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0,
53507c478bd9Sstevel@tonic-gate flag, -1, &done)) != 0 || done) {
53517c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
53527c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53537c478bd9Sstevel@tonic-gate return (error);
53547c478bd9Sstevel@tonic-gate }
53559acbbeafSnn if ((error = i_straccess(stp, access)) != 0) {
53567c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
53579acbbeafSnn releasef(
53589acbbeafSnn STRUCT_FGET(strfdinsert, fildes));
53599acbbeafSnn return (error);
53607c478bd9Sstevel@tonic-gate }
53617c478bd9Sstevel@tonic-gate }
53627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
53637c478bd9Sstevel@tonic-gate
53647c478bd9Sstevel@tonic-gate /*
53657c478bd9Sstevel@tonic-gate * Copy strfdinsert.ctlbuf into native form of
53667c478bd9Sstevel@tonic-gate * ctlbuf to pass down into strmakemsg().
53677c478bd9Sstevel@tonic-gate */
53687c478bd9Sstevel@tonic-gate mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen);
53697c478bd9Sstevel@tonic-gate mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len);
53707c478bd9Sstevel@tonic-gate mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf);
53717c478bd9Sstevel@tonic-gate
53727c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf);
53737c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len);
53747c478bd9Sstevel@tonic-gate uio.uio_iov = &iov;
53757c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1;
53767c478bd9Sstevel@tonic-gate uio.uio_loffset = 0;
53777c478bd9Sstevel@tonic-gate uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE :
53787c478bd9Sstevel@tonic-gate UIO_SYSSPACE;
53797c478bd9Sstevel@tonic-gate uio.uio_fmode = 0;
53807c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED;
53817c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len;
53827c478bd9Sstevel@tonic-gate if ((error = strmakemsg(&mctl,
53837c478bd9Sstevel@tonic-gate &msgsize, &uio, stp,
53847c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) {
53857c478bd9Sstevel@tonic-gate STRUCT_FSET(strfdinsert, databuf.len, msgsize);
53867c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
53877c478bd9Sstevel@tonic-gate return (error);
53887c478bd9Sstevel@tonic-gate }
53897c478bd9Sstevel@tonic-gate
53907c478bd9Sstevel@tonic-gate STRUCT_FSET(strfdinsert, databuf.len, msgsize);
53917c478bd9Sstevel@tonic-gate
53927c478bd9Sstevel@tonic-gate /*
53937c478bd9Sstevel@tonic-gate * Place the possibly reencoded queue pointer 'offset' bytes
53947c478bd9Sstevel@tonic-gate * from the start of the control portion of the message.
53957c478bd9Sstevel@tonic-gate */
53967c478bd9Sstevel@tonic-gate *((t_uscalar_t *)(mp->b_rptr +
53977c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, offset))) = ival;
53987c478bd9Sstevel@tonic-gate
53997c478bd9Sstevel@tonic-gate /*
54007c478bd9Sstevel@tonic-gate * Put message downstream.
54017c478bd9Sstevel@tonic-gate */
54027c478bd9Sstevel@tonic-gate stream_willservice(stp);
54037c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, mp);
54047c478bd9Sstevel@tonic-gate stream_runservice(stp);
54057c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes));
54067c478bd9Sstevel@tonic-gate return (error);
5407d3e55dcdSgww }
54087c478bd9Sstevel@tonic-gate
54097c478bd9Sstevel@tonic-gate case I_SENDFD:
5410d3e55dcdSgww {
54117c478bd9Sstevel@tonic-gate struct file *fp;
54127c478bd9Sstevel@tonic-gate
54137c478bd9Sstevel@tonic-gate if ((fp = getf((int)arg)) == NULL)
54147c478bd9Sstevel@tonic-gate return (EBADF);
54157c478bd9Sstevel@tonic-gate error = do_sendfp(stp, fp, crp);
5416005d3febSMarek Pospisil if (auditing) {
54177c478bd9Sstevel@tonic-gate audit_fdsend((int)arg, fp, error);
54187c478bd9Sstevel@tonic-gate }
54197c478bd9Sstevel@tonic-gate releasef((int)arg);
54207c478bd9Sstevel@tonic-gate return (error);
5421d3e55dcdSgww }
54227c478bd9Sstevel@tonic-gate
54237c478bd9Sstevel@tonic-gate case I_RECVFD:
54247c478bd9Sstevel@tonic-gate case I_E_RECVFD:
5425d3e55dcdSgww {
54267c478bd9Sstevel@tonic-gate struct k_strrecvfd *srf;
54277c478bd9Sstevel@tonic-gate int i, fd;
54287c478bd9Sstevel@tonic-gate
54297c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
54307c478bd9Sstevel@tonic-gate while (!(mp = getq(rdq))) {
54317c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STREOF)) {
54327c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54337c478bd9Sstevel@tonic-gate return (ENXIO);
54347c478bd9Sstevel@tonic-gate }
54357c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, GETWAIT, (ssize_t)0,
54367c478bd9Sstevel@tonic-gate flag, -1, &done)) != 0 || done) {
54377c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54387c478bd9Sstevel@tonic-gate return (error);
54397c478bd9Sstevel@tonic-gate }
54409acbbeafSnn if ((error = i_straccess(stp, access)) != 0) {
54417c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54429acbbeafSnn return (error);
54437c478bd9Sstevel@tonic-gate }
54447c478bd9Sstevel@tonic-gate }
54457c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type != M_PASSFP) {
54467c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band);
54477c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54487c478bd9Sstevel@tonic-gate return (EBADMSG);
54497c478bd9Sstevel@tonic-gate }
54507c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54517c478bd9Sstevel@tonic-gate
54527c478bd9Sstevel@tonic-gate srf = (struct k_strrecvfd *)mp->b_rptr;
54537c478bd9Sstevel@tonic-gate if ((fd = ufalloc(0)) == -1) {
54547c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
54557c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band);
54567c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54577c478bd9Sstevel@tonic-gate return (EMFILE);
54587c478bd9Sstevel@tonic-gate }
54597c478bd9Sstevel@tonic-gate if (cmd == I_RECVFD) {
54607c478bd9Sstevel@tonic-gate struct o_strrecvfd ostrfd;
54617c478bd9Sstevel@tonic-gate
54627c478bd9Sstevel@tonic-gate /* check to see if uid/gid values are too large. */
54637c478bd9Sstevel@tonic-gate
54647c478bd9Sstevel@tonic-gate if (srf->uid > (o_uid_t)USHRT_MAX ||
54657c478bd9Sstevel@tonic-gate srf->gid > (o_gid_t)USHRT_MAX) {
54667c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
54677c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band);
54687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
54697c478bd9Sstevel@tonic-gate setf(fd, NULL); /* release fd entry */
54707c478bd9Sstevel@tonic-gate return (EOVERFLOW);
54717c478bd9Sstevel@tonic-gate }
54727c478bd9Sstevel@tonic-gate
54737c478bd9Sstevel@tonic-gate ostrfd.fd = fd;
54747c478bd9Sstevel@tonic-gate ostrfd.uid = (o_uid_t)srf->uid;
54757c478bd9Sstevel@tonic-gate ostrfd.gid = (o_gid_t)srf->gid;
54767c478bd9Sstevel@tonic-gate
54777c478bd9Sstevel@tonic-gate /* Null the filler bits */
54787c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++)
54797c478bd9Sstevel@tonic-gate ostrfd.fill[i] = 0;
54807c478bd9Sstevel@tonic-gate
54817c478bd9Sstevel@tonic-gate error = strcopyout(&ostrfd, (void *)arg,
54827c478bd9Sstevel@tonic-gate sizeof (struct o_strrecvfd), copyflag);
54837c478bd9Sstevel@tonic-gate } else { /* I_E_RECVFD */
54847c478bd9Sstevel@tonic-gate struct strrecvfd strfd;
54857c478bd9Sstevel@tonic-gate
54867c478bd9Sstevel@tonic-gate strfd.fd = fd;
54877c478bd9Sstevel@tonic-gate strfd.uid = srf->uid;
54887c478bd9Sstevel@tonic-gate strfd.gid = srf->gid;
54897c478bd9Sstevel@tonic-gate
54907c478bd9Sstevel@tonic-gate /* null the filler bits */
54917c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++)
54927c478bd9Sstevel@tonic-gate strfd.fill[i] = 0;
54937c478bd9Sstevel@tonic-gate
54947c478bd9Sstevel@tonic-gate error = strcopyout(&strfd, (void *)arg,
54957c478bd9Sstevel@tonic-gate sizeof (struct strrecvfd), copyflag);
54967c478bd9Sstevel@tonic-gate }
54977c478bd9Sstevel@tonic-gate
54987c478bd9Sstevel@tonic-gate if (error) {
54997c478bd9Sstevel@tonic-gate setf(fd, NULL); /* release fd entry */
55007c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
55017c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band);
55027c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
55037c478bd9Sstevel@tonic-gate return (error);
55047c478bd9Sstevel@tonic-gate }
5505005d3febSMarek Pospisil if (auditing) {
55067c478bd9Sstevel@tonic-gate audit_fdrecv(fd, srf->fp);
55077c478bd9Sstevel@tonic-gate }
55087c478bd9Sstevel@tonic-gate
55097c478bd9Sstevel@tonic-gate /*
55107c478bd9Sstevel@tonic-gate * Always increment f_count since the freemsg() below will
55117c478bd9Sstevel@tonic-gate * always call free_passfp() which performs a closef().
55127c478bd9Sstevel@tonic-gate */
55137c478bd9Sstevel@tonic-gate mutex_enter(&srf->fp->f_tlock);
55147c478bd9Sstevel@tonic-gate srf->fp->f_count++;
55157c478bd9Sstevel@tonic-gate mutex_exit(&srf->fp->f_tlock);
55167c478bd9Sstevel@tonic-gate setf(fd, srf->fp);
55177c478bd9Sstevel@tonic-gate freemsg(mp);
55187c478bd9Sstevel@tonic-gate return (0);
5519d3e55dcdSgww }
55207c478bd9Sstevel@tonic-gate
55217c478bd9Sstevel@tonic-gate case I_SWROPT:
55227c478bd9Sstevel@tonic-gate /*
55237c478bd9Sstevel@tonic-gate * Set/clear the write options. arg is a bit
55247c478bd9Sstevel@tonic-gate * mask with any of the following bits set...
5525c0423dd8SToomas Soome * SNDZERO - send zero length message
55267c478bd9Sstevel@tonic-gate * SNDPIPE - send sigpipe to process if
55277c478bd9Sstevel@tonic-gate * sd_werror is set and process is
55287c478bd9Sstevel@tonic-gate * doing a write or putmsg.
55297c478bd9Sstevel@tonic-gate * The new stream head write options should reflect
55307c478bd9Sstevel@tonic-gate * what is in arg.
55317c478bd9Sstevel@tonic-gate */
55327c478bd9Sstevel@tonic-gate if (arg & ~(SNDZERO|SNDPIPE))
55337c478bd9Sstevel@tonic-gate return (EINVAL);
55347c478bd9Sstevel@tonic-gate
55357c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
55367c478bd9Sstevel@tonic-gate stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO);
55377c478bd9Sstevel@tonic-gate if (arg & SNDZERO)
55387c478bd9Sstevel@tonic-gate stp->sd_wput_opt |= SW_SNDZERO;
55397c478bd9Sstevel@tonic-gate if (arg & SNDPIPE)
55407c478bd9Sstevel@tonic-gate stp->sd_wput_opt |= SW_SIGPIPE;
55417c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
55427c478bd9Sstevel@tonic-gate return (0);
55437c478bd9Sstevel@tonic-gate
55447c478bd9Sstevel@tonic-gate case I_GWROPT:
5545d3e55dcdSgww {
55467c478bd9Sstevel@tonic-gate int wropt = 0;
55477c478bd9Sstevel@tonic-gate
55487c478bd9Sstevel@tonic-gate if (stp->sd_wput_opt & SW_SNDZERO)
55497c478bd9Sstevel@tonic-gate wropt |= SNDZERO;
55507c478bd9Sstevel@tonic-gate if (stp->sd_wput_opt & SW_SIGPIPE)
55517c478bd9Sstevel@tonic-gate wropt |= SNDPIPE;
55527c478bd9Sstevel@tonic-gate return (strcopyout(&wropt, (void *)arg, sizeof (wropt),
55537c478bd9Sstevel@tonic-gate copyflag));
5554d3e55dcdSgww }
55557c478bd9Sstevel@tonic-gate
55567c478bd9Sstevel@tonic-gate case I_LIST:
55577c478bd9Sstevel@tonic-gate /*
55587c478bd9Sstevel@tonic-gate * Returns all the modules found on this stream,
55597c478bd9Sstevel@tonic-gate * upto the driver. If argument is NULL, return the
55607c478bd9Sstevel@tonic-gate * number of modules (including driver). If argument
55617c478bd9Sstevel@tonic-gate * is not NULL, copy the names into the structure
55627c478bd9Sstevel@tonic-gate * provided.
55637c478bd9Sstevel@tonic-gate */
55647c478bd9Sstevel@tonic-gate
5565d3e55dcdSgww {
55667c478bd9Sstevel@tonic-gate queue_t *q;
5567a45f3f93Smeem char *qname;
5568a45f3f93Smeem int i, nmods;
5569a45f3f93Smeem struct str_mlist *mlist;
55707c478bd9Sstevel@tonic-gate STRUCT_DECL(str_list, strlist);
55717c478bd9Sstevel@tonic-gate
55727e12ceb3SToomas Soome if (arg == 0) { /* Return number of modules plus driver */
5573a45f3f93Smeem if (stp->sd_vnode->v_type == VFIFO)
55747c478bd9Sstevel@tonic-gate *rvalp = stp->sd_pushcnt;
5575a45f3f93Smeem else
55767c478bd9Sstevel@tonic-gate *rvalp = stp->sd_pushcnt + 1;
5577a45f3f93Smeem return (0);
5578a45f3f93Smeem }
55797c478bd9Sstevel@tonic-gate
5580a45f3f93Smeem STRUCT_INIT(strlist, flag);
55817c478bd9Sstevel@tonic-gate
5582a45f3f93Smeem error = strcopyin((void *)arg, STRUCT_BUF(strlist),
5583a45f3f93Smeem STRUCT_SIZE(strlist), copyflag);
5584a45f3f93Smeem if (error != 0)
5585a45f3f93Smeem return (error);
55867c478bd9Sstevel@tonic-gate
5587a45f3f93Smeem mlist = STRUCT_FGETP(strlist, sl_modlist);
5588a45f3f93Smeem nmods = STRUCT_FGET(strlist, sl_nmods);
5589a45f3f93Smeem if (nmods <= 0)
5590a45f3f93Smeem return (EINVAL);
55917c478bd9Sstevel@tonic-gate
5592a45f3f93Smeem claimstr(stp->sd_wrq);
5593a45f3f93Smeem q = stp->sd_wrq;
5594a45f3f93Smeem for (i = 0; i < nmods && _SAMESTR(q); i++, q = q->q_next) {
5595a45f3f93Smeem qname = Q2NAME(q->q_next);
5596a45f3f93Smeem error = strcopyout(qname, &mlist[i], strlen(qname) + 1,
5597a45f3f93Smeem copyflag);
5598a45f3f93Smeem if (error != 0) {
5599a45f3f93Smeem releasestr(stp->sd_wrq);
5600a45f3f93Smeem return (error);
56017c478bd9Sstevel@tonic-gate }
56027c478bd9Sstevel@tonic-gate }
5603a45f3f93Smeem releasestr(stp->sd_wrq);
5604a45f3f93Smeem return (strcopyout(&i, (void *)arg, sizeof (int), copyflag));
5605d3e55dcdSgww }
56067c478bd9Sstevel@tonic-gate
56077c478bd9Sstevel@tonic-gate case I_CKBAND:
5608d3e55dcdSgww {
56097c478bd9Sstevel@tonic-gate queue_t *q;
56107c478bd9Sstevel@tonic-gate qband_t *qbp;
56117c478bd9Sstevel@tonic-gate
56127c478bd9Sstevel@tonic-gate if ((arg < 0) || (arg >= NBAND))
56137c478bd9Sstevel@tonic-gate return (EINVAL);
56147c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
56157c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q));
56167c478bd9Sstevel@tonic-gate if (arg > (int)q->q_nband) {
56177c478bd9Sstevel@tonic-gate *rvalp = 0;
56187c478bd9Sstevel@tonic-gate } else {
56197c478bd9Sstevel@tonic-gate if (arg == 0) {
56207c478bd9Sstevel@tonic-gate if (q->q_first)
56217c478bd9Sstevel@tonic-gate *rvalp = 1;
56227c478bd9Sstevel@tonic-gate else
56237c478bd9Sstevel@tonic-gate *rvalp = 0;
56247c478bd9Sstevel@tonic-gate } else {
56257c478bd9Sstevel@tonic-gate qbp = q->q_bandp;
56267c478bd9Sstevel@tonic-gate while (--arg > 0)
56277c478bd9Sstevel@tonic-gate qbp = qbp->qb_next;
56287c478bd9Sstevel@tonic-gate if (qbp->qb_first)
56297c478bd9Sstevel@tonic-gate *rvalp = 1;
56307c478bd9Sstevel@tonic-gate else
56317c478bd9Sstevel@tonic-gate *rvalp = 0;
56327c478bd9Sstevel@tonic-gate }
56337c478bd9Sstevel@tonic-gate }
56347c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q));
56357c478bd9Sstevel@tonic-gate return (0);
5636d3e55dcdSgww }
56377c478bd9Sstevel@tonic-gate
56387c478bd9Sstevel@tonic-gate case I_GETBAND:
5639d3e55dcdSgww {
56407c478bd9Sstevel@tonic-gate int intpri;
56417c478bd9Sstevel@tonic-gate queue_t *q;
56427c478bd9Sstevel@tonic-gate
56437c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
56447c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q));
56457c478bd9Sstevel@tonic-gate mp = q->q_first;
56467c478bd9Sstevel@tonic-gate if (!mp) {
56477c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q));
56487c478bd9Sstevel@tonic-gate return (ENODATA);
56497c478bd9Sstevel@tonic-gate }
56507c478bd9Sstevel@tonic-gate intpri = (int)mp->b_band;
56517c478bd9Sstevel@tonic-gate error = strcopyout(&intpri, (void *)arg, sizeof (int),
56527c478bd9Sstevel@tonic-gate copyflag);
56537c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q));
56547c478bd9Sstevel@tonic-gate return (error);
5655d3e55dcdSgww }
56567c478bd9Sstevel@tonic-gate
56577c478bd9Sstevel@tonic-gate case I_ATMARK:
5658d3e55dcdSgww {
56597c478bd9Sstevel@tonic-gate queue_t *q;
56607c478bd9Sstevel@tonic-gate
56617c478bd9Sstevel@tonic-gate if (arg & ~(ANYMARK|LASTMARK))
56627c478bd9Sstevel@tonic-gate return (EINVAL);
56637c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
56647c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
56657c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) {
56667c478bd9Sstevel@tonic-gate *rvalp = 1;
56677c478bd9Sstevel@tonic-gate } else {
56687c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q));
56697c478bd9Sstevel@tonic-gate mp = q->q_first;
56707c478bd9Sstevel@tonic-gate
56717c478bd9Sstevel@tonic-gate if (mp == NULL)
56727c478bd9Sstevel@tonic-gate *rvalp = 0;
56737c478bd9Sstevel@tonic-gate else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK))
56747c478bd9Sstevel@tonic-gate *rvalp = 1;
56757c478bd9Sstevel@tonic-gate else if ((arg == LASTMARK) && (mp == stp->sd_mark))
56767c478bd9Sstevel@tonic-gate *rvalp = 1;
56777c478bd9Sstevel@tonic-gate else
56787c478bd9Sstevel@tonic-gate *rvalp = 0;
56797c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q));
56807c478bd9Sstevel@tonic-gate }
56817c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
56827c478bd9Sstevel@tonic-gate return (0);
5683d3e55dcdSgww }
56847c478bd9Sstevel@tonic-gate
56857c478bd9Sstevel@tonic-gate case I_CANPUT:
5686d3e55dcdSgww {
56877c478bd9Sstevel@tonic-gate char band;
56887c478bd9Sstevel@tonic-gate
56897c478bd9Sstevel@tonic-gate if ((arg < 0) || (arg >= NBAND))
56907c478bd9Sstevel@tonic-gate return (EINVAL);
56917c478bd9Sstevel@tonic-gate band = (char)arg;
56927c478bd9Sstevel@tonic-gate *rvalp = bcanputnext(stp->sd_wrq, band);
56937c478bd9Sstevel@tonic-gate return (0);
5694d3e55dcdSgww }
56957c478bd9Sstevel@tonic-gate
56967c478bd9Sstevel@tonic-gate case I_SETCLTIME:
5697d3e55dcdSgww {
56987c478bd9Sstevel@tonic-gate int closetime;
56997c478bd9Sstevel@tonic-gate
57007c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &closetime, sizeof (int),
57017c478bd9Sstevel@tonic-gate copyflag);
57027c478bd9Sstevel@tonic-gate if (error)
57037c478bd9Sstevel@tonic-gate return (error);
57047c478bd9Sstevel@tonic-gate if (closetime < 0)
57057c478bd9Sstevel@tonic-gate return (EINVAL);
57067c478bd9Sstevel@tonic-gate
57077c478bd9Sstevel@tonic-gate stp->sd_closetime = closetime;
57087c478bd9Sstevel@tonic-gate return (0);
5709d3e55dcdSgww }
57107c478bd9Sstevel@tonic-gate
57117c478bd9Sstevel@tonic-gate case I_GETCLTIME:
5712d3e55dcdSgww {
57137c478bd9Sstevel@tonic-gate int closetime;
57147c478bd9Sstevel@tonic-gate
57157c478bd9Sstevel@tonic-gate closetime = stp->sd_closetime;
57167c478bd9Sstevel@tonic-gate return (strcopyout(&closetime, (void *)arg, sizeof (int),
57177c478bd9Sstevel@tonic-gate copyflag));
5718d3e55dcdSgww }
57197c478bd9Sstevel@tonic-gate
57207c478bd9Sstevel@tonic-gate case TIOCGSID:
57217c478bd9Sstevel@tonic-gate {
57227c478bd9Sstevel@tonic-gate pid_t sid;
57237c478bd9Sstevel@tonic-gate
57249acbbeafSnn mutex_enter(&stp->sd_lock);
57257c478bd9Sstevel@tonic-gate if (stp->sd_sidp == NULL) {
57269acbbeafSnn mutex_exit(&stp->sd_lock);
57277c478bd9Sstevel@tonic-gate return (ENOTTY);
57287c478bd9Sstevel@tonic-gate }
57297c478bd9Sstevel@tonic-gate sid = stp->sd_sidp->pid_id;
57309acbbeafSnn mutex_exit(&stp->sd_lock);
57317c478bd9Sstevel@tonic-gate return (strcopyout(&sid, (void *)arg, sizeof (pid_t),
57327c478bd9Sstevel@tonic-gate copyflag));
57337c478bd9Sstevel@tonic-gate }
57347c478bd9Sstevel@tonic-gate
57357c478bd9Sstevel@tonic-gate case TIOCSPGRP:
57367c478bd9Sstevel@tonic-gate {
57377c478bd9Sstevel@tonic-gate pid_t pgrp;
57387c478bd9Sstevel@tonic-gate proc_t *q;
57397c478bd9Sstevel@tonic-gate pid_t sid, fg_pgid, bg_pgid;
57407c478bd9Sstevel@tonic-gate
57417c478bd9Sstevel@tonic-gate if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t),
57427c478bd9Sstevel@tonic-gate copyflag))
57437c478bd9Sstevel@tonic-gate return (error);
57447c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
57457c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
57467c478bd9Sstevel@tonic-gate if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) {
57477c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
57487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
57497c478bd9Sstevel@tonic-gate return (ENOTTY);
57507c478bd9Sstevel@tonic-gate }
57517c478bd9Sstevel@tonic-gate if (pgrp == stp->sd_pgidp->pid_id) {
57527c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
57537c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
57547c478bd9Sstevel@tonic-gate return (0);
57557c478bd9Sstevel@tonic-gate }
57567c478bd9Sstevel@tonic-gate if (pgrp <= 0 || pgrp >= maxpid) {
57577c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
57587c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
57597c478bd9Sstevel@tonic-gate return (EINVAL);
57607c478bd9Sstevel@tonic-gate }
57617c478bd9Sstevel@tonic-gate if ((q = pgfind(pgrp)) == NULL ||
57627c478bd9Sstevel@tonic-gate q->p_sessp != ttoproc(curthread)->p_sessp) {
57637c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
57647c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
57657c478bd9Sstevel@tonic-gate return (EPERM);
57667c478bd9Sstevel@tonic-gate }
57677c478bd9Sstevel@tonic-gate sid = stp->sd_sidp->pid_id;
57687c478bd9Sstevel@tonic-gate fg_pgid = q->p_pgrp;
57697c478bd9Sstevel@tonic-gate bg_pgid = stp->sd_pgidp->pid_id;
57707c478bd9Sstevel@tonic-gate CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid);
57717c478bd9Sstevel@tonic-gate PID_RELE(stp->sd_pgidp);
57729acbbeafSnn ctty_clear_sighuped();
57737c478bd9Sstevel@tonic-gate stp->sd_pgidp = q->p_pgidp;
57747c478bd9Sstevel@tonic-gate PID_HOLD(stp->sd_pgidp);
57757c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
57767c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
57777c478bd9Sstevel@tonic-gate return (0);
57787c478bd9Sstevel@tonic-gate }
57797c478bd9Sstevel@tonic-gate
57807c478bd9Sstevel@tonic-gate case TIOCGPGRP:
57817c478bd9Sstevel@tonic-gate {
57827c478bd9Sstevel@tonic-gate pid_t pgrp;
57837c478bd9Sstevel@tonic-gate
57849acbbeafSnn mutex_enter(&stp->sd_lock);
57857c478bd9Sstevel@tonic-gate if (stp->sd_sidp == NULL) {
57869acbbeafSnn mutex_exit(&stp->sd_lock);
57877c478bd9Sstevel@tonic-gate return (ENOTTY);
57887c478bd9Sstevel@tonic-gate }
57897c478bd9Sstevel@tonic-gate pgrp = stp->sd_pgidp->pid_id;
57909acbbeafSnn mutex_exit(&stp->sd_lock);
57917c478bd9Sstevel@tonic-gate return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t),
57927c478bd9Sstevel@tonic-gate copyflag));
57937c478bd9Sstevel@tonic-gate }
57947c478bd9Sstevel@tonic-gate
57959acbbeafSnn case TIOCSCTTY:
57969acbbeafSnn {
57979acbbeafSnn return (strctty(stp));
57989acbbeafSnn }
57999acbbeafSnn
58009acbbeafSnn case TIOCNOTTY:
58019acbbeafSnn {
58029acbbeafSnn /* freectty() always assumes curproc. */
58039acbbeafSnn if (freectty(B_FALSE) != 0)
58049acbbeafSnn return (0);
58059acbbeafSnn return (ENOTTY);
58069acbbeafSnn }
58079acbbeafSnn
58087c478bd9Sstevel@tonic-gate case FIONBIO:
58097c478bd9Sstevel@tonic-gate case FIOASYNC:
58107c478bd9Sstevel@tonic-gate return (0); /* handled by the upper layer */
58117c478bd9Sstevel@tonic-gate }
58127c478bd9Sstevel@tonic-gate }
58137c478bd9Sstevel@tonic-gate
58147c478bd9Sstevel@tonic-gate /*
58157c478bd9Sstevel@tonic-gate * Custom free routine used for M_PASSFP messages.
58167c478bd9Sstevel@tonic-gate */
58177c478bd9Sstevel@tonic-gate static void
free_passfp(struct k_strrecvfd * srf)58187c478bd9Sstevel@tonic-gate free_passfp(struct k_strrecvfd *srf)
58197c478bd9Sstevel@tonic-gate {
58207c478bd9Sstevel@tonic-gate (void) closef(srf->fp);
58217c478bd9Sstevel@tonic-gate kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t));
58227c478bd9Sstevel@tonic-gate }
58237c478bd9Sstevel@tonic-gate
58247c478bd9Sstevel@tonic-gate /* ARGSUSED */
58257c478bd9Sstevel@tonic-gate int
do_sendfp(struct stdata * stp,struct file * fp,struct cred * cr)58267c478bd9Sstevel@tonic-gate do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr)
58277c478bd9Sstevel@tonic-gate {
58287c478bd9Sstevel@tonic-gate queue_t *qp, *nextqp;
58297c478bd9Sstevel@tonic-gate struct k_strrecvfd *srf;
58307c478bd9Sstevel@tonic-gate mblk_t *mp;
58317c478bd9Sstevel@tonic-gate frtn_t *frtnp;
58327c478bd9Sstevel@tonic-gate size_t bufsize;
58337c478bd9Sstevel@tonic-gate queue_t *mate = NULL;
58347c478bd9Sstevel@tonic-gate syncq_t *sq = NULL;
58357c478bd9Sstevel@tonic-gate int retval = 0;
58367c478bd9Sstevel@tonic-gate
58377c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP)
58387c478bd9Sstevel@tonic-gate return (ENXIO);
58397c478bd9Sstevel@tonic-gate
58407c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq);
58417c478bd9Sstevel@tonic-gate
58427c478bd9Sstevel@tonic-gate /* Fastpath, we have a pipe, and we are already mated, use it. */
58437c478bd9Sstevel@tonic-gate if (STRMATED(stp)) {
58447c478bd9Sstevel@tonic-gate qp = _RD(stp->sd_mate->sd_wrq);
58457c478bd9Sstevel@tonic-gate claimstr(qp);
58467c478bd9Sstevel@tonic-gate mate = qp;
58477c478bd9Sstevel@tonic-gate } else { /* Not already mated. */
58487c478bd9Sstevel@tonic-gate
58497c478bd9Sstevel@tonic-gate /*
58507c478bd9Sstevel@tonic-gate * Walk the stream to the end of this one.
58517c478bd9Sstevel@tonic-gate * assumes that the claimstr() will prevent
58527c478bd9Sstevel@tonic-gate * plumbing between the stream head and the
58537c478bd9Sstevel@tonic-gate * driver from changing
58547c478bd9Sstevel@tonic-gate */
58557c478bd9Sstevel@tonic-gate qp = stp->sd_wrq;
58567c478bd9Sstevel@tonic-gate
58577c478bd9Sstevel@tonic-gate /*
58587c478bd9Sstevel@tonic-gate * Loop until we reach the end of this stream.
58597c478bd9Sstevel@tonic-gate * On completion, qp points to the write queue
58607c478bd9Sstevel@tonic-gate * at the end of the stream, or the read queue
58617c478bd9Sstevel@tonic-gate * at the stream head if this is a fifo.
58627c478bd9Sstevel@tonic-gate */
58637c478bd9Sstevel@tonic-gate while (((qp = qp->q_next) != NULL) && _SAMESTR(qp))
58647c478bd9Sstevel@tonic-gate ;
58657c478bd9Sstevel@tonic-gate
58667c478bd9Sstevel@tonic-gate /*
58677c478bd9Sstevel@tonic-gate * Just in case we get a q_next which is NULL, but
58687c478bd9Sstevel@tonic-gate * not at the end of the stream. This is actually
58697c478bd9Sstevel@tonic-gate * broken, so we set an assert to catch it in
58707c478bd9Sstevel@tonic-gate * debug, and set an error and return if not debug.
58717c478bd9Sstevel@tonic-gate */
58727c478bd9Sstevel@tonic-gate ASSERT(qp);
58737c478bd9Sstevel@tonic-gate if (qp == NULL) {
58747c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq);
58757c478bd9Sstevel@tonic-gate return (EINVAL);
58767c478bd9Sstevel@tonic-gate }
58777c478bd9Sstevel@tonic-gate
58787c478bd9Sstevel@tonic-gate /*
58797c478bd9Sstevel@tonic-gate * Enter the syncq for the driver, so (hopefully)
58807c478bd9Sstevel@tonic-gate * the queue values will not change on us.
58817c478bd9Sstevel@tonic-gate * XXXX - This will only prevent the race IFF only
58827c478bd9Sstevel@tonic-gate * the write side modifies the q_next member, and
58837c478bd9Sstevel@tonic-gate * the put procedure is protected by at least
58847c478bd9Sstevel@tonic-gate * MT_PERQ.
58857c478bd9Sstevel@tonic-gate */
58867c478bd9Sstevel@tonic-gate if ((sq = qp->q_syncq) != NULL)
58877c478bd9Sstevel@tonic-gate entersq(sq, SQ_PUT);
58887c478bd9Sstevel@tonic-gate
58897c478bd9Sstevel@tonic-gate /* Now get the q_next value from this qp. */
58907c478bd9Sstevel@tonic-gate nextqp = qp->q_next;
58917c478bd9Sstevel@tonic-gate
58927c478bd9Sstevel@tonic-gate /*
58937c478bd9Sstevel@tonic-gate * If nextqp exists and the other stream is different
58947c478bd9Sstevel@tonic-gate * from this one claim the stream, set the mate, and
58957c478bd9Sstevel@tonic-gate * get the read queue at the stream head of the other
58967c478bd9Sstevel@tonic-gate * stream. Assumes that nextqp was at least valid when
58977c478bd9Sstevel@tonic-gate * we got it. Hopefully the entersq of the driver
58987c478bd9Sstevel@tonic-gate * will prevent it from changing on us.
58997c478bd9Sstevel@tonic-gate */
59007c478bd9Sstevel@tonic-gate if ((nextqp != NULL) && (STREAM(nextqp) != stp)) {
59017c478bd9Sstevel@tonic-gate ASSERT(qp->q_qinfo->qi_srvp);
59027c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp);
59037c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp);
59047c478bd9Sstevel@tonic-gate claimstr(nextqp);
59057c478bd9Sstevel@tonic-gate
59067c478bd9Sstevel@tonic-gate /* Make sure we still have a q_next */
59077c478bd9Sstevel@tonic-gate if (nextqp != qp->q_next) {
59087c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq);
59097c478bd9Sstevel@tonic-gate releasestr(nextqp);
59107c478bd9Sstevel@tonic-gate return (EINVAL);
59117c478bd9Sstevel@tonic-gate }
59127c478bd9Sstevel@tonic-gate
59137c478bd9Sstevel@tonic-gate qp = _RD(STREAM(nextqp)->sd_wrq);
59147c478bd9Sstevel@tonic-gate mate = qp;
59157c478bd9Sstevel@tonic-gate }
59167c478bd9Sstevel@tonic-gate /* If we entered the synq above, leave it. */
59177c478bd9Sstevel@tonic-gate if (sq != NULL)
59187c478bd9Sstevel@tonic-gate leavesq(sq, SQ_PUT);
59197c478bd9Sstevel@tonic-gate } /* STRMATED(STP) */
59207c478bd9Sstevel@tonic-gate
59217c478bd9Sstevel@tonic-gate /* XXX prevents substitution of the ops vector */
59227c478bd9Sstevel@tonic-gate if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) {
59237c478bd9Sstevel@tonic-gate retval = EINVAL;
59247c478bd9Sstevel@tonic-gate goto out;
59257c478bd9Sstevel@tonic-gate }
59267c478bd9Sstevel@tonic-gate
59277c478bd9Sstevel@tonic-gate if (qp->q_flag & QFULL) {
59287c478bd9Sstevel@tonic-gate retval = EAGAIN;
59297c478bd9Sstevel@tonic-gate goto out;
59307c478bd9Sstevel@tonic-gate }
59317c478bd9Sstevel@tonic-gate
59327c478bd9Sstevel@tonic-gate /*
59337c478bd9Sstevel@tonic-gate * Since M_PASSFP messages include a file descriptor, we use
59347c478bd9Sstevel@tonic-gate * esballoc() and specify a custom free routine (free_passfp()) that
59357c478bd9Sstevel@tonic-gate * will close the descriptor as part of freeing the message. For
59367c478bd9Sstevel@tonic-gate * convenience, we stash the frtn_t right after the data block.
59377c478bd9Sstevel@tonic-gate */
59387c478bd9Sstevel@tonic-gate bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t);
59397c478bd9Sstevel@tonic-gate srf = kmem_alloc(bufsize, KM_NOSLEEP);
59407c478bd9Sstevel@tonic-gate if (srf == NULL) {
59417c478bd9Sstevel@tonic-gate retval = EAGAIN;
59427c478bd9Sstevel@tonic-gate goto out;
59437c478bd9Sstevel@tonic-gate }
59447c478bd9Sstevel@tonic-gate
59457c478bd9Sstevel@tonic-gate frtnp = (frtn_t *)(srf + 1);
59467c478bd9Sstevel@tonic-gate frtnp->free_arg = (caddr_t)srf;
59477c478bd9Sstevel@tonic-gate frtnp->free_func = free_passfp;
59487c478bd9Sstevel@tonic-gate
59497c478bd9Sstevel@tonic-gate mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp);
59507c478bd9Sstevel@tonic-gate if (mp == NULL) {
59517c478bd9Sstevel@tonic-gate kmem_free(srf, bufsize);
59527c478bd9Sstevel@tonic-gate retval = EAGAIN;
59537c478bd9Sstevel@tonic-gate goto out;
59547c478bd9Sstevel@tonic-gate }
59557c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (struct k_strrecvfd);
59567c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PASSFP;
59577c478bd9Sstevel@tonic-gate
59587c478bd9Sstevel@tonic-gate srf->fp = fp;
59597c478bd9Sstevel@tonic-gate srf->uid = crgetuid(curthread->t_cred);
59607c478bd9Sstevel@tonic-gate srf->gid = crgetgid(curthread->t_cred);
59617c478bd9Sstevel@tonic-gate mutex_enter(&fp->f_tlock);
59627c478bd9Sstevel@tonic-gate fp->f_count++;
59637c478bd9Sstevel@tonic-gate mutex_exit(&fp->f_tlock);
59647c478bd9Sstevel@tonic-gate
59657c478bd9Sstevel@tonic-gate put(qp, mp);
59667c478bd9Sstevel@tonic-gate out:
59677c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq);
59687c478bd9Sstevel@tonic-gate if (mate)
59697c478bd9Sstevel@tonic-gate releasestr(mate);
59707c478bd9Sstevel@tonic-gate return (retval);
59717c478bd9Sstevel@tonic-gate }
59727c478bd9Sstevel@tonic-gate
59737c478bd9Sstevel@tonic-gate /*
59747c478bd9Sstevel@tonic-gate * Send an ioctl message downstream and wait for acknowledgement.
59757c478bd9Sstevel@tonic-gate * flags may be set to either U_TO_K or K_TO_K and a combination
59767c478bd9Sstevel@tonic-gate * of STR_NOERROR or STR_NOSIG
59777c478bd9Sstevel@tonic-gate * STR_NOSIG: Signals are essentially ignored or held and have
59787c478bd9Sstevel@tonic-gate * no effect for the duration of the call.
59797c478bd9Sstevel@tonic-gate * STR_NOERROR: Ignores stream head read, write and hup errors.
59807c478bd9Sstevel@tonic-gate * Additionally, if an existing ioctl times out, it is assumed
59817c478bd9Sstevel@tonic-gate * lost and and this ioctl will continue as if the previous ioctl had
59827c478bd9Sstevel@tonic-gate * finished. ETIME may be returned if this ioctl times out (i.e.
59837c478bd9Sstevel@tonic-gate * ic_timout is not INFTIM). Non-stream head errors may be returned if
59847c478bd9Sstevel@tonic-gate * the ioc_error indicates that the driver/module had problems,
59857c478bd9Sstevel@tonic-gate * an EFAULT was found when accessing user data, a lack of
5986c0423dd8SToomas Soome * resources, etc.
59877c478bd9Sstevel@tonic-gate */
59887c478bd9Sstevel@tonic-gate int
strdoioctl(struct stdata * stp,struct strioctl * strioc,int fflags,int flag,cred_t * crp,int * rvalp)59897c478bd9Sstevel@tonic-gate strdoioctl(
59907c478bd9Sstevel@tonic-gate struct stdata *stp,
59917c478bd9Sstevel@tonic-gate struct strioctl *strioc,
59927c478bd9Sstevel@tonic-gate int fflags, /* file flags with model info */
59937c478bd9Sstevel@tonic-gate int flag,
59947c478bd9Sstevel@tonic-gate cred_t *crp,
59957c478bd9Sstevel@tonic-gate int *rvalp)
59967c478bd9Sstevel@tonic-gate {
59977c478bd9Sstevel@tonic-gate mblk_t *bp;
59987c478bd9Sstevel@tonic-gate struct iocblk *iocbp;
59997c478bd9Sstevel@tonic-gate struct copyreq *reqp;
60007c478bd9Sstevel@tonic-gate struct copyresp *resp;
60017c478bd9Sstevel@tonic-gate int id;
60027c478bd9Sstevel@tonic-gate int transparent = 0;
60037c478bd9Sstevel@tonic-gate int error = 0;
60047c478bd9Sstevel@tonic-gate int len = 0;
60057c478bd9Sstevel@tonic-gate caddr_t taddr;
60067c478bd9Sstevel@tonic-gate int copyflag = (flag & (U_TO_K | K_TO_K));
60077c478bd9Sstevel@tonic-gate int sigflag = (flag & STR_NOSIG);
60087c478bd9Sstevel@tonic-gate int errs;
60097c478bd9Sstevel@tonic-gate uint_t waitflags;
601086c7bc49SAnil udupa boolean_t set_iocwaitne = B_FALSE;
60117c478bd9Sstevel@tonic-gate
60127c478bd9Sstevel@tonic-gate ASSERT(copyflag == U_TO_K || copyflag == K_TO_K);
60137c478bd9Sstevel@tonic-gate ASSERT((fflags & FMODELS) != 0);
60147c478bd9Sstevel@tonic-gate
60157c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR,
6016d3e55dcdSgww TR_STRDOIOCTL,
6017d3e55dcdSgww "strdoioctl:stp %p strioc %p", stp, strioc);
60187c478bd9Sstevel@tonic-gate if (strioc->ic_len == TRANSPARENT) { /* send arg in M_DATA block */
60197c478bd9Sstevel@tonic-gate transparent = 1;
60207c478bd9Sstevel@tonic-gate strioc->ic_len = sizeof (intptr_t);
60217c478bd9Sstevel@tonic-gate }
60227c478bd9Sstevel@tonic-gate
60237c478bd9Sstevel@tonic-gate if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz))
60247c478bd9Sstevel@tonic-gate return (EINVAL);
60257c478bd9Sstevel@tonic-gate
60267c478bd9Sstevel@tonic-gate if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error,
6027de8c4a14SErik Nordmark crp, curproc->p_pid)) == NULL)
60287c478bd9Sstevel@tonic-gate return (error);
60297c478bd9Sstevel@tonic-gate
60307c478bd9Sstevel@tonic-gate bzero(bp->b_wptr, sizeof (union ioctypes));
60317c478bd9Sstevel@tonic-gate
60327c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_wptr;
60337c478bd9Sstevel@tonic-gate iocbp->ioc_count = strioc->ic_len;
60347c478bd9Sstevel@tonic-gate iocbp->ioc_cmd = strioc->ic_cmd;
60357c478bd9Sstevel@tonic-gate iocbp->ioc_flag = (fflags & FMODELS);
60367c478bd9Sstevel@tonic-gate
60377c478bd9Sstevel@tonic-gate crhold(crp);
60387c478bd9Sstevel@tonic-gate iocbp->ioc_cr = crp;
60397c478bd9Sstevel@tonic-gate DB_TYPE(bp) = M_IOCTL;
60407c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (struct iocblk);
60417c478bd9Sstevel@tonic-gate
60427c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR)
60437c478bd9Sstevel@tonic-gate errs = STPLEX;
60447c478bd9Sstevel@tonic-gate else
60457c478bd9Sstevel@tonic-gate errs = STRHUP|STRDERR|STWRERR|STPLEX;
60467c478bd9Sstevel@tonic-gate
60477c478bd9Sstevel@tonic-gate /*
60487c478bd9Sstevel@tonic-gate * If there is data to copy into ioctl block, do so.
60497c478bd9Sstevel@tonic-gate */
60507c478bd9Sstevel@tonic-gate if (iocbp->ioc_count > 0) {
60517c478bd9Sstevel@tonic-gate if (transparent)
60527c478bd9Sstevel@tonic-gate /*
60537c478bd9Sstevel@tonic-gate * Note: STR_NOERROR does not have an effect
60547c478bd9Sstevel@tonic-gate * in putiocd()
60557c478bd9Sstevel@tonic-gate */
60567c478bd9Sstevel@tonic-gate id = K_TO_K | sigflag;
60577c478bd9Sstevel@tonic-gate else
60587c478bd9Sstevel@tonic-gate id = flag;
60597c478bd9Sstevel@tonic-gate if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) {
60607c478bd9Sstevel@tonic-gate freemsg(bp);
60617c478bd9Sstevel@tonic-gate crfree(crp);
60627c478bd9Sstevel@tonic-gate return (error);
60637c478bd9Sstevel@tonic-gate }
60647c478bd9Sstevel@tonic-gate
60657c478bd9Sstevel@tonic-gate /*
60667c478bd9Sstevel@tonic-gate * We could have slept copying in user pages.
60677c478bd9Sstevel@tonic-gate * Recheck the stream head state (the other end
60687c478bd9Sstevel@tonic-gate * of a pipe could have gone away).
60697c478bd9Sstevel@tonic-gate */
60707c478bd9Sstevel@tonic-gate if (stp->sd_flag & errs) {
60717c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
60727c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0);
60737c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
60747c478bd9Sstevel@tonic-gate if (error != 0) {
60757c478bd9Sstevel@tonic-gate freemsg(bp);
60767c478bd9Sstevel@tonic-gate crfree(crp);
60777c478bd9Sstevel@tonic-gate return (error);
60787c478bd9Sstevel@tonic-gate }
60797c478bd9Sstevel@tonic-gate }
60807c478bd9Sstevel@tonic-gate }
60817c478bd9Sstevel@tonic-gate if (transparent)
60827c478bd9Sstevel@tonic-gate iocbp->ioc_count = TRANSPARENT;
60837c478bd9Sstevel@tonic-gate
60847c478bd9Sstevel@tonic-gate /*
60857c478bd9Sstevel@tonic-gate * Block for up to STRTIMOUT milliseconds if there is an outstanding
60867c478bd9Sstevel@tonic-gate * ioctl for this stream already running. All processes
60877c478bd9Sstevel@tonic-gate * sleeping here will be awakened as a result of an ACK
60887c478bd9Sstevel@tonic-gate * or NAK being received for the outstanding ioctl, or
60897c478bd9Sstevel@tonic-gate * as a result of the timer expiring on the outstanding
60907c478bd9Sstevel@tonic-gate * ioctl (a failure), or as a result of any waiting
60917c478bd9Sstevel@tonic-gate * process's timer expiring (also a failure).
60927c478bd9Sstevel@tonic-gate */
60937c478bd9Sstevel@tonic-gate
60947c478bd9Sstevel@tonic-gate error = 0;
60957c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
609686c7bc49SAnil udupa while ((stp->sd_flag & IOCWAIT) ||
609786c7bc49SAnil udupa (!set_iocwaitne && (stp->sd_flag & IOCWAITNE))) {
60987c478bd9Sstevel@tonic-gate clock_t cv_rval;
60997c478bd9Sstevel@tonic-gate
61007c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR,
6101d3e55dcdSgww TR_STRDOIOCTL_WAIT,
6102d3e55dcdSgww "strdoioctl sleeps - IOCWAIT");
61037c478bd9Sstevel@tonic-gate cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock,
61047c478bd9Sstevel@tonic-gate STRTIMOUT, sigflag);
61057c478bd9Sstevel@tonic-gate if (cv_rval <= 0) {
61067c478bd9Sstevel@tonic-gate if (cv_rval == 0) {
61077c478bd9Sstevel@tonic-gate error = EINTR;
61087c478bd9Sstevel@tonic-gate } else {
61097c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR) {
61107c478bd9Sstevel@tonic-gate /*
61117c478bd9Sstevel@tonic-gate * Terminating current ioctl in
61127c478bd9Sstevel@tonic-gate * progress -- assume it got lost and
61137c478bd9Sstevel@tonic-gate * wake up the other thread so that the
61147c478bd9Sstevel@tonic-gate * operation completes.
61157c478bd9Sstevel@tonic-gate */
61167c478bd9Sstevel@tonic-gate if (!(stp->sd_flag & IOCWAITNE)) {
611786c7bc49SAnil udupa set_iocwaitne = B_TRUE;
61187c478bd9Sstevel@tonic-gate stp->sd_flag |= IOCWAITNE;
61197c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor);
61207c478bd9Sstevel@tonic-gate }
61217c478bd9Sstevel@tonic-gate /*
61227c478bd9Sstevel@tonic-gate * Otherwise, there's a running
61237c478bd9Sstevel@tonic-gate * STR_NOERROR -- we have no choice
61247c478bd9Sstevel@tonic-gate * here but to wait forever (or until
61257c478bd9Sstevel@tonic-gate * interrupted).
61267c478bd9Sstevel@tonic-gate */
61277c478bd9Sstevel@tonic-gate } else {
61287c478bd9Sstevel@tonic-gate /*
61297c478bd9Sstevel@tonic-gate * pending ioctl has caused
61307c478bd9Sstevel@tonic-gate * us to time out
61317c478bd9Sstevel@tonic-gate */
61327c478bd9Sstevel@tonic-gate error = ETIME;
61337c478bd9Sstevel@tonic-gate }
61347c478bd9Sstevel@tonic-gate }
61357c478bd9Sstevel@tonic-gate } else if ((stp->sd_flag & errs)) {
61367c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0);
61377c478bd9Sstevel@tonic-gate }
61387c478bd9Sstevel@tonic-gate if (error) {
61397c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
61407c478bd9Sstevel@tonic-gate freemsg(bp);
61417c478bd9Sstevel@tonic-gate crfree(crp);
61427c478bd9Sstevel@tonic-gate return (error);
61437c478bd9Sstevel@tonic-gate }
61447c478bd9Sstevel@tonic-gate }
61457c478bd9Sstevel@tonic-gate
61467c478bd9Sstevel@tonic-gate /*
61477c478bd9Sstevel@tonic-gate * Have control of ioctl mechanism.
61487c478bd9Sstevel@tonic-gate * Send down ioctl packet and wait for response.
61497c478bd9Sstevel@tonic-gate */
61507c478bd9Sstevel@tonic-gate if (stp->sd_iocblk != (mblk_t *)-1) {
61517c478bd9Sstevel@tonic-gate freemsg(stp->sd_iocblk);
61527c478bd9Sstevel@tonic-gate }
61537c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL;
61547c478bd9Sstevel@tonic-gate
61557c478bd9Sstevel@tonic-gate /*
61567c478bd9Sstevel@tonic-gate * If this is marked with 'noerror' (internal; mostly
61577c478bd9Sstevel@tonic-gate * I_{P,}{UN,}LINK), then make sure nobody else is able to get
61587c478bd9Sstevel@tonic-gate * in here by setting IOCWAITNE.
61597c478bd9Sstevel@tonic-gate */
61607c478bd9Sstevel@tonic-gate waitflags = IOCWAIT;
61617c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR)
61627c478bd9Sstevel@tonic-gate waitflags |= IOCWAITNE;
61637c478bd9Sstevel@tonic-gate
61647c478bd9Sstevel@tonic-gate stp->sd_flag |= waitflags;
61657c478bd9Sstevel@tonic-gate
61667c478bd9Sstevel@tonic-gate /*
61677c478bd9Sstevel@tonic-gate * Assign sequence number.
61687c478bd9Sstevel@tonic-gate */
61697c478bd9Sstevel@tonic-gate iocbp->ioc_id = stp->sd_iocid = getiocseqno();
61707c478bd9Sstevel@tonic-gate
61717c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
61727c478bd9Sstevel@tonic-gate
61737c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
6174d3e55dcdSgww TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp);
61757c478bd9Sstevel@tonic-gate stream_willservice(stp);
61767c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp);
61777c478bd9Sstevel@tonic-gate stream_runservice(stp);
61787c478bd9Sstevel@tonic-gate
61797c478bd9Sstevel@tonic-gate /*
61807c478bd9Sstevel@tonic-gate * Timed wait for acknowledgment. The wait time is limited by the
61817c478bd9Sstevel@tonic-gate * timeout value, which must be a positive integer (number of
6182c28749e9Skais * milliseconds) to wait, or 0 (use default value of STRTIMOUT
61837c478bd9Sstevel@tonic-gate * milliseconds), or -1 (wait forever). This will be awakened
61847c478bd9Sstevel@tonic-gate * either by an ACK/NAK message arriving, the timer expiring, or
61857c478bd9Sstevel@tonic-gate * the timer expiring on another ioctl waiting for control of the
61867c478bd9Sstevel@tonic-gate * mechanism.
61877c478bd9Sstevel@tonic-gate */
61887c478bd9Sstevel@tonic-gate waitioc:
61897c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
61907c478bd9Sstevel@tonic-gate
61917c478bd9Sstevel@tonic-gate
61927c478bd9Sstevel@tonic-gate /*
61937c478bd9Sstevel@tonic-gate * If the reply has already arrived, don't sleep. If awakened from
61947c478bd9Sstevel@tonic-gate * the sleep, fail only if the reply has not arrived by then.
61957c478bd9Sstevel@tonic-gate * Otherwise, process the reply.
61967c478bd9Sstevel@tonic-gate */
61977c478bd9Sstevel@tonic-gate while (!stp->sd_iocblk) {
61987c478bd9Sstevel@tonic-gate clock_t cv_rval;
61997c478bd9Sstevel@tonic-gate
62007c478bd9Sstevel@tonic-gate if (stp->sd_flag & errs) {
62017c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0);
62027c478bd9Sstevel@tonic-gate if (error != 0) {
62037c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
62047c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
62057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
62067c478bd9Sstevel@tonic-gate crfree(crp);
62077c478bd9Sstevel@tonic-gate return (error);
62087c478bd9Sstevel@tonic-gate }
62097c478bd9Sstevel@tonic-gate }
62107c478bd9Sstevel@tonic-gate
62117c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR,
6212d3e55dcdSgww TR_STRDOIOCTL_WAIT2,
6213d3e55dcdSgww "strdoioctl sleeps awaiting reply");
62147c478bd9Sstevel@tonic-gate ASSERT(error == 0);
62157c478bd9Sstevel@tonic-gate
62167c478bd9Sstevel@tonic-gate cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock,
62177c478bd9Sstevel@tonic-gate (strioc->ic_timout ?
62187c478bd9Sstevel@tonic-gate strioc->ic_timout * 1000 : STRTIMOUT), sigflag);
62197c478bd9Sstevel@tonic-gate
62207c478bd9Sstevel@tonic-gate /*
62217c478bd9Sstevel@tonic-gate * There are four possible cases here: interrupt, timeout,
62227c478bd9Sstevel@tonic-gate * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a
62237c478bd9Sstevel@tonic-gate * valid M_IOCTL reply).
62247c478bd9Sstevel@tonic-gate *
62257c478bd9Sstevel@tonic-gate * If we've been awakened by a STR_NOERROR ioctl on some other
62267c478bd9Sstevel@tonic-gate * thread, then sd_iocblk will still be NULL, and IOCWAITNE
62277c478bd9Sstevel@tonic-gate * will be set. Pretend as if we just timed out. Note that
62287c478bd9Sstevel@tonic-gate * this other thread waited at least STRTIMOUT before trying to
62297c478bd9Sstevel@tonic-gate * awaken our thread, so this is indistinguishable (even for
62307c478bd9Sstevel@tonic-gate * INFTIM) from the case where we failed with ETIME waiting on
62317c478bd9Sstevel@tonic-gate * IOCWAIT in the prior loop.
62327c478bd9Sstevel@tonic-gate */
62337c478bd9Sstevel@tonic-gate if (cv_rval > 0 && !(flag & STR_NOERROR) &&
62347c478bd9Sstevel@tonic-gate stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) {
62357c478bd9Sstevel@tonic-gate cv_rval = -1;
62367c478bd9Sstevel@tonic-gate }
62377c478bd9Sstevel@tonic-gate
62387c478bd9Sstevel@tonic-gate /*
62397c478bd9Sstevel@tonic-gate * note: STR_NOERROR does not protect
62407c478bd9Sstevel@tonic-gate * us here.. use ic_timout < 0
62417c478bd9Sstevel@tonic-gate */
62427c478bd9Sstevel@tonic-gate if (cv_rval <= 0) {
62437c478bd9Sstevel@tonic-gate if (cv_rval == 0) {
62447c478bd9Sstevel@tonic-gate error = EINTR;
62457c478bd9Sstevel@tonic-gate } else {
62467c478bd9Sstevel@tonic-gate error = ETIME;
62477c478bd9Sstevel@tonic-gate }
62487c478bd9Sstevel@tonic-gate /*
62497c478bd9Sstevel@tonic-gate * A message could have come in after we were scheduled
62507c478bd9Sstevel@tonic-gate * but before we were actually run.
62517c478bd9Sstevel@tonic-gate */
62527c478bd9Sstevel@tonic-gate bp = stp->sd_iocblk;
62537c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL;
62547c478bd9Sstevel@tonic-gate if (bp != NULL) {
62557c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_COPYIN) ||
62567c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_COPYOUT)) {
62577c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
62587c478bd9Sstevel@tonic-gate if (bp->b_cont) {
62597c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
62607c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
62617c478bd9Sstevel@tonic-gate }
62627c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA;
62637c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr +
6264d3e55dcdSgww sizeof (struct copyresp);
62657c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr;
62667c478bd9Sstevel@tonic-gate resp->cp_rval =
62677c478bd9Sstevel@tonic-gate (caddr_t)1; /* failure */
62687c478bd9Sstevel@tonic-gate stream_willservice(stp);
62697c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp);
62707c478bd9Sstevel@tonic-gate stream_runservice(stp);
62717c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
62727c478bd9Sstevel@tonic-gate } else {
62737c478bd9Sstevel@tonic-gate freemsg(bp);
62747c478bd9Sstevel@tonic-gate }
62757c478bd9Sstevel@tonic-gate }
62767c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
62777c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
62787c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
62797c478bd9Sstevel@tonic-gate crfree(crp);
62807c478bd9Sstevel@tonic-gate return (error);
62817c478bd9Sstevel@tonic-gate }
62827c478bd9Sstevel@tonic-gate }
62837c478bd9Sstevel@tonic-gate bp = stp->sd_iocblk;
62847c478bd9Sstevel@tonic-gate /*
62857c478bd9Sstevel@tonic-gate * Note: it is strictly impossible to get here with sd_iocblk set to
62867c478bd9Sstevel@tonic-gate * -1. This is because the initial loop above doesn't allow any new
62877c478bd9Sstevel@tonic-gate * ioctls into the fray until all others have passed this point.
62887c478bd9Sstevel@tonic-gate */
62897c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp != (mblk_t *)-1);
62907c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR,
6291d3e55dcdSgww TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp);
62927c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_IOCACK) ||
62937c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_IOCNAK)) {
62947c478bd9Sstevel@tonic-gate /* for detection of duplicate ioctl replies */
62957c478bd9Sstevel@tonic-gate stp->sd_iocblk = (mblk_t *)-1;
62967c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
62977c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
62987c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
62997c478bd9Sstevel@tonic-gate } else {
63007c478bd9Sstevel@tonic-gate /*
63017c478bd9Sstevel@tonic-gate * flags not cleared here because we're still doing
63027c478bd9Sstevel@tonic-gate * copy in/out for ioctl.
63037c478bd9Sstevel@tonic-gate */
63047c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL;
63057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
63067c478bd9Sstevel@tonic-gate }
63077c478bd9Sstevel@tonic-gate
63087c478bd9Sstevel@tonic-gate
63097c478bd9Sstevel@tonic-gate /*
63107c478bd9Sstevel@tonic-gate * Have received acknowledgment.
63117c478bd9Sstevel@tonic-gate */
63127c478bd9Sstevel@tonic-gate
63137c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
63147c478bd9Sstevel@tonic-gate case M_IOCACK:
63157c478bd9Sstevel@tonic-gate /*
63167c478bd9Sstevel@tonic-gate * Positive ack.
63177c478bd9Sstevel@tonic-gate */
63187c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr;
63197c478bd9Sstevel@tonic-gate
63207c478bd9Sstevel@tonic-gate /*
63217c478bd9Sstevel@tonic-gate * Set error if indicated.
63227c478bd9Sstevel@tonic-gate */
63237c478bd9Sstevel@tonic-gate if (iocbp->ioc_error) {
63247c478bd9Sstevel@tonic-gate error = iocbp->ioc_error;
63257c478bd9Sstevel@tonic-gate break;
63267c478bd9Sstevel@tonic-gate }
63277c478bd9Sstevel@tonic-gate
63287c478bd9Sstevel@tonic-gate /*
63297c478bd9Sstevel@tonic-gate * Set return value.
63307c478bd9Sstevel@tonic-gate */
63317c478bd9Sstevel@tonic-gate *rvalp = iocbp->ioc_rval;
63327c478bd9Sstevel@tonic-gate
63337c478bd9Sstevel@tonic-gate /*
63347c478bd9Sstevel@tonic-gate * Data may have been returned in ACK message (ioc_count > 0).
63357c478bd9Sstevel@tonic-gate * If so, copy it out to the user's buffer.
63367c478bd9Sstevel@tonic-gate */
63377c478bd9Sstevel@tonic-gate if (iocbp->ioc_count && !transparent) {
63387c478bd9Sstevel@tonic-gate if (error = getiocd(bp, strioc->ic_dp, copyflag))
63397c478bd9Sstevel@tonic-gate break;
63407c478bd9Sstevel@tonic-gate }
63417c478bd9Sstevel@tonic-gate if (!transparent) {
63427c478bd9Sstevel@tonic-gate if (len) /* an M_COPYOUT was used with I_STR */
63437c478bd9Sstevel@tonic-gate strioc->ic_len = len;
63447c478bd9Sstevel@tonic-gate else
63457c478bd9Sstevel@tonic-gate strioc->ic_len = (int)iocbp->ioc_count;
63467c478bd9Sstevel@tonic-gate }
63477c478bd9Sstevel@tonic-gate break;
63487c478bd9Sstevel@tonic-gate
63497c478bd9Sstevel@tonic-gate case M_IOCNAK:
63507c478bd9Sstevel@tonic-gate /*
63517c478bd9Sstevel@tonic-gate * Negative ack.
63527c478bd9Sstevel@tonic-gate *
63537c478bd9Sstevel@tonic-gate * The only thing to do is set error as specified
63547c478bd9Sstevel@tonic-gate * in neg ack packet.
63557c478bd9Sstevel@tonic-gate */
63567c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr;
63577c478bd9Sstevel@tonic-gate
63587c478bd9Sstevel@tonic-gate error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL);
63597c478bd9Sstevel@tonic-gate break;
63607c478bd9Sstevel@tonic-gate
63617c478bd9Sstevel@tonic-gate case M_COPYIN:
63627c478bd9Sstevel@tonic-gate /*
63637c478bd9Sstevel@tonic-gate * Driver or module has requested user ioctl data.
63647c478bd9Sstevel@tonic-gate */
63657c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr;
63667c478bd9Sstevel@tonic-gate
63677c478bd9Sstevel@tonic-gate /*
63687c478bd9Sstevel@tonic-gate * M_COPYIN should *never* have a message attached, though
63697c478bd9Sstevel@tonic-gate * it's harmless if it does -- thus, panic on a DEBUG
63707c478bd9Sstevel@tonic-gate * kernel and just free it on a non-DEBUG build.
63717c478bd9Sstevel@tonic-gate */
63727c478bd9Sstevel@tonic-gate ASSERT(bp->b_cont == NULL);
63737c478bd9Sstevel@tonic-gate if (bp->b_cont != NULL) {
63747c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
63757c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
63767c478bd9Sstevel@tonic-gate }
63777c478bd9Sstevel@tonic-gate
63787c478bd9Sstevel@tonic-gate error = putiocd(bp, reqp->cq_addr, flag, crp);
63797c478bd9Sstevel@tonic-gate if (error && bp->b_cont) {
63807c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
63817c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
63827c478bd9Sstevel@tonic-gate }
63837c478bd9Sstevel@tonic-gate
63847c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
63857c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA;
63867c478bd9Sstevel@tonic-gate
6387de8c4a14SErik Nordmark mblk_setcred(bp, crp, curproc->p_pid);
63887c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr;
63897c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)(uintptr_t)error;
63907c478bd9Sstevel@tonic-gate resp->cp_flag = (fflags & FMODELS);
63917c478bd9Sstevel@tonic-gate
63927c478bd9Sstevel@tonic-gate stream_willservice(stp);
63937c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp);
63947c478bd9Sstevel@tonic-gate stream_runservice(stp);
63957c478bd9Sstevel@tonic-gate
63967c478bd9Sstevel@tonic-gate if (error) {
63977c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
63987c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
63997c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
64007c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
64017c478bd9Sstevel@tonic-gate crfree(crp);
64027c478bd9Sstevel@tonic-gate return (error);
64037c478bd9Sstevel@tonic-gate }
64047c478bd9Sstevel@tonic-gate
64057c478bd9Sstevel@tonic-gate goto waitioc;
64067c478bd9Sstevel@tonic-gate
64077c478bd9Sstevel@tonic-gate case M_COPYOUT:
64087c478bd9Sstevel@tonic-gate /*
64097c478bd9Sstevel@tonic-gate * Driver or module has ioctl data for a user.
64107c478bd9Sstevel@tonic-gate */
64117c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr;
64127c478bd9Sstevel@tonic-gate ASSERT(bp->b_cont != NULL);
64137c478bd9Sstevel@tonic-gate
64147c478bd9Sstevel@tonic-gate /*
64157c478bd9Sstevel@tonic-gate * Always (transparent or non-transparent )
64167c478bd9Sstevel@tonic-gate * use the address specified in the request
64177c478bd9Sstevel@tonic-gate */
64187c478bd9Sstevel@tonic-gate taddr = reqp->cq_addr;
64197c478bd9Sstevel@tonic-gate if (!transparent)
64207c478bd9Sstevel@tonic-gate len = (int)reqp->cq_size;
64217c478bd9Sstevel@tonic-gate
64227c478bd9Sstevel@tonic-gate /* copyout data to the provided address */
64237c478bd9Sstevel@tonic-gate error = getiocd(bp, taddr, copyflag);
64247c478bd9Sstevel@tonic-gate
64257c478bd9Sstevel@tonic-gate freemsg(bp->b_cont);
64267c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
64277c478bd9Sstevel@tonic-gate
64287c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp);
64297c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA;
64307c478bd9Sstevel@tonic-gate
6431de8c4a14SErik Nordmark mblk_setcred(bp, crp, curproc->p_pid);
64327c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr;
64337c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)(uintptr_t)error;
64347c478bd9Sstevel@tonic-gate resp->cp_flag = (fflags & FMODELS);
64357c478bd9Sstevel@tonic-gate
64367c478bd9Sstevel@tonic-gate stream_willservice(stp);
64377c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp);
64387c478bd9Sstevel@tonic-gate stream_runservice(stp);
64397c478bd9Sstevel@tonic-gate
64407c478bd9Sstevel@tonic-gate if (error) {
64417c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
64427c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
64437c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
64447c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
64457c478bd9Sstevel@tonic-gate crfree(crp);
64467c478bd9Sstevel@tonic-gate return (error);
64477c478bd9Sstevel@tonic-gate }
64487c478bd9Sstevel@tonic-gate goto waitioc;
64497c478bd9Sstevel@tonic-gate
64507c478bd9Sstevel@tonic-gate default:
64517c478bd9Sstevel@tonic-gate ASSERT(0);
64527c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
64537c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags;
64547c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor);
64557c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
64567c478bd9Sstevel@tonic-gate break;
64577c478bd9Sstevel@tonic-gate }
64587c478bd9Sstevel@tonic-gate
64597c478bd9Sstevel@tonic-gate freemsg(bp);
64607c478bd9Sstevel@tonic-gate crfree(crp);
64617c478bd9Sstevel@tonic-gate return (error);
64627c478bd9Sstevel@tonic-gate }
64637c478bd9Sstevel@tonic-gate
6464ca9327a6Smeem /*
6465ca9327a6Smeem * Send an M_CMD message downstream and wait for a reply. This is a ptools
6466ca9327a6Smeem * special used to retrieve information from modules/drivers a stream without
6467ca9327a6Smeem * being subjected to flow control or interfering with pending messages on the
6468ca9327a6Smeem * stream (e.g. an ioctl in flight).
6469ca9327a6Smeem */
6470ca9327a6Smeem int
strdocmd(struct stdata * stp,struct strcmd * scp,cred_t * crp)6471ca9327a6Smeem strdocmd(struct stdata *stp, struct strcmd *scp, cred_t *crp)
6472ca9327a6Smeem {
6473ca9327a6Smeem mblk_t *mp;
6474ca9327a6Smeem struct cmdblk *cmdp;
6475ca9327a6Smeem int error = 0;
6476ca9327a6Smeem int errs = STRHUP|STRDERR|STWRERR|STPLEX;
6477ca9327a6Smeem clock_t rval, timeout = STRTIMOUT;
6478ca9327a6Smeem
6479ca9327a6Smeem if (scp->sc_len < 0 || scp->sc_len > sizeof (scp->sc_buf) ||
6480ca9327a6Smeem scp->sc_timeout < -1)
6481ca9327a6Smeem return (EINVAL);
6482ca9327a6Smeem
6483ca9327a6Smeem if (scp->sc_timeout > 0)
6484ca9327a6Smeem timeout = scp->sc_timeout * MILLISEC;
6485ca9327a6Smeem
6486de8c4a14SErik Nordmark if ((mp = allocb_cred(sizeof (struct cmdblk), crp,
6487de8c4a14SErik Nordmark curproc->p_pid)) == NULL)
6488ca9327a6Smeem return (ENOMEM);
6489ca9327a6Smeem
6490ca9327a6Smeem crhold(crp);
6491ca9327a6Smeem
6492ca9327a6Smeem cmdp = (struct cmdblk *)mp->b_wptr;
6493ca9327a6Smeem cmdp->cb_cr = crp;
6494ca9327a6Smeem cmdp->cb_cmd = scp->sc_cmd;
6495ca9327a6Smeem cmdp->cb_len = scp->sc_len;
6496ca9327a6Smeem cmdp->cb_error = 0;
6497ca9327a6Smeem mp->b_wptr += sizeof (struct cmdblk);
6498ca9327a6Smeem
6499ca9327a6Smeem DB_TYPE(mp) = M_CMD;
6500ca9327a6Smeem DB_CPID(mp) = curproc->p_pid;
6501ca9327a6Smeem
6502ca9327a6Smeem /*
6503ca9327a6Smeem * Copy in the payload.
6504ca9327a6Smeem */
6505ca9327a6Smeem if (cmdp->cb_len > 0) {
6506de8c4a14SErik Nordmark mp->b_cont = allocb_cred(sizeof (scp->sc_buf), crp,
6507de8c4a14SErik Nordmark curproc->p_pid);
6508ca9327a6Smeem if (mp->b_cont == NULL) {
6509ca9327a6Smeem error = ENOMEM;
6510ca9327a6Smeem goto out;
6511ca9327a6Smeem }
6512ca9327a6Smeem
6513ca9327a6Smeem /* cb_len comes from sc_len, which has already been checked */
6514ca9327a6Smeem ASSERT(cmdp->cb_len <= sizeof (scp->sc_buf));
6515ca9327a6Smeem (void) bcopy(scp->sc_buf, mp->b_cont->b_wptr, cmdp->cb_len);
6516ca9327a6Smeem mp->b_cont->b_wptr += cmdp->cb_len;
6517ca9327a6Smeem DB_CPID(mp->b_cont) = curproc->p_pid;
6518ca9327a6Smeem }
6519ca9327a6Smeem
6520ca9327a6Smeem /*
6521ca9327a6Smeem * Since this mechanism is strictly for ptools, and since only one
6522ca9327a6Smeem * process can be grabbed at a time, we simply fail if there's
6523ca9327a6Smeem * currently an operation pending.
6524ca9327a6Smeem */
6525ca9327a6Smeem mutex_enter(&stp->sd_lock);
6526ca9327a6Smeem if (stp->sd_flag & STRCMDWAIT) {
6527ca9327a6Smeem mutex_exit(&stp->sd_lock);
6528ca9327a6Smeem error = EBUSY;
6529ca9327a6Smeem goto out;
6530ca9327a6Smeem }
6531ca9327a6Smeem stp->sd_flag |= STRCMDWAIT;
6532ca9327a6Smeem ASSERT(stp->sd_cmdblk == NULL);
6533ca9327a6Smeem mutex_exit(&stp->sd_lock);
6534ca9327a6Smeem
6535ca9327a6Smeem putnext(stp->sd_wrq, mp);
6536ca9327a6Smeem mp = NULL;
6537ca9327a6Smeem
6538ca9327a6Smeem /*
6539ca9327a6Smeem * Timed wait for acknowledgment. If the reply has already arrived,
6540ca9327a6Smeem * don't sleep. If awakened from the sleep, fail only if the reply
6541ca9327a6Smeem * has not arrived by then. Otherwise, process the reply.
6542ca9327a6Smeem */
6543ca9327a6Smeem mutex_enter(&stp->sd_lock);
6544ca9327a6Smeem while (stp->sd_cmdblk == NULL) {
6545ca9327a6Smeem if (stp->sd_flag & errs) {
6546ca9327a6Smeem if ((error = strgeterr(stp, errs, 0)) != 0)
6547ca9327a6Smeem goto waitout;
6548ca9327a6Smeem }
6549ca9327a6Smeem
6550ca9327a6Smeem rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock, timeout, 0);
6551ca9327a6Smeem if (stp->sd_cmdblk != NULL)
6552ca9327a6Smeem break;
6553ca9327a6Smeem
6554ca9327a6Smeem if (rval <= 0) {
6555ca9327a6Smeem error = (rval == 0) ? EINTR : ETIME;
6556ca9327a6Smeem goto waitout;
6557ca9327a6Smeem }
6558ca9327a6Smeem }
6559ca9327a6Smeem
6560ca9327a6Smeem /*
6561ca9327a6Smeem * We received a reply.
6562ca9327a6Smeem */
6563ca9327a6Smeem mp = stp->sd_cmdblk;
6564ca9327a6Smeem stp->sd_cmdblk = NULL;
6565ca9327a6Smeem ASSERT(mp != NULL && DB_TYPE(mp) == M_CMD);
6566ca9327a6Smeem ASSERT(stp->sd_flag & STRCMDWAIT);
6567ca9327a6Smeem stp->sd_flag &= ~STRCMDWAIT;
6568ca9327a6Smeem mutex_exit(&stp->sd_lock);
6569ca9327a6Smeem
6570ca9327a6Smeem cmdp = (struct cmdblk *)mp->b_rptr;
6571ca9327a6Smeem if ((error = cmdp->cb_error) != 0)
6572ca9327a6Smeem goto out;
6573ca9327a6Smeem
6574ca9327a6Smeem /*
6575ca9327a6Smeem * Data may have been returned in the reply (cb_len > 0).
6576ca9327a6Smeem * If so, copy it out to the user's buffer.
6577ca9327a6Smeem */
6578ca9327a6Smeem if (cmdp->cb_len > 0) {
6579ca9327a6Smeem if (mp->b_cont == NULL || MBLKL(mp->b_cont) < cmdp->cb_len) {
6580ca9327a6Smeem error = EPROTO;
6581ca9327a6Smeem goto out;
6582ca9327a6Smeem }
6583ca9327a6Smeem
6584ca9327a6Smeem cmdp->cb_len = MIN(cmdp->cb_len, sizeof (scp->sc_buf));
6585ca9327a6Smeem (void) bcopy(mp->b_cont->b_rptr, scp->sc_buf, cmdp->cb_len);
6586ca9327a6Smeem }
6587ca9327a6Smeem scp->sc_len = cmdp->cb_len;
6588ca9327a6Smeem out:
6589ca9327a6Smeem freemsg(mp);
6590ca9327a6Smeem crfree(crp);
6591ca9327a6Smeem return (error);
6592ca9327a6Smeem waitout:
6593ca9327a6Smeem ASSERT(stp->sd_cmdblk == NULL);
6594ca9327a6Smeem stp->sd_flag &= ~STRCMDWAIT;
6595ca9327a6Smeem mutex_exit(&stp->sd_lock);
6596ca9327a6Smeem crfree(crp);
6597ca9327a6Smeem return (error);
6598ca9327a6Smeem }
6599ca9327a6Smeem
66007c478bd9Sstevel@tonic-gate /*
66017c478bd9Sstevel@tonic-gate * For the SunOS keyboard driver.
66027c478bd9Sstevel@tonic-gate * Return the next available "ioctl" sequence number.
66037c478bd9Sstevel@tonic-gate * Exported, so that streams modules can send "ioctl" messages
66047c478bd9Sstevel@tonic-gate * downstream from their open routine.
66057c478bd9Sstevel@tonic-gate */
66067c478bd9Sstevel@tonic-gate int
getiocseqno(void)66077c478bd9Sstevel@tonic-gate getiocseqno(void)
66087c478bd9Sstevel@tonic-gate {
66097c478bd9Sstevel@tonic-gate int i;
66107c478bd9Sstevel@tonic-gate
66117c478bd9Sstevel@tonic-gate mutex_enter(&strresources);
66127c478bd9Sstevel@tonic-gate i = ++ioc_id;
66137c478bd9Sstevel@tonic-gate mutex_exit(&strresources);
66147c478bd9Sstevel@tonic-gate return (i);
66157c478bd9Sstevel@tonic-gate }
66167c478bd9Sstevel@tonic-gate
66177c478bd9Sstevel@tonic-gate /*
66187c478bd9Sstevel@tonic-gate * Get the next message from the read queue. If the message is
66197c478bd9Sstevel@tonic-gate * priority, STRPRI will have been set by strrput(). This flag
66207c478bd9Sstevel@tonic-gate * should be reset only when the entire message at the front of the
66217c478bd9Sstevel@tonic-gate * queue as been consumed.
66227c478bd9Sstevel@tonic-gate *
66237c478bd9Sstevel@tonic-gate * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
66247c478bd9Sstevel@tonic-gate */
66257c478bd9Sstevel@tonic-gate int
strgetmsg(struct vnode * vp,struct strbuf * mctl,struct strbuf * mdata,unsigned char * prip,int * flagsp,int fmode,rval_t * rvp)66267c478bd9Sstevel@tonic-gate strgetmsg(
66277c478bd9Sstevel@tonic-gate struct vnode *vp,
66287c478bd9Sstevel@tonic-gate struct strbuf *mctl,
66297c478bd9Sstevel@tonic-gate struct strbuf *mdata,
66307c478bd9Sstevel@tonic-gate unsigned char *prip,
66317c478bd9Sstevel@tonic-gate int *flagsp,
66327c478bd9Sstevel@tonic-gate int fmode,
66337c478bd9Sstevel@tonic-gate rval_t *rvp)
66347c478bd9Sstevel@tonic-gate {
66357c478bd9Sstevel@tonic-gate struct stdata *stp;
66367c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp;
66377c478bd9Sstevel@tonic-gate mblk_t *savemp = NULL;
66387c478bd9Sstevel@tonic-gate mblk_t *savemptail = NULL;
66397c478bd9Sstevel@tonic-gate uint_t old_sd_flag;
6640c6f039c7SToomas Soome int flg = MSG_BAND;
66417c478bd9Sstevel@tonic-gate int more = 0;
66427c478bd9Sstevel@tonic-gate int error = 0;
66437c478bd9Sstevel@tonic-gate char first = 1;
66447c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */
66457c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
66467c478bd9Sstevel@tonic-gate unsigned char pri = 0;
66477c478bd9Sstevel@tonic-gate queue_t *q;
66487c478bd9Sstevel@tonic-gate int pr = 0; /* Partial read successful */
66497c478bd9Sstevel@tonic-gate struct uio uios;
66507c478bd9Sstevel@tonic-gate struct uio *uiop = &uios;
66517c478bd9Sstevel@tonic-gate struct iovec iovs;
66527c478bd9Sstevel@tonic-gate unsigned char type;
66537c478bd9Sstevel@tonic-gate
66547c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER,
6655d3e55dcdSgww "strgetmsg:%p", vp);
66567c478bd9Sstevel@tonic-gate
66577c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
66587c478bd9Sstevel@tonic-gate stp = vp->v_stream;
66597c478bd9Sstevel@tonic-gate rvp->r_val1 = 0;
66607c478bd9Sstevel@tonic-gate
66619acbbeafSnn mutex_enter(&stp->sd_lock);
66629acbbeafSnn
66639acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
66649acbbeafSnn mutex_exit(&stp->sd_lock);
66659acbbeafSnn return (error);
66669acbbeafSnn }
66677c478bd9Sstevel@tonic-gate
66687c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) {
66697c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 0);
66709acbbeafSnn if (error != 0) {
66719acbbeafSnn mutex_exit(&stp->sd_lock);
66727c478bd9Sstevel@tonic-gate return (error);
66739acbbeafSnn }
66747c478bd9Sstevel@tonic-gate }
66759acbbeafSnn mutex_exit(&stp->sd_lock);
66767c478bd9Sstevel@tonic-gate
66777c478bd9Sstevel@tonic-gate switch (*flagsp) {
66787c478bd9Sstevel@tonic-gate case MSG_HIPRI:
66797c478bd9Sstevel@tonic-gate if (*prip != 0)
66807c478bd9Sstevel@tonic-gate return (EINVAL);
66817c478bd9Sstevel@tonic-gate break;
66827c478bd9Sstevel@tonic-gate
66837c478bd9Sstevel@tonic-gate case MSG_ANY:
66847c478bd9Sstevel@tonic-gate case MSG_BAND:
66857c478bd9Sstevel@tonic-gate break;
66867c478bd9Sstevel@tonic-gate
66877c478bd9Sstevel@tonic-gate default:
66887c478bd9Sstevel@tonic-gate return (EINVAL);
66897c478bd9Sstevel@tonic-gate }
66907c478bd9Sstevel@tonic-gate /*
66917c478bd9Sstevel@tonic-gate * Setup uio and iov for data part
66927c478bd9Sstevel@tonic-gate */
66937c478bd9Sstevel@tonic-gate iovs.iov_base = mdata->buf;
66947c478bd9Sstevel@tonic-gate iovs.iov_len = mdata->maxlen;
66957c478bd9Sstevel@tonic-gate uios.uio_iov = &iovs;
66967c478bd9Sstevel@tonic-gate uios.uio_iovcnt = 1;
66977c478bd9Sstevel@tonic-gate uios.uio_loffset = 0;
66987c478bd9Sstevel@tonic-gate uios.uio_segflg = UIO_USERSPACE;
66997c478bd9Sstevel@tonic-gate uios.uio_fmode = 0;
67007c478bd9Sstevel@tonic-gate uios.uio_extflg = UIO_COPY_CACHED;
67017c478bd9Sstevel@tonic-gate uios.uio_resid = mdata->maxlen;
67027c478bd9Sstevel@tonic-gate uios.uio_offset = 0;
67037c478bd9Sstevel@tonic-gate
67047c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
67057c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
67067c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag;
67077c478bd9Sstevel@tonic-gate mark = 0;
67087c478bd9Sstevel@tonic-gate for (;;) {
67097c478bd9Sstevel@tonic-gate int done = 0;
67107c478bd9Sstevel@tonic-gate mblk_t *q_first = q->q_first;
67117c478bd9Sstevel@tonic-gate
67127c478bd9Sstevel@tonic-gate /*
67137c478bd9Sstevel@tonic-gate * Get the next message of appropriate priority
67147c478bd9Sstevel@tonic-gate * from the stream head. If the caller is interested
67157c478bd9Sstevel@tonic-gate * in band or hipri messages, then they should already
67167c478bd9Sstevel@tonic-gate * be enqueued at the stream head. On the other hand
67177c478bd9Sstevel@tonic-gate * if the caller wants normal (band 0) messages, they
67187c478bd9Sstevel@tonic-gate * might be deferred in a synchronous stream and they
67197c478bd9Sstevel@tonic-gate * will need to be pulled up.
67207c478bd9Sstevel@tonic-gate *
67217c478bd9Sstevel@tonic-gate * After we have dequeued a message, we might find that
67227c478bd9Sstevel@tonic-gate * it was a deferred M_SIG that was enqueued at the
67237c478bd9Sstevel@tonic-gate * stream head. It must now be posted as part of the
67247c478bd9Sstevel@tonic-gate * read by calling strsignal_nolock().
67257c478bd9Sstevel@tonic-gate *
67267c478bd9Sstevel@tonic-gate * Also note that strrput does not enqueue an M_PCSIG,
67277c478bd9Sstevel@tonic-gate * and there cannot be more than one hipri message,
67287c478bd9Sstevel@tonic-gate * so there was no need to have the M_PCSIG case.
67297c478bd9Sstevel@tonic-gate *
67307c478bd9Sstevel@tonic-gate * At some time it might be nice to try and wrap the
67317c478bd9Sstevel@tonic-gate * functionality of kstrgetmsg() and strgetmsg() into
67327c478bd9Sstevel@tonic-gate * a common routine so to reduce the amount of replicated
67337c478bd9Sstevel@tonic-gate * code (since they are extremely similar).
67347c478bd9Sstevel@tonic-gate */
67357c478bd9Sstevel@tonic-gate if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) {
67367c478bd9Sstevel@tonic-gate /* Asking for normal, band0 data */
67377c478bd9Sstevel@tonic-gate bp = strget(stp, q, uiop, first, &error);
67387c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
67397c478bd9Sstevel@tonic-gate if (bp != NULL) {
6740a45f3f93Smeem if (DB_TYPE(bp) == M_SIG) {
67417c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr,
6742a45f3f93Smeem bp->b_band);
6743a45f3f93Smeem freemsg(bp);
67447c478bd9Sstevel@tonic-gate continue;
67457c478bd9Sstevel@tonic-gate } else {
67467c478bd9Sstevel@tonic-gate break;
67477c478bd9Sstevel@tonic-gate }
67487c478bd9Sstevel@tonic-gate }
6749a45f3f93Smeem if (error != 0)
67507c478bd9Sstevel@tonic-gate goto getmout;
67517c478bd9Sstevel@tonic-gate
67527c478bd9Sstevel@tonic-gate /*
67537c478bd9Sstevel@tonic-gate * We can't depend on the value of STRPRI here because
67547c478bd9Sstevel@tonic-gate * the stream head may be in transit. Therefore, we
67557c478bd9Sstevel@tonic-gate * must look at the type of the first message to
67567c478bd9Sstevel@tonic-gate * determine if a high priority messages is waiting
67577c478bd9Sstevel@tonic-gate */
67587c478bd9Sstevel@tonic-gate } else if ((*flagsp & MSG_HIPRI) && q_first != NULL &&
6759a45f3f93Smeem DB_TYPE(q_first) >= QPCTL &&
6760301ce41fSja (bp = getq_noenab(q, 0)) != NULL) {
67617c478bd9Sstevel@tonic-gate /* Asked for HIPRI and got one */
6762a45f3f93Smeem ASSERT(DB_TYPE(bp) >= QPCTL);
67637c478bd9Sstevel@tonic-gate break;
67647c478bd9Sstevel@tonic-gate } else if ((*flagsp & MSG_BAND) && q_first != NULL &&
6765a45f3f93Smeem ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
6766301ce41fSja (bp = getq_noenab(q, 0)) != NULL) {
67677c478bd9Sstevel@tonic-gate /*
67687c478bd9Sstevel@tonic-gate * Asked for at least band "prip" and got either at
67697c478bd9Sstevel@tonic-gate * least that band or a hipri message.
67707c478bd9Sstevel@tonic-gate */
6771a45f3f93Smeem ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
6772a45f3f93Smeem if (DB_TYPE(bp) == M_SIG) {
6773a45f3f93Smeem strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
6774a45f3f93Smeem freemsg(bp);
67757c478bd9Sstevel@tonic-gate continue;
67767c478bd9Sstevel@tonic-gate } else {
67777c478bd9Sstevel@tonic-gate break;
67787c478bd9Sstevel@tonic-gate }
67797c478bd9Sstevel@tonic-gate }
67807c478bd9Sstevel@tonic-gate
67817c478bd9Sstevel@tonic-gate /* No data. Time to sleep? */
67827c478bd9Sstevel@tonic-gate qbackenable(q, 0);
67837c478bd9Sstevel@tonic-gate
67847c478bd9Sstevel@tonic-gate /*
67857c478bd9Sstevel@tonic-gate * If STRHUP or STREOF, return 0 length control and data.
67867c478bd9Sstevel@tonic-gate * If resid is 0, then a read(fd,buf,0) was done. Do not
67877c478bd9Sstevel@tonic-gate * sleep to satisfy this request because by default we have
67887c478bd9Sstevel@tonic-gate * zero bytes to return.
67897c478bd9Sstevel@tonic-gate */
67907c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 &&
67917c478bd9Sstevel@tonic-gate mdata->maxlen == 0)) {
67927c478bd9Sstevel@tonic-gate mctl->len = mdata->len = 0;
67937c478bd9Sstevel@tonic-gate *flagsp = 0;
67947c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
67957c478bd9Sstevel@tonic-gate return (0);
67967c478bd9Sstevel@tonic-gate }
67977c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT,
6798d3e55dcdSgww "strgetmsg calls strwaitq:%p, %p",
6799d3e55dcdSgww vp, uiop);
68007c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1,
68017c478bd9Sstevel@tonic-gate &done)) != 0) || done) {
68027c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE,
6803d3e55dcdSgww "strgetmsg error or done:%p, %p",
6804d3e55dcdSgww vp, uiop);
68057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
68067c478bd9Sstevel@tonic-gate return (error);
68077c478bd9Sstevel@tonic-gate }
68087c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE,
6809d3e55dcdSgww "strgetmsg awakes:%p, %p", vp, uiop);
68109acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
68117c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
68129acbbeafSnn return (error);
68137c478bd9Sstevel@tonic-gate }
68147c478bd9Sstevel@tonic-gate first = 0;
68157c478bd9Sstevel@tonic-gate }
68167c478bd9Sstevel@tonic-gate ASSERT(bp != NULL);
68177c478bd9Sstevel@tonic-gate /*
68187c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not completely
68197c478bd9Sstevel@tonic-gate * consumed this information will be put in the mblk
68207c478bd9Sstevel@tonic-gate * that is putback.
68217c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed
68227c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if
68237c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is
68247c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set.
68257c478bd9Sstevel@tonic-gate */
68267c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
68277c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
6828d3e55dcdSgww (MSGMARKNEXT|MSGNOTMARKNEXT));
68297c478bd9Sstevel@tonic-gate if (mark != 0 && bp == stp->sd_mark) {
68307c478bd9Sstevel@tonic-gate mark |= _LASTMARK;
68317c478bd9Sstevel@tonic-gate stp->sd_mark = NULL;
68327c478bd9Sstevel@tonic-gate }
68337c478bd9Sstevel@tonic-gate /*
68347c478bd9Sstevel@tonic-gate * keep track of the original message type and priority
68357c478bd9Sstevel@tonic-gate */
68367c478bd9Sstevel@tonic-gate pri = bp->b_band;
68377c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type;
68387c478bd9Sstevel@tonic-gate if (type == M_PASSFP) {
68397c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
68407c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
68417c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK;
68427c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
68437c478bd9Sstevel@tonic-gate qbackenable(q, pri);
68447c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
68457c478bd9Sstevel@tonic-gate return (EBADMSG);
68467c478bd9Sstevel@tonic-gate }
68477c478bd9Sstevel@tonic-gate ASSERT(type != M_SIG);
68487c478bd9Sstevel@tonic-gate
68497c478bd9Sstevel@tonic-gate /*
68507c478bd9Sstevel@tonic-gate * Set this flag so strrput will not generate signals. Need to
68517c478bd9Sstevel@tonic-gate * make sure this flag is cleared before leaving this routine
68527c478bd9Sstevel@tonic-gate * else signals will stop being sent.
68537c478bd9Sstevel@tonic-gate */
68547c478bd9Sstevel@tonic-gate stp->sd_flag |= STRGETINPROG;
68557c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
68567c478bd9Sstevel@tonic-gate
68577c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
68587c478bd9Sstevel@tonic-gate stream_runservice(stp);
68597c478bd9Sstevel@tonic-gate
68607c478bd9Sstevel@tonic-gate /*
68617c478bd9Sstevel@tonic-gate * Set HIPRI flag if message is priority.
68627c478bd9Sstevel@tonic-gate */
68637c478bd9Sstevel@tonic-gate if (type >= QPCTL)
68647c478bd9Sstevel@tonic-gate flg = MSG_HIPRI;
68657c478bd9Sstevel@tonic-gate else
68667c478bd9Sstevel@tonic-gate flg = MSG_BAND;
68677c478bd9Sstevel@tonic-gate
68687c478bd9Sstevel@tonic-gate /*
68697c478bd9Sstevel@tonic-gate * First process PROTO or PCPROTO blocks, if any.
68707c478bd9Sstevel@tonic-gate */
68717c478bd9Sstevel@tonic-gate if (mctl->maxlen >= 0 && type != M_DATA) {
68727c478bd9Sstevel@tonic-gate size_t n, bcnt;
68737c478bd9Sstevel@tonic-gate char *ubuf;
68747c478bd9Sstevel@tonic-gate
68757c478bd9Sstevel@tonic-gate bcnt = mctl->maxlen;
68767c478bd9Sstevel@tonic-gate ubuf = mctl->buf;
68777c478bd9Sstevel@tonic-gate while (bp != NULL && bp->b_datap->db_type != M_DATA) {
68787c478bd9Sstevel@tonic-gate if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 &&
68797c478bd9Sstevel@tonic-gate copyout(bp->b_rptr, ubuf, n)) {
68807c478bd9Sstevel@tonic-gate error = EFAULT;
68817c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
68827c478bd9Sstevel@tonic-gate /*
68837c478bd9Sstevel@tonic-gate * clear stream head pri flag based on
68847c478bd9Sstevel@tonic-gate * first message type
68857c478bd9Sstevel@tonic-gate */
68867c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
68877c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
68887c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
68897c478bd9Sstevel@tonic-gate }
68907c478bd9Sstevel@tonic-gate more = 0;
68917c478bd9Sstevel@tonic-gate freemsg(bp);
68927c478bd9Sstevel@tonic-gate goto getmout;
68937c478bd9Sstevel@tonic-gate }
68947c478bd9Sstevel@tonic-gate ubuf += n;
68957c478bd9Sstevel@tonic-gate bp->b_rptr += n;
68967c478bd9Sstevel@tonic-gate if (bp->b_rptr >= bp->b_wptr) {
68977c478bd9Sstevel@tonic-gate nbp = bp;
68987c478bd9Sstevel@tonic-gate bp = bp->b_cont;
68997c478bd9Sstevel@tonic-gate freeb(nbp);
69007c478bd9Sstevel@tonic-gate }
69017c478bd9Sstevel@tonic-gate ASSERT(n <= bcnt);
69027c478bd9Sstevel@tonic-gate bcnt -= n;
69037c478bd9Sstevel@tonic-gate if (bcnt == 0)
69047c478bd9Sstevel@tonic-gate break;
69057c478bd9Sstevel@tonic-gate }
69067c478bd9Sstevel@tonic-gate mctl->len = mctl->maxlen - bcnt;
69077c478bd9Sstevel@tonic-gate } else
69087c478bd9Sstevel@tonic-gate mctl->len = -1;
69097c478bd9Sstevel@tonic-gate
69107c478bd9Sstevel@tonic-gate if (bp && bp->b_datap->db_type != M_DATA) {
69117c478bd9Sstevel@tonic-gate /*
69127c478bd9Sstevel@tonic-gate * More PROTO blocks in msg.
69137c478bd9Sstevel@tonic-gate */
69147c478bd9Sstevel@tonic-gate more |= MORECTL;
69157c478bd9Sstevel@tonic-gate savemp = bp;
69167c478bd9Sstevel@tonic-gate while (bp && bp->b_datap->db_type != M_DATA) {
69177c478bd9Sstevel@tonic-gate savemptail = bp;
69187c478bd9Sstevel@tonic-gate bp = bp->b_cont;
69197c478bd9Sstevel@tonic-gate }
69207c478bd9Sstevel@tonic-gate savemptail->b_cont = NULL;
69217c478bd9Sstevel@tonic-gate }
69227c478bd9Sstevel@tonic-gate
69237c478bd9Sstevel@tonic-gate /*
69247c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any.
69257c478bd9Sstevel@tonic-gate */
69267c478bd9Sstevel@tonic-gate if (mdata->maxlen >= 0 && bp) {
69277c478bd9Sstevel@tonic-gate /*
69287c478bd9Sstevel@tonic-gate * struiocopyout will consume a potential zero-length
69297c478bd9Sstevel@tonic-gate * M_DATA even if uio_resid is zero.
69307c478bd9Sstevel@tonic-gate */
69317c478bd9Sstevel@tonic-gate size_t oldresid = uiop->uio_resid;
69327c478bd9Sstevel@tonic-gate
69337c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error);
69347c478bd9Sstevel@tonic-gate if (error != 0) {
69357c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
69367c478bd9Sstevel@tonic-gate /*
69377c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
69387c478bd9Sstevel@tonic-gate * first message
69397c478bd9Sstevel@tonic-gate */
69407c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
69417c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
69427c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
69437c478bd9Sstevel@tonic-gate }
69447c478bd9Sstevel@tonic-gate more = 0;
69457c478bd9Sstevel@tonic-gate freemsg(savemp);
69467c478bd9Sstevel@tonic-gate goto getmout;
69477c478bd9Sstevel@tonic-gate }
69487c478bd9Sstevel@tonic-gate /*
69497c478bd9Sstevel@tonic-gate * (pr == 1) indicates a partial read.
69507c478bd9Sstevel@tonic-gate */
69517c478bd9Sstevel@tonic-gate if (oldresid > uiop->uio_resid)
69527c478bd9Sstevel@tonic-gate pr = 1;
69537c478bd9Sstevel@tonic-gate mdata->len = mdata->maxlen - uiop->uio_resid;
69547c478bd9Sstevel@tonic-gate } else
69557c478bd9Sstevel@tonic-gate mdata->len = -1;
69567c478bd9Sstevel@tonic-gate
69577c478bd9Sstevel@tonic-gate if (bp) { /* more data blocks in msg */
69587c478bd9Sstevel@tonic-gate more |= MOREDATA;
69597c478bd9Sstevel@tonic-gate if (savemp)
69607c478bd9Sstevel@tonic-gate savemptail->b_cont = bp;
69617c478bd9Sstevel@tonic-gate else
69627c478bd9Sstevel@tonic-gate savemp = bp;
69637c478bd9Sstevel@tonic-gate }
69647c478bd9Sstevel@tonic-gate
69657c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
69667c478bd9Sstevel@tonic-gate if (savemp) {
69677c478bd9Sstevel@tonic-gate if (pr && (savemp->b_datap->db_type == M_DATA) &&
69687c478bd9Sstevel@tonic-gate msgnodata(savemp)) {
69697c478bd9Sstevel@tonic-gate /*
69707c478bd9Sstevel@tonic-gate * Avoid queuing a zero-length tail part of
69717c478bd9Sstevel@tonic-gate * a message. pr=1 indicates that we read some of
69727c478bd9Sstevel@tonic-gate * the message.
69737c478bd9Sstevel@tonic-gate */
69747c478bd9Sstevel@tonic-gate freemsg(savemp);
69757c478bd9Sstevel@tonic-gate more &= ~MOREDATA;
69767c478bd9Sstevel@tonic-gate /*
69777c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
69787c478bd9Sstevel@tonic-gate * first message
69797c478bd9Sstevel@tonic-gate */
69807c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
69817c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
69827c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
69837c478bd9Sstevel@tonic-gate }
69847c478bd9Sstevel@tonic-gate } else {
69857c478bd9Sstevel@tonic-gate savemp->b_band = pri;
69867c478bd9Sstevel@tonic-gate /*
69877c478bd9Sstevel@tonic-gate * If the first message was HIPRI and the one we're
69887c478bd9Sstevel@tonic-gate * putting back isn't, then clear STRPRI, otherwise
69897c478bd9Sstevel@tonic-gate * set STRPRI again. Note that we must set STRPRI
69907c478bd9Sstevel@tonic-gate * again since the flush logic in strrput_nondata()
69917c478bd9Sstevel@tonic-gate * may have cleared it while we had sd_lock dropped.
69927c478bd9Sstevel@tonic-gate */
69937c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
69947c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
69957c478bd9Sstevel@tonic-gate if (queclass(savemp) < QPCTL)
69967c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
69977c478bd9Sstevel@tonic-gate else
69987c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI;
69997c478bd9Sstevel@tonic-gate } else if (queclass(savemp) >= QPCTL) {
70007c478bd9Sstevel@tonic-gate /*
70017c478bd9Sstevel@tonic-gate * The first message was not a HIPRI message,
70027c478bd9Sstevel@tonic-gate * but the one we are about to putback is.
70037c478bd9Sstevel@tonic-gate * For simplicitly, we do not allow for HIPRI
70047c478bd9Sstevel@tonic-gate * messages to be embedded in the message
70057c478bd9Sstevel@tonic-gate * body, so just force it to same type as
70067c478bd9Sstevel@tonic-gate * first message.
70077c478bd9Sstevel@tonic-gate */
70087c478bd9Sstevel@tonic-gate ASSERT(type == M_DATA || type == M_PROTO);
70097c478bd9Sstevel@tonic-gate ASSERT(savemp->b_datap->db_type == M_PCPROTO);
70107c478bd9Sstevel@tonic-gate savemp->b_datap->db_type = type;
70117c478bd9Sstevel@tonic-gate }
70127c478bd9Sstevel@tonic-gate if (mark != 0) {
70137c478bd9Sstevel@tonic-gate savemp->b_flag |= mark & ~_LASTMARK;
70147c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) &&
70157c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL)) {
70167c478bd9Sstevel@tonic-gate /*
70177c478bd9Sstevel@tonic-gate * If another marked message arrived
70187c478bd9Sstevel@tonic-gate * while sd_lock was not held sd_mark
70197c478bd9Sstevel@tonic-gate * would be non-NULL.
70207c478bd9Sstevel@tonic-gate */
70217c478bd9Sstevel@tonic-gate stp->sd_mark = savemp;
70227c478bd9Sstevel@tonic-gate }
70237c478bd9Sstevel@tonic-gate }
70247c478bd9Sstevel@tonic-gate putback(stp, q, savemp, pri);
70257c478bd9Sstevel@tonic-gate }
70267c478bd9Sstevel@tonic-gate } else {
70277c478bd9Sstevel@tonic-gate /*
70287c478bd9Sstevel@tonic-gate * The complete message was consumed.
70297c478bd9Sstevel@tonic-gate *
70307c478bd9Sstevel@tonic-gate * If another M_PCPROTO arrived while sd_lock was not held
70317c478bd9Sstevel@tonic-gate * it would have been discarded since STRPRI was still set.
70327c478bd9Sstevel@tonic-gate *
70337c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information
70347c478bd9Sstevel@tonic-gate * to the stream head just in case
70357c478bd9Sstevel@tonic-gate * the read queue becomes empty.
70367c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
70377c478bd9Sstevel@tonic-gate * first message
70387c478bd9Sstevel@tonic-gate *
70397c478bd9Sstevel@tonic-gate * If the stream head was at the mark
70407c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above
70417c478bd9Sstevel@tonic-gate * and some data was consumed then we have
70427c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is
70437c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in
70447c478bd9Sstevel@tonic-gate * strrput during the copyout above causing
70457c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that
70467c478bd9Sstevel@tonic-gate * flag.
70477c478bd9Sstevel@tonic-gate */
70487c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
70497c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
70507c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
70517c478bd9Sstevel@tonic-gate }
70527c478bd9Sstevel@tonic-gate if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
70537c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) {
70547c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK;
70557c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK;
70567c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) {
70577c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
70587c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK;
70597c478bd9Sstevel@tonic-gate } else {
70607c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
70617c478bd9Sstevel@tonic-gate }
70627c478bd9Sstevel@tonic-gate } else if (pr && (old_sd_flag & STRATMARK)) {
70637c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
70647c478bd9Sstevel@tonic-gate }
70657c478bd9Sstevel@tonic-gate }
70667c478bd9Sstevel@tonic-gate
70677c478bd9Sstevel@tonic-gate *flagsp = flg;
70687c478bd9Sstevel@tonic-gate *prip = pri;
70697c478bd9Sstevel@tonic-gate
70707c478bd9Sstevel@tonic-gate /*
70717c478bd9Sstevel@tonic-gate * Getmsg cleanup processing - if the state of the queue has changed
70727c478bd9Sstevel@tonic-gate * some signals may need to be sent and/or poll awakened.
70737c478bd9Sstevel@tonic-gate */
70747c478bd9Sstevel@tonic-gate getmout:
70757c478bd9Sstevel@tonic-gate qbackenable(q, pri);
70767c478bd9Sstevel@tonic-gate
70777c478bd9Sstevel@tonic-gate /*
70787c478bd9Sstevel@tonic-gate * We dropped the stream head lock above. Send all M_SIG messages
70797c478bd9Sstevel@tonic-gate * before processing stream head for SIGPOLL messages.
70807c478bd9Sstevel@tonic-gate */
70817c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
70827c478bd9Sstevel@tonic-gate while ((bp = q->q_first) != NULL &&
70837c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_SIG)) {
70847c478bd9Sstevel@tonic-gate /*
70857c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the read queue can not
70867c478bd9Sstevel@tonic-gate * change.
70877c478bd9Sstevel@tonic-gate */
70887c478bd9Sstevel@tonic-gate bp = getq(q);
70897c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
70907c478bd9Sstevel@tonic-gate
7091a45f3f93Smeem strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
70927c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
70937c478bd9Sstevel@tonic-gate freemsg(bp);
70947c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
70957c478bd9Sstevel@tonic-gate stream_runservice(stp);
70967c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
70977c478bd9Sstevel@tonic-gate }
70987c478bd9Sstevel@tonic-gate
70997c478bd9Sstevel@tonic-gate /*
71007c478bd9Sstevel@tonic-gate * stream head cannot change while we make the determination
71017c478bd9Sstevel@tonic-gate * whether or not to send a signal. Drop the flag to allow strrput
71027c478bd9Sstevel@tonic-gate * to send firstmsgsigs again.
71037c478bd9Sstevel@tonic-gate */
71047c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRGETINPROG;
71057c478bd9Sstevel@tonic-gate
71067c478bd9Sstevel@tonic-gate /*
71077c478bd9Sstevel@tonic-gate * If the type of message at the front of the queue changed
71087c478bd9Sstevel@tonic-gate * due to the receive the appropriate signals and pollwakeup events
71097c478bd9Sstevel@tonic-gate * are generated. The type of changes are:
71107c478bd9Sstevel@tonic-gate * Processed a hipri message, q_first is not hipri.
71117c478bd9Sstevel@tonic-gate * Processed a band X message, and q_first is band Y.
71127c478bd9Sstevel@tonic-gate * The generated signals and pollwakeups are identical to what
71137c478bd9Sstevel@tonic-gate * strrput() generates should the message that is now on q_first
71147c478bd9Sstevel@tonic-gate * arrive to an empty read queue.
71157c478bd9Sstevel@tonic-gate *
71167c478bd9Sstevel@tonic-gate * Note: only strrput will send a signal for a hipri message.
71177c478bd9Sstevel@tonic-gate */
71187c478bd9Sstevel@tonic-gate if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
71197c478bd9Sstevel@tonic-gate strsigset_t signals = 0;
71207c478bd9Sstevel@tonic-gate strpollset_t pollwakeups = 0;
71217c478bd9Sstevel@tonic-gate
71227c478bd9Sstevel@tonic-gate if (flg & MSG_HIPRI) {
71237c478bd9Sstevel@tonic-gate /*
71247c478bd9Sstevel@tonic-gate * Removed a hipri message. Regular data at
71257c478bd9Sstevel@tonic-gate * the front of the queue.
71267c478bd9Sstevel@tonic-gate */
71277c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
71287c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDNORM;
71297c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
71307c478bd9Sstevel@tonic-gate } else {
71317c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDBAND;
71327c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
71337c478bd9Sstevel@tonic-gate }
71347c478bd9Sstevel@tonic-gate } else if (pri != bp->b_band) {
71357c478bd9Sstevel@tonic-gate /*
71367c478bd9Sstevel@tonic-gate * The band is different for the new q_first.
71377c478bd9Sstevel@tonic-gate */
71387c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
71397c478bd9Sstevel@tonic-gate signals = S_RDNORM;
71407c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
71417c478bd9Sstevel@tonic-gate } else {
71427c478bd9Sstevel@tonic-gate signals = S_RDBAND;
71437c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
71447c478bd9Sstevel@tonic-gate }
71457c478bd9Sstevel@tonic-gate }
71467c478bd9Sstevel@tonic-gate
71477c478bd9Sstevel@tonic-gate if (pollwakeups != 0) {
71487c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) {
71497c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN))
71507c478bd9Sstevel@tonic-gate goto no_pollwake;
71517c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN;
71527c478bd9Sstevel@tonic-gate }
71537c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
71547c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups);
71557c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
71567c478bd9Sstevel@tonic-gate }
71577c478bd9Sstevel@tonic-gate no_pollwake:
71587c478bd9Sstevel@tonic-gate
71597c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals)
71607c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
71617c478bd9Sstevel@tonic-gate }
71627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
71637c478bd9Sstevel@tonic-gate
71647c478bd9Sstevel@tonic-gate rvp->r_val1 = more;
71657c478bd9Sstevel@tonic-gate return (error);
71667c478bd9Sstevel@tonic-gate #undef _LASTMARK
71677c478bd9Sstevel@tonic-gate }
71687c478bd9Sstevel@tonic-gate
71697c478bd9Sstevel@tonic-gate /*
71707c478bd9Sstevel@tonic-gate * Get the next message from the read queue. If the message is
71717c478bd9Sstevel@tonic-gate * priority, STRPRI will have been set by strrput(). This flag
71727c478bd9Sstevel@tonic-gate * should be reset only when the entire message at the front of the
71737c478bd9Sstevel@tonic-gate * queue as been consumed.
71747c478bd9Sstevel@tonic-gate *
71757c478bd9Sstevel@tonic-gate * If uiop is NULL all data is returned in mctlp.
71767c478bd9Sstevel@tonic-gate * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed
71777c478bd9Sstevel@tonic-gate * not enabled.
71787c478bd9Sstevel@tonic-gate * The timeout parameter is in milliseconds; -1 for infinity.
71797c478bd9Sstevel@tonic-gate * This routine handles the consolidation private flags:
71807c478bd9Sstevel@tonic-gate * MSG_IGNERROR Ignore any stream head error except STPLEX.
71817c478bd9Sstevel@tonic-gate * MSG_DELAYERROR Defer the error check until the queue is empty.
71827c478bd9Sstevel@tonic-gate * MSG_HOLDSIG Hold signals while waiting for data.
71837c478bd9Sstevel@tonic-gate * MSG_IPEEK Only peek at messages.
71847c478bd9Sstevel@tonic-gate * MSG_DISCARDTAIL Discard the tail M_DATA part of the message
71857c478bd9Sstevel@tonic-gate * that doesn't fit.
71867c478bd9Sstevel@tonic-gate * MSG_NOMARK If the message is marked leave it on the queue.
71877c478bd9Sstevel@tonic-gate *
71887c478bd9Sstevel@tonic-gate * NOTE: strgetmsg and kstrgetmsg have much of the logic in common.
71897c478bd9Sstevel@tonic-gate */
71907c478bd9Sstevel@tonic-gate int
kstrgetmsg(struct vnode * vp,mblk_t ** mctlp,struct uio * uiop,unsigned char * prip,int * flagsp,clock_t timout,rval_t * rvp)71917c478bd9Sstevel@tonic-gate kstrgetmsg(
71927c478bd9Sstevel@tonic-gate struct vnode *vp,
71937c478bd9Sstevel@tonic-gate mblk_t **mctlp,
71947c478bd9Sstevel@tonic-gate struct uio *uiop,
71957c478bd9Sstevel@tonic-gate unsigned char *prip,
71967c478bd9Sstevel@tonic-gate int *flagsp,
71977c478bd9Sstevel@tonic-gate clock_t timout,
71987c478bd9Sstevel@tonic-gate rval_t *rvp)
71997c478bd9Sstevel@tonic-gate {
72007c478bd9Sstevel@tonic-gate struct stdata *stp;
72017c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp;
72027c478bd9Sstevel@tonic-gate mblk_t *savemp = NULL;
72037c478bd9Sstevel@tonic-gate mblk_t *savemptail = NULL;
72047c478bd9Sstevel@tonic-gate int flags;
72057c478bd9Sstevel@tonic-gate uint_t old_sd_flag;
7206c6f039c7SToomas Soome int flg = MSG_BAND;
72077c478bd9Sstevel@tonic-gate int more = 0;
72087c478bd9Sstevel@tonic-gate int error = 0;
72097c478bd9Sstevel@tonic-gate char first = 1;
72107c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */
72117c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */
72127c478bd9Sstevel@tonic-gate unsigned char pri = 0;
72137c478bd9Sstevel@tonic-gate queue_t *q;
72147c478bd9Sstevel@tonic-gate int pr = 0; /* Partial read successful */
72157c478bd9Sstevel@tonic-gate unsigned char type;
72167c478bd9Sstevel@tonic-gate
72177c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER,
7218d3e55dcdSgww "kstrgetmsg:%p", vp);
72197c478bd9Sstevel@tonic-gate
72207c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
72217c478bd9Sstevel@tonic-gate stp = vp->v_stream;
72227c478bd9Sstevel@tonic-gate rvp->r_val1 = 0;
72237c478bd9Sstevel@tonic-gate
72249acbbeafSnn mutex_enter(&stp->sd_lock);
72259acbbeafSnn
72269acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
72279acbbeafSnn mutex_exit(&stp->sd_lock);
72289acbbeafSnn return (error);
72299acbbeafSnn }
72307c478bd9Sstevel@tonic-gate
72317c478bd9Sstevel@tonic-gate flags = *flagsp;
72327c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) {
72337c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STPLEX) ||
72347c478bd9Sstevel@tonic-gate (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) {
72357c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX,
7236d3e55dcdSgww (flags & MSG_IPEEK));
72379acbbeafSnn if (error != 0) {
72389acbbeafSnn mutex_exit(&stp->sd_lock);
72397c478bd9Sstevel@tonic-gate return (error);
72409acbbeafSnn }
72417c478bd9Sstevel@tonic-gate }
72427c478bd9Sstevel@tonic-gate }
72439acbbeafSnn mutex_exit(&stp->sd_lock);
72447c478bd9Sstevel@tonic-gate
72457c478bd9Sstevel@tonic-gate switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) {
72467c478bd9Sstevel@tonic-gate case MSG_HIPRI:
72477c478bd9Sstevel@tonic-gate if (*prip != 0)
72487c478bd9Sstevel@tonic-gate return (EINVAL);
72497c478bd9Sstevel@tonic-gate break;
72507c478bd9Sstevel@tonic-gate
72517c478bd9Sstevel@tonic-gate case MSG_ANY:
72527c478bd9Sstevel@tonic-gate case MSG_BAND:
72537c478bd9Sstevel@tonic-gate break;
72547c478bd9Sstevel@tonic-gate
72557c478bd9Sstevel@tonic-gate default:
72567c478bd9Sstevel@tonic-gate return (EINVAL);
72577c478bd9Sstevel@tonic-gate }
72587c478bd9Sstevel@tonic-gate
72597c478bd9Sstevel@tonic-gate retry:
72607c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq);
72617c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
72627c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag;
72637c478bd9Sstevel@tonic-gate mark = 0;
72647c478bd9Sstevel@tonic-gate for (;;) {
72657c478bd9Sstevel@tonic-gate int done = 0;
72667c478bd9Sstevel@tonic-gate int waitflag;
72677c478bd9Sstevel@tonic-gate int fmode;
72687c478bd9Sstevel@tonic-gate mblk_t *q_first = q->q_first;
72697c478bd9Sstevel@tonic-gate
72707c478bd9Sstevel@tonic-gate /*
72717c478bd9Sstevel@tonic-gate * This section of the code operates just like the code
72727c478bd9Sstevel@tonic-gate * in strgetmsg(). There is a comment there about what
72737c478bd9Sstevel@tonic-gate * is going on here.
72747c478bd9Sstevel@tonic-gate */
72757c478bd9Sstevel@tonic-gate if (!(flags & (MSG_HIPRI|MSG_BAND))) {
72767c478bd9Sstevel@tonic-gate /* Asking for normal, band0 data */
72777c478bd9Sstevel@tonic-gate bp = strget(stp, q, uiop, first, &error);
72787c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
72797c478bd9Sstevel@tonic-gate if (bp != NULL) {
7280a45f3f93Smeem if (DB_TYPE(bp) == M_SIG) {
72817c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr,
7282a45f3f93Smeem bp->b_band);
7283a45f3f93Smeem freemsg(bp);
72847c478bd9Sstevel@tonic-gate continue;
72857c478bd9Sstevel@tonic-gate } else {
72867c478bd9Sstevel@tonic-gate break;
72877c478bd9Sstevel@tonic-gate }
72887c478bd9Sstevel@tonic-gate }
72897c478bd9Sstevel@tonic-gate if (error != 0) {
72907c478bd9Sstevel@tonic-gate goto getmout;
72917c478bd9Sstevel@tonic-gate }
72927c478bd9Sstevel@tonic-gate /*
72937c478bd9Sstevel@tonic-gate * We can't depend on the value of STRPRI here because
72947c478bd9Sstevel@tonic-gate * the stream head may be in transit. Therefore, we
72957c478bd9Sstevel@tonic-gate * must look at the type of the first message to
72967c478bd9Sstevel@tonic-gate * determine if a high priority messages is waiting
72977c478bd9Sstevel@tonic-gate */
72987c478bd9Sstevel@tonic-gate } else if ((flags & MSG_HIPRI) && q_first != NULL &&
7299a45f3f93Smeem DB_TYPE(q_first) >= QPCTL &&
7300301ce41fSja (bp = getq_noenab(q, 0)) != NULL) {
7301a45f3f93Smeem ASSERT(DB_TYPE(bp) >= QPCTL);
73027c478bd9Sstevel@tonic-gate break;
73037c478bd9Sstevel@tonic-gate } else if ((flags & MSG_BAND) && q_first != NULL &&
7304a45f3f93Smeem ((q_first->b_band >= *prip) || DB_TYPE(q_first) >= QPCTL) &&
7305301ce41fSja (bp = getq_noenab(q, 0)) != NULL) {
73067c478bd9Sstevel@tonic-gate /*
73077c478bd9Sstevel@tonic-gate * Asked for at least band "prip" and got either at
73087c478bd9Sstevel@tonic-gate * least that band or a hipri message.
73097c478bd9Sstevel@tonic-gate */
7310a45f3f93Smeem ASSERT(bp->b_band >= *prip || DB_TYPE(bp) >= QPCTL);
7311a45f3f93Smeem if (DB_TYPE(bp) == M_SIG) {
7312a45f3f93Smeem strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
7313a45f3f93Smeem freemsg(bp);
73147c478bd9Sstevel@tonic-gate continue;
73157c478bd9Sstevel@tonic-gate } else {
73167c478bd9Sstevel@tonic-gate break;
73177c478bd9Sstevel@tonic-gate }
73187c478bd9Sstevel@tonic-gate }
73197c478bd9Sstevel@tonic-gate
73207c478bd9Sstevel@tonic-gate /* No data. Time to sleep? */
73217c478bd9Sstevel@tonic-gate qbackenable(q, 0);
73227c478bd9Sstevel@tonic-gate
73237c478bd9Sstevel@tonic-gate /*
73247c478bd9Sstevel@tonic-gate * Delayed error notification?
73257c478bd9Sstevel@tonic-gate */
73267c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRDERR|STPLEX)) &&
73277c478bd9Sstevel@tonic-gate (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) {
73287c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX,
7329d3e55dcdSgww (flags & MSG_IPEEK));
73307c478bd9Sstevel@tonic-gate if (error != 0) {
73317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
73327c478bd9Sstevel@tonic-gate return (error);
73337c478bd9Sstevel@tonic-gate }
73347c478bd9Sstevel@tonic-gate }
73357c478bd9Sstevel@tonic-gate
73367c478bd9Sstevel@tonic-gate /*
73377c478bd9Sstevel@tonic-gate * If STRHUP or STREOF, return 0 length control and data.
73387c478bd9Sstevel@tonic-gate * If a read(fd,buf,0) has been done, do not sleep, just
73397c478bd9Sstevel@tonic-gate * return.
73407c478bd9Sstevel@tonic-gate *
73417c478bd9Sstevel@tonic-gate * If mctlp == NULL and uiop == NULL, then the code will
73427c478bd9Sstevel@tonic-gate * do the strwaitq. This is an understood way of saying
73437c478bd9Sstevel@tonic-gate * sleep "polling" until a message is received.
73447c478bd9Sstevel@tonic-gate */
73457c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRHUP|STREOF)) ||
73467c478bd9Sstevel@tonic-gate (uiop != NULL && uiop->uio_resid == 0)) {
73477c478bd9Sstevel@tonic-gate if (mctlp != NULL)
73487c478bd9Sstevel@tonic-gate *mctlp = NULL;
73497c478bd9Sstevel@tonic-gate *flagsp = 0;
73507c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
73517c478bd9Sstevel@tonic-gate return (0);
73527c478bd9Sstevel@tonic-gate }
73537c478bd9Sstevel@tonic-gate
73547c478bd9Sstevel@tonic-gate waitflag = GETWAIT;
73557c478bd9Sstevel@tonic-gate if (flags &
73567c478bd9Sstevel@tonic-gate (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) {
73577c478bd9Sstevel@tonic-gate if (flags & MSG_HOLDSIG)
73587c478bd9Sstevel@tonic-gate waitflag |= STR_NOSIG;
73597c478bd9Sstevel@tonic-gate if (flags & MSG_IGNERROR)
73607c478bd9Sstevel@tonic-gate waitflag |= STR_NOERROR;
73617c478bd9Sstevel@tonic-gate if (flags & MSG_IPEEK)
73627c478bd9Sstevel@tonic-gate waitflag |= STR_PEEK;
73637c478bd9Sstevel@tonic-gate if (flags & MSG_DELAYERROR)
73647c478bd9Sstevel@tonic-gate waitflag |= STR_DELAYERR;
73657c478bd9Sstevel@tonic-gate }
73667c478bd9Sstevel@tonic-gate if (uiop != NULL)
73677c478bd9Sstevel@tonic-gate fmode = uiop->uio_fmode;
73687c478bd9Sstevel@tonic-gate else
73697c478bd9Sstevel@tonic-gate fmode = 0;
73707c478bd9Sstevel@tonic-gate
73717c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT,
7372d3e55dcdSgww "kstrgetmsg calls strwaitq:%p, %p",
7373d3e55dcdSgww vp, uiop);
73747c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, waitflag, (ssize_t)0,
737517169044Sbrutus fmode, timout, &done))) != 0 || done) {
73767c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE,
7377d3e55dcdSgww "kstrgetmsg error or done:%p, %p",
7378d3e55dcdSgww vp, uiop);
73797c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
73807c478bd9Sstevel@tonic-gate return (error);
73817c478bd9Sstevel@tonic-gate }
73827c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE,
7383d3e55dcdSgww "kstrgetmsg awakes:%p, %p", vp, uiop);
73849acbbeafSnn if ((error = i_straccess(stp, JCREAD)) != 0) {
73857c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
73869acbbeafSnn return (error);
73877c478bd9Sstevel@tonic-gate }
73887c478bd9Sstevel@tonic-gate first = 0;
73897c478bd9Sstevel@tonic-gate }
73907c478bd9Sstevel@tonic-gate ASSERT(bp != NULL);
73917c478bd9Sstevel@tonic-gate /*
73927c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not completely
73937c478bd9Sstevel@tonic-gate * consumed this information will be put in the mblk
73947c478bd9Sstevel@tonic-gate * that is putback.
73957c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed
73967c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if
73977c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is
73987c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set.
73997c478bd9Sstevel@tonic-gate */
74007c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT);
74017c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
7402d3e55dcdSgww (MSGMARKNEXT|MSGNOTMARKNEXT));
74037c478bd9Sstevel@tonic-gate pri = bp->b_band;
74047c478bd9Sstevel@tonic-gate if (mark != 0) {
74057c478bd9Sstevel@tonic-gate /*
74067c478bd9Sstevel@tonic-gate * If the caller doesn't want the mark return.
74077c478bd9Sstevel@tonic-gate * Used to implement MSG_WAITALL in sockets.
74087c478bd9Sstevel@tonic-gate */
74097c478bd9Sstevel@tonic-gate if (flags & MSG_NOMARK) {
74107c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
74117c478bd9Sstevel@tonic-gate qbackenable(q, pri);
74127c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
74137c478bd9Sstevel@tonic-gate return (EWOULDBLOCK);
74147c478bd9Sstevel@tonic-gate }
74157c478bd9Sstevel@tonic-gate if (bp == stp->sd_mark) {
74167c478bd9Sstevel@tonic-gate mark |= _LASTMARK;
74177c478bd9Sstevel@tonic-gate stp->sd_mark = NULL;
74187c478bd9Sstevel@tonic-gate }
74197c478bd9Sstevel@tonic-gate }
74207c478bd9Sstevel@tonic-gate
74217c478bd9Sstevel@tonic-gate /*
74227c478bd9Sstevel@tonic-gate * keep track of the first message type
74237c478bd9Sstevel@tonic-gate */
74247c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type;
74257c478bd9Sstevel@tonic-gate
74267c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_PASSFP) {
74277c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
74287c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
74297c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK;
74307c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
74317c478bd9Sstevel@tonic-gate qbackenable(q, pri);
74327c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
74337c478bd9Sstevel@tonic-gate return (EBADMSG);
74347c478bd9Sstevel@tonic-gate }
74357c478bd9Sstevel@tonic-gate ASSERT(type != M_SIG);
74367c478bd9Sstevel@tonic-gate
74377c478bd9Sstevel@tonic-gate if (flags & MSG_IPEEK) {
74387c478bd9Sstevel@tonic-gate /*
74397c478bd9Sstevel@tonic-gate * Clear any struioflag - we do the uiomove over again
74407c478bd9Sstevel@tonic-gate * when peeking since it simplifies the code.
74417c478bd9Sstevel@tonic-gate *
74427c478bd9Sstevel@tonic-gate * Dup the message and put the original back on the queue.
74437c478bd9Sstevel@tonic-gate * If dupmsg() fails, try again with copymsg() to see if
74447c478bd9Sstevel@tonic-gate * there is indeed a shortage of memory. dupmsg() may fail
74457c478bd9Sstevel@tonic-gate * if db_ref in any of the messages reaches its limit.
74467c478bd9Sstevel@tonic-gate */
744717169044Sbrutus
74487c478bd9Sstevel@tonic-gate if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) {
74497c478bd9Sstevel@tonic-gate /*
74507c478bd9Sstevel@tonic-gate * Restore the state of the stream head since we
74517c478bd9Sstevel@tonic-gate * need to drop sd_lock (strwaitbuf is sleeping).
74527c478bd9Sstevel@tonic-gate */
74537c478bd9Sstevel@tonic-gate size_t size = msgdsize(bp);
74547c478bd9Sstevel@tonic-gate
74557c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
74567c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
74577c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK;
74587c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
74597c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
74607c478bd9Sstevel@tonic-gate error = strwaitbuf(size, BPRI_HI);
74617c478bd9Sstevel@tonic-gate if (error) {
74627c478bd9Sstevel@tonic-gate /*
74637c478bd9Sstevel@tonic-gate * There is no net change to the queue thus
74647c478bd9Sstevel@tonic-gate * no need to qbackenable.
74657c478bd9Sstevel@tonic-gate */
74667c478bd9Sstevel@tonic-gate return (error);
74677c478bd9Sstevel@tonic-gate }
74687c478bd9Sstevel@tonic-gate goto retry;
74697c478bd9Sstevel@tonic-gate }
74707c478bd9Sstevel@tonic-gate
74717c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL))
74727c478bd9Sstevel@tonic-gate stp->sd_mark = bp;
74737c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK;
74747c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri);
74757c478bd9Sstevel@tonic-gate bp = nbp;
74767c478bd9Sstevel@tonic-gate }
74777c478bd9Sstevel@tonic-gate
74787c478bd9Sstevel@tonic-gate /*
74797c478bd9Sstevel@tonic-gate * Set this flag so strrput will not generate signals. Need to
74807c478bd9Sstevel@tonic-gate * make sure this flag is cleared before leaving this routine
74817c478bd9Sstevel@tonic-gate * else signals will stop being sent.
74827c478bd9Sstevel@tonic-gate */
74837c478bd9Sstevel@tonic-gate stp->sd_flag |= STRGETINPROG;
74847c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
74857c478bd9Sstevel@tonic-gate
748651dd2c77Svk if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA)) {
748751dd2c77Svk mblk_t *tmp, *prevmp;
7488c28749e9Skais
748951dd2c77Svk /*
749051dd2c77Svk * Put first non-data mblk back to stream head and
749151dd2c77Svk * cut the mblk chain so sd_rputdatafunc only sees
749251dd2c77Svk * M_DATA mblks. We can skip the first mblk since it
749351dd2c77Svk * is M_DATA according to the condition above.
749451dd2c77Svk */
749551dd2c77Svk for (prevmp = bp, tmp = bp->b_cont; tmp != NULL;
749651dd2c77Svk prevmp = tmp, tmp = tmp->b_cont) {
749751dd2c77Svk if (DB_TYPE(tmp) != M_DATA) {
749851dd2c77Svk prevmp->b_cont = NULL;
749951dd2c77Svk mutex_enter(&stp->sd_lock);
750051dd2c77Svk putback(stp, q, tmp, tmp->b_band);
750151dd2c77Svk mutex_exit(&stp->sd_lock);
750251dd2c77Svk break;
750351dd2c77Svk }
750451dd2c77Svk }
750551dd2c77Svk
750651dd2c77Svk bp = (stp->sd_rputdatafunc)(stp->sd_vnode, bp,
750751dd2c77Svk NULL, NULL, NULL, NULL);
7508c28749e9Skais
7509c28749e9Skais if (bp == NULL)
7510c28749e9Skais goto retry;
7511c28749e9Skais }
7512c28749e9Skais
75137c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
75147c478bd9Sstevel@tonic-gate stream_runservice(stp);
75157c478bd9Sstevel@tonic-gate
75167c478bd9Sstevel@tonic-gate /*
75177c478bd9Sstevel@tonic-gate * Set HIPRI flag if message is priority.
75187c478bd9Sstevel@tonic-gate */
75197c478bd9Sstevel@tonic-gate if (type >= QPCTL)
75207c478bd9Sstevel@tonic-gate flg = MSG_HIPRI;
75217c478bd9Sstevel@tonic-gate else
75227c478bd9Sstevel@tonic-gate flg = MSG_BAND;
75237c478bd9Sstevel@tonic-gate
75247c478bd9Sstevel@tonic-gate /*
75257c478bd9Sstevel@tonic-gate * First process PROTO or PCPROTO blocks, if any.
75267c478bd9Sstevel@tonic-gate */
75277c478bd9Sstevel@tonic-gate if (mctlp != NULL && type != M_DATA) {
75287c478bd9Sstevel@tonic-gate mblk_t *nbp;
75297c478bd9Sstevel@tonic-gate
75307c478bd9Sstevel@tonic-gate *mctlp = bp;
75317c478bd9Sstevel@tonic-gate while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA)
75327c478bd9Sstevel@tonic-gate bp = bp->b_cont;
75337c478bd9Sstevel@tonic-gate nbp = bp->b_cont;
75347c478bd9Sstevel@tonic-gate bp->b_cont = NULL;
75357c478bd9Sstevel@tonic-gate bp = nbp;
75367c478bd9Sstevel@tonic-gate }
75377c478bd9Sstevel@tonic-gate
75387c478bd9Sstevel@tonic-gate if (bp && bp->b_datap->db_type != M_DATA) {
75397c478bd9Sstevel@tonic-gate /*
75407c478bd9Sstevel@tonic-gate * More PROTO blocks in msg. Will only happen if mctlp is NULL.
75417c478bd9Sstevel@tonic-gate */
75427c478bd9Sstevel@tonic-gate more |= MORECTL;
75437c478bd9Sstevel@tonic-gate savemp = bp;
75447c478bd9Sstevel@tonic-gate while (bp && bp->b_datap->db_type != M_DATA) {
75457c478bd9Sstevel@tonic-gate savemptail = bp;
75467c478bd9Sstevel@tonic-gate bp = bp->b_cont;
75477c478bd9Sstevel@tonic-gate }
75487c478bd9Sstevel@tonic-gate savemptail->b_cont = NULL;
75497c478bd9Sstevel@tonic-gate }
75507c478bd9Sstevel@tonic-gate
75517c478bd9Sstevel@tonic-gate /*
75527c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any.
75537c478bd9Sstevel@tonic-gate */
75547c478bd9Sstevel@tonic-gate if (uiop == NULL) {
75557c478bd9Sstevel@tonic-gate /* Append data to tail of mctlp */
755617169044Sbrutus
75577c478bd9Sstevel@tonic-gate if (mctlp != NULL) {
75587c478bd9Sstevel@tonic-gate mblk_t **mpp = mctlp;
75597c478bd9Sstevel@tonic-gate
75607c478bd9Sstevel@tonic-gate while (*mpp != NULL)
75617c478bd9Sstevel@tonic-gate mpp = &((*mpp)->b_cont);
75627c478bd9Sstevel@tonic-gate *mpp = bp;
75637c478bd9Sstevel@tonic-gate bp = NULL;
75647c478bd9Sstevel@tonic-gate }
75657c478bd9Sstevel@tonic-gate } else if (uiop->uio_resid >= 0 && bp) {
75667c478bd9Sstevel@tonic-gate size_t oldresid = uiop->uio_resid;
75677c478bd9Sstevel@tonic-gate
75687c478bd9Sstevel@tonic-gate /*
75697c478bd9Sstevel@tonic-gate * If a streams message is likely to consist
75707c478bd9Sstevel@tonic-gate * of many small mblks, it is pulled up into
75717c478bd9Sstevel@tonic-gate * one continuous chunk of memory.
757294e7edb1Slucy wang - Sun Microsystems - Beijing China * The size of the first mblk may be bogus because
757394e7edb1Slucy wang - Sun Microsystems - Beijing China * successive read() calls on the socket reduce
757494e7edb1Slucy wang - Sun Microsystems - Beijing China * the size of this mblk until it is exhausted
757594e7edb1Slucy wang - Sun Microsystems - Beijing China * and then the code walks on to the next. Thus
757694e7edb1Slucy wang - Sun Microsystems - Beijing China * the size of the mblk may not be the original size
757794e7edb1Slucy wang - Sun Microsystems - Beijing China * that was passed up, it's simply a remainder
757894e7edb1Slucy wang - Sun Microsystems - Beijing China * and hence can be very small without any
757994e7edb1Slucy wang - Sun Microsystems - Beijing China * implication that the packet is badly fragmented.
758094e7edb1Slucy wang - Sun Microsystems - Beijing China * So the size of the possible second mblk is
758194e7edb1Slucy wang - Sun Microsystems - Beijing China * used to spot a badly fragmented packet.
75827c478bd9Sstevel@tonic-gate * see longer comment at top of page
75837c478bd9Sstevel@tonic-gate * by mblk_pull_len declaration.
75847c478bd9Sstevel@tonic-gate */
75857c478bd9Sstevel@tonic-gate
758694e7edb1Slucy wang - Sun Microsystems - Beijing China if (bp->b_cont != NULL && MBLKL(bp->b_cont) < mblk_pull_len) {
75877c478bd9Sstevel@tonic-gate (void) pullupmsg(bp, -1);
75887c478bd9Sstevel@tonic-gate }
75897c478bd9Sstevel@tonic-gate
75907c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error);
75917c478bd9Sstevel@tonic-gate if (error != 0) {
75927c478bd9Sstevel@tonic-gate if (mctlp != NULL) {
75937c478bd9Sstevel@tonic-gate freemsg(*mctlp);
75947c478bd9Sstevel@tonic-gate *mctlp = NULL;
75957c478bd9Sstevel@tonic-gate } else
75967c478bd9Sstevel@tonic-gate freemsg(savemp);
75977c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
75987c478bd9Sstevel@tonic-gate /*
75997c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
76007c478bd9Sstevel@tonic-gate * first message
76017c478bd9Sstevel@tonic-gate */
76027c478bd9Sstevel@tonic-gate if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
76037c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
76047c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
76057c478bd9Sstevel@tonic-gate }
76067c478bd9Sstevel@tonic-gate more = 0;
76077c478bd9Sstevel@tonic-gate goto getmout;
76087c478bd9Sstevel@tonic-gate }
76097c478bd9Sstevel@tonic-gate /*
76107c478bd9Sstevel@tonic-gate * (pr == 1) indicates a partial read.
76117c478bd9Sstevel@tonic-gate */
76127c478bd9Sstevel@tonic-gate if (oldresid > uiop->uio_resid)
76137c478bd9Sstevel@tonic-gate pr = 1;
76147c478bd9Sstevel@tonic-gate }
76157c478bd9Sstevel@tonic-gate
76167c478bd9Sstevel@tonic-gate if (bp) { /* more data blocks in msg */
76177c478bd9Sstevel@tonic-gate more |= MOREDATA;
76187c478bd9Sstevel@tonic-gate if (savemp)
76197c478bd9Sstevel@tonic-gate savemptail->b_cont = bp;
76207c478bd9Sstevel@tonic-gate else
76217c478bd9Sstevel@tonic-gate savemp = bp;
76227c478bd9Sstevel@tonic-gate }
76237c478bd9Sstevel@tonic-gate
76247c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
76257c478bd9Sstevel@tonic-gate if (savemp) {
76267c478bd9Sstevel@tonic-gate if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) {
76277c478bd9Sstevel@tonic-gate /*
76287c478bd9Sstevel@tonic-gate * When MSG_DISCARDTAIL is set or
76297c478bd9Sstevel@tonic-gate * when peeking discard any tail. When peeking this
76307c478bd9Sstevel@tonic-gate * is the tail of the dup that was copied out - the
76317c478bd9Sstevel@tonic-gate * message has already been putback on the queue.
76327c478bd9Sstevel@tonic-gate * Return MOREDATA to the caller even though the data
76337c478bd9Sstevel@tonic-gate * is discarded. This is used by sockets (to
76347c478bd9Sstevel@tonic-gate * set MSG_TRUNC).
76357c478bd9Sstevel@tonic-gate */
76367c478bd9Sstevel@tonic-gate freemsg(savemp);
76377c478bd9Sstevel@tonic-gate if (!(flags & MSG_IPEEK) && (type >= QPCTL)) {
76387c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
76397c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
76407c478bd9Sstevel@tonic-gate }
76417c478bd9Sstevel@tonic-gate } else if (pr && (savemp->b_datap->db_type == M_DATA) &&
7642d3e55dcdSgww msgnodata(savemp)) {
76437c478bd9Sstevel@tonic-gate /*
76447c478bd9Sstevel@tonic-gate * Avoid queuing a zero-length tail part of
76457c478bd9Sstevel@tonic-gate * a message. pr=1 indicates that we read some of
76467c478bd9Sstevel@tonic-gate * the message.
76477c478bd9Sstevel@tonic-gate */
76487c478bd9Sstevel@tonic-gate freemsg(savemp);
76497c478bd9Sstevel@tonic-gate more &= ~MOREDATA;
76507c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
76517c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
76527c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
76537c478bd9Sstevel@tonic-gate }
76547c478bd9Sstevel@tonic-gate } else {
76557c478bd9Sstevel@tonic-gate savemp->b_band = pri;
76567c478bd9Sstevel@tonic-gate /*
76577c478bd9Sstevel@tonic-gate * If the first message was HIPRI and the one we're
76587c478bd9Sstevel@tonic-gate * putting back isn't, then clear STRPRI, otherwise
76597c478bd9Sstevel@tonic-gate * set STRPRI again. Note that we must set STRPRI
76607c478bd9Sstevel@tonic-gate * again since the flush logic in strrput_nondata()
76617c478bd9Sstevel@tonic-gate * may have cleared it while we had sd_lock dropped.
76627c478bd9Sstevel@tonic-gate */
766317169044Sbrutus
76647c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
76657c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
76667c478bd9Sstevel@tonic-gate if (queclass(savemp) < QPCTL)
76677c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
76687c478bd9Sstevel@tonic-gate else
76697c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI;
76707c478bd9Sstevel@tonic-gate } else if (queclass(savemp) >= QPCTL) {
76717c478bd9Sstevel@tonic-gate /*
76727c478bd9Sstevel@tonic-gate * The first message was not a HIPRI message,
76737c478bd9Sstevel@tonic-gate * but the one we are about to putback is.
76747c478bd9Sstevel@tonic-gate * For simplicitly, we do not allow for HIPRI
76757c478bd9Sstevel@tonic-gate * messages to be embedded in the message
76767c478bd9Sstevel@tonic-gate * body, so just force it to same type as
76777c478bd9Sstevel@tonic-gate * first message.
76787c478bd9Sstevel@tonic-gate */
76797c478bd9Sstevel@tonic-gate ASSERT(type == M_DATA || type == M_PROTO);
76807c478bd9Sstevel@tonic-gate ASSERT(savemp->b_datap->db_type == M_PCPROTO);
76817c478bd9Sstevel@tonic-gate savemp->b_datap->db_type = type;
76827c478bd9Sstevel@tonic-gate }
76837c478bd9Sstevel@tonic-gate if (mark != 0) {
76847c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) &&
76857c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL)) {
76867c478bd9Sstevel@tonic-gate /*
76877c478bd9Sstevel@tonic-gate * If another marked message arrived
76887c478bd9Sstevel@tonic-gate * while sd_lock was not held sd_mark
76897c478bd9Sstevel@tonic-gate * would be non-NULL.
76907c478bd9Sstevel@tonic-gate */
76917c478bd9Sstevel@tonic-gate stp->sd_mark = savemp;
76927c478bd9Sstevel@tonic-gate }
76937c478bd9Sstevel@tonic-gate savemp->b_flag |= mark & ~_LASTMARK;
76947c478bd9Sstevel@tonic-gate }
76957c478bd9Sstevel@tonic-gate putback(stp, q, savemp, pri);
76967c478bd9Sstevel@tonic-gate }
76977c478bd9Sstevel@tonic-gate } else if (!(flags & MSG_IPEEK)) {
76987c478bd9Sstevel@tonic-gate /*
76997c478bd9Sstevel@tonic-gate * The complete message was consumed.
77007c478bd9Sstevel@tonic-gate *
77017c478bd9Sstevel@tonic-gate * If another M_PCPROTO arrived while sd_lock was not held
77027c478bd9Sstevel@tonic-gate * it would have been discarded since STRPRI was still set.
77037c478bd9Sstevel@tonic-gate *
77047c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information
77057c478bd9Sstevel@tonic-gate * to the stream head just in case
77067c478bd9Sstevel@tonic-gate * the read queue becomes empty.
77077c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on
77087c478bd9Sstevel@tonic-gate * first message
77097c478bd9Sstevel@tonic-gate *
77107c478bd9Sstevel@tonic-gate * If the stream head was at the mark
77117c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above
77127c478bd9Sstevel@tonic-gate * and some data was consumed then we have
77137c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is
77147c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in
77157c478bd9Sstevel@tonic-gate * strrput during the copyout above causing
77167c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that
77177c478bd9Sstevel@tonic-gate * flag.
77187c478bd9Sstevel@tonic-gate * XXX A "perimeter" would help by single-threading strrput,
77197c478bd9Sstevel@tonic-gate * strread, strgetmsg and kstrgetmsg.
77207c478bd9Sstevel@tonic-gate */
77217c478bd9Sstevel@tonic-gate if (type >= QPCTL) {
77227c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO);
77237c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI;
77247c478bd9Sstevel@tonic-gate }
77257c478bd9Sstevel@tonic-gate if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) {
77267c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) {
77277c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK;
77287c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK;
77297c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) {
77307c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
77317c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK;
77327c478bd9Sstevel@tonic-gate } else {
77337c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(STRATMARK|STRNOTATMARK);
77347c478bd9Sstevel@tonic-gate }
77357c478bd9Sstevel@tonic-gate } else if (pr && (old_sd_flag & STRATMARK)) {
77367c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
77377c478bd9Sstevel@tonic-gate }
77387c478bd9Sstevel@tonic-gate }
77397c478bd9Sstevel@tonic-gate
77407c478bd9Sstevel@tonic-gate *flagsp = flg;
77417c478bd9Sstevel@tonic-gate *prip = pri;
77427c478bd9Sstevel@tonic-gate
77437c478bd9Sstevel@tonic-gate /*
77447c478bd9Sstevel@tonic-gate * Getmsg cleanup processing - if the state of the queue has changed
77457c478bd9Sstevel@tonic-gate * some signals may need to be sent and/or poll awakened.
77467c478bd9Sstevel@tonic-gate */
77477c478bd9Sstevel@tonic-gate getmout:
77487c478bd9Sstevel@tonic-gate qbackenable(q, pri);
77497c478bd9Sstevel@tonic-gate
77507c478bd9Sstevel@tonic-gate /*
77517c478bd9Sstevel@tonic-gate * We dropped the stream head lock above. Send all M_SIG messages
77527c478bd9Sstevel@tonic-gate * before processing stream head for SIGPOLL messages.
77537c478bd9Sstevel@tonic-gate */
77547c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
77557c478bd9Sstevel@tonic-gate while ((bp = q->q_first) != NULL &&
77567c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_SIG)) {
77577c478bd9Sstevel@tonic-gate /*
77587c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the read queue can not
77597c478bd9Sstevel@tonic-gate * change.
77607c478bd9Sstevel@tonic-gate */
77617c478bd9Sstevel@tonic-gate bp = getq(q);
77627c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG);
77637c478bd9Sstevel@tonic-gate
7764a45f3f93Smeem strsignal_nolock(stp, *bp->b_rptr, bp->b_band);
77657c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
77667c478bd9Sstevel@tonic-gate freemsg(bp);
77677c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp))
77687c478bd9Sstevel@tonic-gate stream_runservice(stp);
77697c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
77707c478bd9Sstevel@tonic-gate }
77717c478bd9Sstevel@tonic-gate
77727c478bd9Sstevel@tonic-gate /*
77737c478bd9Sstevel@tonic-gate * stream head cannot change while we make the determination
77747c478bd9Sstevel@tonic-gate * whether or not to send a signal. Drop the flag to allow strrput
77757c478bd9Sstevel@tonic-gate * to send firstmsgsigs again.
77767c478bd9Sstevel@tonic-gate */
77777c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRGETINPROG;
77787c478bd9Sstevel@tonic-gate
77797c478bd9Sstevel@tonic-gate /*
77807c478bd9Sstevel@tonic-gate * If the type of message at the front of the queue changed
77817c478bd9Sstevel@tonic-gate * due to the receive the appropriate signals and pollwakeup events
77827c478bd9Sstevel@tonic-gate * are generated. The type of changes are:
77837c478bd9Sstevel@tonic-gate * Processed a hipri message, q_first is not hipri.
77847c478bd9Sstevel@tonic-gate * Processed a band X message, and q_first is band Y.
77857c478bd9Sstevel@tonic-gate * The generated signals and pollwakeups are identical to what
77867c478bd9Sstevel@tonic-gate * strrput() generates should the message that is now on q_first
77877c478bd9Sstevel@tonic-gate * arrive to an empty read queue.
77887c478bd9Sstevel@tonic-gate *
77897c478bd9Sstevel@tonic-gate * Note: only strrput will send a signal for a hipri message.
77907c478bd9Sstevel@tonic-gate */
77917c478bd9Sstevel@tonic-gate if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) {
77927c478bd9Sstevel@tonic-gate strsigset_t signals = 0;
77937c478bd9Sstevel@tonic-gate strpollset_t pollwakeups = 0;
77947c478bd9Sstevel@tonic-gate
77957c478bd9Sstevel@tonic-gate if (flg & MSG_HIPRI) {
77967c478bd9Sstevel@tonic-gate /*
77977c478bd9Sstevel@tonic-gate * Removed a hipri message. Regular data at
77987c478bd9Sstevel@tonic-gate * the front of the queue.
77997c478bd9Sstevel@tonic-gate */
78007c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
78017c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDNORM;
78027c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
78037c478bd9Sstevel@tonic-gate } else {
78047c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDBAND;
78057c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
78067c478bd9Sstevel@tonic-gate }
78077c478bd9Sstevel@tonic-gate } else if (pri != bp->b_band) {
78087c478bd9Sstevel@tonic-gate /*
78097c478bd9Sstevel@tonic-gate * The band is different for the new q_first.
78107c478bd9Sstevel@tonic-gate */
78117c478bd9Sstevel@tonic-gate if (bp->b_band == 0) {
78127c478bd9Sstevel@tonic-gate signals = S_RDNORM;
78137c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM;
78147c478bd9Sstevel@tonic-gate } else {
78157c478bd9Sstevel@tonic-gate signals = S_RDBAND;
78167c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND;
78177c478bd9Sstevel@tonic-gate }
78187c478bd9Sstevel@tonic-gate }
78197c478bd9Sstevel@tonic-gate
78207c478bd9Sstevel@tonic-gate if (pollwakeups != 0) {
78217c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) {
78227c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN))
78237c478bd9Sstevel@tonic-gate goto no_pollwake;
78247c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN;
78257c478bd9Sstevel@tonic-gate }
78267c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
78277c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups);
78287c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
78297c478bd9Sstevel@tonic-gate }
78307c478bd9Sstevel@tonic-gate no_pollwake:
78317c478bd9Sstevel@tonic-gate
78327c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals)
78337c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, bp->b_band, 0);
78347c478bd9Sstevel@tonic-gate }
78357c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
78367c478bd9Sstevel@tonic-gate
78377c478bd9Sstevel@tonic-gate rvp->r_val1 = more;
78387c478bd9Sstevel@tonic-gate return (error);
78397c478bd9Sstevel@tonic-gate #undef _LASTMARK
78407c478bd9Sstevel@tonic-gate }
78417c478bd9Sstevel@tonic-gate
78427c478bd9Sstevel@tonic-gate /*
78437c478bd9Sstevel@tonic-gate * Put a message downstream.
78447c478bd9Sstevel@tonic-gate *
78457c478bd9Sstevel@tonic-gate * NOTE: strputmsg and kstrputmsg have much of the logic in common.
78467c478bd9Sstevel@tonic-gate */
78477c478bd9Sstevel@tonic-gate int
strputmsg(struct vnode * vp,struct strbuf * mctl,struct strbuf * mdata,unsigned char pri,int flag,int fmode)78487c478bd9Sstevel@tonic-gate strputmsg(
78497c478bd9Sstevel@tonic-gate struct vnode *vp,
78507c478bd9Sstevel@tonic-gate struct strbuf *mctl,
78517c478bd9Sstevel@tonic-gate struct strbuf *mdata,
78527c478bd9Sstevel@tonic-gate unsigned char pri,
78537c478bd9Sstevel@tonic-gate int flag,
78547c478bd9Sstevel@tonic-gate int fmode)
78557c478bd9Sstevel@tonic-gate {
78567c478bd9Sstevel@tonic-gate struct stdata *stp;
78577c478bd9Sstevel@tonic-gate queue_t *wqp;
78587c478bd9Sstevel@tonic-gate mblk_t *mp;
78597c478bd9Sstevel@tonic-gate ssize_t msgsize;
78607c478bd9Sstevel@tonic-gate ssize_t rmin, rmax;
78617c478bd9Sstevel@tonic-gate int error;
78627c478bd9Sstevel@tonic-gate struct uio uios;
78637c478bd9Sstevel@tonic-gate struct uio *uiop = &uios;
78647c478bd9Sstevel@tonic-gate struct iovec iovs;
78657c478bd9Sstevel@tonic-gate int xpg4 = 0;
78667c478bd9Sstevel@tonic-gate
78677c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
78687c478bd9Sstevel@tonic-gate stp = vp->v_stream;
78697c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq;
78707c478bd9Sstevel@tonic-gate
78717c478bd9Sstevel@tonic-gate /*
78727c478bd9Sstevel@tonic-gate * If it is an XPG4 application, we need to send
78737c478bd9Sstevel@tonic-gate * SIGPIPE below
78747c478bd9Sstevel@tonic-gate */
78757c478bd9Sstevel@tonic-gate
78767c478bd9Sstevel@tonic-gate xpg4 = (flag & MSG_XPG4) ? 1 : 0;
78777c478bd9Sstevel@tonic-gate flag &= ~MSG_XPG4;
78787c478bd9Sstevel@tonic-gate
7879005d3febSMarek Pospisil if (AU_AUDITING())
78807c478bd9Sstevel@tonic-gate audit_strputmsg(vp, mctl, mdata, pri, flag, fmode);
78817c478bd9Sstevel@tonic-gate
78829acbbeafSnn mutex_enter(&stp->sd_lock);
78839acbbeafSnn
78849acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
78859acbbeafSnn mutex_exit(&stp->sd_lock);
78869acbbeafSnn return (error);
78879acbbeafSnn }
78887c478bd9Sstevel@tonic-gate
78897c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
78907c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_FALSE, xpg4);
78919acbbeafSnn if (error != 0) {
78929acbbeafSnn mutex_exit(&stp->sd_lock);
78937c478bd9Sstevel@tonic-gate return (error);
78949acbbeafSnn }
78957c478bd9Sstevel@tonic-gate }
78967c478bd9Sstevel@tonic-gate
78979acbbeafSnn mutex_exit(&stp->sd_lock);
78989acbbeafSnn
78997c478bd9Sstevel@tonic-gate /*
79007c478bd9Sstevel@tonic-gate * Check for legal flag value.
79017c478bd9Sstevel@tonic-gate */
79027c478bd9Sstevel@tonic-gate switch (flag) {
79037c478bd9Sstevel@tonic-gate case MSG_HIPRI:
79047c478bd9Sstevel@tonic-gate if ((mctl->len < 0) || (pri != 0))
79057c478bd9Sstevel@tonic-gate return (EINVAL);
79067c478bd9Sstevel@tonic-gate break;
79077c478bd9Sstevel@tonic-gate case MSG_BAND:
79087c478bd9Sstevel@tonic-gate break;
79097c478bd9Sstevel@tonic-gate
79107c478bd9Sstevel@tonic-gate default:
79117c478bd9Sstevel@tonic-gate return (EINVAL);
79127c478bd9Sstevel@tonic-gate }
79137c478bd9Sstevel@tonic-gate
79147c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN,
7915d3e55dcdSgww "strputmsg in:stp %p", stp);
79167c478bd9Sstevel@tonic-gate
79177c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */
79187c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz;
79197c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz;
79207c478bd9Sstevel@tonic-gate
79217c478bd9Sstevel@tonic-gate /*
79227c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within the
79237c478bd9Sstevel@tonic-gate * limits of the max and min receive packet sizes and do
79247c478bd9Sstevel@tonic-gate * not exceed system limit.
79257c478bd9Sstevel@tonic-gate */
79267c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ));
79277c478bd9Sstevel@tonic-gate if (rmax == 0) {
79287c478bd9Sstevel@tonic-gate return (ERANGE);
79297c478bd9Sstevel@tonic-gate }
79307c478bd9Sstevel@tonic-gate /*
79317c478bd9Sstevel@tonic-gate * Use the MAXIMUM of sd_maxblk and q_maxpsz.
79327c478bd9Sstevel@tonic-gate * Needed to prevent partial failures in the strmakedata loop.
79337c478bd9Sstevel@tonic-gate */
79347c478bd9Sstevel@tonic-gate if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
79357c478bd9Sstevel@tonic-gate rmax = stp->sd_maxblk;
79367c478bd9Sstevel@tonic-gate
79377c478bd9Sstevel@tonic-gate if ((msgsize = mdata->len) < 0) {
79387c478bd9Sstevel@tonic-gate msgsize = 0;
79397c478bd9Sstevel@tonic-gate rmin = 0; /* no range check for NULL data part */
79407c478bd9Sstevel@tonic-gate }
79417c478bd9Sstevel@tonic-gate if ((msgsize < rmin) ||
79427c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ)) ||
79437c478bd9Sstevel@tonic-gate (mctl->len > strctlsz)) {
79447c478bd9Sstevel@tonic-gate return (ERANGE);
79457c478bd9Sstevel@tonic-gate }
79467c478bd9Sstevel@tonic-gate
79477c478bd9Sstevel@tonic-gate /*
79487c478bd9Sstevel@tonic-gate * Setup uio and iov for data part
79497c478bd9Sstevel@tonic-gate */
79507c478bd9Sstevel@tonic-gate iovs.iov_base = mdata->buf;
79517c478bd9Sstevel@tonic-gate iovs.iov_len = msgsize;
79527c478bd9Sstevel@tonic-gate uios.uio_iov = &iovs;
79537c478bd9Sstevel@tonic-gate uios.uio_iovcnt = 1;
79547c478bd9Sstevel@tonic-gate uios.uio_loffset = 0;
79557c478bd9Sstevel@tonic-gate uios.uio_segflg = UIO_USERSPACE;
79567c478bd9Sstevel@tonic-gate uios.uio_fmode = fmode;
79577c478bd9Sstevel@tonic-gate uios.uio_extflg = UIO_COPY_DEFAULT;
79587c478bd9Sstevel@tonic-gate uios.uio_resid = msgsize;
79597c478bd9Sstevel@tonic-gate uios.uio_offset = 0;
79607c478bd9Sstevel@tonic-gate
79617c478bd9Sstevel@tonic-gate /* Ignore flow control in strput for HIPRI */
79627c478bd9Sstevel@tonic-gate if (flag & MSG_HIPRI)
79637c478bd9Sstevel@tonic-gate flag |= MSG_IGNFLOW;
79647c478bd9Sstevel@tonic-gate
79657c478bd9Sstevel@tonic-gate for (;;) {
79667c478bd9Sstevel@tonic-gate int done = 0;
79677c478bd9Sstevel@tonic-gate
79687c478bd9Sstevel@tonic-gate /*
79697c478bd9Sstevel@tonic-gate * strput will always free the ctl mblk - even when strput
79707c478bd9Sstevel@tonic-gate * fails.
79717c478bd9Sstevel@tonic-gate */
79727c478bd9Sstevel@tonic-gate if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) {
79737c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
7974d3e55dcdSgww "strputmsg out:stp %p out %d error %d",
7975d3e55dcdSgww stp, 1, error);
79767c478bd9Sstevel@tonic-gate return (error);
79777c478bd9Sstevel@tonic-gate }
79787c478bd9Sstevel@tonic-gate /*
79797c478bd9Sstevel@tonic-gate * Verify that the whole message can be transferred by
79807c478bd9Sstevel@tonic-gate * strput.
79817c478bd9Sstevel@tonic-gate */
79827c478bd9Sstevel@tonic-gate ASSERT(stp->sd_maxblk == INFPSZ ||
7983d3e55dcdSgww stp->sd_maxblk >= mdata->len);
79847c478bd9Sstevel@tonic-gate
79857c478bd9Sstevel@tonic-gate msgsize = mdata->len;
79867c478bd9Sstevel@tonic-gate error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
79877c478bd9Sstevel@tonic-gate mdata->len = msgsize;
79887c478bd9Sstevel@tonic-gate
79897c478bd9Sstevel@tonic-gate if (error == 0)
79907c478bd9Sstevel@tonic-gate break;
79917c478bd9Sstevel@tonic-gate
79927c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK)
79937c478bd9Sstevel@tonic-gate goto out;
79947c478bd9Sstevel@tonic-gate
79957c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
79967c478bd9Sstevel@tonic-gate /*
79977c478bd9Sstevel@tonic-gate * Check for a missed wakeup.
79987c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across
79997c478bd9Sstevel@tonic-gate * the canputnext.
80007c478bd9Sstevel@tonic-gate */
80017c478bd9Sstevel@tonic-gate if (bcanputnext(wqp, pri)) {
80027c478bd9Sstevel@tonic-gate /* Try again */
80037c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
80047c478bd9Sstevel@tonic-gate continue;
80057c478bd9Sstevel@tonic-gate }
80067c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT,
8007d3e55dcdSgww "strputmsg wait:stp %p waits pri %d", stp, pri);
80087c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1,
80097c478bd9Sstevel@tonic-gate &done)) != 0) || done) {
80107c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
80117c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
8012d3e55dcdSgww "strputmsg out:q %p out %d error %d",
8013d3e55dcdSgww stp, 0, error);
80147c478bd9Sstevel@tonic-gate return (error);
80157c478bd9Sstevel@tonic-gate }
80167c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE,
8017d3e55dcdSgww "strputmsg wake:stp %p wakes", stp);
80189acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
80199acbbeafSnn mutex_exit(&stp->sd_lock);
80209acbbeafSnn return (error);
80219acbbeafSnn }
80227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
80237c478bd9Sstevel@tonic-gate }
80247c478bd9Sstevel@tonic-gate out:
80257c478bd9Sstevel@tonic-gate /*
80267c478bd9Sstevel@tonic-gate * For historic reasons, applications expect EAGAIN
80277c478bd9Sstevel@tonic-gate * when data mblk could not be allocated. so change
80287c478bd9Sstevel@tonic-gate * ENOMEM back to EAGAIN
80297c478bd9Sstevel@tonic-gate */
80307c478bd9Sstevel@tonic-gate if (error == ENOMEM)
80317c478bd9Sstevel@tonic-gate error = EAGAIN;
80327c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT,
8033d3e55dcdSgww "strputmsg out:stp %p out %d error %d", stp, 2, error);
80347c478bd9Sstevel@tonic-gate return (error);
80357c478bd9Sstevel@tonic-gate }
80367c478bd9Sstevel@tonic-gate
80377c478bd9Sstevel@tonic-gate /*
80387c478bd9Sstevel@tonic-gate * Put a message downstream.
80397c478bd9Sstevel@tonic-gate * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop.
80407c478bd9Sstevel@tonic-gate * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio
80417c478bd9Sstevel@tonic-gate * and the fmode parameter.
80427c478bd9Sstevel@tonic-gate *
80437c478bd9Sstevel@tonic-gate * This routine handles the consolidation private flags:
80447c478bd9Sstevel@tonic-gate * MSG_IGNERROR Ignore any stream head error except STPLEX.
80457c478bd9Sstevel@tonic-gate * MSG_HOLDSIG Hold signals while waiting for data.
80467c478bd9Sstevel@tonic-gate * MSG_IGNFLOW Don't check streams flow control.
80477c478bd9Sstevel@tonic-gate *
80487c478bd9Sstevel@tonic-gate * NOTE: strputmsg and kstrputmsg have much of the logic in common.
80497c478bd9Sstevel@tonic-gate */
80507c478bd9Sstevel@tonic-gate int
kstrputmsg(struct vnode * vp,mblk_t * mctl,struct uio * uiop,ssize_t msgsize,unsigned char pri,int flag,int fmode)80517c478bd9Sstevel@tonic-gate kstrputmsg(
80527c478bd9Sstevel@tonic-gate struct vnode *vp,
80537c478bd9Sstevel@tonic-gate mblk_t *mctl,
80547c478bd9Sstevel@tonic-gate struct uio *uiop,
80557c478bd9Sstevel@tonic-gate ssize_t msgsize,
80567c478bd9Sstevel@tonic-gate unsigned char pri,
80577c478bd9Sstevel@tonic-gate int flag,
80587c478bd9Sstevel@tonic-gate int fmode)
80597c478bd9Sstevel@tonic-gate {
80607c478bd9Sstevel@tonic-gate struct stdata *stp;
80617c478bd9Sstevel@tonic-gate queue_t *wqp;
80627c478bd9Sstevel@tonic-gate ssize_t rmin, rmax;
80637c478bd9Sstevel@tonic-gate int error;
80647c478bd9Sstevel@tonic-gate
80657c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
80667c478bd9Sstevel@tonic-gate stp = vp->v_stream;
80677c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq;
8068005d3febSMarek Pospisil if (AU_AUDITING())
80697c478bd9Sstevel@tonic-gate audit_strputmsg(vp, NULL, NULL, pri, flag, fmode);
8070e4506d67Smeem if (mctl == NULL)
8071e4506d67Smeem return (EINVAL);
80727c478bd9Sstevel@tonic-gate
80739acbbeafSnn mutex_enter(&stp->sd_lock);
80749acbbeafSnn
80759acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
80769acbbeafSnn mutex_exit(&stp->sd_lock);
80779acbbeafSnn freemsg(mctl);
80789acbbeafSnn return (error);
80797c478bd9Sstevel@tonic-gate }
80807c478bd9Sstevel@tonic-gate
80817c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) {
80827c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) {
80837c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_FALSE, B_TRUE);
80847c478bd9Sstevel@tonic-gate if (error != 0) {
80859acbbeafSnn mutex_exit(&stp->sd_lock);
80867c478bd9Sstevel@tonic-gate freemsg(mctl);
80877c478bd9Sstevel@tonic-gate return (error);
80887c478bd9Sstevel@tonic-gate }
80897c478bd9Sstevel@tonic-gate }
80907c478bd9Sstevel@tonic-gate }
80917c478bd9Sstevel@tonic-gate
80929acbbeafSnn mutex_exit(&stp->sd_lock);
80939acbbeafSnn
80947c478bd9Sstevel@tonic-gate /*
80957c478bd9Sstevel@tonic-gate * Check for legal flag value.
80967c478bd9Sstevel@tonic-gate */
80977c478bd9Sstevel@tonic-gate switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) {
80987c478bd9Sstevel@tonic-gate case MSG_HIPRI:
8099e4506d67Smeem if (pri != 0) {
81007c478bd9Sstevel@tonic-gate freemsg(mctl);
81017c478bd9Sstevel@tonic-gate return (EINVAL);
81027c478bd9Sstevel@tonic-gate }
81037c478bd9Sstevel@tonic-gate break;
81047c478bd9Sstevel@tonic-gate case MSG_BAND:
81057c478bd9Sstevel@tonic-gate break;
81067c478bd9Sstevel@tonic-gate default:
81077c478bd9Sstevel@tonic-gate freemsg(mctl);
81087c478bd9Sstevel@tonic-gate return (EINVAL);
81097c478bd9Sstevel@tonic-gate }
81107c478bd9Sstevel@tonic-gate
81117c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN,
8112d3e55dcdSgww "kstrputmsg in:stp %p", stp);
81137c478bd9Sstevel@tonic-gate
81147c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */
81157c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz;
81167c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz;
81177c478bd9Sstevel@tonic-gate
81187c478bd9Sstevel@tonic-gate /*
81197c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within the
81207c478bd9Sstevel@tonic-gate * limits of the max and min receive packet sizes and do
81217c478bd9Sstevel@tonic-gate * not exceed system limit.
81227c478bd9Sstevel@tonic-gate */
81237c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ));
81247c478bd9Sstevel@tonic-gate if (rmax == 0) {
81257c478bd9Sstevel@tonic-gate freemsg(mctl);
81267c478bd9Sstevel@tonic-gate return (ERANGE);
81277c478bd9Sstevel@tonic-gate }
81287c478bd9Sstevel@tonic-gate /*
81297c478bd9Sstevel@tonic-gate * Use the MAXIMUM of sd_maxblk and q_maxpsz.
81307c478bd9Sstevel@tonic-gate * Needed to prevent partial failures in the strmakedata loop.
81317c478bd9Sstevel@tonic-gate */
81327c478bd9Sstevel@tonic-gate if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk)
81337c478bd9Sstevel@tonic-gate rmax = stp->sd_maxblk;
81347c478bd9Sstevel@tonic-gate
81357c478bd9Sstevel@tonic-gate if (uiop == NULL) {
81367c478bd9Sstevel@tonic-gate msgsize = -1;
81377c478bd9Sstevel@tonic-gate rmin = -1; /* no range check for NULL data part */
81387c478bd9Sstevel@tonic-gate } else {
81397c478bd9Sstevel@tonic-gate /* Use uio flags as well as the fmode parameter flags */
81407c478bd9Sstevel@tonic-gate fmode |= uiop->uio_fmode;
81417c478bd9Sstevel@tonic-gate
81427c478bd9Sstevel@tonic-gate if ((msgsize < rmin) ||
81437c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ))) {
81447c478bd9Sstevel@tonic-gate freemsg(mctl);
81457c478bd9Sstevel@tonic-gate return (ERANGE);
81467c478bd9Sstevel@tonic-gate }
81477c478bd9Sstevel@tonic-gate }
81487c478bd9Sstevel@tonic-gate
81497c478bd9Sstevel@tonic-gate /* Ignore flow control in strput for HIPRI */
81507c478bd9Sstevel@tonic-gate if (flag & MSG_HIPRI)
81517c478bd9Sstevel@tonic-gate flag |= MSG_IGNFLOW;
81527c478bd9Sstevel@tonic-gate
81537c478bd9Sstevel@tonic-gate for (;;) {
81547c478bd9Sstevel@tonic-gate int done = 0;
81557c478bd9Sstevel@tonic-gate int waitflag;
81567c478bd9Sstevel@tonic-gate mblk_t *mp;
81577c478bd9Sstevel@tonic-gate
81587c478bd9Sstevel@tonic-gate /*
81597c478bd9Sstevel@tonic-gate * strput will always free the ctl mblk - even when strput
81607c478bd9Sstevel@tonic-gate * fails. If MSG_IGNFLOW is set then any error returned
81617c478bd9Sstevel@tonic-gate * will cause us to break the loop, so we don't need a copy
81627c478bd9Sstevel@tonic-gate * of the message. If MSG_IGNFLOW is not set, then we can
81637c478bd9Sstevel@tonic-gate * get hit by flow control and be forced to try again. In
81647c478bd9Sstevel@tonic-gate * this case we need to have a copy of the message. We
81657c478bd9Sstevel@tonic-gate * do this using copymsg since the message may get modified
81667c478bd9Sstevel@tonic-gate * by something below us.
81677c478bd9Sstevel@tonic-gate *
81687c478bd9Sstevel@tonic-gate * We've observed that many TPI providers do not check db_ref
81697c478bd9Sstevel@tonic-gate * on the control messages but blindly reuse them for the
81707c478bd9Sstevel@tonic-gate * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more
81717c478bd9Sstevel@tonic-gate * friendly to such providers than using dupmsg. Also, note
81727c478bd9Sstevel@tonic-gate * that sockfs uses MSG_IGNFLOW for all TPI control messages.
81737c478bd9Sstevel@tonic-gate * Only data messages are subject to flow control, hence
81747c478bd9Sstevel@tonic-gate * subject to this copymsg.
81757c478bd9Sstevel@tonic-gate */
81767c478bd9Sstevel@tonic-gate if (flag & MSG_IGNFLOW) {
81777c478bd9Sstevel@tonic-gate mp = mctl;
81787c478bd9Sstevel@tonic-gate mctl = NULL;
81797c478bd9Sstevel@tonic-gate } else {
81807c478bd9Sstevel@tonic-gate do {
81817c478bd9Sstevel@tonic-gate /*
81827c478bd9Sstevel@tonic-gate * If a message has a free pointer, the message
81837c478bd9Sstevel@tonic-gate * must be dupmsg to maintain this pointer.
81847c478bd9Sstevel@tonic-gate * Code using this facility must be sure
81857c478bd9Sstevel@tonic-gate * that modules below will not change the
81867c478bd9Sstevel@tonic-gate * contents of the dblk without checking db_ref
81877c478bd9Sstevel@tonic-gate * first. If db_ref is > 1, then the module
81887c478bd9Sstevel@tonic-gate * needs to do a copymsg first. Otherwise,
81897c478bd9Sstevel@tonic-gate * the contents of the dblk may become
81907c478bd9Sstevel@tonic-gate * inconsistent because the freesmg/freeb below
81917c478bd9Sstevel@tonic-gate * may end up calling atomic_add_32_nv.
81927c478bd9Sstevel@tonic-gate * The atomic_add_32_nv in freeb (accessing
81937c478bd9Sstevel@tonic-gate * all of db_ref, db_type, db_flags, and
81947c478bd9Sstevel@tonic-gate * db_struioflag) does not prevent other threads
81957c478bd9Sstevel@tonic-gate * from concurrently trying to modify e.g.
81967c478bd9Sstevel@tonic-gate * db_type.
81977c478bd9Sstevel@tonic-gate */
81987c478bd9Sstevel@tonic-gate if (mctl->b_datap->db_frtnp != NULL)
81997c478bd9Sstevel@tonic-gate mp = dupmsg(mctl);
82007c478bd9Sstevel@tonic-gate else
82017c478bd9Sstevel@tonic-gate mp = copymsg(mctl);
82027c478bd9Sstevel@tonic-gate
8203e4506d67Smeem if (mp != NULL)
82047c478bd9Sstevel@tonic-gate break;
82057c478bd9Sstevel@tonic-gate
82067c478bd9Sstevel@tonic-gate error = strwaitbuf(msgdsize(mctl), BPRI_MED);
82077c478bd9Sstevel@tonic-gate if (error) {
82087c478bd9Sstevel@tonic-gate freemsg(mctl);
82097c478bd9Sstevel@tonic-gate return (error);
82107c478bd9Sstevel@tonic-gate }
82117c478bd9Sstevel@tonic-gate } while (mp == NULL);
82127c478bd9Sstevel@tonic-gate }
82137c478bd9Sstevel@tonic-gate /*
82147c478bd9Sstevel@tonic-gate * Verify that all of msgsize can be transferred by
82157c478bd9Sstevel@tonic-gate * strput.
82167c478bd9Sstevel@tonic-gate */
8217e4506d67Smeem ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize);
82187c478bd9Sstevel@tonic-gate error = strput(stp, mp, uiop, &msgsize, 0, pri, flag);
82197c478bd9Sstevel@tonic-gate if (error == 0)
82207c478bd9Sstevel@tonic-gate break;
82217c478bd9Sstevel@tonic-gate
82227c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK)
82237c478bd9Sstevel@tonic-gate goto out;
82247c478bd9Sstevel@tonic-gate
82257c478bd9Sstevel@tonic-gate /*
82267c478bd9Sstevel@tonic-gate * IF MSG_IGNFLOW is set we should have broken out of loop
82277c478bd9Sstevel@tonic-gate * above.
82287c478bd9Sstevel@tonic-gate */
82297c478bd9Sstevel@tonic-gate ASSERT(!(flag & MSG_IGNFLOW));
82307c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
82317c478bd9Sstevel@tonic-gate /*
82327c478bd9Sstevel@tonic-gate * Check for a missed wakeup.
82337c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across
82347c478bd9Sstevel@tonic-gate * the canputnext.
82357c478bd9Sstevel@tonic-gate */
82367c478bd9Sstevel@tonic-gate if (bcanputnext(wqp, pri)) {
82377c478bd9Sstevel@tonic-gate /* Try again */
82387c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
82397c478bd9Sstevel@tonic-gate continue;
82407c478bd9Sstevel@tonic-gate }
82417c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT,
8242d3e55dcdSgww "kstrputmsg wait:stp %p waits pri %d", stp, pri);
82437c478bd9Sstevel@tonic-gate
82447c478bd9Sstevel@tonic-gate waitflag = WRITEWAIT;
82457c478bd9Sstevel@tonic-gate if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) {
82467c478bd9Sstevel@tonic-gate if (flag & MSG_HOLDSIG)
82477c478bd9Sstevel@tonic-gate waitflag |= STR_NOSIG;
82487c478bd9Sstevel@tonic-gate if (flag & MSG_IGNERROR)
82497c478bd9Sstevel@tonic-gate waitflag |= STR_NOERROR;
82507c478bd9Sstevel@tonic-gate }
82517c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, waitflag,
82527c478bd9Sstevel@tonic-gate (ssize_t)0, fmode, -1, &done)) != 0) || done) {
82537c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
82547c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8255d3e55dcdSgww "kstrputmsg out:stp %p out %d error %d",
8256d3e55dcdSgww stp, 0, error);
82577c478bd9Sstevel@tonic-gate freemsg(mctl);
82587c478bd9Sstevel@tonic-gate return (error);
82597c478bd9Sstevel@tonic-gate }
82607c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE,
8261d3e55dcdSgww "kstrputmsg wake:stp %p wakes", stp);
82629acbbeafSnn if ((error = i_straccess(stp, JCWRITE)) != 0) {
82639acbbeafSnn mutex_exit(&stp->sd_lock);
82649acbbeafSnn freemsg(mctl);
82659acbbeafSnn return (error);
82667c478bd9Sstevel@tonic-gate }
82679acbbeafSnn mutex_exit(&stp->sd_lock);
82687c478bd9Sstevel@tonic-gate }
82697c478bd9Sstevel@tonic-gate out:
82707c478bd9Sstevel@tonic-gate freemsg(mctl);
82717c478bd9Sstevel@tonic-gate /*
82727c478bd9Sstevel@tonic-gate * For historic reasons, applications expect EAGAIN
82737c478bd9Sstevel@tonic-gate * when data mblk could not be allocated. so change
82747c478bd9Sstevel@tonic-gate * ENOMEM back to EAGAIN
82757c478bd9Sstevel@tonic-gate */
82767c478bd9Sstevel@tonic-gate if (error == ENOMEM)
82777c478bd9Sstevel@tonic-gate error = EAGAIN;
82787c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT,
8279d3e55dcdSgww "kstrputmsg out:stp %p out %d error %d", stp, 2, error);
82807c478bd9Sstevel@tonic-gate return (error);
82817c478bd9Sstevel@tonic-gate }
82827c478bd9Sstevel@tonic-gate
82837c478bd9Sstevel@tonic-gate /*
82847c478bd9Sstevel@tonic-gate * Determines whether the necessary conditions are set on a stream
82857c478bd9Sstevel@tonic-gate * for it to be readable, writeable, or have exceptions.
82867c478bd9Sstevel@tonic-gate *
82877c478bd9Sstevel@tonic-gate * strpoll handles the consolidation private events:
82887c478bd9Sstevel@tonic-gate * POLLNOERR Do not return POLLERR even if there are stream
82897c478bd9Sstevel@tonic-gate * head errors.
82907c478bd9Sstevel@tonic-gate * Used by sockfs.
82917c478bd9Sstevel@tonic-gate * POLLRDDATA Do not return POLLIN unless at least one message on
82927c478bd9Sstevel@tonic-gate * the queue contains one or more M_DATA mblks. Thus
82937c478bd9Sstevel@tonic-gate * when this flag is set a queue with only
82947c478bd9Sstevel@tonic-gate * M_PROTO/M_PCPROTO mblks does not return POLLIN.
82957c478bd9Sstevel@tonic-gate * Used by sockfs to ignore T_EXDATA_IND messages.
82967c478bd9Sstevel@tonic-gate *
82977c478bd9Sstevel@tonic-gate * Note: POLLRDDATA assumes that synch streams only return messages with
82987c478bd9Sstevel@tonic-gate * an M_DATA attached (i.e. not messages consisting of only
82997c478bd9Sstevel@tonic-gate * an M_PROTO/M_PCPROTO part).
83007c478bd9Sstevel@tonic-gate */
83017c478bd9Sstevel@tonic-gate int
strpoll(struct stdata * stp,short events_arg,int anyyet,short * reventsp,struct pollhead ** phpp)830280d5689fSPatrick Mooney strpoll(struct stdata *stp, short events_arg, int anyyet, short *reventsp,
830380d5689fSPatrick Mooney struct pollhead **phpp)
83047c478bd9Sstevel@tonic-gate {
83057c478bd9Sstevel@tonic-gate int events = (ushort_t)events_arg;
83067c478bd9Sstevel@tonic-gate int retevents = 0;
83077c478bd9Sstevel@tonic-gate mblk_t *mp;
83087c478bd9Sstevel@tonic-gate qband_t *qbp;
83097c478bd9Sstevel@tonic-gate long sd_flags = stp->sd_flag;
83107c478bd9Sstevel@tonic-gate int headlocked = 0;
83117c478bd9Sstevel@tonic-gate
83127c478bd9Sstevel@tonic-gate /*
83137c478bd9Sstevel@tonic-gate * For performance, a single 'if' tests for most possible edge
83147c478bd9Sstevel@tonic-gate * conditions in one shot
83157c478bd9Sstevel@tonic-gate */
83167c478bd9Sstevel@tonic-gate if (sd_flags & (STPLEX | STRDERR | STWRERR)) {
83177c478bd9Sstevel@tonic-gate if (sd_flags & STPLEX) {
83187c478bd9Sstevel@tonic-gate *reventsp = POLLNVAL;
83197c478bd9Sstevel@tonic-gate return (EINVAL);
83207c478bd9Sstevel@tonic-gate }
83217c478bd9Sstevel@tonic-gate if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) &&
83227c478bd9Sstevel@tonic-gate (sd_flags & STRDERR)) ||
83237c478bd9Sstevel@tonic-gate ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) &&
83247c478bd9Sstevel@tonic-gate (sd_flags & STWRERR))) {
83257c478bd9Sstevel@tonic-gate if (!(events & POLLNOERR)) {
83267c478bd9Sstevel@tonic-gate *reventsp = POLLERR;
83277c478bd9Sstevel@tonic-gate return (0);
83287c478bd9Sstevel@tonic-gate }
83297c478bd9Sstevel@tonic-gate }
83307c478bd9Sstevel@tonic-gate }
83317c478bd9Sstevel@tonic-gate if (sd_flags & STRHUP) {
83327c478bd9Sstevel@tonic-gate retevents |= POLLHUP;
83337c478bd9Sstevel@tonic-gate } else if (events & (POLLWRNORM | POLLWRBAND)) {
83347c478bd9Sstevel@tonic-gate queue_t *tq;
83357c478bd9Sstevel@tonic-gate queue_t *qp = stp->sd_wrq;
83367c478bd9Sstevel@tonic-gate
83377c478bd9Sstevel@tonic-gate claimstr(qp);
83387c478bd9Sstevel@tonic-gate /* Find next module forward that has a service procedure */
83397c478bd9Sstevel@tonic-gate tq = qp->q_next->q_nfsrv;
83407c478bd9Sstevel@tonic-gate ASSERT(tq != NULL);
83417c478bd9Sstevel@tonic-gate
8342f3bb54f3SPatrick Mooney if (polllock(&stp->sd_pollist, QLOCK(tq)) != 0) {
8343f3bb54f3SPatrick Mooney releasestr(qp);
8344f3bb54f3SPatrick Mooney *reventsp = POLLNVAL;
8345f3bb54f3SPatrick Mooney return (0);
8346f3bb54f3SPatrick Mooney }
83477c478bd9Sstevel@tonic-gate if (events & POLLWRNORM) {
83487c478bd9Sstevel@tonic-gate queue_t *sqp;
83497c478bd9Sstevel@tonic-gate
83507c478bd9Sstevel@tonic-gate if (tq->q_flag & QFULL)
83517c478bd9Sstevel@tonic-gate /* ensure backq svc procedure runs */
83527c478bd9Sstevel@tonic-gate tq->q_flag |= QWANTW;
83537c478bd9Sstevel@tonic-gate else if ((sqp = stp->sd_struiowrq) != NULL) {
83547c478bd9Sstevel@tonic-gate /* Check sync stream barrier write q */
83557c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq));
8356f3bb54f3SPatrick Mooney if (polllock(&stp->sd_pollist,
8357f3bb54f3SPatrick Mooney QLOCK(sqp)) != 0) {
8358f3bb54f3SPatrick Mooney releasestr(qp);
8359f3bb54f3SPatrick Mooney *reventsp = POLLNVAL;
8360f3bb54f3SPatrick Mooney return (0);
8361f3bb54f3SPatrick Mooney }
83627c478bd9Sstevel@tonic-gate if (sqp->q_flag & QFULL)
83637c478bd9Sstevel@tonic-gate /* ensure pollwakeup() is done */
83647c478bd9Sstevel@tonic-gate sqp->q_flag |= QWANTWSYNC;
83657c478bd9Sstevel@tonic-gate else
83667c478bd9Sstevel@tonic-gate retevents |= POLLOUT;
83677c478bd9Sstevel@tonic-gate /* More write events to process ??? */
83687c478bd9Sstevel@tonic-gate if (! (events & POLLWRBAND)) {
83697c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(sqp));
83707c478bd9Sstevel@tonic-gate releasestr(qp);
83717c478bd9Sstevel@tonic-gate goto chkrd;
83727c478bd9Sstevel@tonic-gate }
83737c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(sqp));
8374f3bb54f3SPatrick Mooney if (polllock(&stp->sd_pollist,
8375f3bb54f3SPatrick Mooney QLOCK(tq)) != 0) {
8376f3bb54f3SPatrick Mooney releasestr(qp);
8377f3bb54f3SPatrick Mooney *reventsp = POLLNVAL;
8378f3bb54f3SPatrick Mooney return (0);
8379f3bb54f3SPatrick Mooney }
83807c478bd9Sstevel@tonic-gate } else
83817c478bd9Sstevel@tonic-gate retevents |= POLLOUT;
83827c478bd9Sstevel@tonic-gate }
83837c478bd9Sstevel@tonic-gate if (events & POLLWRBAND) {
83847c478bd9Sstevel@tonic-gate qbp = tq->q_bandp;
83857c478bd9Sstevel@tonic-gate if (qbp) {
83867c478bd9Sstevel@tonic-gate while (qbp) {
83877c478bd9Sstevel@tonic-gate if (qbp->qb_flag & QB_FULL)
83887c478bd9Sstevel@tonic-gate qbp->qb_flag |= QB_WANTW;
83897c478bd9Sstevel@tonic-gate else
83907c478bd9Sstevel@tonic-gate retevents |= POLLWRBAND;
83917c478bd9Sstevel@tonic-gate qbp = qbp->qb_next;
83927c478bd9Sstevel@tonic-gate }
83937c478bd9Sstevel@tonic-gate } else {
83947c478bd9Sstevel@tonic-gate retevents |= POLLWRBAND;
83957c478bd9Sstevel@tonic-gate }
83967c478bd9Sstevel@tonic-gate }
83977c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq));
83987c478bd9Sstevel@tonic-gate releasestr(qp);
83997c478bd9Sstevel@tonic-gate }
84007c478bd9Sstevel@tonic-gate chkrd:
84017c478bd9Sstevel@tonic-gate if (sd_flags & STRPRI) {
84027c478bd9Sstevel@tonic-gate retevents |= (events & POLLPRI);
84037c478bd9Sstevel@tonic-gate } else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) {
84047c478bd9Sstevel@tonic-gate queue_t *qp = _RD(stp->sd_wrq);
84057c478bd9Sstevel@tonic-gate int normevents = (events & (POLLIN | POLLRDNORM));
84067c478bd9Sstevel@tonic-gate
84077c478bd9Sstevel@tonic-gate /*
84087c478bd9Sstevel@tonic-gate * Note: Need to do polllock() here since ps_lock may be
84097c478bd9Sstevel@tonic-gate * held. See bug 4191544.
84107c478bd9Sstevel@tonic-gate */
8411f3bb54f3SPatrick Mooney if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8412f3bb54f3SPatrick Mooney *reventsp = POLLNVAL;
8413f3bb54f3SPatrick Mooney return (0);
8414f3bb54f3SPatrick Mooney }
84157c478bd9Sstevel@tonic-gate headlocked = 1;
84167c478bd9Sstevel@tonic-gate mp = qp->q_first;
84177c478bd9Sstevel@tonic-gate while (mp) {
84187c478bd9Sstevel@tonic-gate /*
84197c478bd9Sstevel@tonic-gate * For POLLRDDATA we scan b_cont and b_next until we
84207c478bd9Sstevel@tonic-gate * find an M_DATA.
84217c478bd9Sstevel@tonic-gate */
84227c478bd9Sstevel@tonic-gate if ((events & POLLRDDATA) &&
84237c478bd9Sstevel@tonic-gate mp->b_datap->db_type != M_DATA) {
84247c478bd9Sstevel@tonic-gate mblk_t *nmp = mp->b_cont;
84257c478bd9Sstevel@tonic-gate
84267c478bd9Sstevel@tonic-gate while (nmp != NULL &&
84277c478bd9Sstevel@tonic-gate nmp->b_datap->db_type != M_DATA)
84287c478bd9Sstevel@tonic-gate nmp = nmp->b_cont;
84297c478bd9Sstevel@tonic-gate if (nmp == NULL) {
84307c478bd9Sstevel@tonic-gate mp = mp->b_next;
84317c478bd9Sstevel@tonic-gate continue;
84327c478bd9Sstevel@tonic-gate }
84337c478bd9Sstevel@tonic-gate }
84347c478bd9Sstevel@tonic-gate if (mp->b_band == 0)
84357c478bd9Sstevel@tonic-gate retevents |= normevents;
84367c478bd9Sstevel@tonic-gate else
84377c478bd9Sstevel@tonic-gate retevents |= (events & (POLLIN | POLLRDBAND));
84387c478bd9Sstevel@tonic-gate break;
84397c478bd9Sstevel@tonic-gate }
844080d5689fSPatrick Mooney if (!(retevents & normevents) && (stp->sd_wakeq & RSLEEP)) {
84417c478bd9Sstevel@tonic-gate /*
84427c478bd9Sstevel@tonic-gate * Sync stream barrier read queue has data.
84437c478bd9Sstevel@tonic-gate */
84447c478bd9Sstevel@tonic-gate retevents |= normevents;
84457c478bd9Sstevel@tonic-gate }
84467c478bd9Sstevel@tonic-gate /* Treat eof as normal data */
84477c478bd9Sstevel@tonic-gate if (sd_flags & STREOF)
84487c478bd9Sstevel@tonic-gate retevents |= normevents;
84497c478bd9Sstevel@tonic-gate }
84507c478bd9Sstevel@tonic-gate
84517c478bd9Sstevel@tonic-gate /*
845280d5689fSPatrick Mooney * Pass back a pollhead if no events are pending or if edge-triggering
845380d5689fSPatrick Mooney * has been configured on this resource.
84547c478bd9Sstevel@tonic-gate */
845580d5689fSPatrick Mooney if ((retevents == 0 && !anyyet) || (events & POLLET)) {
84567c478bd9Sstevel@tonic-gate *phpp = &stp->sd_pollist;
84577c478bd9Sstevel@tonic-gate if (headlocked == 0) {
8458f3bb54f3SPatrick Mooney if (polllock(&stp->sd_pollist, &stp->sd_lock) != 0) {
8459f3bb54f3SPatrick Mooney *reventsp = POLLNVAL;
8460f3bb54f3SPatrick Mooney return (0);
8461f3bb54f3SPatrick Mooney }
84627c478bd9Sstevel@tonic-gate headlocked = 1;
84637c478bd9Sstevel@tonic-gate }
84647c478bd9Sstevel@tonic-gate stp->sd_rput_opt |= SR_POLLIN;
84657c478bd9Sstevel@tonic-gate }
846680d5689fSPatrick Mooney
846780d5689fSPatrick Mooney *reventsp = (short)retevents;
84687c478bd9Sstevel@tonic-gate if (headlocked)
84697c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
84707c478bd9Sstevel@tonic-gate return (0);
84717c478bd9Sstevel@tonic-gate }
84727c478bd9Sstevel@tonic-gate
84737c478bd9Sstevel@tonic-gate /*
84747c478bd9Sstevel@tonic-gate * The purpose of putback() is to assure sleeping polls/reads
84757c478bd9Sstevel@tonic-gate * are awakened when there are no new messages arriving at the,
84767c478bd9Sstevel@tonic-gate * stream head, and a message is placed back on the read queue.
84777c478bd9Sstevel@tonic-gate *
84787c478bd9Sstevel@tonic-gate * sd_lock must be held when messages are placed back on stream
84797c478bd9Sstevel@tonic-gate * head. (getq() holds sd_lock when it removes messages from
84807c478bd9Sstevel@tonic-gate * the queue)
84817c478bd9Sstevel@tonic-gate */
84827c478bd9Sstevel@tonic-gate
84837c478bd9Sstevel@tonic-gate static void
putback(struct stdata * stp,queue_t * q,mblk_t * bp,int band)84847c478bd9Sstevel@tonic-gate putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band)
84857c478bd9Sstevel@tonic-gate {
8486301ce41fSja mblk_t *qfirst;
84877c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock));
84883584396bSja
8489301ce41fSja /*
8490301ce41fSja * As a result of lock-step ordering around q_lock and sd_lock,
8491301ce41fSja * it's possible for function calls like putnext() and
8492301ce41fSja * canputnext() to get an inaccurate picture of how much
8493301ce41fSja * data is really being processed at the stream head.
8494301ce41fSja * We only consolidate with existing messages on the queue
8495301ce41fSja * if the length of the message we want to put back is smaller
8496301ce41fSja * than the queue hiwater mark.
8497301ce41fSja */
84983584396bSja if ((stp->sd_rput_opt & SR_CONSOL_DATA) &&
8499301ce41fSja (DB_TYPE(bp) == M_DATA) && ((qfirst = q->q_first) != NULL) &&
8500301ce41fSja (DB_TYPE(qfirst) == M_DATA) &&
8501301ce41fSja ((qfirst->b_flag & (MSGMARK|MSGDELIM)) == 0) &&
8502301ce41fSja ((bp->b_flag & (MSGMARK|MSGDELIM|MSGMARKNEXT)) == 0) &&
8503301ce41fSja (mp_cont_len(bp, NULL) < q->q_hiwat)) {
85043584396bSja /*
85053584396bSja * We use the same logic as defined in strrput()
85063584396bSja * but in reverse as we are putting back onto the
85073584396bSja * queue and want to retain byte ordering.
8508301ce41fSja * Consolidate M_DATA messages with M_DATA ONLY.
8509301ce41fSja * strrput() allows the consolidation of M_DATA onto
8510301ce41fSja * M_PROTO | M_PCPROTO but not the other way round.
8511301ce41fSja *
85123584396bSja * The consolidation does not take place if the message
85133584396bSja * we are returning to the queue is marked with either
85143584396bSja * of the marks or the delim flag or if q_first
85153584396bSja * is marked with MSGMARK. The MSGMARK check is needed to
85163584396bSja * handle the odd semantics of MSGMARK where essentially
85173584396bSja * the whole message is to be treated as marked.
85183584396bSja * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from q_first
85193584396bSja * to the front of the b_cont chain.
85203584396bSja */
8521301ce41fSja rmvq_noenab(q, qfirst);
85223584396bSja
8523301ce41fSja /*
8524301ce41fSja * The first message in the b_cont list
8525301ce41fSja * tracks MSGMARKNEXT and MSGNOTMARKNEXT.
8526301ce41fSja * We need to handle the case where we
8527301ce41fSja * are appending:
8528301ce41fSja *
8529301ce41fSja * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT.
8530301ce41fSja * 2) a MSGMARKNEXT to a plain message.
8531301ce41fSja * 3) a MSGNOTMARKNEXT to a plain message
8532301ce41fSja * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT
8533301ce41fSja * message.
8534301ce41fSja *
8535301ce41fSja * Thus we never append a MSGMARKNEXT or
8536301ce41fSja * MSGNOTMARKNEXT to a MSGMARKNEXT message.
8537301ce41fSja */
8538301ce41fSja if (qfirst->b_flag & MSGMARKNEXT) {
8539301ce41fSja bp->b_flag |= MSGMARKNEXT;
8540301ce41fSja bp->b_flag &= ~MSGNOTMARKNEXT;
8541301ce41fSja qfirst->b_flag &= ~MSGMARKNEXT;
8542301ce41fSja } else if (qfirst->b_flag & MSGNOTMARKNEXT) {
8543301ce41fSja bp->b_flag |= MSGNOTMARKNEXT;
8544301ce41fSja qfirst->b_flag &= ~MSGNOTMARKNEXT;
85453584396bSja }
8546301ce41fSja
8547301ce41fSja linkb(bp, qfirst);
85483584396bSja }
85497c478bd9Sstevel@tonic-gate (void) putbq(q, bp);
85503584396bSja
85517c478bd9Sstevel@tonic-gate /*
85527c478bd9Sstevel@tonic-gate * A message may have come in when the sd_lock was dropped in the
85537c478bd9Sstevel@tonic-gate * calling routine. If this is the case and STR*ATMARK info was
85547c478bd9Sstevel@tonic-gate * received, need to move that from the stream head to the q_last
85557c478bd9Sstevel@tonic-gate * so that SIOCATMARK can return the proper value.
85567c478bd9Sstevel@tonic-gate */
85577c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) {
85587c478bd9Sstevel@tonic-gate unsigned short *flagp = &q->q_last->b_flag;
85597c478bd9Sstevel@tonic-gate uint_t b_flag = (uint_t)*flagp;
85607c478bd9Sstevel@tonic-gate
85617c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRATMARK) {
85627c478bd9Sstevel@tonic-gate b_flag &= ~MSGNOTMARKNEXT;
85637c478bd9Sstevel@tonic-gate b_flag |= MSGMARKNEXT;
85647c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK;
85657c478bd9Sstevel@tonic-gate } else {
85667c478bd9Sstevel@tonic-gate b_flag &= ~MSGMARKNEXT;
85677c478bd9Sstevel@tonic-gate b_flag |= MSGNOTMARKNEXT;
85687c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK;
85697c478bd9Sstevel@tonic-gate }
85707c478bd9Sstevel@tonic-gate *flagp = (unsigned short) b_flag;
85717c478bd9Sstevel@tonic-gate }
85727c478bd9Sstevel@tonic-gate
85737c478bd9Sstevel@tonic-gate #ifdef DEBUG
85747c478bd9Sstevel@tonic-gate /*
85757c478bd9Sstevel@tonic-gate * Make sure that the flags are not messed up.
85767c478bd9Sstevel@tonic-gate */
85777c478bd9Sstevel@tonic-gate {
85787c478bd9Sstevel@tonic-gate mblk_t *mp;
85797c478bd9Sstevel@tonic-gate mp = q->q_last;
85807c478bd9Sstevel@tonic-gate while (mp != NULL) {
85817c478bd9Sstevel@tonic-gate ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) !=
85827c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT));
85837c478bd9Sstevel@tonic-gate mp = mp->b_cont;
85847c478bd9Sstevel@tonic-gate }
85857c478bd9Sstevel@tonic-gate }
85867c478bd9Sstevel@tonic-gate #endif
85877c478bd9Sstevel@tonic-gate if (q->q_first == bp) {
85887c478bd9Sstevel@tonic-gate short pollevents;
85897c478bd9Sstevel@tonic-gate
85907c478bd9Sstevel@tonic-gate if (stp->sd_flag & RSLEEP) {
85917c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP;
85927c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait);
85937c478bd9Sstevel@tonic-gate }
85947c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRPRI) {
85957c478bd9Sstevel@tonic-gate pollevents = POLLPRI;
85967c478bd9Sstevel@tonic-gate } else {
85977c478bd9Sstevel@tonic-gate if (band == 0) {
85987c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN))
85997c478bd9Sstevel@tonic-gate return;
86007c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN;
86017c478bd9Sstevel@tonic-gate pollevents = POLLIN | POLLRDNORM;
86027c478bd9Sstevel@tonic-gate } else {
86037c478bd9Sstevel@tonic-gate pollevents = POLLIN | POLLRDBAND;
86047c478bd9Sstevel@tonic-gate }
86057c478bd9Sstevel@tonic-gate }
86067c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
86077c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollevents);
86087c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
86097c478bd9Sstevel@tonic-gate }
86107c478bd9Sstevel@tonic-gate }
86117c478bd9Sstevel@tonic-gate
86127c478bd9Sstevel@tonic-gate /*
86137c478bd9Sstevel@tonic-gate * Return the held vnode attached to the stream head of a
86147c478bd9Sstevel@tonic-gate * given queue
86157c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure
86167c478bd9Sstevel@tonic-gate * that the queue does not go away (e.g. pop).
86177c478bd9Sstevel@tonic-gate */
86187c478bd9Sstevel@tonic-gate vnode_t *
strq2vp(queue_t * qp)86197c478bd9Sstevel@tonic-gate strq2vp(queue_t *qp)
86207c478bd9Sstevel@tonic-gate {
86217c478bd9Sstevel@tonic-gate vnode_t *vp;
86227c478bd9Sstevel@tonic-gate vp = STREAM(qp)->sd_vnode;
86237c478bd9Sstevel@tonic-gate ASSERT(vp != NULL);
86247c478bd9Sstevel@tonic-gate VN_HOLD(vp);
86257c478bd9Sstevel@tonic-gate return (vp);
86267c478bd9Sstevel@tonic-gate }
86277c478bd9Sstevel@tonic-gate
86287c478bd9Sstevel@tonic-gate /*
86297c478bd9Sstevel@tonic-gate * return the stream head write queue for the given vp
86307c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure
86317c478bd9Sstevel@tonic-gate * that the stream or vnode do not close.
86327c478bd9Sstevel@tonic-gate */
86337c478bd9Sstevel@tonic-gate queue_t *
strvp2wq(vnode_t * vp)86347c478bd9Sstevel@tonic-gate strvp2wq(vnode_t *vp)
86357c478bd9Sstevel@tonic-gate {
86367c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream != NULL);
86377c478bd9Sstevel@tonic-gate return (vp->v_stream->sd_wrq);
86387c478bd9Sstevel@tonic-gate }
86397c478bd9Sstevel@tonic-gate
86407c478bd9Sstevel@tonic-gate /*
86417c478bd9Sstevel@tonic-gate * pollwakeup stream head
86427c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure
86437c478bd9Sstevel@tonic-gate * that the stream or vnode do not close.
86447c478bd9Sstevel@tonic-gate */
86457c478bd9Sstevel@tonic-gate void
strpollwakeup(vnode_t * vp,short event)86467c478bd9Sstevel@tonic-gate strpollwakeup(vnode_t *vp, short event)
86477c478bd9Sstevel@tonic-gate {
86487c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
86497c478bd9Sstevel@tonic-gate pollwakeup(&vp->v_stream->sd_pollist, event);
86507c478bd9Sstevel@tonic-gate }
86517c478bd9Sstevel@tonic-gate
86527c478bd9Sstevel@tonic-gate /*
86537c478bd9Sstevel@tonic-gate * Mate the stream heads of two vnodes together. If the two vnodes are the
86547c478bd9Sstevel@tonic-gate * same, we just make the write-side point at the read-side -- otherwise,
86557c478bd9Sstevel@tonic-gate * we do a full mate. Only works on vnodes associated with streams that are
86567c478bd9Sstevel@tonic-gate * still being built and thus have only a stream head.
86577c478bd9Sstevel@tonic-gate */
86587c478bd9Sstevel@tonic-gate void
strmate(vnode_t * vp1,vnode_t * vp2)86597c478bd9Sstevel@tonic-gate strmate(vnode_t *vp1, vnode_t *vp2)
86607c478bd9Sstevel@tonic-gate {
86617c478bd9Sstevel@tonic-gate queue_t *wrq1 = strvp2wq(vp1);
86627c478bd9Sstevel@tonic-gate queue_t *wrq2 = strvp2wq(vp2);
86637c478bd9Sstevel@tonic-gate
86647c478bd9Sstevel@tonic-gate /*
86657c478bd9Sstevel@tonic-gate * Verify that there are no modules on the stream yet. We also
86667c478bd9Sstevel@tonic-gate * rely on the stream head always having a service procedure to
86677c478bd9Sstevel@tonic-gate * avoid tweaking q_nfsrv.
86687c478bd9Sstevel@tonic-gate */
86697c478bd9Sstevel@tonic-gate ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL);
86707c478bd9Sstevel@tonic-gate ASSERT(wrq1->q_qinfo->qi_srvp != NULL);
86717c478bd9Sstevel@tonic-gate ASSERT(wrq2->q_qinfo->qi_srvp != NULL);
86727c478bd9Sstevel@tonic-gate
86737c478bd9Sstevel@tonic-gate /*
86747c478bd9Sstevel@tonic-gate * If the queues are the same, just twist; otherwise do a full mate.
86757c478bd9Sstevel@tonic-gate */
86767c478bd9Sstevel@tonic-gate if (wrq1 == wrq2) {
86777c478bd9Sstevel@tonic-gate wrq1->q_next = _RD(wrq1);
86787c478bd9Sstevel@tonic-gate } else {
86797c478bd9Sstevel@tonic-gate wrq1->q_next = _RD(wrq2);
86807c478bd9Sstevel@tonic-gate wrq2->q_next = _RD(wrq1);
86817c478bd9Sstevel@tonic-gate STREAM(wrq1)->sd_mate = STREAM(wrq2);
86827c478bd9Sstevel@tonic-gate STREAM(wrq1)->sd_flag |= STRMATE;
86837c478bd9Sstevel@tonic-gate STREAM(wrq2)->sd_mate = STREAM(wrq1);
86847c478bd9Sstevel@tonic-gate STREAM(wrq2)->sd_flag |= STRMATE;
86857c478bd9Sstevel@tonic-gate }
86867c478bd9Sstevel@tonic-gate }
86877c478bd9Sstevel@tonic-gate
86887c478bd9Sstevel@tonic-gate /*
86897c478bd9Sstevel@tonic-gate * XXX will go away when console is correctly fixed.
86907c478bd9Sstevel@tonic-gate * Clean up the console PIDS, from previous I_SETSIG,
86917c478bd9Sstevel@tonic-gate * called only for cnopen which never calls strclean().
86927c478bd9Sstevel@tonic-gate */
86937c478bd9Sstevel@tonic-gate void
str_cn_clean(struct vnode * vp)86947c478bd9Sstevel@tonic-gate str_cn_clean(struct vnode *vp)
86957c478bd9Sstevel@tonic-gate {
86967c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp, *tssp;
86977c478bd9Sstevel@tonic-gate struct stdata *stp;
86987c478bd9Sstevel@tonic-gate struct pid *pidp;
86997c478bd9Sstevel@tonic-gate int update = 0;
87007c478bd9Sstevel@tonic-gate
87017c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream);
87027c478bd9Sstevel@tonic-gate stp = vp->v_stream;
87037c478bd9Sstevel@tonic-gate pssp = NULL;
87047c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock);
87057c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist;
87067c478bd9Sstevel@tonic-gate while (ssp) {
87077c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
87087c478bd9Sstevel@tonic-gate pidp = ssp->ss_pidp;
87097c478bd9Sstevel@tonic-gate /*
87107c478bd9Sstevel@tonic-gate * Get rid of PID if the proc is gone.
87117c478bd9Sstevel@tonic-gate */
87127c478bd9Sstevel@tonic-gate if (pidp->pid_prinactive) {
87137c478bd9Sstevel@tonic-gate tssp = ssp->ss_next;
87147c478bd9Sstevel@tonic-gate if (pssp)
87157c478bd9Sstevel@tonic-gate pssp->ss_next = tssp;
87167c478bd9Sstevel@tonic-gate else
87177c478bd9Sstevel@tonic-gate stp->sd_siglist = tssp;
87187c478bd9Sstevel@tonic-gate ASSERT(pidp->pid_ref <= 1);
87197c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp);
87207c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
87217c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t));
87227c478bd9Sstevel@tonic-gate update = 1;
87237c478bd9Sstevel@tonic-gate ssp = tssp;
87247c478bd9Sstevel@tonic-gate continue;
87257c478bd9Sstevel@tonic-gate } else
87267c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
87277c478bd9Sstevel@tonic-gate pssp = ssp;
87287c478bd9Sstevel@tonic-gate ssp = ssp->ss_next;
87297c478bd9Sstevel@tonic-gate }
87307c478bd9Sstevel@tonic-gate if (update) {
87317c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0;
87327c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next)
87337c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events;
87347c478bd9Sstevel@tonic-gate }
87357c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock);
87367c478bd9Sstevel@tonic-gate }
87377c478bd9Sstevel@tonic-gate
87387c478bd9Sstevel@tonic-gate /*
87397c478bd9Sstevel@tonic-gate * Return B_TRUE if there is data in the message, B_FALSE otherwise.
87407c478bd9Sstevel@tonic-gate */
87417c478bd9Sstevel@tonic-gate static boolean_t
msghasdata(mblk_t * bp)87427c478bd9Sstevel@tonic-gate msghasdata(mblk_t *bp)
87437c478bd9Sstevel@tonic-gate {
87447c478bd9Sstevel@tonic-gate for (; bp; bp = bp->b_cont)
87457c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_DATA) {
87467c478bd9Sstevel@tonic-gate ASSERT(bp->b_wptr >= bp->b_rptr);
87477c478bd9Sstevel@tonic-gate if (bp->b_wptr > bp->b_rptr)
87487c478bd9Sstevel@tonic-gate return (B_TRUE);
87497c478bd9Sstevel@tonic-gate }
87507c478bd9Sstevel@tonic-gate return (B_FALSE);
87517c478bd9Sstevel@tonic-gate }
8752