17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 58ec5a142Sedp * Common Development and Distribution License (the "License"). 68ec5a142Sedp * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 227c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 237c478bd9Sstevel@tonic-gate 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate /* 26*f4b3ec61Sdh155122 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 277c478bd9Sstevel@tonic-gate * Use is subject to license terms. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate #include <sys/types.h> 337c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 347c478bd9Sstevel@tonic-gate #include <sys/param.h> 357c478bd9Sstevel@tonic-gate #include <sys/errno.h> 367c478bd9Sstevel@tonic-gate #include <sys/signal.h> 377c478bd9Sstevel@tonic-gate #include <sys/stat.h> 387c478bd9Sstevel@tonic-gate #include <sys/proc.h> 397c478bd9Sstevel@tonic-gate #include <sys/cred.h> 407c478bd9Sstevel@tonic-gate #include <sys/user.h> 417c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 427c478bd9Sstevel@tonic-gate #include <sys/file.h> 437c478bd9Sstevel@tonic-gate #include <sys/stream.h> 447c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 457c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 467c478bd9Sstevel@tonic-gate #include <sys/tihdr.h> 477c478bd9Sstevel@tonic-gate #include <sys/var.h> 487c478bd9Sstevel@tonic-gate #include <sys/poll.h> 497c478bd9Sstevel@tonic-gate #include <sys/termio.h> 507c478bd9Sstevel@tonic-gate #include <sys/ttold.h> 517c478bd9Sstevel@tonic-gate #include <sys/systm.h> 527c478bd9Sstevel@tonic-gate #include <sys/uio.h> 537c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 547c478bd9Sstevel@tonic-gate #include <sys/sad.h> 55*f4b3ec61Sdh155122 #include <sys/netstack.h> 567c478bd9Sstevel@tonic-gate #include <sys/priocntl.h> 577c478bd9Sstevel@tonic-gate #include <sys/jioctl.h> 587c478bd9Sstevel@tonic-gate #include <sys/procset.h> 597c478bd9Sstevel@tonic-gate #include <sys/session.h> 607c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 617c478bd9Sstevel@tonic-gate #include <sys/filio.h> 627c478bd9Sstevel@tonic-gate #include <sys/vtrace.h> 637c478bd9Sstevel@tonic-gate #include <sys/debug.h> 647c478bd9Sstevel@tonic-gate #include <sys/strredir.h> 657c478bd9Sstevel@tonic-gate #include <sys/fs/fifonode.h> 667c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h> 677c478bd9Sstevel@tonic-gate #include <sys/strlog.h> 687c478bd9Sstevel@tonic-gate #include <sys/strsun.h> 697c478bd9Sstevel@tonic-gate #include <sys/project.h> 707c478bd9Sstevel@tonic-gate #include <sys/kbio.h> 717c478bd9Sstevel@tonic-gate #include <sys/msio.h> 727c478bd9Sstevel@tonic-gate #include <sys/tty.h> 737c478bd9Sstevel@tonic-gate #include <sys/ptyvar.h> 747c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h> 757c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 767c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 777c478bd9Sstevel@tonic-gate #include <sys/sunldi_impl.h> 787c478bd9Sstevel@tonic-gate #include <sys/autoconf.h> 797c478bd9Sstevel@tonic-gate #include <sys/policy.h> 80*f4b3ec61Sdh155122 #include <sys/zone.h> 817c478bd9Sstevel@tonic-gate 829acbbeafSnn35248 839acbbeafSnn35248 /* 849acbbeafSnn35248 * This define helps improve the readability of streams code while 859acbbeafSnn35248 * still maintaining a very old streams performance enhancement. The 869acbbeafSnn35248 * performance enhancement basically involved having all callers 879acbbeafSnn35248 * of straccess() perform the first check that straccess() will do 889acbbeafSnn35248 * locally before actually calling straccess(). (There by reducing 899acbbeafSnn35248 * the number of unnecessary calls to straccess().) 909acbbeafSnn35248 */ 919acbbeafSnn35248 #define i_straccess(x, y) ((stp->sd_sidp == NULL) ? 0 : \ 929acbbeafSnn35248 (stp->sd_vnode->v_type == VFIFO) ? 0 : \ 939acbbeafSnn35248 straccess((x), (y))) 949acbbeafSnn35248 957c478bd9Sstevel@tonic-gate /* 967c478bd9Sstevel@tonic-gate * what is mblk_pull_len? 977c478bd9Sstevel@tonic-gate * 987c478bd9Sstevel@tonic-gate * If a streams message consists of many short messages, 997c478bd9Sstevel@tonic-gate * a performance degradation occurs from copyout overhead. 1007c478bd9Sstevel@tonic-gate * To decrease the per mblk overhead, messages that are 1017c478bd9Sstevel@tonic-gate * likely to consist of many small mblks are pulled up into 1027c478bd9Sstevel@tonic-gate * one continuous chunk of memory. 1037c478bd9Sstevel@tonic-gate * 1047c478bd9Sstevel@tonic-gate * To avoid the processing overhead of examining every 1057c478bd9Sstevel@tonic-gate * mblk, a quick heuristic is used. If the first mblk in 1067c478bd9Sstevel@tonic-gate * the message is shorter than mblk_pull_len, it is likely 1077c478bd9Sstevel@tonic-gate * that the rest of the mblk will be short. 1087c478bd9Sstevel@tonic-gate * 1097c478bd9Sstevel@tonic-gate * This heuristic was decided upon after performance tests 1107c478bd9Sstevel@tonic-gate * indicated that anything more complex slowed down the main 1117c478bd9Sstevel@tonic-gate * code path. 1127c478bd9Sstevel@tonic-gate */ 1137c478bd9Sstevel@tonic-gate #define MBLK_PULL_LEN 64 1147c478bd9Sstevel@tonic-gate uint32_t mblk_pull_len = MBLK_PULL_LEN; 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate /* 1177c478bd9Sstevel@tonic-gate * The sgttyb_handling flag controls the handling of the old BSD 1187c478bd9Sstevel@tonic-gate * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows: 1197c478bd9Sstevel@tonic-gate * 1207c478bd9Sstevel@tonic-gate * 0 - Emit no warnings at all and retain old, broken behavior. 1217c478bd9Sstevel@tonic-gate * 1 - Emit no warnings and silently handle new semantics. 1227c478bd9Sstevel@tonic-gate * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used 1237c478bd9Sstevel@tonic-gate * (once per system invocation). Handle with new semantics. 1247c478bd9Sstevel@tonic-gate * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is 1257c478bd9Sstevel@tonic-gate * made (so that offenders drop core and are easy to debug). 1267c478bd9Sstevel@tonic-gate * 1277c478bd9Sstevel@tonic-gate * The "new semantics" are that TIOCGETP returns B38400 for 1287c478bd9Sstevel@tonic-gate * sg_[io]speed if the corresponding value is over B38400, and that 1297c478bd9Sstevel@tonic-gate * TIOCSET[PN] accept B38400 in these cases to mean "retain current 1307c478bd9Sstevel@tonic-gate * bit rate." 1317c478bd9Sstevel@tonic-gate */ 1327c478bd9Sstevel@tonic-gate int sgttyb_handling = 1; 1337c478bd9Sstevel@tonic-gate static boolean_t sgttyb_complaint; 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate /* don't push drcompat module by default on Style-2 streams */ 1367c478bd9Sstevel@tonic-gate static int push_drcompat = 0; 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate /* 1397c478bd9Sstevel@tonic-gate * id value used to distinguish between different ioctl messages 1407c478bd9Sstevel@tonic-gate */ 1417c478bd9Sstevel@tonic-gate static uint32_t ioc_id; 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate static void putback(struct stdata *, queue_t *, mblk_t *, int); 1447c478bd9Sstevel@tonic-gate static void strcleanall(struct vnode *); 1457c478bd9Sstevel@tonic-gate static int strwsrv(queue_t *); 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate /* 1487c478bd9Sstevel@tonic-gate * qinit and module_info structures for stream head read and write queues 1497c478bd9Sstevel@tonic-gate */ 1507c478bd9Sstevel@tonic-gate struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW }; 1517c478bd9Sstevel@tonic-gate struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 }; 1527c478bd9Sstevel@tonic-gate struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info }; 1537c478bd9Sstevel@tonic-gate struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info }; 1547c478bd9Sstevel@tonic-gate struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT, 1557c478bd9Sstevel@tonic-gate FIFOLOWAT }; 1567c478bd9Sstevel@tonic-gate struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 }; 1577c478bd9Sstevel@tonic-gate struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info }; 1587c478bd9Sstevel@tonic-gate struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info }; 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate extern kmutex_t strresources; /* protects global resources */ 1617c478bd9Sstevel@tonic-gate extern kmutex_t muxifier; /* single-threads multiplexor creation */ 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate static boolean_t msghasdata(mblk_t *bp); 1647c478bd9Sstevel@tonic-gate #define msgnodata(bp) (!msghasdata(bp)) 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate /* 1677c478bd9Sstevel@tonic-gate * Stream head locking notes: 1687c478bd9Sstevel@tonic-gate * There are four monitors associated with the stream head: 1697c478bd9Sstevel@tonic-gate * 1. v_stream monitor: in stropen() and strclose() v_lock 1707c478bd9Sstevel@tonic-gate * is held while the association of vnode and stream 1717c478bd9Sstevel@tonic-gate * head is established or tested for. 1727c478bd9Sstevel@tonic-gate * 2. open/close/push/pop monitor: sd_lock is held while each 1737c478bd9Sstevel@tonic-gate * thread bids for exclusive access to this monitor 1747c478bd9Sstevel@tonic-gate * for opening or closing a stream. In addition, this 1757c478bd9Sstevel@tonic-gate * monitor is entered during pushes and pops. This 1767c478bd9Sstevel@tonic-gate * guarantees that during plumbing operations there 1777c478bd9Sstevel@tonic-gate * is only one thread trying to change the plumbing. 1787c478bd9Sstevel@tonic-gate * Any other threads present in the stream are only 1797c478bd9Sstevel@tonic-gate * using the plumbing. 1807c478bd9Sstevel@tonic-gate * 3. read/write monitor: in the case of read, a thread holds 1817c478bd9Sstevel@tonic-gate * sd_lock while trying to get data from the stream 1827c478bd9Sstevel@tonic-gate * head queue. if there is none to fulfill a read 1837c478bd9Sstevel@tonic-gate * request, it sets RSLEEP and calls cv_wait_sig() down 1847c478bd9Sstevel@tonic-gate * in strwaitq() to await the arrival of new data. 1857c478bd9Sstevel@tonic-gate * when new data arrives in strrput(), sd_lock is acquired 1867c478bd9Sstevel@tonic-gate * before testing for RSLEEP and calling cv_broadcast(). 1877c478bd9Sstevel@tonic-gate * the behavior of strwrite(), strwsrv(), and WSLEEP 1887c478bd9Sstevel@tonic-gate * mirror this. 1897c478bd9Sstevel@tonic-gate * 4. ioctl monitor: sd_lock is gotten to ensure that only one 1907c478bd9Sstevel@tonic-gate * thread is doing an ioctl at a time. 1917c478bd9Sstevel@tonic-gate */ 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate static int 1947c478bd9Sstevel@tonic-gate push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name, 195*f4b3ec61Sdh155122 int anchor, cred_t *crp, uint_t anchor_zoneid) 1967c478bd9Sstevel@tonic-gate { 1977c478bd9Sstevel@tonic-gate int error; 1987c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp; 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) { 2017c478bd9Sstevel@tonic-gate error = (stp->sd_flag & STRHUP) ? ENXIO : EIO; 2027c478bd9Sstevel@tonic-gate return (error); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush) { 2057c478bd9Sstevel@tonic-gate return (EINVAL); 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) { 2097c478bd9Sstevel@tonic-gate stp->sd_flag |= STREOPENFAIL; 2107c478bd9Sstevel@tonic-gate return (EINVAL); 2117c478bd9Sstevel@tonic-gate } 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate /* 2147c478bd9Sstevel@tonic-gate * push new module and call its open routine via qattach 2157c478bd9Sstevel@tonic-gate */ 2167c478bd9Sstevel@tonic-gate if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0) 2177c478bd9Sstevel@tonic-gate return (error); 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 2207c478bd9Sstevel@tonic-gate * Check to see if caller wants a STREAMS anchor 2217c478bd9Sstevel@tonic-gate * put at this place in the stream, and add if so. 2227c478bd9Sstevel@tonic-gate */ 2237c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 224*f4b3ec61Sdh155122 if (anchor == stp->sd_pushcnt) { 2257c478bd9Sstevel@tonic-gate stp->sd_anchor = stp->sd_pushcnt; 226*f4b3ec61Sdh155122 stp->sd_anchorzone = anchor_zoneid; 227*f4b3ec61Sdh155122 } 2287c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate return (0); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate /* 2347c478bd9Sstevel@tonic-gate * Open a stream device. 2357c478bd9Sstevel@tonic-gate */ 2367c478bd9Sstevel@tonic-gate int 2377c478bd9Sstevel@tonic-gate stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp) 2387c478bd9Sstevel@tonic-gate { 2397c478bd9Sstevel@tonic-gate struct stdata *stp; 2407c478bd9Sstevel@tonic-gate queue_t *qp; 2417c478bd9Sstevel@tonic-gate int s; 2427c478bd9Sstevel@tonic-gate dev_t dummydev; 2437c478bd9Sstevel@tonic-gate struct autopush *ap; 2447c478bd9Sstevel@tonic-gate int error = 0; 2457c478bd9Sstevel@tonic-gate ssize_t rmin, rmax; 2467c478bd9Sstevel@tonic-gate int cloneopen; 2477c478bd9Sstevel@tonic-gate queue_t *brq; 2487c478bd9Sstevel@tonic-gate major_t major; 249*f4b3ec61Sdh155122 str_stack_t *ss; 250*f4b3ec61Sdh155122 zoneid_t zoneid; 251*f4b3ec61Sdh155122 uint_t anchor; 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 2547c478bd9Sstevel@tonic-gate if (audit_active) 2557c478bd9Sstevel@tonic-gate audit_stropen(vp, devp, flag, crp); 2567c478bd9Sstevel@tonic-gate #endif 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate /* 2597c478bd9Sstevel@tonic-gate * If the stream already exists, wait for any open in progress 2607c478bd9Sstevel@tonic-gate * to complete, then call the open function of each module and 2617c478bd9Sstevel@tonic-gate * driver in the stream. Otherwise create the stream. 2627c478bd9Sstevel@tonic-gate */ 2637c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp); 2647c478bd9Sstevel@tonic-gate retry: 2657c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 2667c478bd9Sstevel@tonic-gate if ((stp = vp->v_stream) != NULL) { 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate /* 2697c478bd9Sstevel@tonic-gate * Waiting for stream to be created to device 2707c478bd9Sstevel@tonic-gate * due to another open. 2717c478bd9Sstevel@tonic-gate */ 2727c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate if (STRMATED(stp)) { 2757c478bd9Sstevel@tonic-gate struct stdata *strmatep = stp->sd_mate; 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate STRLOCKMATES(stp); 2787c478bd9Sstevel@tonic-gate if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) { 2797c478bd9Sstevel@tonic-gate if (flag & (FNDELAY|FNONBLOCK)) { 2807c478bd9Sstevel@tonic-gate error = EAGAIN; 2817c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 2827c478bd9Sstevel@tonic-gate goto ckreturn; 2837c478bd9Sstevel@tonic-gate } 2847c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 2857c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&strmatep->sd_monitor, 2867c478bd9Sstevel@tonic-gate &strmatep->sd_lock)) { 2877c478bd9Sstevel@tonic-gate error = EINTR; 2887c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 2897c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 2907c478bd9Sstevel@tonic-gate goto ckreturn; 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 2937c478bd9Sstevel@tonic-gate goto retry; 2947c478bd9Sstevel@tonic-gate } 2957c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) { 2967c478bd9Sstevel@tonic-gate if (flag & (FNDELAY|FNONBLOCK)) { 2977c478bd9Sstevel@tonic-gate error = EAGAIN; 2987c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 2997c478bd9Sstevel@tonic-gate goto ckreturn; 3007c478bd9Sstevel@tonic-gate } 3017c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 3027c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) { 3037c478bd9Sstevel@tonic-gate error = EINTR; 3047c478bd9Sstevel@tonic-gate goto ckreturn; 3057c478bd9Sstevel@tonic-gate } 3067c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 3077c478bd9Sstevel@tonic-gate goto retry; 3087c478bd9Sstevel@tonic-gate } 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR)) { 3117c478bd9Sstevel@tonic-gate error = EIO; 3127c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 3137c478bd9Sstevel@tonic-gate goto ckreturn; 3147c478bd9Sstevel@tonic-gate } 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate stp->sd_flag |= STWOPEN; 3177c478bd9Sstevel@tonic-gate STRUNLOCKMATES(stp); 3187c478bd9Sstevel@tonic-gate } else { 3197c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 3207c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) { 3217c478bd9Sstevel@tonic-gate if (flag & (FNDELAY|FNONBLOCK)) { 3227c478bd9Sstevel@tonic-gate error = EAGAIN; 3237c478bd9Sstevel@tonic-gate goto ckreturn; 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) { 3267c478bd9Sstevel@tonic-gate error = EINTR; 3277c478bd9Sstevel@tonic-gate goto ckreturn; 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 3307c478bd9Sstevel@tonic-gate goto retry; /* could be clone! */ 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR)) { 3347c478bd9Sstevel@tonic-gate error = EIO; 3357c478bd9Sstevel@tonic-gate goto ckreturn; 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate stp->sd_flag |= STWOPEN; 3397c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate /* 3437c478bd9Sstevel@tonic-gate * Open all modules and devices down stream to notify 3447c478bd9Sstevel@tonic-gate * that another user is streaming. For modules, set the 3457c478bd9Sstevel@tonic-gate * last argument to MODOPEN and do not pass any open flags. 3467c478bd9Sstevel@tonic-gate * Ignore dummydev since this is not the first open. 3477c478bd9Sstevel@tonic-gate */ 3487c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq); 3497c478bd9Sstevel@tonic-gate qp = stp->sd_wrq; 3507c478bd9Sstevel@tonic-gate while (_SAMESTR(qp)) { 3517c478bd9Sstevel@tonic-gate qp = qp->q_next; 3527c478bd9Sstevel@tonic-gate if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0) 3537c478bd9Sstevel@tonic-gate break; 3547c478bd9Sstevel@tonic-gate } 3557c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 3567c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 3577c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR); 3587c478bd9Sstevel@tonic-gate stp->sd_rerror = 0; 3597c478bd9Sstevel@tonic-gate stp->sd_werror = 0; 3607c478bd9Sstevel@tonic-gate ckreturn: 3617c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 3627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 3637c478bd9Sstevel@tonic-gate return (error); 3647c478bd9Sstevel@tonic-gate } 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate /* 3677c478bd9Sstevel@tonic-gate * This vnode isn't streaming. SPECFS already 3687c478bd9Sstevel@tonic-gate * checked for multiple vnodes pointing to the 3697c478bd9Sstevel@tonic-gate * same stream, so create a stream to the driver. 3707c478bd9Sstevel@tonic-gate */ 3717c478bd9Sstevel@tonic-gate qp = allocq(); 3727c478bd9Sstevel@tonic-gate stp = shalloc(qp); 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate /* 3757c478bd9Sstevel@tonic-gate * Initialize stream head. shalloc() has given us 3767c478bd9Sstevel@tonic-gate * exclusive access, and we have the vnode locked; 3777c478bd9Sstevel@tonic-gate * we can do whatever we want with stp. 3787c478bd9Sstevel@tonic-gate */ 3797c478bd9Sstevel@tonic-gate stp->sd_flag = STWOPEN; 3807c478bd9Sstevel@tonic-gate stp->sd_siglist = NULL; 3817c478bd9Sstevel@tonic-gate stp->sd_pollist.ph_list = NULL; 3827c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 3837c478bd9Sstevel@tonic-gate stp->sd_mark = NULL; 3847c478bd9Sstevel@tonic-gate stp->sd_closetime = STRTIMOUT; 3857c478bd9Sstevel@tonic-gate stp->sd_sidp = NULL; 3867c478bd9Sstevel@tonic-gate stp->sd_pgidp = NULL; 3877c478bd9Sstevel@tonic-gate stp->sd_vnode = vp; 3887c478bd9Sstevel@tonic-gate stp->sd_rerror = 0; 3897c478bd9Sstevel@tonic-gate stp->sd_werror = 0; 3907c478bd9Sstevel@tonic-gate stp->sd_wroff = 0; 391c28749e9Skais stp->sd_tail = 0; 3927c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL; 3937c478bd9Sstevel@tonic-gate stp->sd_pushcnt = 0; 3947c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = 0; 3957c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = INFPSZ - 1; /* used to check for initialization */ 3967c478bd9Sstevel@tonic-gate stp->sd_maxblk = INFPSZ; 3977c478bd9Sstevel@tonic-gate qp->q_ptr = _WR(qp)->q_ptr = stp; 3987c478bd9Sstevel@tonic-gate STREAM(qp) = STREAM(_WR(qp)) = stp; 3997c478bd9Sstevel@tonic-gate vp->v_stream = stp; 4007c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 4017c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) { 4027c478bd9Sstevel@tonic-gate stp->sd_flag |= OLDNDELAY; 4037c478bd9Sstevel@tonic-gate /* 4047c478bd9Sstevel@tonic-gate * This means, both for pipes and fifos 4057c478bd9Sstevel@tonic-gate * strwrite will send SIGPIPE if the other 4067c478bd9Sstevel@tonic-gate * end is closed. For putmsg it depends 4077c478bd9Sstevel@tonic-gate * on whether it is a XPG4_2 application 4087c478bd9Sstevel@tonic-gate * or not 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate stp->sd_wput_opt = SW_SIGPIPE; 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate /* setq might sleep in kmem_alloc - avoid holding locks. */ 4137c478bd9Sstevel@tonic-gate setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE, 4147c478bd9Sstevel@tonic-gate SQ_CI|SQ_CO, B_FALSE); 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate set_qend(qp); 417ad1660d0Smeem stp->sd_strtab = fifo_getinfo(); 4187c478bd9Sstevel@tonic-gate _WR(qp)->q_nfsrv = _WR(qp); 4197c478bd9Sstevel@tonic-gate qp->q_nfsrv = qp; 4207c478bd9Sstevel@tonic-gate /* 4217c478bd9Sstevel@tonic-gate * Wake up others that are waiting for stream to be created. 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 4247c478bd9Sstevel@tonic-gate /* 4257c478bd9Sstevel@tonic-gate * nothing is be pushed on stream yet, so 4267c478bd9Sstevel@tonic-gate * optimized stream head packetsizes are just that 4277c478bd9Sstevel@tonic-gate * of the read queue 4287c478bd9Sstevel@tonic-gate */ 4297c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = qp->q_minpsz; 4307c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = qp->q_maxpsz; 4317c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWOPEN; 4327c478bd9Sstevel@tonic-gate goto fifo_opendone; 4337c478bd9Sstevel@tonic-gate } 4347c478bd9Sstevel@tonic-gate /* setq might sleep in kmem_alloc - avoid holding locks. */ 4357c478bd9Sstevel@tonic-gate setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE); 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate set_qend(qp); 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate /* 4407c478bd9Sstevel@tonic-gate * Open driver and create stream to it (via qattach). 4417c478bd9Sstevel@tonic-gate */ 4427c478bd9Sstevel@tonic-gate cloneopen = (getmajor(*devp) == clone_major); 4437c478bd9Sstevel@tonic-gate if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) { 4447c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 4457c478bd9Sstevel@tonic-gate vp->v_stream = NULL; 4467c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 4477c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 4487c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 4497c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 4507c478bd9Sstevel@tonic-gate freeq(_RD(qp)); 4517c478bd9Sstevel@tonic-gate shfree(stp); 4527c478bd9Sstevel@tonic-gate return (error); 4537c478bd9Sstevel@tonic-gate } 4547c478bd9Sstevel@tonic-gate /* 4557c478bd9Sstevel@tonic-gate * Set sd_strtab after open in order to handle clonable drivers 4567c478bd9Sstevel@tonic-gate */ 4577c478bd9Sstevel@tonic-gate stp->sd_strtab = STREAMSTAB(getmajor(*devp)); 4587c478bd9Sstevel@tonic-gate 4597c478bd9Sstevel@tonic-gate /* 4607c478bd9Sstevel@tonic-gate * Historical note: dummydev used to be be prior to the initial 4617c478bd9Sstevel@tonic-gate * open (via qattach above), which made the value seen 4627c478bd9Sstevel@tonic-gate * inconsistent between an I_PUSH and an autopush of a module. 4637c478bd9Sstevel@tonic-gate */ 4647c478bd9Sstevel@tonic-gate dummydev = *devp; 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate /* 4677c478bd9Sstevel@tonic-gate * For clone open of old style (Q not associated) network driver, 4687c478bd9Sstevel@tonic-gate * push DRMODNAME module to handle DL_ATTACH/DL_DETACH 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate brq = _RD(_WR(qp)->q_next); 4717c478bd9Sstevel@tonic-gate major = getmajor(*devp); 4727c478bd9Sstevel@tonic-gate if (push_drcompat && cloneopen && NETWORK_DRV(major) && 4737c478bd9Sstevel@tonic-gate ((brq->q_flag & _QASSOCIATED) == 0)) { 474*f4b3ec61Sdh155122 if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp, 0) != 0) 4757c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "cannot push " DRMODNAME 4767c478bd9Sstevel@tonic-gate " streams module"); 4777c478bd9Sstevel@tonic-gate } 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate /* 480*f4b3ec61Sdh155122 * Check for autopush. Start with the global zone. If not found 481*f4b3ec61Sdh155122 * check in the local zone. 4827c478bd9Sstevel@tonic-gate */ 483*f4b3ec61Sdh155122 zoneid = GLOBAL_ZONEID; 484*f4b3ec61Sdh155122 retryap: 485*f4b3ec61Sdh155122 ss = netstack_find_by_stackid(zoneid_to_netstackid(zoneid))-> 486*f4b3ec61Sdh155122 netstack_str; 487*f4b3ec61Sdh155122 if ((ap = sad_ap_find_by_dev(*devp, ss)) == NULL) { 488*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 489*f4b3ec61Sdh155122 if (zoneid == GLOBAL_ZONEID) { 490*f4b3ec61Sdh155122 /* 491*f4b3ec61Sdh155122 * None found. Also look in the zone's autopush table. 492*f4b3ec61Sdh155122 */ 493*f4b3ec61Sdh155122 zoneid = crgetzoneid(crp); 494*f4b3ec61Sdh155122 if (zoneid != GLOBAL_ZONEID) 495*f4b3ec61Sdh155122 goto retryap; 496*f4b3ec61Sdh155122 } 4977c478bd9Sstevel@tonic-gate goto opendone; 498*f4b3ec61Sdh155122 } 499*f4b3ec61Sdh155122 anchor = ap->ap_anchor; 500*f4b3ec61Sdh155122 zoneid = crgetzoneid(crp); 5017c478bd9Sstevel@tonic-gate for (s = 0; s < ap->ap_npush; s++) { 5027c478bd9Sstevel@tonic-gate error = push_mod(qp, &dummydev, stp, ap->ap_list[s], 503*f4b3ec61Sdh155122 anchor, crp, zoneid); 5047c478bd9Sstevel@tonic-gate if (error != 0) 5057c478bd9Sstevel@tonic-gate break; 5067c478bd9Sstevel@tonic-gate } 507*f4b3ec61Sdh155122 sad_ap_rele(ap, ss); 508*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate /* 5117c478bd9Sstevel@tonic-gate * let specfs know that open failed part way through 5127c478bd9Sstevel@tonic-gate */ 5137c478bd9Sstevel@tonic-gate if (error) { 5147c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 5157c478bd9Sstevel@tonic-gate stp->sd_flag |= STREOPENFAIL; 5167c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate opendone: 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* 5227c478bd9Sstevel@tonic-gate * Wake up others that are waiting for stream to be created. 5237c478bd9Sstevel@tonic-gate */ 5247c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 5257c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWOPEN; 5267c478bd9Sstevel@tonic-gate 5277c478bd9Sstevel@tonic-gate /* 5287c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of 5297c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream 5307c478bd9Sstevel@tonic-gate * head in the stream head. 5317c478bd9Sstevel@tonic-gate */ 5327c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next)); 5337c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz; 5347c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz; 5357c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next)); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* do this processing here as a performance concern */ 5387c478bd9Sstevel@tonic-gate if (strmsgsz != 0) { 5397c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) 5407c478bd9Sstevel@tonic-gate rmax = strmsgsz; 5417c478bd9Sstevel@tonic-gate else 5427c478bd9Sstevel@tonic-gate rmax = MIN(strmsgsz, rmax); 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq)); 5467c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin; 5477c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax; 5487c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq)); 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate fifo_opendone: 5517c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 5527c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 5537c478bd9Sstevel@tonic-gate return (error); 5547c478bd9Sstevel@tonic-gate } 5557c478bd9Sstevel@tonic-gate 5567c478bd9Sstevel@tonic-gate static int strsink(queue_t *, mblk_t *); 5577c478bd9Sstevel@tonic-gate static struct qinit deadrend = { 5587c478bd9Sstevel@tonic-gate strsink, NULL, NULL, NULL, NULL, &strm_info, NULL 5597c478bd9Sstevel@tonic-gate }; 5607c478bd9Sstevel@tonic-gate static struct qinit deadwend = { 5617c478bd9Sstevel@tonic-gate NULL, NULL, NULL, NULL, NULL, &stwm_info, NULL 5627c478bd9Sstevel@tonic-gate }; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * Close a stream. 5667c478bd9Sstevel@tonic-gate * This is called from closef() on the last close of an open stream. 5677c478bd9Sstevel@tonic-gate * Strclean() will already have removed the siglist and pollist 5687c478bd9Sstevel@tonic-gate * information, so all that remains is to remove all multiplexor links 5697c478bd9Sstevel@tonic-gate * for the stream, pop all the modules (and the driver), and free the 5707c478bd9Sstevel@tonic-gate * stream structure. 5717c478bd9Sstevel@tonic-gate */ 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate int 5747c478bd9Sstevel@tonic-gate strclose(struct vnode *vp, int flag, cred_t *crp) 5757c478bd9Sstevel@tonic-gate { 5767c478bd9Sstevel@tonic-gate struct stdata *stp; 5777c478bd9Sstevel@tonic-gate queue_t *qp; 5787c478bd9Sstevel@tonic-gate int rval; 5797c478bd9Sstevel@tonic-gate int freestp = 1; 5807c478bd9Sstevel@tonic-gate queue_t *rmq; 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 5837c478bd9Sstevel@tonic-gate if (audit_active) 5847c478bd9Sstevel@tonic-gate audit_strclose(vp, flag, crp); 5857c478bd9Sstevel@tonic-gate #endif 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 5887c478bd9Sstevel@tonic-gate TR_STRCLOSE, "strclose:%p", vp); 5897c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate stp = vp->v_stream; 5927c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX)); 5937c478bd9Sstevel@tonic-gate qp = stp->sd_wrq; 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate /* 5967c478bd9Sstevel@tonic-gate * Needed so that strpoll will return non-zero for this fd. 5977c478bd9Sstevel@tonic-gate * Note that with POLLNOERR STRHUP does still cause POLLHUP. 5987c478bd9Sstevel@tonic-gate */ 5997c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 6007c478bd9Sstevel@tonic-gate stp->sd_flag |= STRHUP; 6017c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate /* 6047c478bd9Sstevel@tonic-gate * If the registered process or process group did not have an 6057c478bd9Sstevel@tonic-gate * open instance of this stream then strclean would not be 6067c478bd9Sstevel@tonic-gate * called. Thus at the time of closing all remaining siglist entries 6077c478bd9Sstevel@tonic-gate * are removed. 6087c478bd9Sstevel@tonic-gate */ 6097c478bd9Sstevel@tonic-gate if (stp->sd_siglist != NULL) 6107c478bd9Sstevel@tonic-gate strcleanall(vp); 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate ASSERT(stp->sd_siglist == NULL); 6137c478bd9Sstevel@tonic-gate ASSERT(stp->sd_sigflags == 0); 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate if (STRMATED(stp)) { 6167c478bd9Sstevel@tonic-gate struct stdata *strmatep = stp->sd_mate; 6177c478bd9Sstevel@tonic-gate int waited = 1; 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate STRLOCKMATES(stp); 6207c478bd9Sstevel@tonic-gate while (waited) { 6217c478bd9Sstevel@tonic-gate waited = 0; 6227c478bd9Sstevel@tonic-gate while (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) { 6237c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 6247c478bd9Sstevel@tonic-gate cv_wait(&stp->sd_monitor, &stp->sd_lock); 6257c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 6267c478bd9Sstevel@tonic-gate STRLOCKMATES(stp); 6277c478bd9Sstevel@tonic-gate waited = 1; 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate while (strmatep->sd_flag & 6307c478bd9Sstevel@tonic-gate (STWOPEN|STRCLOSE|STRPLUMB)) { 6317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 6327c478bd9Sstevel@tonic-gate cv_wait(&strmatep->sd_monitor, 6337c478bd9Sstevel@tonic-gate &strmatep->sd_lock); 6347c478bd9Sstevel@tonic-gate mutex_exit(&strmatep->sd_lock); 6357c478bd9Sstevel@tonic-gate STRLOCKMATES(stp); 6367c478bd9Sstevel@tonic-gate waited = 1; 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate stp->sd_flag |= STRCLOSE; 6407c478bd9Sstevel@tonic-gate STRUNLOCKMATES(stp); 6417c478bd9Sstevel@tonic-gate } else { 6427c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 6437c478bd9Sstevel@tonic-gate stp->sd_flag |= STRCLOSE; 6447c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate ASSERT(qp->q_first == NULL); /* No more delayed write */ 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate /* Check if an I_LINK was ever done on this stream */ 6507c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHASLINKS) { 651*f4b3ec61Sdh155122 netstack_t *ns; 652*f4b3ec61Sdh155122 str_stack_t *ss; 653*f4b3ec61Sdh155122 654*f4b3ec61Sdh155122 ns = netstack_find_by_cred(crp); 655*f4b3ec61Sdh155122 ASSERT(ns != NULL); 656*f4b3ec61Sdh155122 ss = ns->netstack_str; 657*f4b3ec61Sdh155122 ASSERT(ss != NULL); 658*f4b3ec61Sdh155122 659*f4b3ec61Sdh155122 (void) munlinkall(stp, LINKCLOSE|LINKNORMAL, crp, &rval, ss); 660*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate while (_SAMESTR(qp)) { 6647c478bd9Sstevel@tonic-gate /* 6657c478bd9Sstevel@tonic-gate * Holding sd_lock prevents q_next from changing in 6667c478bd9Sstevel@tonic-gate * this stream. 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 6697c478bd9Sstevel@tonic-gate if (!(flag & (FNDELAY|FNONBLOCK)) && (stp->sd_closetime > 0)) { 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate /* 6727c478bd9Sstevel@tonic-gate * sleep until awakened by strwsrv() or timeout 6737c478bd9Sstevel@tonic-gate */ 6747c478bd9Sstevel@tonic-gate for (;;) { 6757c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(qp->q_next)); 6767c478bd9Sstevel@tonic-gate if (!(qp->q_next->q_mblkcnt)) { 6777c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(qp->q_next)); 6787c478bd9Sstevel@tonic-gate break; 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate stp->sd_flag |= WSLEEP; 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate /* ensure strwsrv gets enabled */ 6837c478bd9Sstevel@tonic-gate qp->q_next->q_flag |= QWANTW; 6847c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(qp->q_next)); 6857c478bd9Sstevel@tonic-gate /* get out if we timed out or recv'd a signal */ 6867c478bd9Sstevel@tonic-gate if (str_cv_wait(&qp->q_wait, &stp->sd_lock, 6877c478bd9Sstevel@tonic-gate stp->sd_closetime, 0) <= 0) { 6887c478bd9Sstevel@tonic-gate break; 6897c478bd9Sstevel@tonic-gate } 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP; 6927c478bd9Sstevel@tonic-gate } 6937c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate rmq = qp->q_next; 6967c478bd9Sstevel@tonic-gate if (rmq->q_flag & QISDRV) { 6977c478bd9Sstevel@tonic-gate ASSERT(!_SAMESTR(rmq)); 6987c478bd9Sstevel@tonic-gate wait_sq_svc(_RD(qp)->q_syncq); 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate qdetach(_RD(rmq), 1, flag, crp, B_FALSE); 7027c478bd9Sstevel@tonic-gate } 7037c478bd9Sstevel@tonic-gate 7048ec5a142Sedp /* 7058ec5a142Sedp * Since we call pollwakeup in close() now, the poll list should 7068ec5a142Sedp * be empty in most cases. The only exception is the layered devices 7078ec5a142Sedp * (e.g. the console drivers with redirection modules pushed on top 7088ec5a142Sedp * of it). We have to do this after calling qdetach() because 7098ec5a142Sedp * the redirection module won't have torn down the console 7108ec5a142Sedp * redirection until after qdetach() has been invoked. 7118ec5a142Sedp */ 7128ec5a142Sedp if (stp->sd_pollist.ph_list != NULL) { 7138ec5a142Sedp pollwakeup(&stp->sd_pollist, POLLERR); 7148ec5a142Sedp pollhead_clean(&stp->sd_pollist); 7158ec5a142Sedp } 7168ec5a142Sedp ASSERT(stp->sd_pollist.ph_list == NULL); 7178ec5a142Sedp ASSERT(stp->sd_sidp == NULL); 7188ec5a142Sedp ASSERT(stp->sd_pgidp == NULL); 7198ec5a142Sedp 7207c478bd9Sstevel@tonic-gate /* Prevent qenable from re-enabling the stream head queue */ 7217c478bd9Sstevel@tonic-gate disable_svc(_RD(qp)); 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate /* 7247c478bd9Sstevel@tonic-gate * Wait until service procedure of each queue is 7257c478bd9Sstevel@tonic-gate * run, if QINSERVICE is set. 7267c478bd9Sstevel@tonic-gate */ 7277c478bd9Sstevel@tonic-gate wait_svc(_RD(qp)); 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate /* 7307c478bd9Sstevel@tonic-gate * Now, flush both queues. 7317c478bd9Sstevel@tonic-gate */ 7327c478bd9Sstevel@tonic-gate flushq(_RD(qp), FLUSHALL); 7337c478bd9Sstevel@tonic-gate flushq(qp, FLUSHALL); 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate /* 7367c478bd9Sstevel@tonic-gate * If the write queue of the stream head is pointing to a 7377c478bd9Sstevel@tonic-gate * read queue, we have a twisted stream. If the read queue 7387c478bd9Sstevel@tonic-gate * is alive, convert the stream head queues into a dead end. 7397c478bd9Sstevel@tonic-gate * If the read queue is dead, free the dead pair. 7407c478bd9Sstevel@tonic-gate */ 7417c478bd9Sstevel@tonic-gate if (qp->q_next && !_SAMESTR(qp)) { 7427c478bd9Sstevel@tonic-gate if (qp->q_next->q_qinfo == &deadrend) { /* half-closed pipe */ 7437c478bd9Sstevel@tonic-gate flushq(qp->q_next, FLUSHALL); /* ensure no message */ 7447c478bd9Sstevel@tonic-gate shfree(qp->q_next->q_stream); 7457c478bd9Sstevel@tonic-gate freeq(qp->q_next); 7467c478bd9Sstevel@tonic-gate freeq(_RD(qp)); 7477c478bd9Sstevel@tonic-gate } else if (qp->q_next == _RD(qp)) { /* fifo */ 7487c478bd9Sstevel@tonic-gate freeq(_RD(qp)); 7497c478bd9Sstevel@tonic-gate } else { /* pipe */ 7507c478bd9Sstevel@tonic-gate freestp = 0; 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * The q_info pointers are never accessed when 7537c478bd9Sstevel@tonic-gate * SQLOCK is held. 7547c478bd9Sstevel@tonic-gate */ 7557c478bd9Sstevel@tonic-gate ASSERT(qp->q_syncq == _RD(qp)->q_syncq); 7567c478bd9Sstevel@tonic-gate mutex_enter(SQLOCK(qp->q_syncq)); 7577c478bd9Sstevel@tonic-gate qp->q_qinfo = &deadwend; 7587c478bd9Sstevel@tonic-gate _RD(qp)->q_qinfo = &deadrend; 7597c478bd9Sstevel@tonic-gate mutex_exit(SQLOCK(qp->q_syncq)); 7607c478bd9Sstevel@tonic-gate } 7617c478bd9Sstevel@tonic-gate } else { 7627c478bd9Sstevel@tonic-gate freeq(_RD(qp)); /* free stream head queue pair */ 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate mutex_enter(&vp->v_lock); 7667c478bd9Sstevel@tonic-gate if (stp->sd_iocblk) { 7677c478bd9Sstevel@tonic-gate if (stp->sd_iocblk != (mblk_t *)-1) { 7687c478bd9Sstevel@tonic-gate freemsg(stp->sd_iocblk); 7697c478bd9Sstevel@tonic-gate } 7707c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL; 7717c478bd9Sstevel@tonic-gate } 7727c478bd9Sstevel@tonic-gate stp->sd_vnode = NULL; 7737c478bd9Sstevel@tonic-gate vp->v_stream = NULL; 7747c478bd9Sstevel@tonic-gate mutex_exit(&vp->v_lock); 7757c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 7767c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRCLOSE; 7777c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 7787c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate if (freestp) 7817c478bd9Sstevel@tonic-gate shfree(stp); 7827c478bd9Sstevel@tonic-gate return (0); 7837c478bd9Sstevel@tonic-gate } 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate static int 7867c478bd9Sstevel@tonic-gate strsink(queue_t *q, mblk_t *bp) 7877c478bd9Sstevel@tonic-gate { 7887c478bd9Sstevel@tonic-gate struct copyresp *resp; 7897c478bd9Sstevel@tonic-gate 7907c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) { 7917c478bd9Sstevel@tonic-gate case M_FLUSH: 7927c478bd9Sstevel@tonic-gate if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) { 7937c478bd9Sstevel@tonic-gate *bp->b_rptr &= ~FLUSHR; 7947c478bd9Sstevel@tonic-gate bp->b_flag |= MSGNOLOOP; 7957c478bd9Sstevel@tonic-gate /* 7967c478bd9Sstevel@tonic-gate * Protect against the driver passing up 7977c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 7987c478bd9Sstevel@tonic-gate */ 7997c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 8007c478bd9Sstevel@tonic-gate freemsg(bp); 8017c478bd9Sstevel@tonic-gate else 8027c478bd9Sstevel@tonic-gate qreply(q, bp); 8037c478bd9Sstevel@tonic-gate } else { 8047c478bd9Sstevel@tonic-gate freemsg(bp); 8057c478bd9Sstevel@tonic-gate } 8067c478bd9Sstevel@tonic-gate break; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate case M_COPYIN: 8097c478bd9Sstevel@tonic-gate case M_COPYOUT: 8107c478bd9Sstevel@tonic-gate if (bp->b_cont) { 8117c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 8127c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 8137c478bd9Sstevel@tonic-gate } 8147c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA; 8157c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp); 8167c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr; 8177c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)1; /* failure */ 8187c478bd9Sstevel@tonic-gate /* 8197c478bd9Sstevel@tonic-gate * Protect against the driver passing up 8207c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 8217c478bd9Sstevel@tonic-gate */ 8227c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 8237c478bd9Sstevel@tonic-gate freemsg(bp); 8247c478bd9Sstevel@tonic-gate else 8257c478bd9Sstevel@tonic-gate qreply(q, bp); 8267c478bd9Sstevel@tonic-gate break; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate case M_IOCTL: 8297c478bd9Sstevel@tonic-gate if (bp->b_cont) { 8307c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 8317c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 8327c478bd9Sstevel@tonic-gate } 8337c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK; 8347c478bd9Sstevel@tonic-gate /* 8357c478bd9Sstevel@tonic-gate * Protect against the driver passing up 8367c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 8377c478bd9Sstevel@tonic-gate */ 8387c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 8397c478bd9Sstevel@tonic-gate freemsg(bp); 8407c478bd9Sstevel@tonic-gate else 8417c478bd9Sstevel@tonic-gate qreply(q, bp); 8427c478bd9Sstevel@tonic-gate break; 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate default: 8457c478bd9Sstevel@tonic-gate freemsg(bp); 8467c478bd9Sstevel@tonic-gate break; 8477c478bd9Sstevel@tonic-gate } 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate return (0); 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate /* 8537c478bd9Sstevel@tonic-gate * Clean up after a process when it closes a stream. This is called 8547c478bd9Sstevel@tonic-gate * from closef for all closes, whereas strclose is called only for the 8557c478bd9Sstevel@tonic-gate * last close on a stream. The siglist is scanned for entries for the 8567c478bd9Sstevel@tonic-gate * current process, and these are removed. 8577c478bd9Sstevel@tonic-gate */ 8587c478bd9Sstevel@tonic-gate void 8597c478bd9Sstevel@tonic-gate strclean(struct vnode *vp) 8607c478bd9Sstevel@tonic-gate { 8617c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp, *tssp; 8627c478bd9Sstevel@tonic-gate stdata_t *stp; 8637c478bd9Sstevel@tonic-gate int update = 0; 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 8667c478bd9Sstevel@tonic-gate TR_STRCLEAN, "strclean:%p", vp); 8677c478bd9Sstevel@tonic-gate stp = vp->v_stream; 8687c478bd9Sstevel@tonic-gate pssp = NULL; 8697c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 8707c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist; 8717c478bd9Sstevel@tonic-gate while (ssp) { 8727c478bd9Sstevel@tonic-gate if (ssp->ss_pidp == curproc->p_pidp) { 8737c478bd9Sstevel@tonic-gate tssp = ssp->ss_next; 8747c478bd9Sstevel@tonic-gate if (pssp) 8757c478bd9Sstevel@tonic-gate pssp->ss_next = tssp; 8767c478bd9Sstevel@tonic-gate else 8777c478bd9Sstevel@tonic-gate stp->sd_siglist = tssp; 8787c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 8797c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp); 8807c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 8817c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t)); 8827c478bd9Sstevel@tonic-gate update = 1; 8837c478bd9Sstevel@tonic-gate ssp = tssp; 8847c478bd9Sstevel@tonic-gate } else { 8857c478bd9Sstevel@tonic-gate pssp = ssp; 8867c478bd9Sstevel@tonic-gate ssp = ssp->ss_next; 8877c478bd9Sstevel@tonic-gate } 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate if (update) { 8907c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 8917c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 8927c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events; 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 8957c478bd9Sstevel@tonic-gate } 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate /* 8987c478bd9Sstevel@tonic-gate * Used on the last close to remove any remaining items on the siglist. 8997c478bd9Sstevel@tonic-gate * These could be present on the siglist due to I_ESETSIG calls that 9007c478bd9Sstevel@tonic-gate * use process groups or processed that do not have an open file descriptor 9017c478bd9Sstevel@tonic-gate * for this stream (Such entries would not be removed by strclean). 9027c478bd9Sstevel@tonic-gate */ 9037c478bd9Sstevel@tonic-gate static void 9047c478bd9Sstevel@tonic-gate strcleanall(struct vnode *vp) 9057c478bd9Sstevel@tonic-gate { 9067c478bd9Sstevel@tonic-gate strsig_t *ssp, *nssp; 9077c478bd9Sstevel@tonic-gate stdata_t *stp; 9087c478bd9Sstevel@tonic-gate 9097c478bd9Sstevel@tonic-gate stp = vp->v_stream; 9107c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 9117c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist; 9127c478bd9Sstevel@tonic-gate stp->sd_siglist = NULL; 9137c478bd9Sstevel@tonic-gate while (ssp) { 9147c478bd9Sstevel@tonic-gate nssp = ssp->ss_next; 9157c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 9167c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp); 9177c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 9187c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t)); 9197c478bd9Sstevel@tonic-gate ssp = nssp; 9207c478bd9Sstevel@tonic-gate } 9217c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 9227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 9237c478bd9Sstevel@tonic-gate } 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate /* 9267c478bd9Sstevel@tonic-gate * Retrieve the next message from the logical stream head read queue 9277c478bd9Sstevel@tonic-gate * using either rwnext (if sync stream) or getq_noenab. 9287c478bd9Sstevel@tonic-gate * It is the callers responsibility to call qbackenable after 9297c478bd9Sstevel@tonic-gate * it is finished with the message. The caller should not call 9307c478bd9Sstevel@tonic-gate * qbackenable until after any putback calls to avoid spurious backenabling. 9317c478bd9Sstevel@tonic-gate */ 9327c478bd9Sstevel@tonic-gate mblk_t * 9337c478bd9Sstevel@tonic-gate strget(struct stdata *stp, queue_t *q, struct uio *uiop, int first, 9347c478bd9Sstevel@tonic-gate int *errorp) 9357c478bd9Sstevel@tonic-gate { 9367c478bd9Sstevel@tonic-gate mblk_t *bp; 9377c478bd9Sstevel@tonic-gate int error; 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 9407c478bd9Sstevel@tonic-gate /* Holding sd_lock prevents the read queue from changing */ 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate if (uiop != NULL && stp->sd_struiordq != NULL && 9437c478bd9Sstevel@tonic-gate q->q_first == NULL && 9447c478bd9Sstevel@tonic-gate (!first || (stp->sd_wakeq & RSLEEP))) { 9457c478bd9Sstevel@tonic-gate /* 9467c478bd9Sstevel@tonic-gate * Stream supports rwnext() for the read side. 9477c478bd9Sstevel@tonic-gate * If this is the first time we're called by e.g. strread 9487c478bd9Sstevel@tonic-gate * only do the downcall if there is a deferred wakeup 9497c478bd9Sstevel@tonic-gate * (registered in sd_wakeq). 9507c478bd9Sstevel@tonic-gate */ 9517c478bd9Sstevel@tonic-gate struiod_t uiod; 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate if (first) 9547c478bd9Sstevel@tonic-gate stp->sd_wakeq &= ~RSLEEP; 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov, 9577c478bd9Sstevel@tonic-gate sizeof (uiod.d_iov) / sizeof (*uiod.d_iov)); 9587c478bd9Sstevel@tonic-gate uiod.d_mp = 0; 9597c478bd9Sstevel@tonic-gate /* 9607c478bd9Sstevel@tonic-gate * Mark that a thread is in rwnext on the read side 9617c478bd9Sstevel@tonic-gate * to prevent strrput from nacking ioctls immediately. 9627c478bd9Sstevel@tonic-gate * When the last concurrent rwnext returns 9637c478bd9Sstevel@tonic-gate * the ioctls are nack'ed. 9647c478bd9Sstevel@tonic-gate */ 9657c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 9667c478bd9Sstevel@tonic-gate stp->sd_struiodnak++; 9677c478bd9Sstevel@tonic-gate /* 9687c478bd9Sstevel@tonic-gate * Note: rwnext will drop sd_lock. 9697c478bd9Sstevel@tonic-gate */ 9707c478bd9Sstevel@tonic-gate error = rwnext(q, &uiod); 9717c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&stp->sd_lock)); 9727c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 9737c478bd9Sstevel@tonic-gate stp->sd_struiodnak--; 9747c478bd9Sstevel@tonic-gate while (stp->sd_struiodnak == 0 && 9757c478bd9Sstevel@tonic-gate ((bp = stp->sd_struionak) != NULL)) { 9767c478bd9Sstevel@tonic-gate stp->sd_struionak = bp->b_next; 9777c478bd9Sstevel@tonic-gate bp->b_next = NULL; 9787c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK; 9797c478bd9Sstevel@tonic-gate /* 9807c478bd9Sstevel@tonic-gate * Protect against the driver passing up 9817c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 9827c478bd9Sstevel@tonic-gate */ 9837c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 9847c478bd9Sstevel@tonic-gate freemsg(bp); 9857c478bd9Sstevel@tonic-gate else { 9867c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 9877c478bd9Sstevel@tonic-gate qreply(q, bp); 9887c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 9927c478bd9Sstevel@tonic-gate if (error == 0 || error == EWOULDBLOCK) { 9937c478bd9Sstevel@tonic-gate if ((bp = uiod.d_mp) != NULL) { 9947c478bd9Sstevel@tonic-gate *errorp = 0; 9957c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 9967c478bd9Sstevel@tonic-gate return (bp); 9977c478bd9Sstevel@tonic-gate } 9987c478bd9Sstevel@tonic-gate error = 0; 9997c478bd9Sstevel@tonic-gate } else if (error == EINVAL) { 10007c478bd9Sstevel@tonic-gate /* 10017c478bd9Sstevel@tonic-gate * The stream plumbing must have 10027c478bd9Sstevel@tonic-gate * changed while we were away, so 10037c478bd9Sstevel@tonic-gate * just turn off rwnext()s. 10047c478bd9Sstevel@tonic-gate */ 10057c478bd9Sstevel@tonic-gate error = 0; 10067c478bd9Sstevel@tonic-gate } else if (error == EBUSY) { 10077c478bd9Sstevel@tonic-gate /* 10087c478bd9Sstevel@tonic-gate * The module might have data in transit using putnext 10097c478bd9Sstevel@tonic-gate * Fall back on waiting + getq. 10107c478bd9Sstevel@tonic-gate */ 10117c478bd9Sstevel@tonic-gate error = 0; 10127c478bd9Sstevel@tonic-gate } else { 10137c478bd9Sstevel@tonic-gate *errorp = error; 10147c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 10157c478bd9Sstevel@tonic-gate return (NULL); 10167c478bd9Sstevel@tonic-gate } 10177c478bd9Sstevel@tonic-gate /* 10187c478bd9Sstevel@tonic-gate * Try a getq in case a rwnext() generated mblk 10197c478bd9Sstevel@tonic-gate * has bubbled up via strrput(). 10207c478bd9Sstevel@tonic-gate */ 10217c478bd9Sstevel@tonic-gate } 10227c478bd9Sstevel@tonic-gate *errorp = 0; 10237c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 10247c478bd9Sstevel@tonic-gate return (getq_noenab(q)); 10257c478bd9Sstevel@tonic-gate } 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate /* 10287c478bd9Sstevel@tonic-gate * Copy out the message pointed to by `bp' into the uio pointed to by `uiop'. 10297c478bd9Sstevel@tonic-gate * If the message does not fit in the uio the remainder of it is returned; 10307c478bd9Sstevel@tonic-gate * otherwise NULL is returned. Any embedded zero-length mblk_t's are 10317c478bd9Sstevel@tonic-gate * consumed, even if uio_resid reaches zero. On error, `*errorp' is set to 10327c478bd9Sstevel@tonic-gate * the error code, the message is consumed, and NULL is returned. 10337c478bd9Sstevel@tonic-gate */ 10347c478bd9Sstevel@tonic-gate static mblk_t * 10357c478bd9Sstevel@tonic-gate struiocopyout(mblk_t *bp, struct uio *uiop, int *errorp) 10367c478bd9Sstevel@tonic-gate { 10377c478bd9Sstevel@tonic-gate int error; 10387c478bd9Sstevel@tonic-gate ptrdiff_t n; 10397c478bd9Sstevel@tonic-gate mblk_t *nbp; 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate ASSERT(bp->b_wptr >= bp->b_rptr); 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate do { 10447c478bd9Sstevel@tonic-gate if ((n = MIN(uiop->uio_resid, MBLKL(bp))) != 0) { 10457c478bd9Sstevel@tonic-gate ASSERT(n > 0); 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate error = uiomove(bp->b_rptr, n, UIO_READ, uiop); 10487c478bd9Sstevel@tonic-gate if (error != 0) { 10497c478bd9Sstevel@tonic-gate freemsg(bp); 10507c478bd9Sstevel@tonic-gate *errorp = error; 10517c478bd9Sstevel@tonic-gate return (NULL); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate bp->b_rptr += n; 10567c478bd9Sstevel@tonic-gate while (bp != NULL && (bp->b_rptr >= bp->b_wptr)) { 10577c478bd9Sstevel@tonic-gate nbp = bp; 10587c478bd9Sstevel@tonic-gate bp = bp->b_cont; 10597c478bd9Sstevel@tonic-gate freeb(nbp); 10607c478bd9Sstevel@tonic-gate } 10617c478bd9Sstevel@tonic-gate } while (bp != NULL && uiop->uio_resid > 0); 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate *errorp = 0; 10647c478bd9Sstevel@tonic-gate return (bp); 10657c478bd9Sstevel@tonic-gate } 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate /* 10687c478bd9Sstevel@tonic-gate * Read a stream according to the mode flags in sd_flag: 10697c478bd9Sstevel@tonic-gate * 10707c478bd9Sstevel@tonic-gate * (default mode) - Byte stream, msg boundaries are ignored 10717c478bd9Sstevel@tonic-gate * RD_MSGDIS (msg discard) - Read on msg boundaries and throw away 10727c478bd9Sstevel@tonic-gate * any data remaining in msg 10737c478bd9Sstevel@tonic-gate * RD_MSGNODIS (msg non-discard) - Read on msg boundaries and put back 10747c478bd9Sstevel@tonic-gate * any remaining data on head of read queue 10757c478bd9Sstevel@tonic-gate * 10767c478bd9Sstevel@tonic-gate * Consume readable messages on the front of the queue until 10777c478bd9Sstevel@tonic-gate * ttolwp(curthread)->lwp_count 10787c478bd9Sstevel@tonic-gate * is satisfied, the readable messages are exhausted, or a message 10797c478bd9Sstevel@tonic-gate * boundary is reached in a message mode. If no data was read and 10807c478bd9Sstevel@tonic-gate * the stream was not opened with the NDELAY flag, block until data arrives. 10817c478bd9Sstevel@tonic-gate * Otherwise return the data read and update the count. 10827c478bd9Sstevel@tonic-gate * 10837c478bd9Sstevel@tonic-gate * In default mode a 0 length message signifies end-of-file and terminates 10847c478bd9Sstevel@tonic-gate * a read in progress. The 0 length message is removed from the queue 10857c478bd9Sstevel@tonic-gate * only if it is the only message read (no data is read). 10867c478bd9Sstevel@tonic-gate * 10877c478bd9Sstevel@tonic-gate * An attempt to read an M_PROTO or M_PCPROTO message results in an 10887c478bd9Sstevel@tonic-gate * EBADMSG error return, unless either RD_PROTDAT or RD_PROTDIS are set. 10897c478bd9Sstevel@tonic-gate * If RD_PROTDAT is set, M_PROTO and M_PCPROTO messages are read as data. 10907c478bd9Sstevel@tonic-gate * If RD_PROTDIS is set, the M_PROTO and M_PCPROTO parts of the message 10917c478bd9Sstevel@tonic-gate * are unlinked from and M_DATA blocks in the message, the protos are 10927c478bd9Sstevel@tonic-gate * thrown away, and the data is read. 10937c478bd9Sstevel@tonic-gate */ 10947c478bd9Sstevel@tonic-gate /* ARGSUSED */ 10957c478bd9Sstevel@tonic-gate int 10967c478bd9Sstevel@tonic-gate strread(struct vnode *vp, struct uio *uiop, cred_t *crp) 10977c478bd9Sstevel@tonic-gate { 10987c478bd9Sstevel@tonic-gate struct stdata *stp; 10997c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp; 11007c478bd9Sstevel@tonic-gate queue_t *q; 11017c478bd9Sstevel@tonic-gate int error = 0; 11027c478bd9Sstevel@tonic-gate uint_t old_sd_flag; 11037c478bd9Sstevel@tonic-gate int first; 11047c478bd9Sstevel@tonic-gate char rflg; 11057c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */ 11067c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */ 11077c478bd9Sstevel@tonic-gate short delim; 11087c478bd9Sstevel@tonic-gate unsigned char pri = 0; 11097c478bd9Sstevel@tonic-gate char waitflag; 11107c478bd9Sstevel@tonic-gate unsigned char type; 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 11137c478bd9Sstevel@tonic-gate TR_STRREAD_ENTER, "strread:%p", vp); 11147c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 11157c478bd9Sstevel@tonic-gate stp = vp->v_stream; 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 11189acbbeafSnn35248 11199acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 11209acbbeafSnn35248 mutex_exit(&stp->sd_lock); 11219acbbeafSnn35248 return (error); 11229acbbeafSnn35248 } 11239acbbeafSnn35248 11247c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) { 11257c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 0); 11267c478bd9Sstevel@tonic-gate if (error != 0) { 11277c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 11287c478bd9Sstevel@tonic-gate return (error); 11297c478bd9Sstevel@tonic-gate } 11307c478bd9Sstevel@tonic-gate } 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate /* 11337c478bd9Sstevel@tonic-gate * Loop terminates when uiop->uio_resid == 0. 11347c478bd9Sstevel@tonic-gate */ 11357c478bd9Sstevel@tonic-gate rflg = 0; 11367c478bd9Sstevel@tonic-gate waitflag = READWAIT; 11377c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 11387c478bd9Sstevel@tonic-gate for (;;) { 11397c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 11407c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag; 11417c478bd9Sstevel@tonic-gate mark = 0; 11427c478bd9Sstevel@tonic-gate delim = 0; 11437c478bd9Sstevel@tonic-gate first = 1; 11447c478bd9Sstevel@tonic-gate while ((bp = strget(stp, q, uiop, first, &error)) == NULL) { 11457c478bd9Sstevel@tonic-gate int done = 0; 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate if (error != 0) 11507c478bd9Sstevel@tonic-gate goto oops; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STREOF)) { 11537c478bd9Sstevel@tonic-gate goto oops; 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate if (rflg && !(stp->sd_flag & STRDELIM)) { 11567c478bd9Sstevel@tonic-gate goto oops; 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate /* 11597c478bd9Sstevel@tonic-gate * If a read(fd,buf,0) has been done, there is no 11607c478bd9Sstevel@tonic-gate * need to sleep. We always have zero bytes to 11617c478bd9Sstevel@tonic-gate * return. 11627c478bd9Sstevel@tonic-gate */ 11637c478bd9Sstevel@tonic-gate if (uiop->uio_resid == 0) { 11647c478bd9Sstevel@tonic-gate goto oops; 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate qbackenable(q, 0); 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_WAIT, 11707c478bd9Sstevel@tonic-gate "strread calls strwaitq:%p, %p, %p", 11717c478bd9Sstevel@tonic-gate vp, uiop, crp); 11727c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, waitflag, uiop->uio_resid, 11737c478bd9Sstevel@tonic-gate uiop->uio_fmode, -1, &done)) != 0 || done) { 11747c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_DONE, 11757c478bd9Sstevel@tonic-gate "strread error or done:%p, %p, %p", 11767c478bd9Sstevel@tonic-gate vp, uiop, crp); 11777c478bd9Sstevel@tonic-gate if ((uiop->uio_fmode & FNDELAY) && 11787c478bd9Sstevel@tonic-gate (stp->sd_flag & OLDNDELAY) && 11797c478bd9Sstevel@tonic-gate (error == EAGAIN)) 11807c478bd9Sstevel@tonic-gate error = 0; 11817c478bd9Sstevel@tonic-gate goto oops; 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRREAD_AWAKE, 11847c478bd9Sstevel@tonic-gate "strread awakes:%p, %p, %p", vp, uiop, crp); 11859acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 11869acbbeafSnn35248 goto oops; 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate first = 0; 11897c478bd9Sstevel@tonic-gate } 11907c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 11917c478bd9Sstevel@tonic-gate ASSERT(bp); 11927c478bd9Sstevel@tonic-gate pri = bp->b_band; 11937c478bd9Sstevel@tonic-gate /* 11947c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not 11957c478bd9Sstevel@tonic-gate * completely consumed this information will be put in the mblk 11967c478bd9Sstevel@tonic-gate * that is putback. 11977c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed 11987c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if 11997c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is 12007c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set. 12017c478bd9Sstevel@tonic-gate * 12027c478bd9Sstevel@tonic-gate * For some unknown reason strread only breaks the read at the 12037c478bd9Sstevel@tonic-gate * last mark. 12047c478bd9Sstevel@tonic-gate */ 12057c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT); 12067c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) != 12077c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT)); 12087c478bd9Sstevel@tonic-gate if (mark != 0 && bp == stp->sd_mark) { 12097c478bd9Sstevel@tonic-gate if (rflg) { 12107c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 12117c478bd9Sstevel@tonic-gate goto oops; 12127c478bd9Sstevel@tonic-gate } 12137c478bd9Sstevel@tonic-gate mark |= _LASTMARK; 12147c478bd9Sstevel@tonic-gate stp->sd_mark = NULL; 12157c478bd9Sstevel@tonic-gate } 12167c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRDELIM) && (bp->b_flag & MSGDELIM)) 12177c478bd9Sstevel@tonic-gate delim = 1; 12187c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 12217c478bd9Sstevel@tonic-gate stream_runservice(stp); 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type; 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate switch (type) { 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate case M_DATA: 12287c478bd9Sstevel@tonic-gate ismdata: 12297c478bd9Sstevel@tonic-gate if (msgnodata(bp)) { 12307c478bd9Sstevel@tonic-gate if (mark || delim) { 12317c478bd9Sstevel@tonic-gate freemsg(bp); 12327c478bd9Sstevel@tonic-gate } else if (rflg) { 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate /* 12357c478bd9Sstevel@tonic-gate * If already read data put zero 12367c478bd9Sstevel@tonic-gate * length message back on queue else 12377c478bd9Sstevel@tonic-gate * free msg and return 0. 12387c478bd9Sstevel@tonic-gate */ 12397c478bd9Sstevel@tonic-gate bp->b_band = pri; 12407c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 12417c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 12427c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 12437c478bd9Sstevel@tonic-gate } else { 12447c478bd9Sstevel@tonic-gate freemsg(bp); 12457c478bd9Sstevel@tonic-gate } 12467c478bd9Sstevel@tonic-gate error = 0; 12477c478bd9Sstevel@tonic-gate goto oops1; 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate rflg = 1; 12517c478bd9Sstevel@tonic-gate waitflag |= NOINTR; 12527c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error); 12537c478bd9Sstevel@tonic-gate if (error != 0) 12547c478bd9Sstevel@tonic-gate goto oops1; 12557c478bd9Sstevel@tonic-gate 12567c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 12577c478bd9Sstevel@tonic-gate if (bp) { 12587c478bd9Sstevel@tonic-gate /* 12597c478bd9Sstevel@tonic-gate * Have remaining data in message. 12607c478bd9Sstevel@tonic-gate * Free msg if in discard mode. 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate if (stp->sd_read_opt & RD_MSGDIS) { 12637c478bd9Sstevel@tonic-gate freemsg(bp); 12647c478bd9Sstevel@tonic-gate } else { 12657c478bd9Sstevel@tonic-gate bp->b_band = pri; 12667c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && 12677c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL)) 12687c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 12697c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK; 12707c478bd9Sstevel@tonic-gate if (delim) 12717c478bd9Sstevel@tonic-gate bp->b_flag |= MSGDELIM; 12727c478bd9Sstevel@tonic-gate if (msgnodata(bp)) 12737c478bd9Sstevel@tonic-gate freemsg(bp); 12747c478bd9Sstevel@tonic-gate else 12757c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate } else { 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * Consumed the complete message. 12807c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information 12817c478bd9Sstevel@tonic-gate * to the stream head just in case 12827c478bd9Sstevel@tonic-gate * the read queue becomes empty. 12837c478bd9Sstevel@tonic-gate * 12847c478bd9Sstevel@tonic-gate * If the stream head was at the mark 12857c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above 12867c478bd9Sstevel@tonic-gate * and some data was consumed then we have 12877c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is 12887c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in 12897c478bd9Sstevel@tonic-gate * strrput during the copyout above causing 12907c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that 12917c478bd9Sstevel@tonic-gate * flag. 12927c478bd9Sstevel@tonic-gate */ 12937c478bd9Sstevel@tonic-gate if (mark & 12947c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) { 12957c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) { 12967c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK; 12977c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK; 12987c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) { 12997c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 13007c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK; 13017c478bd9Sstevel@tonic-gate } else { 13027c478bd9Sstevel@tonic-gate stp->sd_flag &= 13037c478bd9Sstevel@tonic-gate ~(STRATMARK|STRNOTATMARK); 13047c478bd9Sstevel@tonic-gate } 13057c478bd9Sstevel@tonic-gate } else if (rflg && (old_sd_flag & STRATMARK)) { 13067c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 13077c478bd9Sstevel@tonic-gate } 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * Check for signal messages at the front of the read 13127c478bd9Sstevel@tonic-gate * queue and generate the signal(s) if appropriate. 13137c478bd9Sstevel@tonic-gate * The only signal that can be on queue is M_SIG at 13147c478bd9Sstevel@tonic-gate * this point. 13157c478bd9Sstevel@tonic-gate */ 13167c478bd9Sstevel@tonic-gate while ((((bp = q->q_first)) != NULL) && 13177c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_SIG)) { 13187c478bd9Sstevel@tonic-gate bp = getq_noenab(q); 13197c478bd9Sstevel@tonic-gate /* 13207c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the 13217c478bd9Sstevel@tonic-gate * read queue can not change. 13227c478bd9Sstevel@tonic-gate */ 13237c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && 13247c478bd9Sstevel@tonic-gate bp->b_datap->db_type == M_SIG); 13257c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, 13267c478bd9Sstevel@tonic-gate (int32_t)bp->b_band); 13277c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 13287c478bd9Sstevel@tonic-gate freemsg(bp); 13297c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 13307c478bd9Sstevel@tonic-gate stream_runservice(stp); 13317c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 13327c478bd9Sstevel@tonic-gate } 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate if ((uiop->uio_resid == 0) || (mark & _LASTMARK) || 13357c478bd9Sstevel@tonic-gate delim || 13367c478bd9Sstevel@tonic-gate (stp->sd_read_opt & (RD_MSGDIS|RD_MSGNODIS))) { 13377c478bd9Sstevel@tonic-gate goto oops; 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate continue; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate case M_SIG: 13427c478bd9Sstevel@tonic-gate strsignal(stp, *bp->b_rptr, (int32_t)bp->b_band); 13437c478bd9Sstevel@tonic-gate freemsg(bp); 13447c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 13457c478bd9Sstevel@tonic-gate continue; 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate case M_PROTO: 13487c478bd9Sstevel@tonic-gate case M_PCPROTO: 13497c478bd9Sstevel@tonic-gate /* 13507c478bd9Sstevel@tonic-gate * Only data messages are readable. 13517c478bd9Sstevel@tonic-gate * Any others generate an error, unless 13527c478bd9Sstevel@tonic-gate * RD_PROTDIS or RD_PROTDAT is set. 13537c478bd9Sstevel@tonic-gate */ 13547c478bd9Sstevel@tonic-gate if (stp->sd_read_opt & RD_PROTDAT) { 13557c478bd9Sstevel@tonic-gate for (nbp = bp; nbp; nbp = nbp->b_next) { 13567c478bd9Sstevel@tonic-gate if ((nbp->b_datap->db_type == M_PROTO) || 13577c478bd9Sstevel@tonic-gate (nbp->b_datap->db_type == M_PCPROTO)) 13587c478bd9Sstevel@tonic-gate nbp->b_datap->db_type = M_DATA; 13597c478bd9Sstevel@tonic-gate else 13607c478bd9Sstevel@tonic-gate break; 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate /* 13637c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 13647c478bd9Sstevel@tonic-gate * first message 13657c478bd9Sstevel@tonic-gate */ 13667c478bd9Sstevel@tonic-gate if (type == M_PCPROTO) { 13677c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 13687c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 13697c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate goto ismdata; 13727c478bd9Sstevel@tonic-gate } else if (stp->sd_read_opt & RD_PROTDIS) { 13737c478bd9Sstevel@tonic-gate /* 13747c478bd9Sstevel@tonic-gate * discard non-data messages 13757c478bd9Sstevel@tonic-gate */ 13767c478bd9Sstevel@tonic-gate while (bp && 13777c478bd9Sstevel@tonic-gate ((bp->b_datap->db_type == M_PROTO) || 13787c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_PCPROTO))) { 13797c478bd9Sstevel@tonic-gate nbp = unlinkb(bp); 13807c478bd9Sstevel@tonic-gate freeb(bp); 13817c478bd9Sstevel@tonic-gate bp = nbp; 13827c478bd9Sstevel@tonic-gate } 13837c478bd9Sstevel@tonic-gate /* 13847c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 13857c478bd9Sstevel@tonic-gate * first message 13867c478bd9Sstevel@tonic-gate */ 13877c478bd9Sstevel@tonic-gate if (type == M_PCPROTO) { 13887c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 13897c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 13907c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate if (bp) { 13937c478bd9Sstevel@tonic-gate bp->b_band = pri; 13947c478bd9Sstevel@tonic-gate goto ismdata; 13957c478bd9Sstevel@tonic-gate } else { 13967c478bd9Sstevel@tonic-gate break; 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate } 13997c478bd9Sstevel@tonic-gate /* FALLTHRU */ 14007c478bd9Sstevel@tonic-gate case M_PASSFP: 14017c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_PASSFP) && 14027c478bd9Sstevel@tonic-gate (stp->sd_read_opt & RD_PROTDIS)) { 14037c478bd9Sstevel@tonic-gate freemsg(bp); 14047c478bd9Sstevel@tonic-gate break; 14057c478bd9Sstevel@tonic-gate } 14067c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 14077c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 14087c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 14097c478bd9Sstevel@tonic-gate if (rflg == 0) 14107c478bd9Sstevel@tonic-gate error = EBADMSG; 14117c478bd9Sstevel@tonic-gate goto oops1; 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate default: 14147c478bd9Sstevel@tonic-gate /* 14157c478bd9Sstevel@tonic-gate * Garbage on stream head read queue. 14167c478bd9Sstevel@tonic-gate */ 14177c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "bad %x found at stream head\n", 14187c478bd9Sstevel@tonic-gate bp->b_datap->db_type); 14197c478bd9Sstevel@tonic-gate freemsg(bp); 14207c478bd9Sstevel@tonic-gate goto oops1; 14217c478bd9Sstevel@tonic-gate } 14227c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 14237c478bd9Sstevel@tonic-gate } 14247c478bd9Sstevel@tonic-gate oops: 14257c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 14267c478bd9Sstevel@tonic-gate oops1: 14277c478bd9Sstevel@tonic-gate qbackenable(q, pri); 14287c478bd9Sstevel@tonic-gate return (error); 14297c478bd9Sstevel@tonic-gate #undef _LASTMARK 14307c478bd9Sstevel@tonic-gate } 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate /* 14337c478bd9Sstevel@tonic-gate * Default processing of M_PROTO/M_PCPROTO messages. 14347c478bd9Sstevel@tonic-gate * Determine which wakeups and signals are needed. 14357c478bd9Sstevel@tonic-gate * This can be replaced by a user-specified procedure for kernel users 14367c478bd9Sstevel@tonic-gate * of STREAMS. 14377c478bd9Sstevel@tonic-gate */ 14387c478bd9Sstevel@tonic-gate /* ARGSUSED */ 14397c478bd9Sstevel@tonic-gate mblk_t * 14407c478bd9Sstevel@tonic-gate strrput_proto(vnode_t *vp, mblk_t *mp, 14417c478bd9Sstevel@tonic-gate strwakeup_t *wakeups, strsigset_t *firstmsgsigs, 14427c478bd9Sstevel@tonic-gate strsigset_t *allmsgsigs, strpollset_t *pollwakeups) 14437c478bd9Sstevel@tonic-gate { 14447c478bd9Sstevel@tonic-gate *wakeups = RSLEEP; 14457c478bd9Sstevel@tonic-gate *allmsgsigs = 0; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) { 14487c478bd9Sstevel@tonic-gate case M_PROTO: 14497c478bd9Sstevel@tonic-gate if (mp->b_band == 0) { 14507c478bd9Sstevel@tonic-gate *firstmsgsigs = S_INPUT | S_RDNORM; 14517c478bd9Sstevel@tonic-gate *pollwakeups = POLLIN | POLLRDNORM; 14527c478bd9Sstevel@tonic-gate } else { 14537c478bd9Sstevel@tonic-gate *firstmsgsigs = S_INPUT | S_RDBAND; 14547c478bd9Sstevel@tonic-gate *pollwakeups = POLLIN | POLLRDBAND; 14557c478bd9Sstevel@tonic-gate } 14567c478bd9Sstevel@tonic-gate break; 14577c478bd9Sstevel@tonic-gate case M_PCPROTO: 14587c478bd9Sstevel@tonic-gate *firstmsgsigs = S_HIPRI; 14597c478bd9Sstevel@tonic-gate *pollwakeups = POLLPRI; 14607c478bd9Sstevel@tonic-gate break; 14617c478bd9Sstevel@tonic-gate } 14627c478bd9Sstevel@tonic-gate return (mp); 14637c478bd9Sstevel@tonic-gate } 14647c478bd9Sstevel@tonic-gate 14657c478bd9Sstevel@tonic-gate /* 14667c478bd9Sstevel@tonic-gate * Default processing of everything but M_DATA, M_PROTO, M_PCPROTO and 14677c478bd9Sstevel@tonic-gate * M_PASSFP messages. 14687c478bd9Sstevel@tonic-gate * Determine which wakeups and signals are needed. 14697c478bd9Sstevel@tonic-gate * This can be replaced by a user-specified procedure for kernel users 14707c478bd9Sstevel@tonic-gate * of STREAMS. 14717c478bd9Sstevel@tonic-gate */ 14727c478bd9Sstevel@tonic-gate /* ARGSUSED */ 14737c478bd9Sstevel@tonic-gate mblk_t * 14747c478bd9Sstevel@tonic-gate strrput_misc(vnode_t *vp, mblk_t *mp, 14757c478bd9Sstevel@tonic-gate strwakeup_t *wakeups, strsigset_t *firstmsgsigs, 14767c478bd9Sstevel@tonic-gate strsigset_t *allmsgsigs, strpollset_t *pollwakeups) 14777c478bd9Sstevel@tonic-gate { 14787c478bd9Sstevel@tonic-gate *wakeups = 0; 14797c478bd9Sstevel@tonic-gate *firstmsgsigs = 0; 14807c478bd9Sstevel@tonic-gate *allmsgsigs = 0; 14817c478bd9Sstevel@tonic-gate *pollwakeups = 0; 14827c478bd9Sstevel@tonic-gate return (mp); 14837c478bd9Sstevel@tonic-gate } 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate /* 14867c478bd9Sstevel@tonic-gate * Stream read put procedure. Called from downstream driver/module 14877c478bd9Sstevel@tonic-gate * with messages for the stream head. Data, protocol, and in-stream 14887c478bd9Sstevel@tonic-gate * signal messages are placed on the queue, others are handled directly. 14897c478bd9Sstevel@tonic-gate */ 14907c478bd9Sstevel@tonic-gate int 14917c478bd9Sstevel@tonic-gate strrput(queue_t *q, mblk_t *bp) 14927c478bd9Sstevel@tonic-gate { 14937c478bd9Sstevel@tonic-gate struct stdata *stp; 14947c478bd9Sstevel@tonic-gate ulong_t rput_opt; 14957c478bd9Sstevel@tonic-gate strwakeup_t wakeups; 14967c478bd9Sstevel@tonic-gate strsigset_t firstmsgsigs; /* Signals if first message on queue */ 14977c478bd9Sstevel@tonic-gate strsigset_t allmsgsigs; /* Signals for all messages */ 14987c478bd9Sstevel@tonic-gate strsigset_t signals; /* Signals events to generate */ 14997c478bd9Sstevel@tonic-gate strpollset_t pollwakeups; 15007c478bd9Sstevel@tonic-gate mblk_t *nextbp; 15017c478bd9Sstevel@tonic-gate uchar_t band = 0; 15027c478bd9Sstevel@tonic-gate int hipri_sig; 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr; 15057c478bd9Sstevel@tonic-gate /* 15067c478bd9Sstevel@tonic-gate * Use rput_opt for optimized access to the SR_ flags except 15077c478bd9Sstevel@tonic-gate * SR_POLLIN. That flag has to be checked under sd_lock since it 15087c478bd9Sstevel@tonic-gate * is modified by strpoll(). 15097c478bd9Sstevel@tonic-gate */ 15107c478bd9Sstevel@tonic-gate rput_opt = stp->sd_rput_opt; 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q)); 15137c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_ENTER, 15147c478bd9Sstevel@tonic-gate "strrput called with message type:q %p bp %p", q, bp); 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate /* 15177c478bd9Sstevel@tonic-gate * Perform initial processing and pass to the parameterized functions. 15187c478bd9Sstevel@tonic-gate */ 15197c478bd9Sstevel@tonic-gate ASSERT(bp->b_next == NULL); 15207c478bd9Sstevel@tonic-gate 15217c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) { 15227c478bd9Sstevel@tonic-gate case M_DATA: 15237c478bd9Sstevel@tonic-gate /* 15247c478bd9Sstevel@tonic-gate * sockfs is the only consumer of STREOF and when it is set, 15257c478bd9Sstevel@tonic-gate * it implies that the receiver is not interested in receiving 15267c478bd9Sstevel@tonic-gate * any more data, hence the mblk is freed to prevent unnecessary 15277c478bd9Sstevel@tonic-gate * message queueing at the stream head. 15287c478bd9Sstevel@tonic-gate */ 15297c478bd9Sstevel@tonic-gate if (stp->sd_flag == STREOF) { 15307c478bd9Sstevel@tonic-gate freemsg(bp); 15317c478bd9Sstevel@tonic-gate return (0); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate if ((rput_opt & SR_IGN_ZEROLEN) && 15347c478bd9Sstevel@tonic-gate bp->b_rptr == bp->b_wptr && msgnodata(bp)) { 15357c478bd9Sstevel@tonic-gate /* 15367c478bd9Sstevel@tonic-gate * Ignore zero-length M_DATA messages. These might be 15377c478bd9Sstevel@tonic-gate * generated by some transports. 15387c478bd9Sstevel@tonic-gate * The zero-length M_DATA messages, even if they 15397c478bd9Sstevel@tonic-gate * are ignored, should effect the atmark tracking and 15407c478bd9Sstevel@tonic-gate * should wake up a thread sleeping in strwaitmark. 15417c478bd9Sstevel@tonic-gate */ 15427c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 15437c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARKNEXT) { 15447c478bd9Sstevel@tonic-gate /* 15457c478bd9Sstevel@tonic-gate * Record the position of the mark either 15467c478bd9Sstevel@tonic-gate * in q_last or in STRATMARK. 15477c478bd9Sstevel@tonic-gate */ 15487c478bd9Sstevel@tonic-gate if (q->q_last != NULL) { 15497c478bd9Sstevel@tonic-gate q->q_last->b_flag &= ~MSGNOTMARKNEXT; 15507c478bd9Sstevel@tonic-gate q->q_last->b_flag |= MSGMARKNEXT; 15517c478bd9Sstevel@tonic-gate } else { 15527c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK; 15537c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK; 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate } else if (bp->b_flag & MSGNOTMARKNEXT) { 15567c478bd9Sstevel@tonic-gate /* 15577c478bd9Sstevel@tonic-gate * Record that this is not the position of 15587c478bd9Sstevel@tonic-gate * the mark either in q_last or in 15597c478bd9Sstevel@tonic-gate * STRNOTATMARK. 15607c478bd9Sstevel@tonic-gate */ 15617c478bd9Sstevel@tonic-gate if (q->q_last != NULL) { 15627c478bd9Sstevel@tonic-gate q->q_last->b_flag &= ~MSGMARKNEXT; 15637c478bd9Sstevel@tonic-gate q->q_last->b_flag |= MSGNOTMARKNEXT; 15647c478bd9Sstevel@tonic-gate } else { 15657c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 15667c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK; 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate if (stp->sd_flag & RSLEEP) { 15707c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP; 15717c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); 15727c478bd9Sstevel@tonic-gate } 15737c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 15747c478bd9Sstevel@tonic-gate freemsg(bp); 15757c478bd9Sstevel@tonic-gate return (0); 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate wakeups = RSLEEP; 15787c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 15797c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDNORM; 15807c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 15817c478bd9Sstevel@tonic-gate } else { 15827c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDBAND; 15837c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 15847c478bd9Sstevel@tonic-gate } 15857c478bd9Sstevel@tonic-gate if (rput_opt & SR_SIGALLDATA) 15867c478bd9Sstevel@tonic-gate allmsgsigs = firstmsgsigs; 15877c478bd9Sstevel@tonic-gate else 15887c478bd9Sstevel@tonic-gate allmsgsigs = 0; 15897c478bd9Sstevel@tonic-gate 15907c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 15917c478bd9Sstevel@tonic-gate if ((rput_opt & SR_CONSOL_DATA) && 15927c478bd9Sstevel@tonic-gate (bp->b_flag & (MSGMARK|MSGDELIM)) == 0) { 15937c478bd9Sstevel@tonic-gate /* 15947c478bd9Sstevel@tonic-gate * Consolidate on M_DATA message onto an M_DATA, 15957c478bd9Sstevel@tonic-gate * M_PROTO, or M_PCPROTO by merging it with q_last. 15967c478bd9Sstevel@tonic-gate * The consolidation does not take place if 15977c478bd9Sstevel@tonic-gate * the old message is marked with either of the 15987c478bd9Sstevel@tonic-gate * marks or the delim flag or if the new 15997c478bd9Sstevel@tonic-gate * message is marked with MSGMARK. The MSGMARK 16007c478bd9Sstevel@tonic-gate * check is needed to handle the odd semantics of 16017c478bd9Sstevel@tonic-gate * MSGMARK where essentially the whole message 16027c478bd9Sstevel@tonic-gate * is to be treated as marked. 16037c478bd9Sstevel@tonic-gate * Carry any MSGMARKNEXT and MSGNOTMARKNEXT from the 16047c478bd9Sstevel@tonic-gate * new message to the front of the b_cont chain. 16057c478bd9Sstevel@tonic-gate */ 16067c478bd9Sstevel@tonic-gate mblk_t *lbp; 16077c478bd9Sstevel@tonic-gate 16087c478bd9Sstevel@tonic-gate lbp = q->q_last; 16097c478bd9Sstevel@tonic-gate if (lbp != NULL && 16107c478bd9Sstevel@tonic-gate (lbp->b_datap->db_type == M_DATA || 16117c478bd9Sstevel@tonic-gate lbp->b_datap->db_type == M_PROTO || 16127c478bd9Sstevel@tonic-gate lbp->b_datap->db_type == M_PCPROTO) && 16137c478bd9Sstevel@tonic-gate !(lbp->b_flag & (MSGDELIM|MSGMARK| 16147c478bd9Sstevel@tonic-gate MSGMARKNEXT))) { 16157c478bd9Sstevel@tonic-gate rmvq_noenab(q, lbp); 16167c478bd9Sstevel@tonic-gate /* 16177c478bd9Sstevel@tonic-gate * The first message in the b_cont list 16187c478bd9Sstevel@tonic-gate * tracks MSGMARKNEXT and MSGNOTMARKNEXT. 16197c478bd9Sstevel@tonic-gate * We need to handle the case where we 16207c478bd9Sstevel@tonic-gate * are appending 16217c478bd9Sstevel@tonic-gate * 16227c478bd9Sstevel@tonic-gate * 1) a MSGMARKNEXT to a MSGNOTMARKNEXT. 16237c478bd9Sstevel@tonic-gate * 2) a MSGMARKNEXT to a plain message. 16247c478bd9Sstevel@tonic-gate * 3) a MSGNOTMARKNEXT to a plain message 16257c478bd9Sstevel@tonic-gate * 4) a MSGNOTMARKNEXT to a MSGNOTMARKNEXT 16267c478bd9Sstevel@tonic-gate * message. 16277c478bd9Sstevel@tonic-gate * 16287c478bd9Sstevel@tonic-gate * Thus we never append a MSGMARKNEXT or 16297c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT to a MSGMARKNEXT message. 16307c478bd9Sstevel@tonic-gate */ 16317c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARKNEXT) { 16327c478bd9Sstevel@tonic-gate lbp->b_flag |= MSGMARKNEXT; 16337c478bd9Sstevel@tonic-gate lbp->b_flag &= ~MSGNOTMARKNEXT; 16347c478bd9Sstevel@tonic-gate bp->b_flag &= ~MSGMARKNEXT; 16357c478bd9Sstevel@tonic-gate } else if (bp->b_flag & MSGNOTMARKNEXT) { 16367c478bd9Sstevel@tonic-gate lbp->b_flag |= MSGNOTMARKNEXT; 16377c478bd9Sstevel@tonic-gate bp->b_flag &= ~MSGNOTMARKNEXT; 16387c478bd9Sstevel@tonic-gate } 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate linkb(lbp, bp); 16417c478bd9Sstevel@tonic-gate bp = lbp; 16427c478bd9Sstevel@tonic-gate /* 16437c478bd9Sstevel@tonic-gate * The new message logically isn't the first 16447c478bd9Sstevel@tonic-gate * even though the q_first check below thinks 16457c478bd9Sstevel@tonic-gate * it is. Clear the firstmsgsigs to make it 16467c478bd9Sstevel@tonic-gate * not appear to be first. 16477c478bd9Sstevel@tonic-gate */ 16487c478bd9Sstevel@tonic-gate firstmsgsigs = 0; 16497c478bd9Sstevel@tonic-gate } 16507c478bd9Sstevel@tonic-gate } 16517c478bd9Sstevel@tonic-gate break; 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate case M_PASSFP: 16547c478bd9Sstevel@tonic-gate wakeups = RSLEEP; 16557c478bd9Sstevel@tonic-gate allmsgsigs = 0; 16567c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 16577c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDNORM; 16587c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 16597c478bd9Sstevel@tonic-gate } else { 16607c478bd9Sstevel@tonic-gate firstmsgsigs = S_INPUT | S_RDBAND; 16617c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 16647c478bd9Sstevel@tonic-gate break; 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate case M_PROTO: 16677c478bd9Sstevel@tonic-gate case M_PCPROTO: 16687c478bd9Sstevel@tonic-gate ASSERT(stp->sd_rprotofunc != NULL); 16697c478bd9Sstevel@tonic-gate bp = (stp->sd_rprotofunc)(stp->sd_vnode, bp, 16707c478bd9Sstevel@tonic-gate &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups); 16717c478bd9Sstevel@tonic-gate #define ALLSIG (S_INPUT|S_HIPRI|S_OUTPUT|S_MSG|S_ERROR|S_HANGUP|S_RDNORM|\ 16727c478bd9Sstevel@tonic-gate S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG) 16737c478bd9Sstevel@tonic-gate #define ALLPOLL (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLWRNORM|POLLRDBAND|\ 16747c478bd9Sstevel@tonic-gate POLLWRBAND) 16757c478bd9Sstevel@tonic-gate 16767c478bd9Sstevel@tonic-gate ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0); 16777c478bd9Sstevel@tonic-gate ASSERT((firstmsgsigs & ~ALLSIG) == 0); 16787c478bd9Sstevel@tonic-gate ASSERT((allmsgsigs & ~ALLSIG) == 0); 16797c478bd9Sstevel@tonic-gate ASSERT((pollwakeups & ~ALLPOLL) == 0); 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 16827c478bd9Sstevel@tonic-gate break; 16837c478bd9Sstevel@tonic-gate 16847c478bd9Sstevel@tonic-gate default: 16857c478bd9Sstevel@tonic-gate ASSERT(stp->sd_rmiscfunc != NULL); 16867c478bd9Sstevel@tonic-gate bp = (stp->sd_rmiscfunc)(stp->sd_vnode, bp, 16877c478bd9Sstevel@tonic-gate &wakeups, &firstmsgsigs, &allmsgsigs, &pollwakeups); 16887c478bd9Sstevel@tonic-gate ASSERT((wakeups & ~(RSLEEP|WSLEEP)) == 0); 16897c478bd9Sstevel@tonic-gate ASSERT((firstmsgsigs & ~ALLSIG) == 0); 16907c478bd9Sstevel@tonic-gate ASSERT((allmsgsigs & ~ALLSIG) == 0); 16917c478bd9Sstevel@tonic-gate ASSERT((pollwakeups & ~ALLPOLL) == 0); 16927c478bd9Sstevel@tonic-gate #undef ALLSIG 16937c478bd9Sstevel@tonic-gate #undef ALLPOLL 16947c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 16957c478bd9Sstevel@tonic-gate break; 16967c478bd9Sstevel@tonic-gate } 16977c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate /* By default generate superset of signals */ 17007c478bd9Sstevel@tonic-gate signals = (firstmsgsigs | allmsgsigs); 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate /* 17037c478bd9Sstevel@tonic-gate * The proto and misc functions can return multiple messages 17047c478bd9Sstevel@tonic-gate * as a b_next chain. Such messages are processed separately. 17057c478bd9Sstevel@tonic-gate */ 17067c478bd9Sstevel@tonic-gate one_more: 17077c478bd9Sstevel@tonic-gate hipri_sig = 0; 17087c478bd9Sstevel@tonic-gate if (bp == NULL) { 17097c478bd9Sstevel@tonic-gate nextbp = NULL; 17107c478bd9Sstevel@tonic-gate } else { 17117c478bd9Sstevel@tonic-gate nextbp = bp->b_next; 17127c478bd9Sstevel@tonic-gate bp->b_next = NULL; 17137c478bd9Sstevel@tonic-gate 17147c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) { 17157c478bd9Sstevel@tonic-gate case M_PCPROTO: 17167c478bd9Sstevel@tonic-gate /* 17177c478bd9Sstevel@tonic-gate * Only one priority protocol message is allowed at the 17187c478bd9Sstevel@tonic-gate * stream head at a time. 17197c478bd9Sstevel@tonic-gate */ 17207c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRPRI) { 17217c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR, TR_STRRPUT_PROTERR, 17227c478bd9Sstevel@tonic-gate "M_PCPROTO already at head"); 17237c478bd9Sstevel@tonic-gate freemsg(bp); 17247c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 17257c478bd9Sstevel@tonic-gate goto done; 17267c478bd9Sstevel@tonic-gate } 17277c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI; 17287c478bd9Sstevel@tonic-gate hipri_sig = 1; 17297c478bd9Sstevel@tonic-gate /* FALLTHRU */ 17307c478bd9Sstevel@tonic-gate case M_DATA: 17317c478bd9Sstevel@tonic-gate case M_PROTO: 17327c478bd9Sstevel@tonic-gate case M_PASSFP: 17337c478bd9Sstevel@tonic-gate band = bp->b_band; 17347c478bd9Sstevel@tonic-gate /* 17357c478bd9Sstevel@tonic-gate * Marking doesn't work well when messages 17367c478bd9Sstevel@tonic-gate * are marked in more than one band. We only 17377c478bd9Sstevel@tonic-gate * remember the last message received, even if 17387c478bd9Sstevel@tonic-gate * it is placed on the queue ahead of other 17397c478bd9Sstevel@tonic-gate * marked messages. 17407c478bd9Sstevel@tonic-gate */ 17417c478bd9Sstevel@tonic-gate if (bp->b_flag & MSGMARK) 17427c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 17437c478bd9Sstevel@tonic-gate (void) putq(q, bp); 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate /* 17467c478bd9Sstevel@tonic-gate * If message is a PCPROTO message, always use 17477c478bd9Sstevel@tonic-gate * firstmsgsigs to determine if a signal should be 17487c478bd9Sstevel@tonic-gate * sent as strrput is the only place to send 17497c478bd9Sstevel@tonic-gate * signals for PCPROTO. Other messages are based on 17507c478bd9Sstevel@tonic-gate * the STRGETINPROG flag. The flag determines if 17517c478bd9Sstevel@tonic-gate * strrput or (k)strgetmsg will be responsible for 17527c478bd9Sstevel@tonic-gate * sending the signals, in the firstmsgsigs case. 17537c478bd9Sstevel@tonic-gate */ 17547c478bd9Sstevel@tonic-gate if ((hipri_sig == 1) || 17557c478bd9Sstevel@tonic-gate (((stp->sd_flag & STRGETINPROG) == 0) && 17567c478bd9Sstevel@tonic-gate (q->q_first == bp))) 17577c478bd9Sstevel@tonic-gate signals = (firstmsgsigs | allmsgsigs); 17587c478bd9Sstevel@tonic-gate else 17597c478bd9Sstevel@tonic-gate signals = allmsgsigs; 17607c478bd9Sstevel@tonic-gate break; 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate default: 17637c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 17647c478bd9Sstevel@tonic-gate (void) strrput_nondata(q, bp); 17657c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 17667c478bd9Sstevel@tonic-gate break; 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 17707c478bd9Sstevel@tonic-gate /* 17717c478bd9Sstevel@tonic-gate * Wake sleeping read/getmsg and cancel deferred wakeup 17727c478bd9Sstevel@tonic-gate */ 17737c478bd9Sstevel@tonic-gate if (wakeups & RSLEEP) 17747c478bd9Sstevel@tonic-gate stp->sd_wakeq &= ~RSLEEP; 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate wakeups &= stp->sd_flag; 17777c478bd9Sstevel@tonic-gate if (wakeups & RSLEEP) { 17787c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP; 17797c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); 17807c478bd9Sstevel@tonic-gate } 17817c478bd9Sstevel@tonic-gate if (wakeups & WSLEEP) { 17827c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP; 17837c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); 17847c478bd9Sstevel@tonic-gate } 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate if (pollwakeups != 0) { 17877c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) { 17887c478bd9Sstevel@tonic-gate /* 17897c478bd9Sstevel@tonic-gate * Can't use rput_opt since it was not 17907c478bd9Sstevel@tonic-gate * read when sd_lock was held and SR_POLLIN is changed 17917c478bd9Sstevel@tonic-gate * by strpoll() under sd_lock. 17927c478bd9Sstevel@tonic-gate */ 17937c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN)) 17947c478bd9Sstevel@tonic-gate goto no_pollwake; 17957c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN; 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 17987c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups); 17997c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 18007c478bd9Sstevel@tonic-gate } 18017c478bd9Sstevel@tonic-gate no_pollwake: 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate /* 18047c478bd9Sstevel@tonic-gate * strsendsig can handle multiple signals with a 18057c478bd9Sstevel@tonic-gate * single call. 18067c478bd9Sstevel@tonic-gate */ 18077c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals) 18087c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, band, 0); 18097c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate 18127c478bd9Sstevel@tonic-gate done: 18137c478bd9Sstevel@tonic-gate if (nextbp == NULL) 18147c478bd9Sstevel@tonic-gate return (0); 18157c478bd9Sstevel@tonic-gate 18167c478bd9Sstevel@tonic-gate /* 18177c478bd9Sstevel@tonic-gate * Any signals were handled the first time. 18187c478bd9Sstevel@tonic-gate * Wakeups and pollwakeups are redone to avoid any race 18197c478bd9Sstevel@tonic-gate * conditions - all the messages are not queued until the 18207c478bd9Sstevel@tonic-gate * last message has been processed by strrput. 18217c478bd9Sstevel@tonic-gate */ 18227c478bd9Sstevel@tonic-gate bp = nextbp; 18237c478bd9Sstevel@tonic-gate signals = firstmsgsigs = allmsgsigs = 0; 18247c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 18257c478bd9Sstevel@tonic-gate goto one_more; 18267c478bd9Sstevel@tonic-gate } 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate static void 18297c478bd9Sstevel@tonic-gate log_dupioc(queue_t *rq, mblk_t *bp) 18307c478bd9Sstevel@tonic-gate { 18317c478bd9Sstevel@tonic-gate queue_t *wq, *qp; 18327c478bd9Sstevel@tonic-gate char *modnames, *mnp, *dname; 18337c478bd9Sstevel@tonic-gate size_t maxmodstr; 18347c478bd9Sstevel@tonic-gate boolean_t islast; 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate /* 18377c478bd9Sstevel@tonic-gate * Allocate a buffer large enough to hold the names of nstrpush modules 18387c478bd9Sstevel@tonic-gate * and one driver, with spaces between and NUL terminator. If we can't 18397c478bd9Sstevel@tonic-gate * get memory, then we'll just log the driver name. 18407c478bd9Sstevel@tonic-gate */ 18417c478bd9Sstevel@tonic-gate maxmodstr = nstrpush * (FMNAMESZ + 1); 18427c478bd9Sstevel@tonic-gate mnp = modnames = kmem_alloc(maxmodstr, KM_NOSLEEP); 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate /* march down write side to print log message down to the driver */ 18457c478bd9Sstevel@tonic-gate wq = WR(rq); 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate /* make sure q_next doesn't shift around while we're grabbing data */ 18487c478bd9Sstevel@tonic-gate claimstr(wq); 18497c478bd9Sstevel@tonic-gate qp = wq->q_next; 18507c478bd9Sstevel@tonic-gate do { 18517c478bd9Sstevel@tonic-gate if ((dname = qp->q_qinfo->qi_minfo->mi_idname) == NULL) 18527c478bd9Sstevel@tonic-gate dname = "?"; 18537c478bd9Sstevel@tonic-gate islast = !SAMESTR(qp) || qp->q_next == NULL; 18547c478bd9Sstevel@tonic-gate if (modnames == NULL) { 18557c478bd9Sstevel@tonic-gate /* 18567c478bd9Sstevel@tonic-gate * If we don't have memory, then get the driver name in 18577c478bd9Sstevel@tonic-gate * the log where we can see it. Note that memory 18587c478bd9Sstevel@tonic-gate * pressure is a possible cause of these sorts of bugs. 18597c478bd9Sstevel@tonic-gate */ 18607c478bd9Sstevel@tonic-gate if (islast) { 18617c478bd9Sstevel@tonic-gate modnames = dname; 18627c478bd9Sstevel@tonic-gate maxmodstr = 0; 18637c478bd9Sstevel@tonic-gate } 18647c478bd9Sstevel@tonic-gate } else { 18657c478bd9Sstevel@tonic-gate mnp += snprintf(mnp, FMNAMESZ + 1, "%s", dname); 18667c478bd9Sstevel@tonic-gate if (!islast) 18677c478bd9Sstevel@tonic-gate *mnp++ = ' '; 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate qp = qp->q_next; 18707c478bd9Sstevel@tonic-gate } while (!islast); 18717c478bd9Sstevel@tonic-gate releasestr(wq); 18727c478bd9Sstevel@tonic-gate /* Cannot happen unless stream head is corrupt. */ 18737c478bd9Sstevel@tonic-gate ASSERT(modnames != NULL); 18747c478bd9Sstevel@tonic-gate (void) strlog(rq->q_qinfo->qi_minfo->mi_idnum, 0, 1, 18757c478bd9Sstevel@tonic-gate SL_CONSOLE|SL_TRACE|SL_ERROR, 18767c478bd9Sstevel@tonic-gate "Warning: stream %p received duplicate %X M_IOC%s; module list: %s", 18777c478bd9Sstevel@tonic-gate rq->q_ptr, ((struct iocblk *)bp->b_rptr)->ioc_cmd, 18787c478bd9Sstevel@tonic-gate (DB_TYPE(bp) == M_IOCACK ? "ACK" : "NAK"), modnames); 18797c478bd9Sstevel@tonic-gate if (maxmodstr != 0) 18807c478bd9Sstevel@tonic-gate kmem_free(modnames, maxmodstr); 18817c478bd9Sstevel@tonic-gate } 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate int 18847c478bd9Sstevel@tonic-gate strrput_nondata(queue_t *q, mblk_t *bp) 18857c478bd9Sstevel@tonic-gate { 18867c478bd9Sstevel@tonic-gate struct stdata *stp; 18877c478bd9Sstevel@tonic-gate struct iocblk *iocbp; 18887c478bd9Sstevel@tonic-gate struct stroptions *sop; 18897c478bd9Sstevel@tonic-gate struct copyreq *reqp; 18907c478bd9Sstevel@tonic-gate struct copyresp *resp; 18917c478bd9Sstevel@tonic-gate unsigned char bpri; 18927c478bd9Sstevel@tonic-gate unsigned char flushed_already = 0; 18937c478bd9Sstevel@tonic-gate 18947c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr; 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX)); 18977c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q)); 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) { 19007c478bd9Sstevel@tonic-gate case M_ERROR: 19017c478bd9Sstevel@tonic-gate /* 19027c478bd9Sstevel@tonic-gate * An error has occurred downstream, the errno is in the first 19037c478bd9Sstevel@tonic-gate * bytes of the message. 19047c478bd9Sstevel@tonic-gate */ 19057c478bd9Sstevel@tonic-gate if ((bp->b_wptr - bp->b_rptr) == 2) { /* New flavor */ 19067c478bd9Sstevel@tonic-gate unsigned char rw = 0; 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 19097c478bd9Sstevel@tonic-gate if (*bp->b_rptr != NOERROR) { /* read error */ 19107c478bd9Sstevel@tonic-gate if (*bp->b_rptr != 0) { 19117c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRDERR) 19127c478bd9Sstevel@tonic-gate flushed_already |= FLUSHR; 19137c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERR; 19147c478bd9Sstevel@tonic-gate rw |= FLUSHR; 19157c478bd9Sstevel@tonic-gate } else { 19167c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERR; 19177c478bd9Sstevel@tonic-gate } 19187c478bd9Sstevel@tonic-gate stp->sd_rerror = *bp->b_rptr; 19197c478bd9Sstevel@tonic-gate } 19207c478bd9Sstevel@tonic-gate bp->b_rptr++; 19217c478bd9Sstevel@tonic-gate if (*bp->b_rptr != NOERROR) { /* write error */ 19227c478bd9Sstevel@tonic-gate if (*bp->b_rptr != 0) { 19237c478bd9Sstevel@tonic-gate if (stp->sd_flag & STWRERR) 19247c478bd9Sstevel@tonic-gate flushed_already |= FLUSHW; 19257c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERR; 19267c478bd9Sstevel@tonic-gate rw |= FLUSHW; 19277c478bd9Sstevel@tonic-gate } else { 19287c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERR; 19297c478bd9Sstevel@tonic-gate } 19307c478bd9Sstevel@tonic-gate stp->sd_werror = *bp->b_rptr; 19317c478bd9Sstevel@tonic-gate } 19327c478bd9Sstevel@tonic-gate if (rw) { 19337c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRRPUT_WAKE, 19347c478bd9Sstevel@tonic-gate "strrput cv_broadcast:q %p, bp %p", 19357c478bd9Sstevel@tonic-gate q, bp); 19367c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* readers */ 19377c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* writers */ 19387c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* ioctllers */ 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 19417c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLERR); 19427c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 19437c478bd9Sstevel@tonic-gate 19447c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_ERROR) 19457c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_ERROR, 0, 19467c478bd9Sstevel@tonic-gate ((rw & FLUSHR) ? stp->sd_rerror : 19477c478bd9Sstevel@tonic-gate stp->sd_werror)); 19487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 19497c478bd9Sstevel@tonic-gate /* 19507c478bd9Sstevel@tonic-gate * Send the M_FLUSH only 19517c478bd9Sstevel@tonic-gate * for the first M_ERROR 19527c478bd9Sstevel@tonic-gate * message on the stream 19537c478bd9Sstevel@tonic-gate */ 19547c478bd9Sstevel@tonic-gate if (flushed_already == rw) { 19557c478bd9Sstevel@tonic-gate freemsg(bp); 19567c478bd9Sstevel@tonic-gate return (0); 19577c478bd9Sstevel@tonic-gate } 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_FLUSH; 19607c478bd9Sstevel@tonic-gate *bp->b_rptr = rw; 19617c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + 1; 19627c478bd9Sstevel@tonic-gate /* 19637c478bd9Sstevel@tonic-gate * Protect against the driver 19647c478bd9Sstevel@tonic-gate * passing up messages after 19657c478bd9Sstevel@tonic-gate * it has done a qprocsoff 19667c478bd9Sstevel@tonic-gate */ 19677c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 19687c478bd9Sstevel@tonic-gate freemsg(bp); 19697c478bd9Sstevel@tonic-gate else 19707c478bd9Sstevel@tonic-gate qreply(q, bp); 19717c478bd9Sstevel@tonic-gate return (0); 19727c478bd9Sstevel@tonic-gate } else 19737c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 19747c478bd9Sstevel@tonic-gate } else if (*bp->b_rptr != 0) { /* Old flavor */ 19757c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR)) 19767c478bd9Sstevel@tonic-gate flushed_already = FLUSHRW; 19777c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 19787c478bd9Sstevel@tonic-gate stp->sd_flag |= (STRDERR|STWRERR); 19797c478bd9Sstevel@tonic-gate stp->sd_rerror = *bp->b_rptr; 19807c478bd9Sstevel@tonic-gate stp->sd_werror = *bp->b_rptr; 19817c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, 19827c478bd9Sstevel@tonic-gate TR_STRRPUT_WAKE2, 19837c478bd9Sstevel@tonic-gate "strrput wakeup #2:q %p, bp %p", q, bp); 19847c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* the readers */ 19857c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* the writers */ 19867c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* ioctllers */ 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 19897c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLERR); 19907c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_ERROR) 19937c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_ERROR, 0, 19947c478bd9Sstevel@tonic-gate (stp->sd_werror ? stp->sd_werror : 19957c478bd9Sstevel@tonic-gate stp->sd_rerror)); 19967c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate /* 19997c478bd9Sstevel@tonic-gate * Send the M_FLUSH only 20007c478bd9Sstevel@tonic-gate * for the first M_ERROR 20017c478bd9Sstevel@tonic-gate * message on the stream 20027c478bd9Sstevel@tonic-gate */ 20037c478bd9Sstevel@tonic-gate if (flushed_already != FLUSHRW) { 20047c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_FLUSH; 20057c478bd9Sstevel@tonic-gate *bp->b_rptr = FLUSHRW; 20067c478bd9Sstevel@tonic-gate /* 20077c478bd9Sstevel@tonic-gate * Protect against the driver passing up 20087c478bd9Sstevel@tonic-gate * messages after it has done a 20097c478bd9Sstevel@tonic-gate * qprocsoff. 20107c478bd9Sstevel@tonic-gate */ 20117c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 20127c478bd9Sstevel@tonic-gate freemsg(bp); 20137c478bd9Sstevel@tonic-gate else 20147c478bd9Sstevel@tonic-gate qreply(q, bp); 20157c478bd9Sstevel@tonic-gate return (0); 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate } 20187c478bd9Sstevel@tonic-gate freemsg(bp); 20197c478bd9Sstevel@tonic-gate return (0); 20207c478bd9Sstevel@tonic-gate 20217c478bd9Sstevel@tonic-gate case M_HANGUP: 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate freemsg(bp); 20247c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 20257c478bd9Sstevel@tonic-gate stp->sd_werror = ENXIO; 20267c478bd9Sstevel@tonic-gate stp->sd_flag |= STRHUP; 20277c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(WSLEEP|RSLEEP); 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate /* 20307c478bd9Sstevel@tonic-gate * send signal if controlling tty 20317c478bd9Sstevel@tonic-gate */ 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate if (stp->sd_sidp) { 20347c478bd9Sstevel@tonic-gate prsignal(stp->sd_sidp, SIGHUP); 20357c478bd9Sstevel@tonic-gate if (stp->sd_sidp != stp->sd_pgidp) 20367c478bd9Sstevel@tonic-gate pgsignal(stp->sd_pgidp, SIGTSTP); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate /* 20407c478bd9Sstevel@tonic-gate * wake up read, write, and exception pollers and 20417c478bd9Sstevel@tonic-gate * reset wakeup mechanism. 20427c478bd9Sstevel@tonic-gate */ 20437c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); /* the readers */ 20447c478bd9Sstevel@tonic-gate cv_broadcast(&_WR(q)->q_wait); /* the writers */ 20457c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); /* the ioctllers */ 20467c478bd9Sstevel@tonic-gate strhup(stp); 20479acbbeafSnn35248 mutex_exit(&stp->sd_lock); 20487c478bd9Sstevel@tonic-gate return (0); 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate case M_UNHANGUP: 20517c478bd9Sstevel@tonic-gate freemsg(bp); 20527c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 20537c478bd9Sstevel@tonic-gate stp->sd_werror = 0; 20547c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRHUP; 20557c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 20567c478bd9Sstevel@tonic-gate return (0); 20577c478bd9Sstevel@tonic-gate 20587c478bd9Sstevel@tonic-gate case M_SIG: 20597c478bd9Sstevel@tonic-gate /* 20607c478bd9Sstevel@tonic-gate * Someone downstream wants to post a signal. The 20617c478bd9Sstevel@tonic-gate * signal to post is contained in the first byte of the 20627c478bd9Sstevel@tonic-gate * message. If the message would go on the front of 20637c478bd9Sstevel@tonic-gate * the queue, send a signal to the process group 20647c478bd9Sstevel@tonic-gate * (if not SIGPOLL) or to the siglist processes 20657c478bd9Sstevel@tonic-gate * (SIGPOLL). If something is already on the queue, 20667c478bd9Sstevel@tonic-gate * OR if we are delivering a delayed suspend (*sigh* 20677c478bd9Sstevel@tonic-gate * another "tty" hack) and there's no one sleeping already, 20687c478bd9Sstevel@tonic-gate * just enqueue the message. 20697c478bd9Sstevel@tonic-gate */ 20707c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 20717c478bd9Sstevel@tonic-gate if (q->q_first || (*bp->b_rptr == SIGTSTP && 20727c478bd9Sstevel@tonic-gate !(stp->sd_flag & RSLEEP))) { 20737c478bd9Sstevel@tonic-gate (void) putq(q, bp); 20747c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 20757c478bd9Sstevel@tonic-gate return (0); 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 20787c478bd9Sstevel@tonic-gate /* FALLTHRU */ 20797c478bd9Sstevel@tonic-gate 20807c478bd9Sstevel@tonic-gate case M_PCSIG: 20817c478bd9Sstevel@tonic-gate /* 20827c478bd9Sstevel@tonic-gate * Don't enqueue, just post the signal. 20837c478bd9Sstevel@tonic-gate */ 20847c478bd9Sstevel@tonic-gate strsignal(stp, *bp->b_rptr, 0L); 20857c478bd9Sstevel@tonic-gate freemsg(bp); 20867c478bd9Sstevel@tonic-gate return (0); 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate case M_FLUSH: 20897c478bd9Sstevel@tonic-gate /* 20907c478bd9Sstevel@tonic-gate * Flush queues. The indication of which queues to flush 20917c478bd9Sstevel@tonic-gate * is in the first byte of the message. If the read queue 20927c478bd9Sstevel@tonic-gate * is specified, then flush it. If FLUSHBAND is set, just 20937c478bd9Sstevel@tonic-gate * flush the band specified by the second byte of the message. 20947c478bd9Sstevel@tonic-gate * 20957c478bd9Sstevel@tonic-gate * If a module has issued a M_SETOPT to not flush hi 20967c478bd9Sstevel@tonic-gate * priority messages off of the stream head, then pass this 20977c478bd9Sstevel@tonic-gate * flag into the flushq code to preserve such messages. 20987c478bd9Sstevel@tonic-gate */ 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate if (*bp->b_rptr & FLUSHR) { 21017c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 21027c478bd9Sstevel@tonic-gate if (*bp->b_rptr & FLUSHBAND) { 21037c478bd9Sstevel@tonic-gate ASSERT((bp->b_wptr - bp->b_rptr) >= 2); 21047c478bd9Sstevel@tonic-gate flushband(q, *(bp->b_rptr + 1), FLUSHALL); 21057c478bd9Sstevel@tonic-gate } else 21067c478bd9Sstevel@tonic-gate flushq_common(q, FLUSHALL, 21077c478bd9Sstevel@tonic-gate stp->sd_read_opt & RFLUSHPCPROT); 21087c478bd9Sstevel@tonic-gate if ((q->q_first == NULL) || 21097c478bd9Sstevel@tonic-gate (q->q_first->b_datap->db_type < QPCTL)) 21107c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 21117c478bd9Sstevel@tonic-gate else { 21127c478bd9Sstevel@tonic-gate ASSERT(stp->sd_flag & STRPRI); 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 21157c478bd9Sstevel@tonic-gate } 21167c478bd9Sstevel@tonic-gate if ((*bp->b_rptr & FLUSHW) && !(bp->b_flag & MSGNOLOOP)) { 21177c478bd9Sstevel@tonic-gate *bp->b_rptr &= ~FLUSHR; 21187c478bd9Sstevel@tonic-gate bp->b_flag |= MSGNOLOOP; 21197c478bd9Sstevel@tonic-gate /* 21207c478bd9Sstevel@tonic-gate * Protect against the driver passing up 21217c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 21227c478bd9Sstevel@tonic-gate */ 21237c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 21247c478bd9Sstevel@tonic-gate freemsg(bp); 21257c478bd9Sstevel@tonic-gate else 21267c478bd9Sstevel@tonic-gate qreply(q, bp); 21277c478bd9Sstevel@tonic-gate return (0); 21287c478bd9Sstevel@tonic-gate } 21297c478bd9Sstevel@tonic-gate freemsg(bp); 21307c478bd9Sstevel@tonic-gate return (0); 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate case M_IOCACK: 21337c478bd9Sstevel@tonic-gate case M_IOCNAK: 21347c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr; 21357c478bd9Sstevel@tonic-gate /* 21367c478bd9Sstevel@tonic-gate * If not waiting for ACK or NAK then just free msg. 21377c478bd9Sstevel@tonic-gate * If incorrect id sequence number then just free msg. 21387c478bd9Sstevel@tonic-gate * If already have ACK or NAK for user then this is a 21397c478bd9Sstevel@tonic-gate * duplicate, display a warning and free the msg. 21407c478bd9Sstevel@tonic-gate */ 21417c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 21427c478bd9Sstevel@tonic-gate if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk || 21437c478bd9Sstevel@tonic-gate (stp->sd_iocid != iocbp->ioc_id)) { 21447c478bd9Sstevel@tonic-gate /* 21457c478bd9Sstevel@tonic-gate * If the ACK/NAK is a dup, display a message 21467c478bd9Sstevel@tonic-gate * Dup is when sd_iocid == ioc_id, and 21477c478bd9Sstevel@tonic-gate * sd_iocblk == <valid ptr> or -1 (the former 21487c478bd9Sstevel@tonic-gate * is when an ioctl has been put on the stream 21497c478bd9Sstevel@tonic-gate * head, but has not yet been consumed, the 21507c478bd9Sstevel@tonic-gate * later is when it has been consumed). 21517c478bd9Sstevel@tonic-gate */ 21527c478bd9Sstevel@tonic-gate if ((stp->sd_iocid == iocbp->ioc_id) && 21537c478bd9Sstevel@tonic-gate (stp->sd_iocblk != NULL)) { 21547c478bd9Sstevel@tonic-gate log_dupioc(q, bp); 21557c478bd9Sstevel@tonic-gate } 21567c478bd9Sstevel@tonic-gate freemsg(bp); 21577c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 21587c478bd9Sstevel@tonic-gate return (0); 21597c478bd9Sstevel@tonic-gate } 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate /* 21627c478bd9Sstevel@tonic-gate * Assign ACK or NAK to user and wake up. 21637c478bd9Sstevel@tonic-gate */ 21647c478bd9Sstevel@tonic-gate stp->sd_iocblk = bp; 21657c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 21667c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 21677c478bd9Sstevel@tonic-gate return (0); 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate case M_COPYIN: 21707c478bd9Sstevel@tonic-gate case M_COPYOUT: 21717c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr; 21727c478bd9Sstevel@tonic-gate 21737c478bd9Sstevel@tonic-gate /* 21747c478bd9Sstevel@tonic-gate * If not waiting for ACK or NAK then just fail request. 21757c478bd9Sstevel@tonic-gate * If already have ACK, NAK, or copy request, then just 21767c478bd9Sstevel@tonic-gate * fail request. 21777c478bd9Sstevel@tonic-gate * If incorrect id sequence number then just fail request. 21787c478bd9Sstevel@tonic-gate */ 21797c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 21807c478bd9Sstevel@tonic-gate if ((stp->sd_flag & IOCWAIT) == 0 || stp->sd_iocblk || 21817c478bd9Sstevel@tonic-gate (stp->sd_iocid != reqp->cq_id)) { 21827c478bd9Sstevel@tonic-gate if (bp->b_cont) { 21837c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 21847c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 21857c478bd9Sstevel@tonic-gate } 21867c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA; 21877c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp); 21887c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr; 21897c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)1; /* failure */ 21907c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 21917c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp); 21927c478bd9Sstevel@tonic-gate return (0); 21937c478bd9Sstevel@tonic-gate } 21947c478bd9Sstevel@tonic-gate 21957c478bd9Sstevel@tonic-gate /* 21967c478bd9Sstevel@tonic-gate * Assign copy request to user and wake up. 21977c478bd9Sstevel@tonic-gate */ 21987c478bd9Sstevel@tonic-gate stp->sd_iocblk = bp; 21997c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 22007c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 22017c478bd9Sstevel@tonic-gate return (0); 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate case M_SETOPTS: 22047c478bd9Sstevel@tonic-gate /* 22057c478bd9Sstevel@tonic-gate * Set stream head options (read option, write offset, 22067c478bd9Sstevel@tonic-gate * min/max packet size, and/or high/low water marks for 22077c478bd9Sstevel@tonic-gate * the read side only). 22087c478bd9Sstevel@tonic-gate */ 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate bpri = 0; 22117c478bd9Sstevel@tonic-gate sop = (struct stroptions *)bp->b_rptr; 22127c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 22137c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_READOPT) { 22147c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RMODEMASK) { 22157c478bd9Sstevel@tonic-gate case RNORM: 22167c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS); 22177c478bd9Sstevel@tonic-gate break; 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate case RMSGD: 22207c478bd9Sstevel@tonic-gate stp->sd_read_opt = 22217c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_MSGNODIS) | 22227c478bd9Sstevel@tonic-gate RD_MSGDIS); 22237c478bd9Sstevel@tonic-gate break; 22247c478bd9Sstevel@tonic-gate 22257c478bd9Sstevel@tonic-gate case RMSGN: 22267c478bd9Sstevel@tonic-gate stp->sd_read_opt = 22277c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_MSGDIS) | 22287c478bd9Sstevel@tonic-gate RD_MSGNODIS); 22297c478bd9Sstevel@tonic-gate break; 22307c478bd9Sstevel@tonic-gate } 22317c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RPROTMASK) { 22327c478bd9Sstevel@tonic-gate case RPROTNORM: 22337c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS); 22347c478bd9Sstevel@tonic-gate break; 22357c478bd9Sstevel@tonic-gate 22367c478bd9Sstevel@tonic-gate case RPROTDAT: 22377c478bd9Sstevel@tonic-gate stp->sd_read_opt = 22387c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_PROTDIS) | 22397c478bd9Sstevel@tonic-gate RD_PROTDAT); 22407c478bd9Sstevel@tonic-gate break; 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate case RPROTDIS: 22437c478bd9Sstevel@tonic-gate stp->sd_read_opt = 22447c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & ~RD_PROTDAT) | 22457c478bd9Sstevel@tonic-gate RD_PROTDIS); 22467c478bd9Sstevel@tonic-gate break; 22477c478bd9Sstevel@tonic-gate } 22487c478bd9Sstevel@tonic-gate switch (sop->so_readopt & RFLUSHMASK) { 22497c478bd9Sstevel@tonic-gate case RFLUSHPCPROT: 22507c478bd9Sstevel@tonic-gate /* 22517c478bd9Sstevel@tonic-gate * This sets the stream head to NOT flush 22527c478bd9Sstevel@tonic-gate * M_PCPROTO messages. 22537c478bd9Sstevel@tonic-gate */ 22547c478bd9Sstevel@tonic-gate stp->sd_read_opt |= RFLUSHPCPROT; 22557c478bd9Sstevel@tonic-gate break; 22567c478bd9Sstevel@tonic-gate } 22577c478bd9Sstevel@tonic-gate } 22587c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ERROPT) { 22597c478bd9Sstevel@tonic-gate switch (sop->so_erropt & RERRMASK) { 22607c478bd9Sstevel@tonic-gate case RERRNORM: 22617c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERRNONPERSIST; 22627c478bd9Sstevel@tonic-gate break; 22637c478bd9Sstevel@tonic-gate case RERRNONPERSIST: 22647c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERRNONPERSIST; 22657c478bd9Sstevel@tonic-gate break; 22667c478bd9Sstevel@tonic-gate } 22677c478bd9Sstevel@tonic-gate switch (sop->so_erropt & WERRMASK) { 22687c478bd9Sstevel@tonic-gate case WERRNORM: 22697c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERRNONPERSIST; 22707c478bd9Sstevel@tonic-gate break; 22717c478bd9Sstevel@tonic-gate case WERRNONPERSIST: 22727c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERRNONPERSIST; 22737c478bd9Sstevel@tonic-gate break; 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate } 22767c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_COPYOPT) { 22777c478bd9Sstevel@tonic-gate if (sop->so_copyopt & ZCVMSAFE) { 22787c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STZCVMSAFE; 22797c478bd9Sstevel@tonic-gate stp->sd_copyflag &= ~STZCVMUNSAFE; 22807c478bd9Sstevel@tonic-gate } else if (sop->so_copyopt & ZCVMUNSAFE) { 22817c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STZCVMUNSAFE; 22827c478bd9Sstevel@tonic-gate stp->sd_copyflag &= ~STZCVMSAFE; 22837c478bd9Sstevel@tonic-gate } 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate if (sop->so_copyopt & COPYCACHED) { 22867c478bd9Sstevel@tonic-gate stp->sd_copyflag |= STRCOPYCACHED; 22877c478bd9Sstevel@tonic-gate } 22887c478bd9Sstevel@tonic-gate } 22897c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_WROFF) 22907c478bd9Sstevel@tonic-gate stp->sd_wroff = sop->so_wroff; 2291c28749e9Skais if (sop->so_flags & SO_TAIL) 2292c28749e9Skais stp->sd_tail = sop->so_tail; 22937c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MINPSZ) 22947c478bd9Sstevel@tonic-gate q->q_minpsz = sop->so_minpsz; 22957c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MAXPSZ) 22967c478bd9Sstevel@tonic-gate q->q_maxpsz = sop->so_maxpsz; 22977c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MAXBLK) 22987c478bd9Sstevel@tonic-gate stp->sd_maxblk = sop->so_maxblk; 22997c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_HIWAT) { 23007c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_BAND) { 23017c478bd9Sstevel@tonic-gate if (strqset(q, QHIWAT, sop->so_band, sop->so_hiwat)) 23027c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 23037c478bd9Sstevel@tonic-gate "strrput: could not allocate qband\n"); 23047c478bd9Sstevel@tonic-gate else 23057c478bd9Sstevel@tonic-gate bpri = sop->so_band; 23067c478bd9Sstevel@tonic-gate } else { 23077c478bd9Sstevel@tonic-gate q->q_hiwat = sop->so_hiwat; 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate } 23107c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_LOWAT) { 23117c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_BAND) { 23127c478bd9Sstevel@tonic-gate if (strqset(q, QLOWAT, sop->so_band, sop->so_lowat)) 23137c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 23147c478bd9Sstevel@tonic-gate "strrput: could not allocate qband\n"); 23157c478bd9Sstevel@tonic-gate else 23167c478bd9Sstevel@tonic-gate bpri = sop->so_band; 23177c478bd9Sstevel@tonic-gate } else { 23187c478bd9Sstevel@tonic-gate q->q_lowat = sop->so_lowat; 23197c478bd9Sstevel@tonic-gate } 23207c478bd9Sstevel@tonic-gate } 23217c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MREADON) 23227c478bd9Sstevel@tonic-gate stp->sd_flag |= SNDMREAD; 23237c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_MREADOFF) 23247c478bd9Sstevel@tonic-gate stp->sd_flag &= ~SNDMREAD; 23257c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NDELON) 23267c478bd9Sstevel@tonic-gate stp->sd_flag |= OLDNDELAY; 23277c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NDELOFF) 23287c478bd9Sstevel@tonic-gate stp->sd_flag &= ~OLDNDELAY; 23297c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ISTTY) 23307c478bd9Sstevel@tonic-gate stp->sd_flag |= STRISTTY; 23317c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_ISNTTY) 23327c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRISTTY; 23337c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_TOSTOP) 23347c478bd9Sstevel@tonic-gate stp->sd_flag |= STRTOSTOP; 23357c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_TONSTOP) 23367c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRTOSTOP; 23377c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_DELIM) 23387c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDELIM; 23397c478bd9Sstevel@tonic-gate if (sop->so_flags & SO_NODELIM) 23407c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDELIM; 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 23437c478bd9Sstevel@tonic-gate freemsg(bp); 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate /* Check backenable in case the water marks changed */ 23467c478bd9Sstevel@tonic-gate qbackenable(q, bpri); 23477c478bd9Sstevel@tonic-gate return (0); 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate /* 23507c478bd9Sstevel@tonic-gate * The following set of cases deal with situations where two stream 23517c478bd9Sstevel@tonic-gate * heads are connected to each other (twisted streams). These messages 23527c478bd9Sstevel@tonic-gate * have no meaning at the stream head. 23537c478bd9Sstevel@tonic-gate */ 23547c478bd9Sstevel@tonic-gate case M_BREAK: 23557c478bd9Sstevel@tonic-gate case M_CTL: 23567c478bd9Sstevel@tonic-gate case M_DELAY: 23577c478bd9Sstevel@tonic-gate case M_START: 23587c478bd9Sstevel@tonic-gate case M_STOP: 23597c478bd9Sstevel@tonic-gate case M_IOCDATA: 23607c478bd9Sstevel@tonic-gate case M_STARTI: 23617c478bd9Sstevel@tonic-gate case M_STOPI: 23627c478bd9Sstevel@tonic-gate freemsg(bp); 23637c478bd9Sstevel@tonic-gate return (0); 23647c478bd9Sstevel@tonic-gate 23657c478bd9Sstevel@tonic-gate case M_IOCTL: 23667c478bd9Sstevel@tonic-gate /* 23677c478bd9Sstevel@tonic-gate * Always NAK this condition 23687c478bd9Sstevel@tonic-gate * (makes no sense) 23697c478bd9Sstevel@tonic-gate * If there is one or more threads in the read side 23707c478bd9Sstevel@tonic-gate * rwnext we have to defer the nacking until that thread 23717c478bd9Sstevel@tonic-gate * returns (in strget). 23727c478bd9Sstevel@tonic-gate */ 23737c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 23747c478bd9Sstevel@tonic-gate if (stp->sd_struiodnak != 0) { 23757c478bd9Sstevel@tonic-gate /* 23767c478bd9Sstevel@tonic-gate * Defer NAK to the streamhead. Queue at the end 23777c478bd9Sstevel@tonic-gate * the list. 23787c478bd9Sstevel@tonic-gate */ 23797c478bd9Sstevel@tonic-gate mblk_t *mp = stp->sd_struionak; 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate while (mp && mp->b_next) 23827c478bd9Sstevel@tonic-gate mp = mp->b_next; 23837c478bd9Sstevel@tonic-gate if (mp) 23847c478bd9Sstevel@tonic-gate mp->b_next = bp; 23857c478bd9Sstevel@tonic-gate else 23867c478bd9Sstevel@tonic-gate stp->sd_struionak = bp; 23877c478bd9Sstevel@tonic-gate bp->b_next = NULL; 23887c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 23897c478bd9Sstevel@tonic-gate return (0); 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 23927c478bd9Sstevel@tonic-gate 23937c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCNAK; 23947c478bd9Sstevel@tonic-gate /* 23957c478bd9Sstevel@tonic-gate * Protect against the driver passing up 23967c478bd9Sstevel@tonic-gate * messages after it has done a qprocsoff. 23977c478bd9Sstevel@tonic-gate */ 23987c478bd9Sstevel@tonic-gate if (_OTHERQ(q)->q_next == NULL) 23997c478bd9Sstevel@tonic-gate freemsg(bp); 24007c478bd9Sstevel@tonic-gate else 24017c478bd9Sstevel@tonic-gate qreply(q, bp); 24027c478bd9Sstevel@tonic-gate return (0); 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate default: 24057c478bd9Sstevel@tonic-gate #ifdef DEBUG 24067c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 24077c478bd9Sstevel@tonic-gate "bad message type %x received at stream head\n", 24087c478bd9Sstevel@tonic-gate bp->b_datap->db_type); 24097c478bd9Sstevel@tonic-gate #endif 24107c478bd9Sstevel@tonic-gate freemsg(bp); 24117c478bd9Sstevel@tonic-gate return (0); 24127c478bd9Sstevel@tonic-gate } 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate /* NOTREACHED */ 24157c478bd9Sstevel@tonic-gate } 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate /* 24187c478bd9Sstevel@tonic-gate * Check if the stream pointed to by `stp' can be written to, and return an 24197c478bd9Sstevel@tonic-gate * error code if not. If `eiohup' is set, then return EIO if STRHUP is set. 24207c478bd9Sstevel@tonic-gate * If `sigpipeok' is set and the SW_SIGPIPE option is enabled on the stream, 24217c478bd9Sstevel@tonic-gate * then always return EPIPE and send a SIGPIPE to the invoking thread. 24227c478bd9Sstevel@tonic-gate */ 24237c478bd9Sstevel@tonic-gate static int 24247c478bd9Sstevel@tonic-gate strwriteable(struct stdata *stp, boolean_t eiohup, boolean_t sigpipeok) 24257c478bd9Sstevel@tonic-gate { 24267c478bd9Sstevel@tonic-gate int error; 24277c478bd9Sstevel@tonic-gate 24287c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate /* 24317c478bd9Sstevel@tonic-gate * For modem support, POSIX states that on writes, EIO should 24327c478bd9Sstevel@tonic-gate * be returned if the stream has been hung up. 24337c478bd9Sstevel@tonic-gate */ 24347c478bd9Sstevel@tonic-gate if (eiohup && (stp->sd_flag & (STPLEX|STRHUP)) == STRHUP) 24357c478bd9Sstevel@tonic-gate error = EIO; 24367c478bd9Sstevel@tonic-gate else 24377c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRHUP|STPLEX|STWRERR, 0); 24387c478bd9Sstevel@tonic-gate 24397c478bd9Sstevel@tonic-gate if (error != 0) { 24407c478bd9Sstevel@tonic-gate if (!(stp->sd_flag & STPLEX) && 24417c478bd9Sstevel@tonic-gate (stp->sd_wput_opt & SW_SIGPIPE) && sigpipeok) { 24427c478bd9Sstevel@tonic-gate tsignal(curthread, SIGPIPE); 24437c478bd9Sstevel@tonic-gate error = EPIPE; 24447c478bd9Sstevel@tonic-gate } 24457c478bd9Sstevel@tonic-gate } 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate return (error); 24487c478bd9Sstevel@tonic-gate } 24497c478bd9Sstevel@tonic-gate 24507c478bd9Sstevel@tonic-gate /* 24517c478bd9Sstevel@tonic-gate * Copyin and send data down a stream. 24527c478bd9Sstevel@tonic-gate * The caller will allocate and copyin any control part that precedes the 24537c478bd9Sstevel@tonic-gate * message and pass than in as mctl. 24547c478bd9Sstevel@tonic-gate * 24557c478bd9Sstevel@tonic-gate * Caller should *not* hold sd_lock. 24567c478bd9Sstevel@tonic-gate * When EWOULDBLOCK is returned the caller has to redo the canputnext 24577c478bd9Sstevel@tonic-gate * under sd_lock in order to avoid missing a backenabling wakeup. 24587c478bd9Sstevel@tonic-gate * 24597c478bd9Sstevel@tonic-gate * Use iosize = -1 to not send any M_DATA. iosize = 0 sends zero-length M_DATA. 24607c478bd9Sstevel@tonic-gate * 24617c478bd9Sstevel@tonic-gate * Set MSG_IGNFLOW in flags to ignore flow control for hipri messages. 24627c478bd9Sstevel@tonic-gate * For sync streams we can only ignore flow control by reverting to using 24637c478bd9Sstevel@tonic-gate * putnext. 24647c478bd9Sstevel@tonic-gate * 24657c478bd9Sstevel@tonic-gate * If sd_maxblk is less than *iosize this routine might return without 24667c478bd9Sstevel@tonic-gate * transferring all of *iosize. In all cases, on return *iosize will contain 24677c478bd9Sstevel@tonic-gate * the amount of data that was transferred. 24687c478bd9Sstevel@tonic-gate */ 24697c478bd9Sstevel@tonic-gate static int 24707c478bd9Sstevel@tonic-gate strput(struct stdata *stp, mblk_t *mctl, struct uio *uiop, ssize_t *iosize, 24717c478bd9Sstevel@tonic-gate int b_flag, int pri, int flags) 24727c478bd9Sstevel@tonic-gate { 24737c478bd9Sstevel@tonic-gate struiod_t uiod; 24747c478bd9Sstevel@tonic-gate mblk_t *mp; 24757c478bd9Sstevel@tonic-gate queue_t *wqp = stp->sd_wrq; 24767c478bd9Sstevel@tonic-gate int error = 0; 24777c478bd9Sstevel@tonic-gate ssize_t count = *iosize; 24787c478bd9Sstevel@tonic-gate cred_t *cr; 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&stp->sd_lock)); 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate if (uiop != NULL && count >= 0) 24837c478bd9Sstevel@tonic-gate flags |= stp->sd_struiowrq ? STRUIO_POSTPONE : 0; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate if (!(flags & STRUIO_POSTPONE)) { 24867c478bd9Sstevel@tonic-gate /* 24877c478bd9Sstevel@tonic-gate * Use regular canputnext, strmakedata, putnext sequence. 24887c478bd9Sstevel@tonic-gate */ 24897c478bd9Sstevel@tonic-gate if (pri == 0) { 24907c478bd9Sstevel@tonic-gate if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) { 24917c478bd9Sstevel@tonic-gate freemsg(mctl); 24927c478bd9Sstevel@tonic-gate return (EWOULDBLOCK); 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate } else { 24957c478bd9Sstevel@tonic-gate if (!(flags & MSG_IGNFLOW) && !bcanputnext(wqp, pri)) { 24967c478bd9Sstevel@tonic-gate freemsg(mctl); 24977c478bd9Sstevel@tonic-gate return (EWOULDBLOCK); 24987c478bd9Sstevel@tonic-gate } 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate if ((error = strmakedata(iosize, uiop, stp, flags, 25027c478bd9Sstevel@tonic-gate &mp)) != 0) { 25037c478bd9Sstevel@tonic-gate freemsg(mctl); 25047c478bd9Sstevel@tonic-gate /* 25057c478bd9Sstevel@tonic-gate * need to change return code to ENOMEM 25067c478bd9Sstevel@tonic-gate * so that this is not confused with 25077c478bd9Sstevel@tonic-gate * flow control, EAGAIN. 25087c478bd9Sstevel@tonic-gate */ 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate if (error == EAGAIN) 25117c478bd9Sstevel@tonic-gate return (ENOMEM); 25127c478bd9Sstevel@tonic-gate else 25137c478bd9Sstevel@tonic-gate return (error); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate if (mctl != NULL) { 25167c478bd9Sstevel@tonic-gate if (mctl->b_cont == NULL) 25177c478bd9Sstevel@tonic-gate mctl->b_cont = mp; 25187c478bd9Sstevel@tonic-gate else if (mp != NULL) 25197c478bd9Sstevel@tonic-gate linkb(mctl, mp); 25207c478bd9Sstevel@tonic-gate mp = mctl; 25217c478bd9Sstevel@tonic-gate /* 25227c478bd9Sstevel@tonic-gate * Note that for interrupt thread, the CRED() is 25237c478bd9Sstevel@tonic-gate * NULL. Don't bother with the pid either. 25247c478bd9Sstevel@tonic-gate */ 25257c478bd9Sstevel@tonic-gate if ((cr = CRED()) != NULL) { 25267c478bd9Sstevel@tonic-gate mblk_setcred(mp, cr); 25277c478bd9Sstevel@tonic-gate DB_CPID(mp) = curproc->p_pid; 25287c478bd9Sstevel@tonic-gate } 25297c478bd9Sstevel@tonic-gate } else if (mp == NULL) 25307c478bd9Sstevel@tonic-gate return (0); 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate mp->b_flag |= b_flag; 25337c478bd9Sstevel@tonic-gate mp->b_band = (uchar_t)pri; 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate if (flags & MSG_IGNFLOW) { 25367c478bd9Sstevel@tonic-gate /* 25377c478bd9Sstevel@tonic-gate * XXX Hack: Don't get stuck running service 25387c478bd9Sstevel@tonic-gate * procedures. This is needed for sockfs when 25397c478bd9Sstevel@tonic-gate * sending the unbind message out of the rput 25407c478bd9Sstevel@tonic-gate * procedure - we don't want a put procedure 25417c478bd9Sstevel@tonic-gate * to run service procedures. 25427c478bd9Sstevel@tonic-gate */ 25437c478bd9Sstevel@tonic-gate putnext(wqp, mp); 25447c478bd9Sstevel@tonic-gate } else { 25457c478bd9Sstevel@tonic-gate stream_willservice(stp); 25467c478bd9Sstevel@tonic-gate putnext(wqp, mp); 25477c478bd9Sstevel@tonic-gate stream_runservice(stp); 25487c478bd9Sstevel@tonic-gate } 25497c478bd9Sstevel@tonic-gate return (0); 25507c478bd9Sstevel@tonic-gate } 25517c478bd9Sstevel@tonic-gate /* 25527c478bd9Sstevel@tonic-gate * Stream supports rwnext() for the write side. 25537c478bd9Sstevel@tonic-gate */ 25547c478bd9Sstevel@tonic-gate if ((error = strmakedata(iosize, uiop, stp, flags, &mp)) != 0) { 25557c478bd9Sstevel@tonic-gate freemsg(mctl); 25567c478bd9Sstevel@tonic-gate /* 25577c478bd9Sstevel@tonic-gate * map EAGAIN to ENOMEM since EAGAIN means "flow controlled". 25587c478bd9Sstevel@tonic-gate */ 25597c478bd9Sstevel@tonic-gate return (error == EAGAIN ? ENOMEM : error); 25607c478bd9Sstevel@tonic-gate } 25617c478bd9Sstevel@tonic-gate if (mctl != NULL) { 25627c478bd9Sstevel@tonic-gate if (mctl->b_cont == NULL) 25637c478bd9Sstevel@tonic-gate mctl->b_cont = mp; 25647c478bd9Sstevel@tonic-gate else if (mp != NULL) 25657c478bd9Sstevel@tonic-gate linkb(mctl, mp); 25667c478bd9Sstevel@tonic-gate mp = mctl; 25677c478bd9Sstevel@tonic-gate /* 25687c478bd9Sstevel@tonic-gate * Note that for interrupt thread, the CRED() is 25697c478bd9Sstevel@tonic-gate * NULL. Don't bother with the pid either. 25707c478bd9Sstevel@tonic-gate */ 25717c478bd9Sstevel@tonic-gate if ((cr = CRED()) != NULL) { 25727c478bd9Sstevel@tonic-gate mblk_setcred(mp, cr); 25737c478bd9Sstevel@tonic-gate DB_CPID(mp) = curproc->p_pid; 25747c478bd9Sstevel@tonic-gate } 25757c478bd9Sstevel@tonic-gate } else if (mp == NULL) { 25767c478bd9Sstevel@tonic-gate return (0); 25777c478bd9Sstevel@tonic-gate } 25787c478bd9Sstevel@tonic-gate 25797c478bd9Sstevel@tonic-gate mp->b_flag |= b_flag; 25807c478bd9Sstevel@tonic-gate mp->b_band = (uchar_t)pri; 25817c478bd9Sstevel@tonic-gate 25827c478bd9Sstevel@tonic-gate (void) uiodup(uiop, &uiod.d_uio, uiod.d_iov, 25837c478bd9Sstevel@tonic-gate sizeof (uiod.d_iov) / sizeof (*uiod.d_iov)); 25847c478bd9Sstevel@tonic-gate uiod.d_uio.uio_offset = 0; 25857c478bd9Sstevel@tonic-gate uiod.d_mp = mp; 25867c478bd9Sstevel@tonic-gate error = rwnext(wqp, &uiod); 25877c478bd9Sstevel@tonic-gate if (! uiod.d_mp) { 25887c478bd9Sstevel@tonic-gate uioskip(uiop, *iosize); 25897c478bd9Sstevel@tonic-gate return (error); 25907c478bd9Sstevel@tonic-gate } 25917c478bd9Sstevel@tonic-gate ASSERT(mp == uiod.d_mp); 25927c478bd9Sstevel@tonic-gate if (error == EINVAL) { 25937c478bd9Sstevel@tonic-gate /* 25947c478bd9Sstevel@tonic-gate * The stream plumbing must have changed while 25957c478bd9Sstevel@tonic-gate * we were away, so just turn off rwnext()s. 25967c478bd9Sstevel@tonic-gate */ 25977c478bd9Sstevel@tonic-gate error = 0; 25987c478bd9Sstevel@tonic-gate } else if (error == EBUSY || error == EWOULDBLOCK) { 25997c478bd9Sstevel@tonic-gate /* 26007c478bd9Sstevel@tonic-gate * Couldn't enter a perimeter or took a page fault, 26017c478bd9Sstevel@tonic-gate * so fall-back to putnext(). 26027c478bd9Sstevel@tonic-gate */ 26037c478bd9Sstevel@tonic-gate error = 0; 26047c478bd9Sstevel@tonic-gate } else { 26057c478bd9Sstevel@tonic-gate freemsg(mp); 26067c478bd9Sstevel@tonic-gate return (error); 26077c478bd9Sstevel@tonic-gate } 26087c478bd9Sstevel@tonic-gate /* Have to check canput before consuming data from the uio */ 26097c478bd9Sstevel@tonic-gate if (pri == 0) { 26107c478bd9Sstevel@tonic-gate if (!canputnext(wqp) && !(flags & MSG_IGNFLOW)) { 26117c478bd9Sstevel@tonic-gate freemsg(mp); 26127c478bd9Sstevel@tonic-gate return (EWOULDBLOCK); 26137c478bd9Sstevel@tonic-gate } 26147c478bd9Sstevel@tonic-gate } else { 26157c478bd9Sstevel@tonic-gate if (!bcanputnext(wqp, pri) && !(flags & MSG_IGNFLOW)) { 26167c478bd9Sstevel@tonic-gate freemsg(mp); 26177c478bd9Sstevel@tonic-gate return (EWOULDBLOCK); 26187c478bd9Sstevel@tonic-gate } 26197c478bd9Sstevel@tonic-gate } 26207c478bd9Sstevel@tonic-gate ASSERT(mp == uiod.d_mp); 26217c478bd9Sstevel@tonic-gate /* Copyin data from the uio */ 26227c478bd9Sstevel@tonic-gate if ((error = struioget(wqp, mp, &uiod, 0)) != 0) { 26237c478bd9Sstevel@tonic-gate freemsg(mp); 26247c478bd9Sstevel@tonic-gate return (error); 26257c478bd9Sstevel@tonic-gate } 26267c478bd9Sstevel@tonic-gate uioskip(uiop, *iosize); 26277c478bd9Sstevel@tonic-gate if (flags & MSG_IGNFLOW) { 26287c478bd9Sstevel@tonic-gate /* 26297c478bd9Sstevel@tonic-gate * XXX Hack: Don't get stuck running service procedures. 26307c478bd9Sstevel@tonic-gate * This is needed for sockfs when sending the unbind message 26317c478bd9Sstevel@tonic-gate * out of the rput procedure - we don't want a put procedure 26327c478bd9Sstevel@tonic-gate * to run service procedures. 26337c478bd9Sstevel@tonic-gate */ 26347c478bd9Sstevel@tonic-gate putnext(wqp, mp); 26357c478bd9Sstevel@tonic-gate } else { 26367c478bd9Sstevel@tonic-gate stream_willservice(stp); 26377c478bd9Sstevel@tonic-gate putnext(wqp, mp); 26387c478bd9Sstevel@tonic-gate stream_runservice(stp); 26397c478bd9Sstevel@tonic-gate } 26407c478bd9Sstevel@tonic-gate return (0); 26417c478bd9Sstevel@tonic-gate } 26427c478bd9Sstevel@tonic-gate 26437c478bd9Sstevel@tonic-gate /* 26447c478bd9Sstevel@tonic-gate * Write attempts to break the write request into messages conforming 26457c478bd9Sstevel@tonic-gate * with the minimum and maximum packet sizes set downstream. 26467c478bd9Sstevel@tonic-gate * 26477c478bd9Sstevel@tonic-gate * Write will not block if downstream queue is full and 26487c478bd9Sstevel@tonic-gate * O_NDELAY is set, otherwise it will block waiting for the queue to get room. 26497c478bd9Sstevel@tonic-gate * 26507c478bd9Sstevel@tonic-gate * A write of zero bytes gets packaged into a zero length message and sent 26517c478bd9Sstevel@tonic-gate * downstream like any other message. 26527c478bd9Sstevel@tonic-gate * 26537c478bd9Sstevel@tonic-gate * If buffers of the requested sizes are not available, the write will 26547c478bd9Sstevel@tonic-gate * sleep until the buffers become available. 26557c478bd9Sstevel@tonic-gate * 26567c478bd9Sstevel@tonic-gate * Write (if specified) will supply a write offset in a message if it 26577c478bd9Sstevel@tonic-gate * makes sense. This can be specified by downstream modules as part of 26587c478bd9Sstevel@tonic-gate * a M_SETOPTS message. Write will not supply the write offset if it 26597c478bd9Sstevel@tonic-gate * cannot supply any data in a buffer. In other words, write will never 26607c478bd9Sstevel@tonic-gate * send down an empty packet due to a write offset. 26617c478bd9Sstevel@tonic-gate */ 26627c478bd9Sstevel@tonic-gate /* ARGSUSED2 */ 26637c478bd9Sstevel@tonic-gate int 26647c478bd9Sstevel@tonic-gate strwrite(struct vnode *vp, struct uio *uiop, cred_t *crp) 26657c478bd9Sstevel@tonic-gate { 2666ff550d0eSmasputra return (strwrite_common(vp, uiop, crp, 0)); 2667ff550d0eSmasputra } 2668ff550d0eSmasputra 2669ff550d0eSmasputra /* ARGSUSED2 */ 2670ff550d0eSmasputra int 2671ff550d0eSmasputra strwrite_common(struct vnode *vp, struct uio *uiop, cred_t *crp, int wflag) 2672ff550d0eSmasputra { 26737c478bd9Sstevel@tonic-gate struct stdata *stp; 26747c478bd9Sstevel@tonic-gate struct queue *wqp; 26757c478bd9Sstevel@tonic-gate ssize_t rmin, rmax; 26767c478bd9Sstevel@tonic-gate ssize_t iosize; 2677ff550d0eSmasputra int waitflag; 26787c478bd9Sstevel@tonic-gate int tempmode; 26797c478bd9Sstevel@tonic-gate int error = 0; 26807c478bd9Sstevel@tonic-gate int b_flag; 26817c478bd9Sstevel@tonic-gate 26827c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 26837c478bd9Sstevel@tonic-gate stp = vp->v_stream; 26847c478bd9Sstevel@tonic-gate 26857c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 26869acbbeafSnn35248 26879acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 26887c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 26897c478bd9Sstevel@tonic-gate return (error); 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate 26929acbbeafSnn35248 if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) { 26939acbbeafSnn35248 error = strwriteable(stp, B_TRUE, B_TRUE); 26949acbbeafSnn35248 if (error != 0) { 26959acbbeafSnn35248 mutex_exit(&stp->sd_lock); 26969acbbeafSnn35248 return (error); 26979acbbeafSnn35248 } 26989acbbeafSnn35248 } 26999acbbeafSnn35248 27009acbbeafSnn35248 mutex_exit(&stp->sd_lock); 27019acbbeafSnn35248 27027c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq; 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate /* get these values from them cached in the stream head */ 27057c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz; 27067c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz; 27077c478bd9Sstevel@tonic-gate 27087c478bd9Sstevel@tonic-gate /* 27097c478bd9Sstevel@tonic-gate * Check the min/max packet size constraints. If min packet size 27107c478bd9Sstevel@tonic-gate * is non-zero, the write cannot be split into multiple messages 27117c478bd9Sstevel@tonic-gate * and still guarantee the size constraints. 27127c478bd9Sstevel@tonic-gate */ 27137c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_IN, "strwrite in:q %p", wqp); 27147c478bd9Sstevel@tonic-gate 27157c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ)); 27167c478bd9Sstevel@tonic-gate if (rmax == 0) { 27177c478bd9Sstevel@tonic-gate return (0); 27187c478bd9Sstevel@tonic-gate } 27197c478bd9Sstevel@tonic-gate if (rmin > 0) { 27207c478bd9Sstevel@tonic-gate if (uiop->uio_resid < rmin) { 27217c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT, 27227c478bd9Sstevel@tonic-gate "strwrite out:q %p out %d error %d", 27237c478bd9Sstevel@tonic-gate wqp, 0, ERANGE); 27247c478bd9Sstevel@tonic-gate return (ERANGE); 27257c478bd9Sstevel@tonic-gate } 27267c478bd9Sstevel@tonic-gate if ((rmax != INFPSZ) && (uiop->uio_resid > rmax)) { 27277c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT, 27287c478bd9Sstevel@tonic-gate "strwrite out:q %p out %d error %d", 27297c478bd9Sstevel@tonic-gate wqp, 1, ERANGE); 27307c478bd9Sstevel@tonic-gate return (ERANGE); 27317c478bd9Sstevel@tonic-gate } 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate /* 27357c478bd9Sstevel@tonic-gate * Do until count satisfied or error. 27367c478bd9Sstevel@tonic-gate */ 2737ff550d0eSmasputra waitflag = WRITEWAIT | wflag; 27387c478bd9Sstevel@tonic-gate if (stp->sd_flag & OLDNDELAY) 27397c478bd9Sstevel@tonic-gate tempmode = uiop->uio_fmode & ~FNDELAY; 27407c478bd9Sstevel@tonic-gate else 27417c478bd9Sstevel@tonic-gate tempmode = uiop->uio_fmode; 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) 27447c478bd9Sstevel@tonic-gate rmax = uiop->uio_resid; 27457c478bd9Sstevel@tonic-gate 27467c478bd9Sstevel@tonic-gate /* 27477c478bd9Sstevel@tonic-gate * Note that tempmode does not get used in strput/strmakedata 27487c478bd9Sstevel@tonic-gate * but only in strwaitq. The other routines use uio_fmode 27497c478bd9Sstevel@tonic-gate * unmodified. 27507c478bd9Sstevel@tonic-gate */ 27517c478bd9Sstevel@tonic-gate 27527c478bd9Sstevel@tonic-gate /* LINTED: constant in conditional context */ 27537c478bd9Sstevel@tonic-gate while (1) { /* breaks when uio_resid reaches zero */ 27547c478bd9Sstevel@tonic-gate /* 27557c478bd9Sstevel@tonic-gate * Determine the size of the next message to be 27567c478bd9Sstevel@tonic-gate * packaged. May have to break write into several 27577c478bd9Sstevel@tonic-gate * messages based on max packet size. 27587c478bd9Sstevel@tonic-gate */ 27597c478bd9Sstevel@tonic-gate iosize = MIN(uiop->uio_resid, rmax); 27607c478bd9Sstevel@tonic-gate 27617c478bd9Sstevel@tonic-gate /* 27627c478bd9Sstevel@tonic-gate * Put block downstream when flow control allows it. 27637c478bd9Sstevel@tonic-gate */ 27647c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRDELIM) && (uiop->uio_resid == iosize)) 27657c478bd9Sstevel@tonic-gate b_flag = MSGDELIM; 27667c478bd9Sstevel@tonic-gate else 27677c478bd9Sstevel@tonic-gate b_flag = 0; 27687c478bd9Sstevel@tonic-gate 27697c478bd9Sstevel@tonic-gate for (;;) { 27707c478bd9Sstevel@tonic-gate int done = 0; 27717c478bd9Sstevel@tonic-gate 27727c478bd9Sstevel@tonic-gate error = strput(stp, NULL, uiop, &iosize, b_flag, 27737c478bd9Sstevel@tonic-gate 0, 0); 27747c478bd9Sstevel@tonic-gate if (error == 0) 27757c478bd9Sstevel@tonic-gate break; 27767c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK) 27777c478bd9Sstevel@tonic-gate goto out; 27787c478bd9Sstevel@tonic-gate 27797c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 27807c478bd9Sstevel@tonic-gate /* 27817c478bd9Sstevel@tonic-gate * Check for a missed wakeup. 27827c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across 27837c478bd9Sstevel@tonic-gate * the canputnext. 27847c478bd9Sstevel@tonic-gate */ 27857c478bd9Sstevel@tonic-gate if (canputnext(wqp)) { 27867c478bd9Sstevel@tonic-gate /* Try again */ 27877c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 27887c478bd9Sstevel@tonic-gate continue; 27897c478bd9Sstevel@tonic-gate } 27907c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAIT, 27917c478bd9Sstevel@tonic-gate "strwrite wait:q %p wait", wqp); 27927c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, waitflag, (ssize_t)0, 27937c478bd9Sstevel@tonic-gate tempmode, -1, &done)) != 0 || done) { 27947c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 27957c478bd9Sstevel@tonic-gate if ((vp->v_type == VFIFO) && 27967c478bd9Sstevel@tonic-gate (uiop->uio_fmode & FNDELAY) && 27977c478bd9Sstevel@tonic-gate (error == EAGAIN)) 27987c478bd9Sstevel@tonic-gate error = 0; 27997c478bd9Sstevel@tonic-gate goto out; 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRWRITE_WAKE, 28027c478bd9Sstevel@tonic-gate "strwrite wake:q %p awakes", wqp); 28039acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 28047c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 28057c478bd9Sstevel@tonic-gate goto out; 28067c478bd9Sstevel@tonic-gate } 28079acbbeafSnn35248 mutex_exit(&stp->sd_lock); 28089acbbeafSnn35248 } 28097c478bd9Sstevel@tonic-gate waitflag |= NOINTR; 28107c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRWRITE_RESID, 28117c478bd9Sstevel@tonic-gate "strwrite resid:q %p uiop %p", wqp, uiop); 28127c478bd9Sstevel@tonic-gate if (uiop->uio_resid) { 28137c478bd9Sstevel@tonic-gate /* Recheck for errors - needed for sockets */ 28147c478bd9Sstevel@tonic-gate if ((stp->sd_wput_opt & SW_RECHECK_ERR) && 28157c478bd9Sstevel@tonic-gate (stp->sd_flag & (STWRERR|STRHUP|STPLEX))) { 28167c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 28177c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_FALSE, B_TRUE); 28187c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 28197c478bd9Sstevel@tonic-gate if (error != 0) 28207c478bd9Sstevel@tonic-gate return (error); 28217c478bd9Sstevel@tonic-gate } 28227c478bd9Sstevel@tonic-gate continue; 28237c478bd9Sstevel@tonic-gate } 28247c478bd9Sstevel@tonic-gate break; 28257c478bd9Sstevel@tonic-gate } 28267c478bd9Sstevel@tonic-gate out: 28277c478bd9Sstevel@tonic-gate /* 28287c478bd9Sstevel@tonic-gate * For historical reasons, applications expect EAGAIN when a data 28297c478bd9Sstevel@tonic-gate * mblk_t cannot be allocated, so change ENOMEM back to EAGAIN. 28307c478bd9Sstevel@tonic-gate */ 28317c478bd9Sstevel@tonic-gate if (error == ENOMEM) 28327c478bd9Sstevel@tonic-gate error = EAGAIN; 28337c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRWRITE_OUT, 28347c478bd9Sstevel@tonic-gate "strwrite out:q %p out %d error %d", wqp, 2, error); 28357c478bd9Sstevel@tonic-gate return (error); 28367c478bd9Sstevel@tonic-gate } 28377c478bd9Sstevel@tonic-gate 28387c478bd9Sstevel@tonic-gate /* 28397c478bd9Sstevel@tonic-gate * Stream head write service routine. 28407c478bd9Sstevel@tonic-gate * Its job is to wake up any sleeping writers when a queue 28417c478bd9Sstevel@tonic-gate * downstream needs data (part of the flow control in putq and getq). 28427c478bd9Sstevel@tonic-gate * It also must wake anyone sleeping on a poll(). 28437c478bd9Sstevel@tonic-gate * For stream head right below mux module, it must also invoke put procedure 28447c478bd9Sstevel@tonic-gate * of next downstream module. 28457c478bd9Sstevel@tonic-gate */ 28467c478bd9Sstevel@tonic-gate int 28477c478bd9Sstevel@tonic-gate strwsrv(queue_t *q) 28487c478bd9Sstevel@tonic-gate { 28497c478bd9Sstevel@tonic-gate struct stdata *stp; 28507c478bd9Sstevel@tonic-gate queue_t *tq; 28517c478bd9Sstevel@tonic-gate qband_t *qbp; 28527c478bd9Sstevel@tonic-gate int i; 28537c478bd9Sstevel@tonic-gate qband_t *myqbp; 28547c478bd9Sstevel@tonic-gate int isevent; 28557c478bd9Sstevel@tonic-gate unsigned char qbf[NBAND]; /* band flushing backenable flags */ 28567c478bd9Sstevel@tonic-gate 28577c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 28587c478bd9Sstevel@tonic-gate TR_STRWSRV, "strwsrv:q %p", q); 28597c478bd9Sstevel@tonic-gate stp = (struct stdata *)q->q_ptr; 28607c478bd9Sstevel@tonic-gate ASSERT(qclaimed(q)); 28617c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 28627c478bd9Sstevel@tonic-gate ASSERT(!(stp->sd_flag & STPLEX)); 28637c478bd9Sstevel@tonic-gate 28647c478bd9Sstevel@tonic-gate if (stp->sd_flag & WSLEEP) { 28657c478bd9Sstevel@tonic-gate stp->sd_flag &= ~WSLEEP; 28667c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); 28677c478bd9Sstevel@tonic-gate } 28687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 28697c478bd9Sstevel@tonic-gate 28707c478bd9Sstevel@tonic-gate /* The other end of a stream pipe went away. */ 28717c478bd9Sstevel@tonic-gate if ((tq = q->q_next) == NULL) { 28727c478bd9Sstevel@tonic-gate return (0); 28737c478bd9Sstevel@tonic-gate } 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate /* Find the next module forward that has a service procedure */ 28767c478bd9Sstevel@tonic-gate claimstr(q); 28777c478bd9Sstevel@tonic-gate tq = q->q_nfsrv; 28787c478bd9Sstevel@tonic-gate ASSERT(tq != NULL); 28797c478bd9Sstevel@tonic-gate 28807c478bd9Sstevel@tonic-gate if ((q->q_flag & QBACK)) { 28817c478bd9Sstevel@tonic-gate if ((tq->q_flag & QFULL)) { 28827c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(tq)); 28837c478bd9Sstevel@tonic-gate if (!(tq->q_flag & QFULL)) { 28847c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq)); 28857c478bd9Sstevel@tonic-gate goto wakeup; 28867c478bd9Sstevel@tonic-gate } 28877c478bd9Sstevel@tonic-gate /* 28887c478bd9Sstevel@tonic-gate * The queue must have become full again. Set QWANTW 28897c478bd9Sstevel@tonic-gate * again so strwsrv will be back enabled when 28907c478bd9Sstevel@tonic-gate * the queue becomes non-full next time. 28917c478bd9Sstevel@tonic-gate */ 28927c478bd9Sstevel@tonic-gate tq->q_flag |= QWANTW; 28937c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq)); 28947c478bd9Sstevel@tonic-gate } else { 28957c478bd9Sstevel@tonic-gate wakeup: 28967c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLWRNORM); 28977c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 28987c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_WRNORM) 28997c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_WRNORM, 0, 0); 29007c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 29017c478bd9Sstevel@tonic-gate } 29027c478bd9Sstevel@tonic-gate } 29037c478bd9Sstevel@tonic-gate 29047c478bd9Sstevel@tonic-gate isevent = 0; 29057c478bd9Sstevel@tonic-gate i = 1; 29067c478bd9Sstevel@tonic-gate bzero((caddr_t)qbf, NBAND); 29077c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(tq)); 29087c478bd9Sstevel@tonic-gate if ((myqbp = q->q_bandp) != NULL) 29097c478bd9Sstevel@tonic-gate for (qbp = tq->q_bandp; qbp && myqbp; qbp = qbp->qb_next) { 29107c478bd9Sstevel@tonic-gate ASSERT(myqbp); 29117c478bd9Sstevel@tonic-gate if ((myqbp->qb_flag & QB_BACK)) { 29127c478bd9Sstevel@tonic-gate if (qbp->qb_flag & QB_FULL) { 29137c478bd9Sstevel@tonic-gate /* 29147c478bd9Sstevel@tonic-gate * The band must have become full again. 29157c478bd9Sstevel@tonic-gate * Set QB_WANTW again so strwsrv will 29167c478bd9Sstevel@tonic-gate * be back enabled when the band becomes 29177c478bd9Sstevel@tonic-gate * non-full next time. 29187c478bd9Sstevel@tonic-gate */ 29197c478bd9Sstevel@tonic-gate qbp->qb_flag |= QB_WANTW; 29207c478bd9Sstevel@tonic-gate } else { 29217c478bd9Sstevel@tonic-gate isevent = 1; 29227c478bd9Sstevel@tonic-gate qbf[i] = 1; 29237c478bd9Sstevel@tonic-gate } 29247c478bd9Sstevel@tonic-gate } 29257c478bd9Sstevel@tonic-gate myqbp = myqbp->qb_next; 29267c478bd9Sstevel@tonic-gate i++; 29277c478bd9Sstevel@tonic-gate } 29287c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq)); 29297c478bd9Sstevel@tonic-gate 29307c478bd9Sstevel@tonic-gate if (isevent) { 29317c478bd9Sstevel@tonic-gate for (i = tq->q_nband; i; i--) { 29327c478bd9Sstevel@tonic-gate if (qbf[i]) { 29337c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, POLLWRBAND); 29347c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 29357c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & S_WRBAND) 29367c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, S_WRBAND, 29377c478bd9Sstevel@tonic-gate (uchar_t)i, 0); 29387c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 29397c478bd9Sstevel@tonic-gate } 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate } 29427c478bd9Sstevel@tonic-gate 29437c478bd9Sstevel@tonic-gate releasestr(q); 29447c478bd9Sstevel@tonic-gate return (0); 29457c478bd9Sstevel@tonic-gate } 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate /* 29487c478bd9Sstevel@tonic-gate * Special case of strcopyin/strcopyout for copying 29497c478bd9Sstevel@tonic-gate * struct strioctl that can deal with both data 29507c478bd9Sstevel@tonic-gate * models. 29517c478bd9Sstevel@tonic-gate */ 29527c478bd9Sstevel@tonic-gate 29537c478bd9Sstevel@tonic-gate #ifdef _LP64 29547c478bd9Sstevel@tonic-gate 29557c478bd9Sstevel@tonic-gate static int 29567c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag) 29577c478bd9Sstevel@tonic-gate { 29587c478bd9Sstevel@tonic-gate struct strioctl32 strioc32; 29597c478bd9Sstevel@tonic-gate struct strioctl *striocp; 29607c478bd9Sstevel@tonic-gate 29617c478bd9Sstevel@tonic-gate if (copyflag & U_TO_K) { 29627c478bd9Sstevel@tonic-gate ASSERT((copyflag & K_TO_K) == 0); 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate if ((flag & FMODELS) == DATAMODEL_ILP32) { 29657c478bd9Sstevel@tonic-gate if (copyin(from, &strioc32, sizeof (strioc32))) 29667c478bd9Sstevel@tonic-gate return (EFAULT); 29677c478bd9Sstevel@tonic-gate 29687c478bd9Sstevel@tonic-gate striocp = (struct strioctl *)to; 29697c478bd9Sstevel@tonic-gate striocp->ic_cmd = strioc32.ic_cmd; 29707c478bd9Sstevel@tonic-gate striocp->ic_timout = strioc32.ic_timout; 29717c478bd9Sstevel@tonic-gate striocp->ic_len = strioc32.ic_len; 29727c478bd9Sstevel@tonic-gate striocp->ic_dp = (char *)(uintptr_t)strioc32.ic_dp; 29737c478bd9Sstevel@tonic-gate 29747c478bd9Sstevel@tonic-gate } else { /* NATIVE data model */ 29757c478bd9Sstevel@tonic-gate if (copyin(from, to, sizeof (struct strioctl))) { 29767c478bd9Sstevel@tonic-gate return (EFAULT); 29777c478bd9Sstevel@tonic-gate } else { 29787c478bd9Sstevel@tonic-gate return (0); 29797c478bd9Sstevel@tonic-gate } 29807c478bd9Sstevel@tonic-gate } 29817c478bd9Sstevel@tonic-gate } else { 29827c478bd9Sstevel@tonic-gate ASSERT(copyflag & K_TO_K); 29837c478bd9Sstevel@tonic-gate bcopy(from, to, sizeof (struct strioctl)); 29847c478bd9Sstevel@tonic-gate } 29857c478bd9Sstevel@tonic-gate return (0); 29867c478bd9Sstevel@tonic-gate } 29877c478bd9Sstevel@tonic-gate 29887c478bd9Sstevel@tonic-gate static int 29897c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag) 29907c478bd9Sstevel@tonic-gate { 29917c478bd9Sstevel@tonic-gate struct strioctl32 strioc32; 29927c478bd9Sstevel@tonic-gate struct strioctl *striocp; 29937c478bd9Sstevel@tonic-gate 29947c478bd9Sstevel@tonic-gate if (copyflag & U_TO_K) { 29957c478bd9Sstevel@tonic-gate ASSERT((copyflag & K_TO_K) == 0); 29967c478bd9Sstevel@tonic-gate 29977c478bd9Sstevel@tonic-gate if ((flag & FMODELS) == DATAMODEL_ILP32) { 29987c478bd9Sstevel@tonic-gate striocp = (struct strioctl *)from; 29997c478bd9Sstevel@tonic-gate strioc32.ic_cmd = striocp->ic_cmd; 30007c478bd9Sstevel@tonic-gate strioc32.ic_timout = striocp->ic_timout; 30017c478bd9Sstevel@tonic-gate strioc32.ic_len = striocp->ic_len; 30027c478bd9Sstevel@tonic-gate strioc32.ic_dp = (caddr32_t)(uintptr_t)striocp->ic_dp; 30037c478bd9Sstevel@tonic-gate ASSERT((char *)(uintptr_t)strioc32.ic_dp == 30047c478bd9Sstevel@tonic-gate striocp->ic_dp); 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate if (copyout(&strioc32, to, sizeof (strioc32))) 30077c478bd9Sstevel@tonic-gate return (EFAULT); 30087c478bd9Sstevel@tonic-gate 30097c478bd9Sstevel@tonic-gate } else { /* NATIVE data model */ 30107c478bd9Sstevel@tonic-gate if (copyout(from, to, sizeof (struct strioctl))) { 30117c478bd9Sstevel@tonic-gate return (EFAULT); 30127c478bd9Sstevel@tonic-gate } else { 30137c478bd9Sstevel@tonic-gate return (0); 30147c478bd9Sstevel@tonic-gate } 30157c478bd9Sstevel@tonic-gate } 30167c478bd9Sstevel@tonic-gate } else { 30177c478bd9Sstevel@tonic-gate ASSERT(copyflag & K_TO_K); 30187c478bd9Sstevel@tonic-gate bcopy(from, to, sizeof (struct strioctl)); 30197c478bd9Sstevel@tonic-gate } 30207c478bd9Sstevel@tonic-gate return (0); 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate 30237c478bd9Sstevel@tonic-gate #else /* ! _LP64 */ 30247c478bd9Sstevel@tonic-gate 30257c478bd9Sstevel@tonic-gate /* ARGSUSED2 */ 30267c478bd9Sstevel@tonic-gate static int 30277c478bd9Sstevel@tonic-gate strcopyin_strioctl(void *from, void *to, int flag, int copyflag) 30287c478bd9Sstevel@tonic-gate { 30297c478bd9Sstevel@tonic-gate return (strcopyin(from, to, sizeof (struct strioctl), copyflag)); 30307c478bd9Sstevel@tonic-gate } 30317c478bd9Sstevel@tonic-gate 30327c478bd9Sstevel@tonic-gate /* ARGSUSED2 */ 30337c478bd9Sstevel@tonic-gate static int 30347c478bd9Sstevel@tonic-gate strcopyout_strioctl(void *from, void *to, int flag, int copyflag) 30357c478bd9Sstevel@tonic-gate { 30367c478bd9Sstevel@tonic-gate return (strcopyout(from, to, sizeof (struct strioctl), copyflag)); 30377c478bd9Sstevel@tonic-gate } 30387c478bd9Sstevel@tonic-gate 30397c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate /* 30427c478bd9Sstevel@tonic-gate * Determine type of job control semantics expected by user. The 30437c478bd9Sstevel@tonic-gate * possibilities are: 30447c478bd9Sstevel@tonic-gate * JCREAD - Behaves like read() on fd; send SIGTTIN 30457c478bd9Sstevel@tonic-gate * JCWRITE - Behaves like write() on fd; send SIGTTOU if TOSTOP set 30467c478bd9Sstevel@tonic-gate * JCSETP - Sets a value in the stream; send SIGTTOU, ignore TOSTOP 30477c478bd9Sstevel@tonic-gate * JCGETP - Gets a value in the stream; no signals. 30487c478bd9Sstevel@tonic-gate * See straccess in strsubr.c for usage of these values. 30497c478bd9Sstevel@tonic-gate * 30507c478bd9Sstevel@tonic-gate * This routine also returns -1 for I_STR as a special case; the 30517c478bd9Sstevel@tonic-gate * caller must call again with the real ioctl number for 30527c478bd9Sstevel@tonic-gate * classification. 30537c478bd9Sstevel@tonic-gate */ 30547c478bd9Sstevel@tonic-gate static int 30557c478bd9Sstevel@tonic-gate job_control_type(int cmd) 30567c478bd9Sstevel@tonic-gate { 30577c478bd9Sstevel@tonic-gate switch (cmd) { 30587c478bd9Sstevel@tonic-gate case I_STR: 30597c478bd9Sstevel@tonic-gate return (-1); 30607c478bd9Sstevel@tonic-gate 30617c478bd9Sstevel@tonic-gate case I_RECVFD: 30627c478bd9Sstevel@tonic-gate case I_E_RECVFD: 30637c478bd9Sstevel@tonic-gate return (JCREAD); 30647c478bd9Sstevel@tonic-gate 30657c478bd9Sstevel@tonic-gate case I_FDINSERT: 30667c478bd9Sstevel@tonic-gate case I_SENDFD: 30677c478bd9Sstevel@tonic-gate return (JCWRITE); 30687c478bd9Sstevel@tonic-gate 30697c478bd9Sstevel@tonic-gate case TCSETA: 30707c478bd9Sstevel@tonic-gate case TCSETAW: 30717c478bd9Sstevel@tonic-gate case TCSETAF: 30727c478bd9Sstevel@tonic-gate case TCSBRK: 30737c478bd9Sstevel@tonic-gate case TCXONC: 30747c478bd9Sstevel@tonic-gate case TCFLSH: 30757c478bd9Sstevel@tonic-gate case TCDSET: /* Obsolete */ 30767c478bd9Sstevel@tonic-gate case TIOCSWINSZ: 30777c478bd9Sstevel@tonic-gate case TCSETS: 30787c478bd9Sstevel@tonic-gate case TCSETSW: 30797c478bd9Sstevel@tonic-gate case TCSETSF: 30807c478bd9Sstevel@tonic-gate case TIOCSETD: 30817c478bd9Sstevel@tonic-gate case TIOCHPCL: 30827c478bd9Sstevel@tonic-gate case TIOCSETP: 30837c478bd9Sstevel@tonic-gate case TIOCSETN: 30847c478bd9Sstevel@tonic-gate case TIOCEXCL: 30857c478bd9Sstevel@tonic-gate case TIOCNXCL: 30867c478bd9Sstevel@tonic-gate case TIOCFLUSH: 30877c478bd9Sstevel@tonic-gate case TIOCSETC: 30887c478bd9Sstevel@tonic-gate case TIOCLBIS: 30897c478bd9Sstevel@tonic-gate case TIOCLBIC: 30907c478bd9Sstevel@tonic-gate case TIOCLSET: 30917c478bd9Sstevel@tonic-gate case TIOCSBRK: 30927c478bd9Sstevel@tonic-gate case TIOCCBRK: 30937c478bd9Sstevel@tonic-gate case TIOCSDTR: 30947c478bd9Sstevel@tonic-gate case TIOCCDTR: 30957c478bd9Sstevel@tonic-gate case TIOCSLTC: 30967c478bd9Sstevel@tonic-gate case TIOCSTOP: 30977c478bd9Sstevel@tonic-gate case TIOCSTART: 30987c478bd9Sstevel@tonic-gate case TIOCSTI: 30997c478bd9Sstevel@tonic-gate case TIOCSPGRP: 31007c478bd9Sstevel@tonic-gate case TIOCMSET: 31017c478bd9Sstevel@tonic-gate case TIOCMBIS: 31027c478bd9Sstevel@tonic-gate case TIOCMBIC: 31037c478bd9Sstevel@tonic-gate case TIOCREMOTE: 31047c478bd9Sstevel@tonic-gate case TIOCSIGNAL: 31057c478bd9Sstevel@tonic-gate case LDSETT: 31067c478bd9Sstevel@tonic-gate case LDSMAP: /* Obsolete */ 31077c478bd9Sstevel@tonic-gate case DIOCSETP: 31087c478bd9Sstevel@tonic-gate case I_FLUSH: 31097c478bd9Sstevel@tonic-gate case I_SRDOPT: 31107c478bd9Sstevel@tonic-gate case I_SETSIG: 31117c478bd9Sstevel@tonic-gate case I_SWROPT: 31127c478bd9Sstevel@tonic-gate case I_FLUSHBAND: 31137c478bd9Sstevel@tonic-gate case I_SETCLTIME: 31147c478bd9Sstevel@tonic-gate case I_SERROPT: 31157c478bd9Sstevel@tonic-gate case I_ESETSIG: 31167c478bd9Sstevel@tonic-gate case FIONBIO: 31177c478bd9Sstevel@tonic-gate case FIOASYNC: 31187c478bd9Sstevel@tonic-gate case FIOSETOWN: 31197c478bd9Sstevel@tonic-gate case JBOOT: /* Obsolete */ 31207c478bd9Sstevel@tonic-gate case JTERM: /* Obsolete */ 31217c478bd9Sstevel@tonic-gate case JTIMOM: /* Obsolete */ 31227c478bd9Sstevel@tonic-gate case JZOMBOOT: /* Obsolete */ 31237c478bd9Sstevel@tonic-gate case JAGENT: /* Obsolete */ 31247c478bd9Sstevel@tonic-gate case JTRUN: /* Obsolete */ 31257c478bd9Sstevel@tonic-gate case JXTPROTO: /* Obsolete */ 31269acbbeafSnn35248 case TIOCSETLD: 31277c478bd9Sstevel@tonic-gate return (JCSETP); 31287c478bd9Sstevel@tonic-gate } 31297c478bd9Sstevel@tonic-gate 31307c478bd9Sstevel@tonic-gate return (JCGETP); 31317c478bd9Sstevel@tonic-gate } 31327c478bd9Sstevel@tonic-gate 31337c478bd9Sstevel@tonic-gate /* 31347c478bd9Sstevel@tonic-gate * ioctl for streams 31357c478bd9Sstevel@tonic-gate */ 31367c478bd9Sstevel@tonic-gate int 31377c478bd9Sstevel@tonic-gate strioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, int copyflag, 31387c478bd9Sstevel@tonic-gate cred_t *crp, int *rvalp) 31397c478bd9Sstevel@tonic-gate { 31407c478bd9Sstevel@tonic-gate struct stdata *stp; 31417c478bd9Sstevel@tonic-gate struct strioctl strioc; 31427c478bd9Sstevel@tonic-gate struct uio uio; 31437c478bd9Sstevel@tonic-gate struct iovec iov; 31447c478bd9Sstevel@tonic-gate int access; 31457c478bd9Sstevel@tonic-gate mblk_t *mp; 31467c478bd9Sstevel@tonic-gate int error = 0; 31477c478bd9Sstevel@tonic-gate int done = 0; 31487c478bd9Sstevel@tonic-gate ssize_t rmin, rmax; 31497c478bd9Sstevel@tonic-gate queue_t *wrq; 31507c478bd9Sstevel@tonic-gate queue_t *rdq; 31517c478bd9Sstevel@tonic-gate boolean_t kioctl = B_FALSE; 31527c478bd9Sstevel@tonic-gate 31537c478bd9Sstevel@tonic-gate if (flag & FKIOCTL) { 31547c478bd9Sstevel@tonic-gate copyflag = K_TO_K; 31557c478bd9Sstevel@tonic-gate kioctl = B_TRUE; 31567c478bd9Sstevel@tonic-gate } 31577c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 31587c478bd9Sstevel@tonic-gate ASSERT(copyflag == U_TO_K || copyflag == K_TO_K); 31597c478bd9Sstevel@tonic-gate stp = vp->v_stream; 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_IOCTL_ENTER, 31627c478bd9Sstevel@tonic-gate "strioctl:stp %p cmd %X arg %lX", stp, cmd, arg); 31637c478bd9Sstevel@tonic-gate 31647c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 31657c478bd9Sstevel@tonic-gate if (audit_active) 31667c478bd9Sstevel@tonic-gate audit_strioctl(vp, cmd, arg, flag, copyflag, crp, rvalp); 31677c478bd9Sstevel@tonic-gate #endif 31687c478bd9Sstevel@tonic-gate 31697c478bd9Sstevel@tonic-gate /* 31707c478bd9Sstevel@tonic-gate * If the copy is kernel to kernel, make sure that the FNATIVE 31717c478bd9Sstevel@tonic-gate * flag is set. After this it would be a serious error to have 31727c478bd9Sstevel@tonic-gate * no model flag. 31737c478bd9Sstevel@tonic-gate */ 31747c478bd9Sstevel@tonic-gate if (copyflag == K_TO_K) 31757c478bd9Sstevel@tonic-gate flag = (flag & ~FMODELS) | FNATIVE; 31767c478bd9Sstevel@tonic-gate 31777c478bd9Sstevel@tonic-gate ASSERT((flag & FMODELS) != 0); 31787c478bd9Sstevel@tonic-gate 31797c478bd9Sstevel@tonic-gate wrq = stp->sd_wrq; 31807c478bd9Sstevel@tonic-gate rdq = _RD(wrq); 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate access = job_control_type(cmd); 31837c478bd9Sstevel@tonic-gate 31847c478bd9Sstevel@tonic-gate /* We should never see these here, should be handled by iwscn */ 31857c478bd9Sstevel@tonic-gate if (cmd == SRIOCSREDIR || cmd == SRIOCISREDIR) 31867c478bd9Sstevel@tonic-gate return (EINVAL); 31877c478bd9Sstevel@tonic-gate 31889acbbeafSnn35248 mutex_enter(&stp->sd_lock); 31899acbbeafSnn35248 if ((access != -1) && ((error = i_straccess(stp, access)) != 0)) { 31909acbbeafSnn35248 mutex_exit(&stp->sd_lock); 31917c478bd9Sstevel@tonic-gate return (error); 31929acbbeafSnn35248 } 31939acbbeafSnn35248 mutex_exit(&stp->sd_lock); 31947c478bd9Sstevel@tonic-gate 31957c478bd9Sstevel@tonic-gate /* 31967c478bd9Sstevel@tonic-gate * Check for sgttyb-related ioctls first, and complain as 31977c478bd9Sstevel@tonic-gate * necessary. 31987c478bd9Sstevel@tonic-gate */ 31997c478bd9Sstevel@tonic-gate switch (cmd) { 32007c478bd9Sstevel@tonic-gate case TIOCGETP: 32017c478bd9Sstevel@tonic-gate case TIOCSETP: 32027c478bd9Sstevel@tonic-gate case TIOCSETN: 32037c478bd9Sstevel@tonic-gate if (sgttyb_handling >= 2 && !sgttyb_complaint) { 32047c478bd9Sstevel@tonic-gate sgttyb_complaint = B_TRUE; 32057c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, 32067c478bd9Sstevel@tonic-gate "application used obsolete TIOC[GS]ET"); 32077c478bd9Sstevel@tonic-gate } 32087c478bd9Sstevel@tonic-gate if (sgttyb_handling >= 3) { 32097c478bd9Sstevel@tonic-gate tsignal(curthread, SIGSYS); 32107c478bd9Sstevel@tonic-gate return (EIO); 32117c478bd9Sstevel@tonic-gate } 32127c478bd9Sstevel@tonic-gate break; 32137c478bd9Sstevel@tonic-gate } 32147c478bd9Sstevel@tonic-gate 32157c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate switch (cmd) { 32187c478bd9Sstevel@tonic-gate case I_RECVFD: 32197c478bd9Sstevel@tonic-gate case I_E_RECVFD: 32207c478bd9Sstevel@tonic-gate case I_PEEK: 32217c478bd9Sstevel@tonic-gate case I_NREAD: 32227c478bd9Sstevel@tonic-gate case FIONREAD: 32237c478bd9Sstevel@tonic-gate case FIORDCHK: 32247c478bd9Sstevel@tonic-gate case I_ATMARK: 32257c478bd9Sstevel@tonic-gate case FIONBIO: 32267c478bd9Sstevel@tonic-gate case FIOASYNC: 32277c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) { 32287c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 0); 32297c478bd9Sstevel@tonic-gate if (error != 0) { 32307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 32317c478bd9Sstevel@tonic-gate return (error); 32327c478bd9Sstevel@tonic-gate } 32337c478bd9Sstevel@tonic-gate } 32347c478bd9Sstevel@tonic-gate break; 32357c478bd9Sstevel@tonic-gate 32367c478bd9Sstevel@tonic-gate default: 32377c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STWRERR|STPLEX)) { 32387c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STWRERR|STPLEX, 0); 32397c478bd9Sstevel@tonic-gate if (error != 0) { 32407c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 32417c478bd9Sstevel@tonic-gate return (error); 32427c478bd9Sstevel@tonic-gate } 32437c478bd9Sstevel@tonic-gate } 32447c478bd9Sstevel@tonic-gate } 32457c478bd9Sstevel@tonic-gate 32467c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 32477c478bd9Sstevel@tonic-gate 32487c478bd9Sstevel@tonic-gate switch (cmd) { 32497c478bd9Sstevel@tonic-gate default: 32507c478bd9Sstevel@tonic-gate /* 32517c478bd9Sstevel@tonic-gate * The stream head has hardcoded knowledge of a 32527c478bd9Sstevel@tonic-gate * miscellaneous collection of terminal-, keyboard- and 32537c478bd9Sstevel@tonic-gate * mouse-related ioctls, enumerated below. This hardcoded 32547c478bd9Sstevel@tonic-gate * knowledge allows the stream head to automatically 32557c478bd9Sstevel@tonic-gate * convert transparent ioctl requests made by userland 32567c478bd9Sstevel@tonic-gate * programs into I_STR ioctls which many old STREAMS 32577c478bd9Sstevel@tonic-gate * modules and drivers require. 32587c478bd9Sstevel@tonic-gate * 32597c478bd9Sstevel@tonic-gate * No new ioctls should ever be added to this list. 32607c478bd9Sstevel@tonic-gate * Instead, the STREAMS module or driver should be written 32617c478bd9Sstevel@tonic-gate * to either handle transparent ioctls or require any 32627c478bd9Sstevel@tonic-gate * userland programs to use I_STR ioctls (by returning 32637c478bd9Sstevel@tonic-gate * EINVAL to any transparent ioctl requests). 32647c478bd9Sstevel@tonic-gate * 32657c478bd9Sstevel@tonic-gate * More importantly, removing ioctls from this list should 32667c478bd9Sstevel@tonic-gate * be done with the utmost care, since our STREAMS modules 32677c478bd9Sstevel@tonic-gate * and drivers *count* on the stream head performing this 32687c478bd9Sstevel@tonic-gate * conversion, and thus may panic while processing 32697c478bd9Sstevel@tonic-gate * transparent ioctl request for one of these ioctls (keep 32707c478bd9Sstevel@tonic-gate * in mind that third party modules and drivers may have 32717c478bd9Sstevel@tonic-gate * similar problems). 32727c478bd9Sstevel@tonic-gate */ 32737c478bd9Sstevel@tonic-gate if (((cmd & IOCTYPE) == LDIOC) || 32747c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == tIOC) || 32757c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == TIOC) || 32767c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == KIOC) || 32777c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == MSIOC) || 32787c478bd9Sstevel@tonic-gate ((cmd & IOCTYPE) == VUIOC)) { 32797c478bd9Sstevel@tonic-gate /* 32807c478bd9Sstevel@tonic-gate * The ioctl is a tty ioctl - set up strioc buffer 32817c478bd9Sstevel@tonic-gate * and call strdoioctl() to do the work. 32827c478bd9Sstevel@tonic-gate */ 32837c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 32847c478bd9Sstevel@tonic-gate return (ENXIO); 32857c478bd9Sstevel@tonic-gate strioc.ic_cmd = cmd; 32867c478bd9Sstevel@tonic-gate strioc.ic_timout = INFTIM; 32877c478bd9Sstevel@tonic-gate 32887c478bd9Sstevel@tonic-gate switch (cmd) { 32897c478bd9Sstevel@tonic-gate 32907c478bd9Sstevel@tonic-gate case TCXONC: 32917c478bd9Sstevel@tonic-gate case TCSBRK: 32927c478bd9Sstevel@tonic-gate case TCFLSH: 32937c478bd9Sstevel@tonic-gate case TCDSET: 32947c478bd9Sstevel@tonic-gate { 32957c478bd9Sstevel@tonic-gate int native_arg = (int)arg; 32967c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (int); 32977c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)&native_arg; 32987c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 32997c478bd9Sstevel@tonic-gate K_TO_K, crp, rvalp)); 33007c478bd9Sstevel@tonic-gate } 33017c478bd9Sstevel@tonic-gate 33027c478bd9Sstevel@tonic-gate case TCSETA: 33037c478bd9Sstevel@tonic-gate case TCSETAW: 33047c478bd9Sstevel@tonic-gate case TCSETAF: 33057c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termio); 33067c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33077c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33087c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33097c478bd9Sstevel@tonic-gate 33107c478bd9Sstevel@tonic-gate case TCSETS: 33117c478bd9Sstevel@tonic-gate case TCSETSW: 33127c478bd9Sstevel@tonic-gate case TCSETSF: 33137c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termios); 33147c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33157c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33167c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33177c478bd9Sstevel@tonic-gate 33187c478bd9Sstevel@tonic-gate case LDSETT: 33197c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct termcb); 33207c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33217c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33227c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33237c478bd9Sstevel@tonic-gate 33247c478bd9Sstevel@tonic-gate case TIOCSETP: 33257c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct sgttyb); 33267c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33277c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33287c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate case TIOCSTI: 33317c478bd9Sstevel@tonic-gate if ((flag & FREAD) == 0 && 33327c478bd9Sstevel@tonic-gate secpolicy_sti(crp) != 0) { 33337c478bd9Sstevel@tonic-gate return (EPERM); 33347c478bd9Sstevel@tonic-gate } 33359acbbeafSnn35248 mutex_enter(&stp->sd_lock); 33369acbbeafSnn35248 mutex_enter(&curproc->p_splock); 33379acbbeafSnn35248 if (stp->sd_sidp != curproc->p_sessp->s_sidp && 33387c478bd9Sstevel@tonic-gate secpolicy_sti(crp) != 0) { 33399acbbeafSnn35248 mutex_exit(&curproc->p_splock); 33409acbbeafSnn35248 mutex_exit(&stp->sd_lock); 33417c478bd9Sstevel@tonic-gate return (EACCES); 33427c478bd9Sstevel@tonic-gate } 33439acbbeafSnn35248 mutex_exit(&curproc->p_splock); 33449acbbeafSnn35248 mutex_exit(&stp->sd_lock); 33457c478bd9Sstevel@tonic-gate 33467c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (char); 33477c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33487c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33497c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33507c478bd9Sstevel@tonic-gate 33517c478bd9Sstevel@tonic-gate case TIOCSWINSZ: 33527c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct winsize); 33537c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33547c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33557c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33567c478bd9Sstevel@tonic-gate 33577c478bd9Sstevel@tonic-gate case TIOCSSIZE: 33587c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct ttysize); 33597c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33607c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33617c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate case TIOCSSOFTCAR: 33647c478bd9Sstevel@tonic-gate case KIOCTRANS: 33657c478bd9Sstevel@tonic-gate case KIOCTRANSABLE: 33667c478bd9Sstevel@tonic-gate case KIOCCMD: 33677c478bd9Sstevel@tonic-gate case KIOCSDIRECT: 33687c478bd9Sstevel@tonic-gate case KIOCSCOMPAT: 33697c478bd9Sstevel@tonic-gate case KIOCSKABORTEN: 33707c478bd9Sstevel@tonic-gate case KIOCSRPTDELAY: 33717c478bd9Sstevel@tonic-gate case KIOCSRPTRATE: 33727c478bd9Sstevel@tonic-gate case VUIDSFORMAT: 33737c478bd9Sstevel@tonic-gate case TIOCSPPS: 33747c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (int); 33757c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33767c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33777c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate case KIOCSETKEY: 33807c478bd9Sstevel@tonic-gate case KIOCGETKEY: 33817c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct kiockey); 33827c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33837c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33847c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33857c478bd9Sstevel@tonic-gate 33867c478bd9Sstevel@tonic-gate case KIOCSKEY: 33877c478bd9Sstevel@tonic-gate case KIOCGKEY: 33887c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct kiockeymap); 33897c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33907c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33917c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33927c478bd9Sstevel@tonic-gate 33937c478bd9Sstevel@tonic-gate case KIOCSLED: 33947c478bd9Sstevel@tonic-gate /* arg is a pointer to char */ 33957c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (char); 33967c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 33977c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 33987c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 33997c478bd9Sstevel@tonic-gate 34007c478bd9Sstevel@tonic-gate case MSIOSETPARMS: 34017c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (Ms_parms); 34027c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 34037c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 34047c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 34057c478bd9Sstevel@tonic-gate 34067c478bd9Sstevel@tonic-gate case VUIDSADDR: 34077c478bd9Sstevel@tonic-gate case VUIDGADDR: 34087c478bd9Sstevel@tonic-gate strioc.ic_len = sizeof (struct vuid_addr_probe); 34097c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 34107c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 34117c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 34127c478bd9Sstevel@tonic-gate 34137c478bd9Sstevel@tonic-gate /* 34147c478bd9Sstevel@tonic-gate * These M_IOCTL's don't require any data to be sent 34157c478bd9Sstevel@tonic-gate * downstream, and the driver will allocate and link 34167c478bd9Sstevel@tonic-gate * on its own mblk_t upon M_IOCACK -- thus we set 34177c478bd9Sstevel@tonic-gate * ic_len to zero and set ic_dp to arg so we know 34187c478bd9Sstevel@tonic-gate * where to copyout to later. 34197c478bd9Sstevel@tonic-gate */ 34207c478bd9Sstevel@tonic-gate case TIOCGSOFTCAR: 34217c478bd9Sstevel@tonic-gate case TIOCGWINSZ: 34227c478bd9Sstevel@tonic-gate case TIOCGSIZE: 34237c478bd9Sstevel@tonic-gate case KIOCGTRANS: 34247c478bd9Sstevel@tonic-gate case KIOCGTRANSABLE: 34257c478bd9Sstevel@tonic-gate case KIOCTYPE: 34267c478bd9Sstevel@tonic-gate case KIOCGDIRECT: 34277c478bd9Sstevel@tonic-gate case KIOCGCOMPAT: 34287c478bd9Sstevel@tonic-gate case KIOCLAYOUT: 34297c478bd9Sstevel@tonic-gate case KIOCGLED: 34307c478bd9Sstevel@tonic-gate case MSIOGETPARMS: 34317c478bd9Sstevel@tonic-gate case MSIOBUTTONS: 34327c478bd9Sstevel@tonic-gate case VUIDGFORMAT: 34337c478bd9Sstevel@tonic-gate case TIOCGPPS: 34347c478bd9Sstevel@tonic-gate case TIOCGPPSEV: 34357c478bd9Sstevel@tonic-gate case TCGETA: 34367c478bd9Sstevel@tonic-gate case TCGETS: 34377c478bd9Sstevel@tonic-gate case LDGETT: 34387c478bd9Sstevel@tonic-gate case TIOCGETP: 34397c478bd9Sstevel@tonic-gate case KIOCGRPTDELAY: 34407c478bd9Sstevel@tonic-gate case KIOCGRPTRATE: 34417c478bd9Sstevel@tonic-gate strioc.ic_len = 0; 34427c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)arg; 34437c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, 34447c478bd9Sstevel@tonic-gate copyflag, crp, rvalp)); 34457c478bd9Sstevel@tonic-gate } 34467c478bd9Sstevel@tonic-gate } 34477c478bd9Sstevel@tonic-gate 34487c478bd9Sstevel@tonic-gate /* 34497c478bd9Sstevel@tonic-gate * Unknown cmd - send it down as a transparent ioctl. 34507c478bd9Sstevel@tonic-gate */ 34517c478bd9Sstevel@tonic-gate strioc.ic_cmd = cmd; 34527c478bd9Sstevel@tonic-gate strioc.ic_timout = INFTIM; 34537c478bd9Sstevel@tonic-gate strioc.ic_len = TRANSPARENT; 34547c478bd9Sstevel@tonic-gate strioc.ic_dp = (char *)&arg; 34557c478bd9Sstevel@tonic-gate 34567c478bd9Sstevel@tonic-gate return (strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp)); 34577c478bd9Sstevel@tonic-gate 34587c478bd9Sstevel@tonic-gate case I_STR: 34597c478bd9Sstevel@tonic-gate /* 34607c478bd9Sstevel@tonic-gate * Stream ioctl. Read in an strioctl buffer from the user 34617c478bd9Sstevel@tonic-gate * along with any data specified and send it downstream. 34627c478bd9Sstevel@tonic-gate * Strdoioctl will wait allow only one ioctl message at 34637c478bd9Sstevel@tonic-gate * a time, and waits for the acknowledgement. 34647c478bd9Sstevel@tonic-gate */ 34657c478bd9Sstevel@tonic-gate 34667c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 34677c478bd9Sstevel@tonic-gate return (ENXIO); 34687c478bd9Sstevel@tonic-gate 34697c478bd9Sstevel@tonic-gate error = strcopyin_strioctl((void *)arg, &strioc, flag, 34707c478bd9Sstevel@tonic-gate copyflag); 34717c478bd9Sstevel@tonic-gate if (error != 0) 34727c478bd9Sstevel@tonic-gate return (error); 34737c478bd9Sstevel@tonic-gate 34747c478bd9Sstevel@tonic-gate if ((strioc.ic_len < 0) || (strioc.ic_timout < -1)) 34757c478bd9Sstevel@tonic-gate return (EINVAL); 34767c478bd9Sstevel@tonic-gate 34777c478bd9Sstevel@tonic-gate access = job_control_type(strioc.ic_cmd); 34789acbbeafSnn35248 mutex_enter(&stp->sd_lock); 34799acbbeafSnn35248 if ((access != -1) && 34809acbbeafSnn35248 ((error = i_straccess(stp, access)) != 0)) { 34819acbbeafSnn35248 mutex_exit(&stp->sd_lock); 34827c478bd9Sstevel@tonic-gate return (error); 34839acbbeafSnn35248 } 34849acbbeafSnn35248 mutex_exit(&stp->sd_lock); 34857c478bd9Sstevel@tonic-gate 34867c478bd9Sstevel@tonic-gate /* 34877c478bd9Sstevel@tonic-gate * The I_STR facility provides a trap door for malicious 34887c478bd9Sstevel@tonic-gate * code to send down bogus streamio(7I) ioctl commands to 34897c478bd9Sstevel@tonic-gate * unsuspecting STREAMS modules and drivers which expect to 34907c478bd9Sstevel@tonic-gate * only get these messages from the stream head. 34917c478bd9Sstevel@tonic-gate * Explicitly prohibit any streamio ioctls which can be 34927c478bd9Sstevel@tonic-gate * passed downstream by the stream head. Note that we do 34937c478bd9Sstevel@tonic-gate * not block all streamio ioctls because the ioctl 34947c478bd9Sstevel@tonic-gate * numberspace is not well managed and thus it's possible 34957c478bd9Sstevel@tonic-gate * that a module or driver's ioctl numbers may accidentally 34967c478bd9Sstevel@tonic-gate * collide with them. 34977c478bd9Sstevel@tonic-gate */ 34987c478bd9Sstevel@tonic-gate switch (strioc.ic_cmd) { 34997c478bd9Sstevel@tonic-gate case I_LINK: 35007c478bd9Sstevel@tonic-gate case I_PLINK: 35017c478bd9Sstevel@tonic-gate case I_UNLINK: 35027c478bd9Sstevel@tonic-gate case I_PUNLINK: 35037c478bd9Sstevel@tonic-gate case _I_GETPEERCRED: 35047c478bd9Sstevel@tonic-gate case _I_PLINK_LH: 35057c478bd9Sstevel@tonic-gate return (EINVAL); 35067c478bd9Sstevel@tonic-gate } 35077c478bd9Sstevel@tonic-gate 35087c478bd9Sstevel@tonic-gate error = strdoioctl(stp, &strioc, flag, copyflag, crp, rvalp); 35097c478bd9Sstevel@tonic-gate if (error == 0) { 35107c478bd9Sstevel@tonic-gate error = strcopyout_strioctl(&strioc, (void *)arg, 35117c478bd9Sstevel@tonic-gate flag, copyflag); 35127c478bd9Sstevel@tonic-gate } 35137c478bd9Sstevel@tonic-gate return (error); 35147c478bd9Sstevel@tonic-gate 35157c478bd9Sstevel@tonic-gate case I_NREAD: 35167c478bd9Sstevel@tonic-gate /* 35177c478bd9Sstevel@tonic-gate * Return number of bytes of data in first message 35187c478bd9Sstevel@tonic-gate * in queue in "arg" and return the number of messages 35197c478bd9Sstevel@tonic-gate * in queue in return value. 35207c478bd9Sstevel@tonic-gate */ 35217c478bd9Sstevel@tonic-gate { 35227c478bd9Sstevel@tonic-gate size_t size; 35237c478bd9Sstevel@tonic-gate int retval; 35247c478bd9Sstevel@tonic-gate int count = 0; 35257c478bd9Sstevel@tonic-gate 35267c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq)); 35277c478bd9Sstevel@tonic-gate 35287c478bd9Sstevel@tonic-gate size = msgdsize(rdq->q_first); 35297c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next) 35307c478bd9Sstevel@tonic-gate count++; 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 35337c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) { 35347c478bd9Sstevel@tonic-gate infod_t infod; 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_COUNT; 35377c478bd9Sstevel@tonic-gate infod.d_count = 0; 35387c478bd9Sstevel@tonic-gate if (count == 0) { 35397c478bd9Sstevel@tonic-gate infod.d_cmd |= INFOD_FIRSTBYTES; 35407c478bd9Sstevel@tonic-gate infod.d_bytes = 0; 35417c478bd9Sstevel@tonic-gate } 35427c478bd9Sstevel@tonic-gate infod.d_res = 0; 35437c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod); 35447c478bd9Sstevel@tonic-gate count += infod.d_count; 35457c478bd9Sstevel@tonic-gate if (infod.d_res & INFOD_FIRSTBYTES) 35467c478bd9Sstevel@tonic-gate size = infod.d_bytes; 35477c478bd9Sstevel@tonic-gate } 35487c478bd9Sstevel@tonic-gate 35497c478bd9Sstevel@tonic-gate /* 35507c478bd9Sstevel@tonic-gate * Drop down from size_t to the "int" required by the 35517c478bd9Sstevel@tonic-gate * interface. Cap at INT_MAX. 35527c478bd9Sstevel@tonic-gate */ 35537c478bd9Sstevel@tonic-gate retval = MIN(size, INT_MAX); 35547c478bd9Sstevel@tonic-gate error = strcopyout(&retval, (void *)arg, sizeof (retval), 35557c478bd9Sstevel@tonic-gate copyflag); 35567c478bd9Sstevel@tonic-gate if (!error) 35577c478bd9Sstevel@tonic-gate *rvalp = count; 35587c478bd9Sstevel@tonic-gate return (error); 35597c478bd9Sstevel@tonic-gate } 35607c478bd9Sstevel@tonic-gate 35617c478bd9Sstevel@tonic-gate case FIONREAD: 35627c478bd9Sstevel@tonic-gate /* 35637c478bd9Sstevel@tonic-gate * Return number of bytes of data in all data messages 35647c478bd9Sstevel@tonic-gate * in queue in "arg". 35657c478bd9Sstevel@tonic-gate */ 35667c478bd9Sstevel@tonic-gate { 35677c478bd9Sstevel@tonic-gate size_t size = 0; 35687c478bd9Sstevel@tonic-gate int retval; 35697c478bd9Sstevel@tonic-gate 35707c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq)); 35717c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next) 35727c478bd9Sstevel@tonic-gate size += msgdsize(mp); 35737c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 35747c478bd9Sstevel@tonic-gate 35757c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) { 35767c478bd9Sstevel@tonic-gate infod_t infod; 35777c478bd9Sstevel@tonic-gate 35787c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_BYTES; 35797c478bd9Sstevel@tonic-gate infod.d_res = 0; 35807c478bd9Sstevel@tonic-gate infod.d_bytes = 0; 35817c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod); 35827c478bd9Sstevel@tonic-gate size += infod.d_bytes; 35837c478bd9Sstevel@tonic-gate } 35847c478bd9Sstevel@tonic-gate 35857c478bd9Sstevel@tonic-gate /* 35867c478bd9Sstevel@tonic-gate * Drop down from size_t to the "int" required by the 35877c478bd9Sstevel@tonic-gate * interface. Cap at INT_MAX. 35887c478bd9Sstevel@tonic-gate */ 35897c478bd9Sstevel@tonic-gate retval = MIN(size, INT_MAX); 35907c478bd9Sstevel@tonic-gate error = strcopyout(&retval, (void *)arg, sizeof (retval), 35917c478bd9Sstevel@tonic-gate copyflag); 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate *rvalp = 0; 35947c478bd9Sstevel@tonic-gate return (error); 35957c478bd9Sstevel@tonic-gate } 35967c478bd9Sstevel@tonic-gate case FIORDCHK: 35977c478bd9Sstevel@tonic-gate /* 35987c478bd9Sstevel@tonic-gate * FIORDCHK does not use arg value (like FIONREAD), 35997c478bd9Sstevel@tonic-gate * instead a count is returned. I_NREAD value may 36007c478bd9Sstevel@tonic-gate * not be accurate but safe. The real thing to do is 36017c478bd9Sstevel@tonic-gate * to add the msgdsizes of all data messages until 36027c478bd9Sstevel@tonic-gate * a non-data message. 36037c478bd9Sstevel@tonic-gate */ 36047c478bd9Sstevel@tonic-gate { 36057c478bd9Sstevel@tonic-gate size_t size = 0; 36067c478bd9Sstevel@tonic-gate 36077c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq)); 36087c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next) 36097c478bd9Sstevel@tonic-gate size += msgdsize(mp); 36107c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 36117c478bd9Sstevel@tonic-gate 36127c478bd9Sstevel@tonic-gate if (stp->sd_struiordq) { 36137c478bd9Sstevel@tonic-gate infod_t infod; 36147c478bd9Sstevel@tonic-gate 36157c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_BYTES; 36167c478bd9Sstevel@tonic-gate infod.d_res = 0; 36177c478bd9Sstevel@tonic-gate infod.d_bytes = 0; 36187c478bd9Sstevel@tonic-gate (void) infonext(rdq, &infod); 36197c478bd9Sstevel@tonic-gate size += infod.d_bytes; 36207c478bd9Sstevel@tonic-gate } 36217c478bd9Sstevel@tonic-gate 36227c478bd9Sstevel@tonic-gate /* 36237c478bd9Sstevel@tonic-gate * Since ioctl returns an int, and memory sizes under 36247c478bd9Sstevel@tonic-gate * LP64 may not fit, we return INT_MAX if the count was 36257c478bd9Sstevel@tonic-gate * actually greater. 36267c478bd9Sstevel@tonic-gate */ 36277c478bd9Sstevel@tonic-gate *rvalp = MIN(size, INT_MAX); 36287c478bd9Sstevel@tonic-gate return (0); 36297c478bd9Sstevel@tonic-gate } 36307c478bd9Sstevel@tonic-gate 36317c478bd9Sstevel@tonic-gate case I_FIND: 36327c478bd9Sstevel@tonic-gate /* 36337c478bd9Sstevel@tonic-gate * Get module name. 36347c478bd9Sstevel@tonic-gate */ 36357c478bd9Sstevel@tonic-gate { 36367c478bd9Sstevel@tonic-gate char mname[FMNAMESZ + 1]; 36377c478bd9Sstevel@tonic-gate queue_t *q; 36387c478bd9Sstevel@tonic-gate 36397c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg, 36407c478bd9Sstevel@tonic-gate mname, FMNAMESZ + 1, NULL); 36417c478bd9Sstevel@tonic-gate if (error) 36427c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT); 36437c478bd9Sstevel@tonic-gate 36447c478bd9Sstevel@tonic-gate /* 36457c478bd9Sstevel@tonic-gate * Return EINVAL if we're handed a bogus module name. 36467c478bd9Sstevel@tonic-gate */ 36477c478bd9Sstevel@tonic-gate if (fmodsw_find(mname, FMODSW_LOAD) == NULL) { 36487c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR, 36497c478bd9Sstevel@tonic-gate TR_I_CANT_FIND, "couldn't I_FIND"); 36507c478bd9Sstevel@tonic-gate return (EINVAL); 36517c478bd9Sstevel@tonic-gate } 36527c478bd9Sstevel@tonic-gate 36537c478bd9Sstevel@tonic-gate *rvalp = 0; 36547c478bd9Sstevel@tonic-gate 36557c478bd9Sstevel@tonic-gate /* Look downstream to see if module is there. */ 36567c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq); 36577c478bd9Sstevel@tonic-gate for (q = stp->sd_wrq->q_next; q; q = q->q_next) { 36587c478bd9Sstevel@tonic-gate if (q->q_flag&QREADR) { 36597c478bd9Sstevel@tonic-gate q = NULL; 36607c478bd9Sstevel@tonic-gate break; 36617c478bd9Sstevel@tonic-gate } 36627c478bd9Sstevel@tonic-gate if (strcmp(mname, q->q_qinfo->qi_minfo->mi_idname) == 0) 36637c478bd9Sstevel@tonic-gate break; 36647c478bd9Sstevel@tonic-gate } 36657c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate *rvalp = (q ? 1 : 0); 36687c478bd9Sstevel@tonic-gate return (error); 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate 36717c478bd9Sstevel@tonic-gate case I_PUSH: 36727c478bd9Sstevel@tonic-gate case __I_PUSH_NOCTTY: 36737c478bd9Sstevel@tonic-gate /* 36747c478bd9Sstevel@tonic-gate * Push a module. 36757c478bd9Sstevel@tonic-gate * For the case __I_PUSH_NOCTTY push a module but 36767c478bd9Sstevel@tonic-gate * do not allocate controlling tty. See bugid 4025044 36777c478bd9Sstevel@tonic-gate */ 36787c478bd9Sstevel@tonic-gate 36797c478bd9Sstevel@tonic-gate { 36807c478bd9Sstevel@tonic-gate char mname[FMNAMESZ + 1]; 36817c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp; 36827c478bd9Sstevel@tonic-gate dev_t dummydev; 36837c478bd9Sstevel@tonic-gate 36847c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 36857c478bd9Sstevel@tonic-gate return (ENXIO); 36867c478bd9Sstevel@tonic-gate 36877c478bd9Sstevel@tonic-gate /* 36887c478bd9Sstevel@tonic-gate * Get module name and look up in fmodsw. 36897c478bd9Sstevel@tonic-gate */ 36907c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : copystr)((void *)arg, 36917c478bd9Sstevel@tonic-gate mname, FMNAMESZ + 1, NULL); 36927c478bd9Sstevel@tonic-gate if (error) 36937c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT); 36947c478bd9Sstevel@tonic-gate 36957c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(mname, FMODSW_HOLD | FMODSW_LOAD)) == 36967c478bd9Sstevel@tonic-gate NULL) 36977c478bd9Sstevel@tonic-gate return (EINVAL); 36987c478bd9Sstevel@tonic-gate 36997c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_I_PUSH, 37007c478bd9Sstevel@tonic-gate "I_PUSH:fp %p stp %p", fp, stp); 37017c478bd9Sstevel@tonic-gate 37027c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd)) { 37037c478bd9Sstevel@tonic-gate fmodsw_rele(fp); 37047c478bd9Sstevel@tonic-gate return (error); 37057c478bd9Sstevel@tonic-gate } 37067c478bd9Sstevel@tonic-gate 37077c478bd9Sstevel@tonic-gate /* 37087c478bd9Sstevel@tonic-gate * See if any more modules can be pushed on this stream. 37097c478bd9Sstevel@tonic-gate * Note that this check must be done after strstartplumb() 37107c478bd9Sstevel@tonic-gate * since otherwise multiple threads issuing I_PUSHes on 37117c478bd9Sstevel@tonic-gate * the same stream will be able to exceed nstrpush. 37127c478bd9Sstevel@tonic-gate */ 37137c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 37147c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush) { 37157c478bd9Sstevel@tonic-gate fmodsw_rele(fp); 37167c478bd9Sstevel@tonic-gate strendplumb(stp); 37177c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 37187c478bd9Sstevel@tonic-gate return (EINVAL); 37197c478bd9Sstevel@tonic-gate } 37207c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 37217c478bd9Sstevel@tonic-gate 37227c478bd9Sstevel@tonic-gate /* 37237c478bd9Sstevel@tonic-gate * Push new module and call its open routine 37247c478bd9Sstevel@tonic-gate * via qattach(). Modules don't change device 37257c478bd9Sstevel@tonic-gate * numbers, so just ignore dummydev here. 37267c478bd9Sstevel@tonic-gate */ 37277c478bd9Sstevel@tonic-gate dummydev = vp->v_rdev; 37287c478bd9Sstevel@tonic-gate if ((error = qattach(rdq, &dummydev, 0, crp, fp, 37297c478bd9Sstevel@tonic-gate B_FALSE)) == 0) { 37307c478bd9Sstevel@tonic-gate if (vp->v_type == VCHR && /* sorry, no pipes allowed */ 37317c478bd9Sstevel@tonic-gate (cmd == I_PUSH) && (stp->sd_flag & STRISTTY)) { 37327c478bd9Sstevel@tonic-gate /* 37337c478bd9Sstevel@tonic-gate * try to allocate it as a controlling terminal 37347c478bd9Sstevel@tonic-gate */ 37359acbbeafSnn35248 (void) strctty(stp); 37367c478bd9Sstevel@tonic-gate } 37377c478bd9Sstevel@tonic-gate } 37387c478bd9Sstevel@tonic-gate 37397c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 37407c478bd9Sstevel@tonic-gate 37417c478bd9Sstevel@tonic-gate /* 37427c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of 37437c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream 37447c478bd9Sstevel@tonic-gate * head in the stream head. 37457c478bd9Sstevel@tonic-gate */ 37467c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next)); 37477c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz; 37487c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz; 37497c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next)); 37507c478bd9Sstevel@tonic-gate 37517c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */ 37527c478bd9Sstevel@tonic-gate if (strmsgsz != 0) { 37537c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) 37547c478bd9Sstevel@tonic-gate rmax = strmsgsz; 37557c478bd9Sstevel@tonic-gate else { 37567c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) 37577c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax); 37587c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax); 37597c478bd9Sstevel@tonic-gate } 37607c478bd9Sstevel@tonic-gate } 37617c478bd9Sstevel@tonic-gate 37627c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq)); 37637c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin; 37647c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax; 37657c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq)); 37667c478bd9Sstevel@tonic-gate 37677c478bd9Sstevel@tonic-gate strendplumb(stp); 37687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 37697c478bd9Sstevel@tonic-gate return (error); 37707c478bd9Sstevel@tonic-gate } 37717c478bd9Sstevel@tonic-gate 37727c478bd9Sstevel@tonic-gate case I_POP: 37737c478bd9Sstevel@tonic-gate { 37747c478bd9Sstevel@tonic-gate queue_t *q; 37757c478bd9Sstevel@tonic-gate 37767c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 37777c478bd9Sstevel@tonic-gate return (ENXIO); 37787c478bd9Sstevel@tonic-gate if (!wrq->q_next) /* for broken pipes */ 37797c478bd9Sstevel@tonic-gate return (EINVAL); 37807c478bd9Sstevel@tonic-gate 37817c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd)) 37827c478bd9Sstevel@tonic-gate return (error); 37837c478bd9Sstevel@tonic-gate 37847c478bd9Sstevel@tonic-gate /* 37857c478bd9Sstevel@tonic-gate * If there is an anchor on this stream and popping 37867c478bd9Sstevel@tonic-gate * the current module would attempt to pop through the 37877c478bd9Sstevel@tonic-gate * anchor, then disallow the pop unless we have sufficient 37887c478bd9Sstevel@tonic-gate * privileges; take the cheapest (non-locking) check 37897c478bd9Sstevel@tonic-gate * first. 37907c478bd9Sstevel@tonic-gate */ 3791*f4b3ec61Sdh155122 if (secpolicy_ip_config(crp, B_TRUE) != 0 || 3792*f4b3ec61Sdh155122 (stp->sd_anchorzone != crgetzoneid(crp))) { 37937c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 37947c478bd9Sstevel@tonic-gate /* 37957c478bd9Sstevel@tonic-gate * Anchors only apply if there's at least one 37967c478bd9Sstevel@tonic-gate * module on the stream (sd_pushcnt > 0). 37977c478bd9Sstevel@tonic-gate */ 37987c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt > 0 && 37997c478bd9Sstevel@tonic-gate stp->sd_pushcnt == stp->sd_anchor && 38007c478bd9Sstevel@tonic-gate stp->sd_vnode->v_type != VFIFO) { 38017c478bd9Sstevel@tonic-gate strendplumb(stp); 38027c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 3803*f4b3ec61Sdh155122 if (stp->sd_anchorzone != crgetzoneid(crp)) 3804*f4b3ec61Sdh155122 return (EINVAL); 38057c478bd9Sstevel@tonic-gate /* Audit and report error */ 3806*f4b3ec61Sdh155122 return (secpolicy_ip_config(crp, B_FALSE)); 38077c478bd9Sstevel@tonic-gate } 38087c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 38097c478bd9Sstevel@tonic-gate } 38107c478bd9Sstevel@tonic-gate 38117c478bd9Sstevel@tonic-gate q = wrq->q_next; 38127c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_I_POP, 38137c478bd9Sstevel@tonic-gate "I_POP:%p from %p", q, stp); 38147c478bd9Sstevel@tonic-gate if (q->q_next == NULL || (q->q_flag & (QREADR|QISDRV))) { 38157c478bd9Sstevel@tonic-gate error = EINVAL; 38167c478bd9Sstevel@tonic-gate } else { 38177c478bd9Sstevel@tonic-gate qdetach(_RD(q), 1, flag, crp, B_FALSE); 38187c478bd9Sstevel@tonic-gate error = 0; 38197c478bd9Sstevel@tonic-gate } 38207c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 38217c478bd9Sstevel@tonic-gate 38227c478bd9Sstevel@tonic-gate /* 38237c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of 38247c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream 38257c478bd9Sstevel@tonic-gate * head in the stream head. 38267c478bd9Sstevel@tonic-gate */ 38277c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq->q_next)); 38287c478bd9Sstevel@tonic-gate rmin = wrq->q_next->q_minpsz; 38297c478bd9Sstevel@tonic-gate rmax = wrq->q_next->q_maxpsz; 38307c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq->q_next)); 38317c478bd9Sstevel@tonic-gate 38327c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */ 38337c478bd9Sstevel@tonic-gate if (strmsgsz != 0) { 38347c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) 38357c478bd9Sstevel@tonic-gate rmax = strmsgsz; 38367c478bd9Sstevel@tonic-gate else { 38377c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) 38387c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax); 38397c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax); 38407c478bd9Sstevel@tonic-gate } 38417c478bd9Sstevel@tonic-gate } 38427c478bd9Sstevel@tonic-gate 38437c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq)); 38447c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin; 38457c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax; 38467c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq)); 38477c478bd9Sstevel@tonic-gate 38487c478bd9Sstevel@tonic-gate /* If we popped through the anchor, then reset the anchor. */ 3849*f4b3ec61Sdh155122 if (stp->sd_pushcnt < stp->sd_anchor) { 38507c478bd9Sstevel@tonic-gate stp->sd_anchor = 0; 3851*f4b3ec61Sdh155122 stp->sd_anchorzone = 0; 3852*f4b3ec61Sdh155122 } 38537c478bd9Sstevel@tonic-gate strendplumb(stp); 38547c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 38557c478bd9Sstevel@tonic-gate return (error); 38567c478bd9Sstevel@tonic-gate } 38577c478bd9Sstevel@tonic-gate 38587c478bd9Sstevel@tonic-gate case _I_MUXID2FD: 38597c478bd9Sstevel@tonic-gate { 38607c478bd9Sstevel@tonic-gate /* 38617c478bd9Sstevel@tonic-gate * Create a fd for a I_PLINK'ed lower stream with a given 38627c478bd9Sstevel@tonic-gate * muxid. With the fd, application can send down ioctls, 38637c478bd9Sstevel@tonic-gate * like I_LIST, to the previously I_PLINK'ed stream. Note 38647c478bd9Sstevel@tonic-gate * that after getting the fd, the application has to do an 38657c478bd9Sstevel@tonic-gate * I_PUNLINK on the muxid before it can do any operation 38667c478bd9Sstevel@tonic-gate * on the lower stream. This is required by spec1170. 38677c478bd9Sstevel@tonic-gate * 38687c478bd9Sstevel@tonic-gate * The fd used to do this ioctl should point to the same 38697c478bd9Sstevel@tonic-gate * controlling device used to do the I_PLINK. If it uses 38707c478bd9Sstevel@tonic-gate * a different stream or an invalid muxid, I_MUXID2FD will 38717c478bd9Sstevel@tonic-gate * fail. The error code is set to EINVAL. 38727c478bd9Sstevel@tonic-gate * 38737c478bd9Sstevel@tonic-gate * The intended use of this interface is the following. 38747c478bd9Sstevel@tonic-gate * An application I_PLINK'ed a stream and exits. The fd 38757c478bd9Sstevel@tonic-gate * to the lower stream is gone. Another application 38767c478bd9Sstevel@tonic-gate * wants to get a fd to the lower stream, it uses I_MUXID2FD. 38777c478bd9Sstevel@tonic-gate */ 38787c478bd9Sstevel@tonic-gate int muxid = (int)arg; 38797c478bd9Sstevel@tonic-gate int fd; 38807c478bd9Sstevel@tonic-gate linkinfo_t *linkp; 38817c478bd9Sstevel@tonic-gate struct file *fp; 3882*f4b3ec61Sdh155122 netstack_t *ns; 3883*f4b3ec61Sdh155122 str_stack_t *ss; 38847c478bd9Sstevel@tonic-gate 38857c478bd9Sstevel@tonic-gate /* 38867c478bd9Sstevel@tonic-gate * Do not allow the wildcard muxid. This ioctl is not 38877c478bd9Sstevel@tonic-gate * intended to find arbitrary link. 38887c478bd9Sstevel@tonic-gate */ 38897c478bd9Sstevel@tonic-gate if (muxid == 0) { 38907c478bd9Sstevel@tonic-gate return (EINVAL); 38917c478bd9Sstevel@tonic-gate } 38927c478bd9Sstevel@tonic-gate 3893*f4b3ec61Sdh155122 ns = netstack_find_by_cred(crp); 3894*f4b3ec61Sdh155122 ASSERT(ns != NULL); 3895*f4b3ec61Sdh155122 ss = ns->netstack_str; 3896*f4b3ec61Sdh155122 ASSERT(ss != NULL); 3897*f4b3ec61Sdh155122 38987c478bd9Sstevel@tonic-gate mutex_enter(&muxifier); 3899*f4b3ec61Sdh155122 linkp = findlinks(vp->v_stream, muxid, LINKPERSIST, ss); 39007c478bd9Sstevel@tonic-gate if (linkp == NULL) { 39017c478bd9Sstevel@tonic-gate mutex_exit(&muxifier); 3902*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 39037c478bd9Sstevel@tonic-gate return (EINVAL); 39047c478bd9Sstevel@tonic-gate } 39057c478bd9Sstevel@tonic-gate 39067c478bd9Sstevel@tonic-gate if ((fd = ufalloc(0)) == -1) { 39077c478bd9Sstevel@tonic-gate mutex_exit(&muxifier); 3908*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 39097c478bd9Sstevel@tonic-gate return (EMFILE); 39107c478bd9Sstevel@tonic-gate } 39117c478bd9Sstevel@tonic-gate fp = linkp->li_fpdown; 39127c478bd9Sstevel@tonic-gate mutex_enter(&fp->f_tlock); 39137c478bd9Sstevel@tonic-gate fp->f_count++; 39147c478bd9Sstevel@tonic-gate mutex_exit(&fp->f_tlock); 39157c478bd9Sstevel@tonic-gate mutex_exit(&muxifier); 39167c478bd9Sstevel@tonic-gate setf(fd, fp); 39177c478bd9Sstevel@tonic-gate *rvalp = fd; 3918*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 39197c478bd9Sstevel@tonic-gate return (0); 39207c478bd9Sstevel@tonic-gate } 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate case _I_INSERT: 39237c478bd9Sstevel@tonic-gate { 39247c478bd9Sstevel@tonic-gate /* 39257c478bd9Sstevel@tonic-gate * To insert a module to a given position in a stream. 39267c478bd9Sstevel@tonic-gate * In the first release, only allow privileged user 3927*f4b3ec61Sdh155122 * to use this ioctl. Furthermore, the insert is only allowed 3928*f4b3ec61Sdh155122 * below an anchor if the zoneid is the same as the zoneid 3929*f4b3ec61Sdh155122 * which created the anchor. 39307c478bd9Sstevel@tonic-gate * 39317c478bd9Sstevel@tonic-gate * Note that we do not plan to support this ioctl 39327c478bd9Sstevel@tonic-gate * on pipes in the first release. We want to learn more 39337c478bd9Sstevel@tonic-gate * about the implications of these ioctls before extending 39347c478bd9Sstevel@tonic-gate * their support. And we do not think these features are 39357c478bd9Sstevel@tonic-gate * valuable for pipes. 39367c478bd9Sstevel@tonic-gate * 39377c478bd9Sstevel@tonic-gate * Neither do we support O/C hot stream. Note that only 39387c478bd9Sstevel@tonic-gate * the upper streams of TCP/IP stack are O/C hot streams. 39397c478bd9Sstevel@tonic-gate * The lower IP stream is not. 39407c478bd9Sstevel@tonic-gate * When there is a O/C cold barrier, we only allow inserts 39417c478bd9Sstevel@tonic-gate * above the barrier. 39427c478bd9Sstevel@tonic-gate */ 39437c478bd9Sstevel@tonic-gate STRUCT_DECL(strmodconf, strmodinsert); 39447c478bd9Sstevel@tonic-gate char mod_name[FMNAMESZ + 1]; 39457c478bd9Sstevel@tonic-gate fmodsw_impl_t *fp; 39467c478bd9Sstevel@tonic-gate dev_t dummydev; 39477c478bd9Sstevel@tonic-gate queue_t *tmp_wrq; 39487c478bd9Sstevel@tonic-gate int pos; 39497c478bd9Sstevel@tonic-gate boolean_t is_insert; 39507c478bd9Sstevel@tonic-gate 39517c478bd9Sstevel@tonic-gate STRUCT_INIT(strmodinsert, flag); 39527c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 39537c478bd9Sstevel@tonic-gate return (ENXIO); 39547c478bd9Sstevel@tonic-gate if (STRMATED(stp)) 39557c478bd9Sstevel@tonic-gate return (EINVAL); 39567c478bd9Sstevel@tonic-gate if ((error = secpolicy_net_config(crp, B_FALSE)) != 0) 39577c478bd9Sstevel@tonic-gate return (error); 3958*f4b3ec61Sdh155122 if (stp->sd_anchor != 0 && 3959*f4b3ec61Sdh155122 stp->sd_anchorzone != crgetzoneid(crp)) 3960*f4b3ec61Sdh155122 return (EINVAL); 39617c478bd9Sstevel@tonic-gate 39627c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strmodinsert), 39637c478bd9Sstevel@tonic-gate STRUCT_SIZE(strmodinsert), copyflag); 39647c478bd9Sstevel@tonic-gate if (error) 39657c478bd9Sstevel@tonic-gate return (error); 39667c478bd9Sstevel@tonic-gate 39677c478bd9Sstevel@tonic-gate /* 39687c478bd9Sstevel@tonic-gate * Get module name and look up in fmodsw. 39697c478bd9Sstevel@tonic-gate */ 39707c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : 39717c478bd9Sstevel@tonic-gate copystr)(STRUCT_FGETP(strmodinsert, mod_name), 39727c478bd9Sstevel@tonic-gate mod_name, FMNAMESZ + 1, NULL); 39737c478bd9Sstevel@tonic-gate if (error) 39747c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT); 39757c478bd9Sstevel@tonic-gate 39767c478bd9Sstevel@tonic-gate if ((fp = fmodsw_find(mod_name, FMODSW_HOLD | FMODSW_LOAD)) == 39777c478bd9Sstevel@tonic-gate NULL) 39787c478bd9Sstevel@tonic-gate return (EINVAL); 39797c478bd9Sstevel@tonic-gate 39807c478bd9Sstevel@tonic-gate if (error = strstartplumb(stp, flag, cmd)) { 39817c478bd9Sstevel@tonic-gate fmodsw_rele(fp); 39827c478bd9Sstevel@tonic-gate return (error); 39837c478bd9Sstevel@tonic-gate } 39847c478bd9Sstevel@tonic-gate 39857c478bd9Sstevel@tonic-gate /* 39867c478bd9Sstevel@tonic-gate * Is this _I_INSERT just like an I_PUSH? We need to know 39877c478bd9Sstevel@tonic-gate * this because we do some optimizations if this is a 39887c478bd9Sstevel@tonic-gate * module being pushed. 39897c478bd9Sstevel@tonic-gate */ 39907c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodinsert, pos); 39917c478bd9Sstevel@tonic-gate is_insert = (pos != 0); 39927c478bd9Sstevel@tonic-gate 39937c478bd9Sstevel@tonic-gate /* 39947c478bd9Sstevel@tonic-gate * Make sure pos is valid. Even though it is not an I_PUSH, 39957c478bd9Sstevel@tonic-gate * we impose the same limit on the number of modules in a 39967c478bd9Sstevel@tonic-gate * stream. 39977c478bd9Sstevel@tonic-gate */ 39987c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 39997c478bd9Sstevel@tonic-gate if (stp->sd_pushcnt >= nstrpush || pos < 0 || 40007c478bd9Sstevel@tonic-gate pos > stp->sd_pushcnt) { 40017c478bd9Sstevel@tonic-gate fmodsw_rele(fp); 40027c478bd9Sstevel@tonic-gate strendplumb(stp); 40037c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 40047c478bd9Sstevel@tonic-gate return (EINVAL); 40057c478bd9Sstevel@tonic-gate } 4006*f4b3ec61Sdh155122 if (stp->sd_anchor != 0) { 4007*f4b3ec61Sdh155122 /* 4008*f4b3ec61Sdh155122 * Is this insert below the anchor? 4009*f4b3ec61Sdh155122 * Pushcnt hasn't been increased yet hence 4010*f4b3ec61Sdh155122 * we test for greater than here, and greater or 4011*f4b3ec61Sdh155122 * equal after qattach. 4012*f4b3ec61Sdh155122 */ 4013*f4b3ec61Sdh155122 if (pos > (stp->sd_pushcnt - stp->sd_anchor) && 4014*f4b3ec61Sdh155122 stp->sd_anchorzone != crgetzoneid(crp)) { 4015*f4b3ec61Sdh155122 fmodsw_rele(fp); 4016*f4b3ec61Sdh155122 strendplumb(stp); 4017*f4b3ec61Sdh155122 mutex_exit(&stp->sd_lock); 4018*f4b3ec61Sdh155122 return (EPERM); 4019*f4b3ec61Sdh155122 } 4020*f4b3ec61Sdh155122 } 4021*f4b3ec61Sdh155122 40227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 40237c478bd9Sstevel@tonic-gate 40247c478bd9Sstevel@tonic-gate /* 40257c478bd9Sstevel@tonic-gate * First find the correct position this module to 40267c478bd9Sstevel@tonic-gate * be inserted. We don't need to call claimstr() 40277c478bd9Sstevel@tonic-gate * as the stream should not be changing at this point. 40287c478bd9Sstevel@tonic-gate * 40297c478bd9Sstevel@tonic-gate * Insert new module and call its open routine 40307c478bd9Sstevel@tonic-gate * via qattach(). Modules don't change device 40317c478bd9Sstevel@tonic-gate * numbers, so just ignore dummydev here. 40327c478bd9Sstevel@tonic-gate */ 40337c478bd9Sstevel@tonic-gate for (tmp_wrq = stp->sd_wrq; pos > 0; 40347c478bd9Sstevel@tonic-gate tmp_wrq = tmp_wrq->q_next, pos--) { 40357c478bd9Sstevel@tonic-gate ASSERT(SAMESTR(tmp_wrq)); 40367c478bd9Sstevel@tonic-gate } 40377c478bd9Sstevel@tonic-gate dummydev = vp->v_rdev; 40387c478bd9Sstevel@tonic-gate if ((error = qattach(_RD(tmp_wrq), &dummydev, 0, crp, 40397c478bd9Sstevel@tonic-gate fp, is_insert)) != 0) { 40407c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 40417c478bd9Sstevel@tonic-gate strendplumb(stp); 40427c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 40437c478bd9Sstevel@tonic-gate return (error); 40447c478bd9Sstevel@tonic-gate } 40457c478bd9Sstevel@tonic-gate 40467c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 40477c478bd9Sstevel@tonic-gate 40487c478bd9Sstevel@tonic-gate /* 40497c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of 40507c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream 40517c478bd9Sstevel@tonic-gate * head in the stream head. 40527c478bd9Sstevel@tonic-gate */ 40537c478bd9Sstevel@tonic-gate if (!is_insert) { 40547c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq->q_next)); 40557c478bd9Sstevel@tonic-gate rmin = stp->sd_wrq->q_next->q_minpsz; 40567c478bd9Sstevel@tonic-gate rmax = stp->sd_wrq->q_next->q_maxpsz; 40577c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq->q_next)); 40587c478bd9Sstevel@tonic-gate 40597c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */ 40607c478bd9Sstevel@tonic-gate if (strmsgsz != 0) { 40617c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) { 40627c478bd9Sstevel@tonic-gate rmax = strmsgsz; 40637c478bd9Sstevel@tonic-gate } else { 40647c478bd9Sstevel@tonic-gate rmax = MIN(strmsgsz, rmax); 40657c478bd9Sstevel@tonic-gate } 40667c478bd9Sstevel@tonic-gate } 40677c478bd9Sstevel@tonic-gate 40687c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq)); 40697c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin; 40707c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax; 40717c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq)); 40727c478bd9Sstevel@tonic-gate } 40737c478bd9Sstevel@tonic-gate 40747c478bd9Sstevel@tonic-gate /* 40757c478bd9Sstevel@tonic-gate * Need to update the anchor value if this module is 40767c478bd9Sstevel@tonic-gate * inserted below the anchor point. 40777c478bd9Sstevel@tonic-gate */ 40787c478bd9Sstevel@tonic-gate if (stp->sd_anchor != 0) { 40797c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodinsert, pos); 40807c478bd9Sstevel@tonic-gate if (pos >= (stp->sd_pushcnt - stp->sd_anchor)) 40817c478bd9Sstevel@tonic-gate stp->sd_anchor++; 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate 40847c478bd9Sstevel@tonic-gate strendplumb(stp); 40857c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 40867c478bd9Sstevel@tonic-gate return (0); 40877c478bd9Sstevel@tonic-gate } 40887c478bd9Sstevel@tonic-gate 40897c478bd9Sstevel@tonic-gate case _I_REMOVE: 40907c478bd9Sstevel@tonic-gate { 40917c478bd9Sstevel@tonic-gate /* 40927c478bd9Sstevel@tonic-gate * To remove a module with a given name in a stream. The 40937c478bd9Sstevel@tonic-gate * caller of this ioctl needs to provide both the name and 40947c478bd9Sstevel@tonic-gate * the position of the module to be removed. This eliminates 40957c478bd9Sstevel@tonic-gate * the ambiguity of removal if a module is inserted/pushed 40967c478bd9Sstevel@tonic-gate * multiple times in a stream. In the first release, only 40977c478bd9Sstevel@tonic-gate * allow privileged user to use this ioctl. 4098*f4b3ec61Sdh155122 * Furthermore, the remove is only allowed 4099*f4b3ec61Sdh155122 * below an anchor if the zoneid is the same as the zoneid 4100*f4b3ec61Sdh155122 * which created the anchor. 41017c478bd9Sstevel@tonic-gate * 41027c478bd9Sstevel@tonic-gate * Note that we do not plan to support this ioctl 41037c478bd9Sstevel@tonic-gate * on pipes in the first release. We want to learn more 41047c478bd9Sstevel@tonic-gate * about the implications of these ioctls before extending 41057c478bd9Sstevel@tonic-gate * their support. And we do not think these features are 41067c478bd9Sstevel@tonic-gate * valuable for pipes. 41077c478bd9Sstevel@tonic-gate * 41087c478bd9Sstevel@tonic-gate * Neither do we support O/C hot stream. Note that only 41097c478bd9Sstevel@tonic-gate * the upper streams of TCP/IP stack are O/C hot streams. 41107c478bd9Sstevel@tonic-gate * The lower IP stream is not. 41117c478bd9Sstevel@tonic-gate * When there is a O/C cold barrier we do not allow removal 41127c478bd9Sstevel@tonic-gate * below the barrier. 41137c478bd9Sstevel@tonic-gate * 41147c478bd9Sstevel@tonic-gate * Also note that _I_REMOVE cannot be used to remove a 41157c478bd9Sstevel@tonic-gate * driver or the stream head. 41167c478bd9Sstevel@tonic-gate */ 41177c478bd9Sstevel@tonic-gate STRUCT_DECL(strmodconf, strmodremove); 41187c478bd9Sstevel@tonic-gate queue_t *q; 41197c478bd9Sstevel@tonic-gate int pos; 41207c478bd9Sstevel@tonic-gate char mod_name[FMNAMESZ + 1]; 41217c478bd9Sstevel@tonic-gate boolean_t is_remove; 41227c478bd9Sstevel@tonic-gate 41237c478bd9Sstevel@tonic-gate STRUCT_INIT(strmodremove, flag); 41247c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 41257c478bd9Sstevel@tonic-gate return (ENXIO); 41267c478bd9Sstevel@tonic-gate if (STRMATED(stp)) 41277c478bd9Sstevel@tonic-gate return (EINVAL); 41287c478bd9Sstevel@tonic-gate if ((error = secpolicy_net_config(crp, B_FALSE)) != 0) 41297c478bd9Sstevel@tonic-gate return (error); 4130*f4b3ec61Sdh155122 if (stp->sd_anchor != 0 && 4131*f4b3ec61Sdh155122 stp->sd_anchorzone != crgetzoneid(crp)) 4132*f4b3ec61Sdh155122 return (EINVAL); 41337c478bd9Sstevel@tonic-gate 41347c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strmodremove), 41357c478bd9Sstevel@tonic-gate STRUCT_SIZE(strmodremove), copyflag); 41367c478bd9Sstevel@tonic-gate if (error) 41377c478bd9Sstevel@tonic-gate return (error); 41387c478bd9Sstevel@tonic-gate 41397c478bd9Sstevel@tonic-gate error = (copyflag & U_TO_K ? copyinstr : 41407c478bd9Sstevel@tonic-gate copystr)(STRUCT_FGETP(strmodremove, mod_name), 41417c478bd9Sstevel@tonic-gate mod_name, FMNAMESZ + 1, NULL); 41427c478bd9Sstevel@tonic-gate if (error) 41437c478bd9Sstevel@tonic-gate return ((error == ENAMETOOLONG) ? EINVAL : EFAULT); 41447c478bd9Sstevel@tonic-gate 41457c478bd9Sstevel@tonic-gate if ((error = strstartplumb(stp, flag, cmd)) != 0) 41467c478bd9Sstevel@tonic-gate return (error); 41477c478bd9Sstevel@tonic-gate 41487c478bd9Sstevel@tonic-gate /* 41497c478bd9Sstevel@tonic-gate * Match the name of given module to the name of module at 41507c478bd9Sstevel@tonic-gate * the given position. 41517c478bd9Sstevel@tonic-gate */ 41527c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodremove, pos); 41537c478bd9Sstevel@tonic-gate 41547c478bd9Sstevel@tonic-gate is_remove = (pos != 0); 41557c478bd9Sstevel@tonic-gate for (q = stp->sd_wrq->q_next; SAMESTR(q) && pos > 0; 41567c478bd9Sstevel@tonic-gate q = q->q_next, pos--) 41577c478bd9Sstevel@tonic-gate ; 41587c478bd9Sstevel@tonic-gate if (pos > 0 || ! SAMESTR(q) || 41597c478bd9Sstevel@tonic-gate strncmp(q->q_qinfo->qi_minfo->mi_idname, mod_name, 41607c478bd9Sstevel@tonic-gate strlen(q->q_qinfo->qi_minfo->mi_idname)) != 0) { 41617c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 41627c478bd9Sstevel@tonic-gate strendplumb(stp); 41637c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 41647c478bd9Sstevel@tonic-gate return (EINVAL); 41657c478bd9Sstevel@tonic-gate } 41667c478bd9Sstevel@tonic-gate 4167*f4b3ec61Sdh155122 /* 4168*f4b3ec61Sdh155122 * If the position is at or below an anchor, then the zoneid 4169*f4b3ec61Sdh155122 * must match the zoneid that created the anchor. 4170*f4b3ec61Sdh155122 */ 4171*f4b3ec61Sdh155122 if (stp->sd_anchor != 0) { 4172*f4b3ec61Sdh155122 pos = STRUCT_FGET(strmodremove, pos); 4173*f4b3ec61Sdh155122 if (pos >= (stp->sd_pushcnt - stp->sd_anchor) && 4174*f4b3ec61Sdh155122 stp->sd_anchorzone != crgetzoneid(crp)) { 4175*f4b3ec61Sdh155122 mutex_enter(&stp->sd_lock); 4176*f4b3ec61Sdh155122 strendplumb(stp); 4177*f4b3ec61Sdh155122 mutex_exit(&stp->sd_lock); 4178*f4b3ec61Sdh155122 return (EPERM); 4179*f4b3ec61Sdh155122 } 4180*f4b3ec61Sdh155122 } 4181*f4b3ec61Sdh155122 4182*f4b3ec61Sdh155122 41837c478bd9Sstevel@tonic-gate ASSERT(!(q->q_flag & QREADR)); 41847c478bd9Sstevel@tonic-gate qdetach(_RD(q), 1, flag, crp, is_remove); 41857c478bd9Sstevel@tonic-gate 41867c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 41877c478bd9Sstevel@tonic-gate 41887c478bd9Sstevel@tonic-gate /* 41897c478bd9Sstevel@tonic-gate * As a performance concern we are caching the values of 41907c478bd9Sstevel@tonic-gate * q_minpsz and q_maxpsz of the module below the stream 41917c478bd9Sstevel@tonic-gate * head in the stream head. 41927c478bd9Sstevel@tonic-gate */ 41937c478bd9Sstevel@tonic-gate if (!is_remove) { 41947c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq->q_next)); 41957c478bd9Sstevel@tonic-gate rmin = wrq->q_next->q_minpsz; 41967c478bd9Sstevel@tonic-gate rmax = wrq->q_next->q_maxpsz; 41977c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq->q_next)); 41987c478bd9Sstevel@tonic-gate 41997c478bd9Sstevel@tonic-gate /* Do this processing here as a performance concern */ 42007c478bd9Sstevel@tonic-gate if (strmsgsz != 0) { 42017c478bd9Sstevel@tonic-gate if (rmax == INFPSZ) 42027c478bd9Sstevel@tonic-gate rmax = strmsgsz; 42037c478bd9Sstevel@tonic-gate else { 42047c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) 42057c478bd9Sstevel@tonic-gate rmax = MIN(PIPE_BUF, rmax); 42067c478bd9Sstevel@tonic-gate else rmax = MIN(strmsgsz, rmax); 42077c478bd9Sstevel@tonic-gate } 42087c478bd9Sstevel@tonic-gate } 42097c478bd9Sstevel@tonic-gate 42107c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(wrq)); 42117c478bd9Sstevel@tonic-gate stp->sd_qn_minpsz = rmin; 42127c478bd9Sstevel@tonic-gate stp->sd_qn_maxpsz = rmax; 42137c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(wrq)); 42147c478bd9Sstevel@tonic-gate } 42157c478bd9Sstevel@tonic-gate 42167c478bd9Sstevel@tonic-gate /* 42177c478bd9Sstevel@tonic-gate * Need to update the anchor value if this module is removed 42187c478bd9Sstevel@tonic-gate * at or below the anchor point. If the removed module is at 42197c478bd9Sstevel@tonic-gate * the anchor point, remove the anchor for this stream if 42207c478bd9Sstevel@tonic-gate * there is no module above the anchor point. Otherwise, if 42217c478bd9Sstevel@tonic-gate * the removed module is below the anchor point, decrement the 42227c478bd9Sstevel@tonic-gate * anchor point by 1. 42237c478bd9Sstevel@tonic-gate */ 42247c478bd9Sstevel@tonic-gate if (stp->sd_anchor != 0) { 42257c478bd9Sstevel@tonic-gate pos = STRUCT_FGET(strmodremove, pos); 4226*f4b3ec61Sdh155122 if (pos == stp->sd_pushcnt - stp->sd_anchor + 1) 42277c478bd9Sstevel@tonic-gate stp->sd_anchor = 0; 42287c478bd9Sstevel@tonic-gate else if (pos > (stp->sd_pushcnt - stp->sd_anchor + 1)) 42297c478bd9Sstevel@tonic-gate stp->sd_anchor--; 42307c478bd9Sstevel@tonic-gate } 42317c478bd9Sstevel@tonic-gate 42327c478bd9Sstevel@tonic-gate strendplumb(stp); 42337c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 42347c478bd9Sstevel@tonic-gate return (0); 42357c478bd9Sstevel@tonic-gate } 42367c478bd9Sstevel@tonic-gate 42377c478bd9Sstevel@tonic-gate case I_ANCHOR: 42387c478bd9Sstevel@tonic-gate /* 42397c478bd9Sstevel@tonic-gate * Set the anchor position on the stream to reside at 42407c478bd9Sstevel@tonic-gate * the top module (in other words, the top module 42417c478bd9Sstevel@tonic-gate * cannot be popped). Anchors with a FIFO make no 42427c478bd9Sstevel@tonic-gate * obvious sense, so they're not allowed. 42437c478bd9Sstevel@tonic-gate */ 42447c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 42457c478bd9Sstevel@tonic-gate 42467c478bd9Sstevel@tonic-gate if (stp->sd_vnode->v_type == VFIFO) { 42477c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 42487c478bd9Sstevel@tonic-gate return (EINVAL); 42497c478bd9Sstevel@tonic-gate } 4250*f4b3ec61Sdh155122 /* Only allow the same zoneid to update the anchor */ 4251*f4b3ec61Sdh155122 if (stp->sd_anchor != 0 && 4252*f4b3ec61Sdh155122 stp->sd_anchorzone != crgetzoneid(crp)) { 4253*f4b3ec61Sdh155122 mutex_exit(&stp->sd_lock); 4254*f4b3ec61Sdh155122 return (EINVAL); 4255*f4b3ec61Sdh155122 } 42567c478bd9Sstevel@tonic-gate stp->sd_anchor = stp->sd_pushcnt; 4257*f4b3ec61Sdh155122 stp->sd_anchorzone = crgetzoneid(crp); 42587c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 42597c478bd9Sstevel@tonic-gate return (0); 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate case I_LOOK: 42627c478bd9Sstevel@tonic-gate /* 42637c478bd9Sstevel@tonic-gate * Get name of first module downstream. 42647c478bd9Sstevel@tonic-gate * If no module, return an error. 42657c478bd9Sstevel@tonic-gate */ 42667c478bd9Sstevel@tonic-gate { 42677c478bd9Sstevel@tonic-gate claimstr(wrq); 42687c478bd9Sstevel@tonic-gate if (_SAMESTR(wrq) && wrq->q_next->q_next) { 42697c478bd9Sstevel@tonic-gate char *name = wrq->q_next->q_qinfo->qi_minfo->mi_idname; 42707c478bd9Sstevel@tonic-gate error = strcopyout(name, (void *)arg, strlen(name) + 1, 42717c478bd9Sstevel@tonic-gate copyflag); 42727c478bd9Sstevel@tonic-gate releasestr(wrq); 42737c478bd9Sstevel@tonic-gate return (error); 42747c478bd9Sstevel@tonic-gate } 42757c478bd9Sstevel@tonic-gate releasestr(wrq); 42767c478bd9Sstevel@tonic-gate return (EINVAL); 42777c478bd9Sstevel@tonic-gate } 42787c478bd9Sstevel@tonic-gate 42797c478bd9Sstevel@tonic-gate case I_LINK: 42807c478bd9Sstevel@tonic-gate case I_PLINK: 42817c478bd9Sstevel@tonic-gate /* 42827c478bd9Sstevel@tonic-gate * Link a multiplexor. 42837c478bd9Sstevel@tonic-gate */ 4284*f4b3ec61Sdh155122 error = mlink(vp, cmd, (int)arg, crp, rvalp, 0); 4285*f4b3ec61Sdh155122 return (error); 42867c478bd9Sstevel@tonic-gate 42877c478bd9Sstevel@tonic-gate case _I_PLINK_LH: 42887c478bd9Sstevel@tonic-gate /* 42897c478bd9Sstevel@tonic-gate * Link a multiplexor: Call must originate from kernel. 42907c478bd9Sstevel@tonic-gate */ 42917c478bd9Sstevel@tonic-gate if (kioctl) 42927c478bd9Sstevel@tonic-gate return (ldi_mlink_lh(vp, cmd, arg, crp, rvalp)); 42937c478bd9Sstevel@tonic-gate 42947c478bd9Sstevel@tonic-gate return (EINVAL); 42957c478bd9Sstevel@tonic-gate case I_UNLINK: 42967c478bd9Sstevel@tonic-gate case I_PUNLINK: 42977c478bd9Sstevel@tonic-gate /* 42987c478bd9Sstevel@tonic-gate * Unlink a multiplexor. 42997c478bd9Sstevel@tonic-gate * If arg is -1, unlink all links for which this is the 43007c478bd9Sstevel@tonic-gate * controlling stream. Otherwise, arg is an index number 43017c478bd9Sstevel@tonic-gate * for a link to be removed. 43027c478bd9Sstevel@tonic-gate */ 43037c478bd9Sstevel@tonic-gate { 43047c478bd9Sstevel@tonic-gate struct linkinfo *linkp; 43057c478bd9Sstevel@tonic-gate int native_arg = (int)arg; 43067c478bd9Sstevel@tonic-gate int type; 4307*f4b3ec61Sdh155122 netstack_t *ns; 4308*f4b3ec61Sdh155122 str_stack_t *ss; 43097c478bd9Sstevel@tonic-gate 43107c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 43117c478bd9Sstevel@tonic-gate TR_I_UNLINK, "I_UNLINK/I_PUNLINK:%p", stp); 43127c478bd9Sstevel@tonic-gate if (vp->v_type == VFIFO) { 43137c478bd9Sstevel@tonic-gate return (EINVAL); 43147c478bd9Sstevel@tonic-gate } 43157c478bd9Sstevel@tonic-gate if (cmd == I_UNLINK) 43167c478bd9Sstevel@tonic-gate type = LINKNORMAL; 43177c478bd9Sstevel@tonic-gate else /* I_PUNLINK */ 43187c478bd9Sstevel@tonic-gate type = LINKPERSIST; 43197c478bd9Sstevel@tonic-gate if (native_arg == 0) { 43207c478bd9Sstevel@tonic-gate return (EINVAL); 43217c478bd9Sstevel@tonic-gate } 4322*f4b3ec61Sdh155122 ns = netstack_find_by_cred(crp); 4323*f4b3ec61Sdh155122 ASSERT(ns != NULL); 4324*f4b3ec61Sdh155122 ss = ns->netstack_str; 4325*f4b3ec61Sdh155122 ASSERT(ss != NULL); 4326*f4b3ec61Sdh155122 43277c478bd9Sstevel@tonic-gate if (native_arg == MUXID_ALL) 4328*f4b3ec61Sdh155122 error = munlinkall(stp, type, crp, rvalp, ss); 43297c478bd9Sstevel@tonic-gate else { 43307c478bd9Sstevel@tonic-gate mutex_enter(&muxifier); 4331*f4b3ec61Sdh155122 if (!(linkp = findlinks(stp, (int)arg, type, ss))) { 43327c478bd9Sstevel@tonic-gate /* invalid user supplied index number */ 43337c478bd9Sstevel@tonic-gate mutex_exit(&muxifier); 4334*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 43357c478bd9Sstevel@tonic-gate return (EINVAL); 43367c478bd9Sstevel@tonic-gate } 43377c478bd9Sstevel@tonic-gate /* munlink drops the muxifier lock */ 4338*f4b3ec61Sdh155122 error = munlink(stp, linkp, type, crp, rvalp, ss); 43397c478bd9Sstevel@tonic-gate } 4340*f4b3ec61Sdh155122 netstack_rele(ss->ss_netstack); 43417c478bd9Sstevel@tonic-gate return (error); 43427c478bd9Sstevel@tonic-gate } 43437c478bd9Sstevel@tonic-gate 43447c478bd9Sstevel@tonic-gate case I_FLUSH: 43457c478bd9Sstevel@tonic-gate /* 43467c478bd9Sstevel@tonic-gate * send a flush message downstream 43477c478bd9Sstevel@tonic-gate * flush message can indicate 43487c478bd9Sstevel@tonic-gate * FLUSHR - flush read queue 43497c478bd9Sstevel@tonic-gate * FLUSHW - flush write queue 43507c478bd9Sstevel@tonic-gate * FLUSHRW - flush read/write queue 43517c478bd9Sstevel@tonic-gate */ 43527c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 43537c478bd9Sstevel@tonic-gate return (ENXIO); 43547c478bd9Sstevel@tonic-gate if (arg & ~FLUSHRW) 43557c478bd9Sstevel@tonic-gate return (EINVAL); 43567c478bd9Sstevel@tonic-gate 43577c478bd9Sstevel@tonic-gate for (;;) { 43587c478bd9Sstevel@tonic-gate if (putnextctl1(stp->sd_wrq, M_FLUSH, (int)arg)) { 43597c478bd9Sstevel@tonic-gate break; 43607c478bd9Sstevel@tonic-gate } 43617c478bd9Sstevel@tonic-gate if (error = strwaitbuf(1, BPRI_HI)) { 43627c478bd9Sstevel@tonic-gate return (error); 43637c478bd9Sstevel@tonic-gate } 43647c478bd9Sstevel@tonic-gate } 43657c478bd9Sstevel@tonic-gate 43667c478bd9Sstevel@tonic-gate /* 43677c478bd9Sstevel@tonic-gate * Send down an unsupported ioctl and wait for the nack 43687c478bd9Sstevel@tonic-gate * in order to allow the M_FLUSH to propagate back 43697c478bd9Sstevel@tonic-gate * up to the stream head. 43707c478bd9Sstevel@tonic-gate * Replaces if (qready()) runqueues(); 43717c478bd9Sstevel@tonic-gate */ 43727c478bd9Sstevel@tonic-gate strioc.ic_cmd = -1; /* The unsupported ioctl */ 43737c478bd9Sstevel@tonic-gate strioc.ic_timout = 0; 43747c478bd9Sstevel@tonic-gate strioc.ic_len = 0; 43757c478bd9Sstevel@tonic-gate strioc.ic_dp = NULL; 43767c478bd9Sstevel@tonic-gate (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp); 43777c478bd9Sstevel@tonic-gate *rvalp = 0; 43787c478bd9Sstevel@tonic-gate return (0); 43797c478bd9Sstevel@tonic-gate 43807c478bd9Sstevel@tonic-gate case I_FLUSHBAND: 43817c478bd9Sstevel@tonic-gate { 43827c478bd9Sstevel@tonic-gate struct bandinfo binfo; 43837c478bd9Sstevel@tonic-gate 43847c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &binfo, sizeof (binfo), 43857c478bd9Sstevel@tonic-gate copyflag); 43867c478bd9Sstevel@tonic-gate if (error) 43877c478bd9Sstevel@tonic-gate return (error); 43887c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 43897c478bd9Sstevel@tonic-gate return (ENXIO); 43907c478bd9Sstevel@tonic-gate if (binfo.bi_flag & ~FLUSHRW) 43917c478bd9Sstevel@tonic-gate return (EINVAL); 43927c478bd9Sstevel@tonic-gate while (!(mp = allocb(2, BPRI_HI))) { 43937c478bd9Sstevel@tonic-gate if (error = strwaitbuf(2, BPRI_HI)) 43947c478bd9Sstevel@tonic-gate return (error); 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_FLUSH; 43977c478bd9Sstevel@tonic-gate *mp->b_wptr++ = binfo.bi_flag | FLUSHBAND; 43987c478bd9Sstevel@tonic-gate *mp->b_wptr++ = binfo.bi_pri; 43997c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, mp); 44007c478bd9Sstevel@tonic-gate /* 44017c478bd9Sstevel@tonic-gate * Send down an unsupported ioctl and wait for the nack 44027c478bd9Sstevel@tonic-gate * in order to allow the M_FLUSH to propagate back 44037c478bd9Sstevel@tonic-gate * up to the stream head. 44047c478bd9Sstevel@tonic-gate * Replaces if (qready()) runqueues(); 44057c478bd9Sstevel@tonic-gate */ 44067c478bd9Sstevel@tonic-gate strioc.ic_cmd = -1; /* The unsupported ioctl */ 44077c478bd9Sstevel@tonic-gate strioc.ic_timout = 0; 44087c478bd9Sstevel@tonic-gate strioc.ic_len = 0; 44097c478bd9Sstevel@tonic-gate strioc.ic_dp = NULL; 44107c478bd9Sstevel@tonic-gate (void) strdoioctl(stp, &strioc, flag, K_TO_K, crp, rvalp); 44117c478bd9Sstevel@tonic-gate *rvalp = 0; 44127c478bd9Sstevel@tonic-gate return (0); 44137c478bd9Sstevel@tonic-gate } 44147c478bd9Sstevel@tonic-gate 44157c478bd9Sstevel@tonic-gate case I_SRDOPT: 44167c478bd9Sstevel@tonic-gate /* 44177c478bd9Sstevel@tonic-gate * Set read options 44187c478bd9Sstevel@tonic-gate * 44197c478bd9Sstevel@tonic-gate * RNORM - default stream mode 44207c478bd9Sstevel@tonic-gate * RMSGN - message no discard 44217c478bd9Sstevel@tonic-gate * RMSGD - message discard 44227c478bd9Sstevel@tonic-gate * RPROTNORM - fail read with EBADMSG for M_[PC]PROTOs 44237c478bd9Sstevel@tonic-gate * RPROTDAT - convert M_[PC]PROTOs to M_DATAs 44247c478bd9Sstevel@tonic-gate * RPROTDIS - discard M_[PC]PROTOs and retain M_DATAs 44257c478bd9Sstevel@tonic-gate */ 44267c478bd9Sstevel@tonic-gate if (arg & ~(RMODEMASK | RPROTMASK)) 44277c478bd9Sstevel@tonic-gate return (EINVAL); 44287c478bd9Sstevel@tonic-gate 44297c478bd9Sstevel@tonic-gate if ((arg & (RMSGD|RMSGN)) == (RMSGD|RMSGN)) 44307c478bd9Sstevel@tonic-gate return (EINVAL); 44317c478bd9Sstevel@tonic-gate 44327c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 44337c478bd9Sstevel@tonic-gate switch (arg & RMODEMASK) { 44347c478bd9Sstevel@tonic-gate case RNORM: 44357c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_MSGDIS | RD_MSGNODIS); 44367c478bd9Sstevel@tonic-gate break; 44377c478bd9Sstevel@tonic-gate case RMSGD: 44387c478bd9Sstevel@tonic-gate stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGNODIS) | 44397c478bd9Sstevel@tonic-gate RD_MSGDIS; 44407c478bd9Sstevel@tonic-gate break; 44417c478bd9Sstevel@tonic-gate case RMSGN: 44427c478bd9Sstevel@tonic-gate stp->sd_read_opt = (stp->sd_read_opt & ~RD_MSGDIS) | 44437c478bd9Sstevel@tonic-gate RD_MSGNODIS; 44447c478bd9Sstevel@tonic-gate break; 44457c478bd9Sstevel@tonic-gate } 44467c478bd9Sstevel@tonic-gate 44477c478bd9Sstevel@tonic-gate switch (arg & RPROTMASK) { 44487c478bd9Sstevel@tonic-gate case RPROTNORM: 44497c478bd9Sstevel@tonic-gate stp->sd_read_opt &= ~(RD_PROTDAT | RD_PROTDIS); 44507c478bd9Sstevel@tonic-gate break; 44517c478bd9Sstevel@tonic-gate 44527c478bd9Sstevel@tonic-gate case RPROTDAT: 44537c478bd9Sstevel@tonic-gate stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDIS) | 44547c478bd9Sstevel@tonic-gate RD_PROTDAT); 44557c478bd9Sstevel@tonic-gate break; 44567c478bd9Sstevel@tonic-gate 44577c478bd9Sstevel@tonic-gate case RPROTDIS: 44587c478bd9Sstevel@tonic-gate stp->sd_read_opt = ((stp->sd_read_opt & ~RD_PROTDAT) | 44597c478bd9Sstevel@tonic-gate RD_PROTDIS); 44607c478bd9Sstevel@tonic-gate break; 44617c478bd9Sstevel@tonic-gate } 44627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 44637c478bd9Sstevel@tonic-gate return (0); 44647c478bd9Sstevel@tonic-gate 44657c478bd9Sstevel@tonic-gate case I_GRDOPT: 44667c478bd9Sstevel@tonic-gate /* 44677c478bd9Sstevel@tonic-gate * Get read option and return the value 44687c478bd9Sstevel@tonic-gate * to spot pointed to by arg 44697c478bd9Sstevel@tonic-gate */ 44707c478bd9Sstevel@tonic-gate { 44717c478bd9Sstevel@tonic-gate int rdopt; 44727c478bd9Sstevel@tonic-gate 44737c478bd9Sstevel@tonic-gate rdopt = ((stp->sd_read_opt & RD_MSGDIS) ? RMSGD : 44747c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & RD_MSGNODIS) ? RMSGN : RNORM)); 44757c478bd9Sstevel@tonic-gate rdopt |= ((stp->sd_read_opt & RD_PROTDAT) ? RPROTDAT : 44767c478bd9Sstevel@tonic-gate ((stp->sd_read_opt & RD_PROTDIS) ? RPROTDIS : RPROTNORM)); 44777c478bd9Sstevel@tonic-gate 44787c478bd9Sstevel@tonic-gate return (strcopyout(&rdopt, (void *)arg, sizeof (int), 44797c478bd9Sstevel@tonic-gate copyflag)); 44807c478bd9Sstevel@tonic-gate } 44817c478bd9Sstevel@tonic-gate 44827c478bd9Sstevel@tonic-gate case I_SERROPT: 44837c478bd9Sstevel@tonic-gate /* 44847c478bd9Sstevel@tonic-gate * Set error options 44857c478bd9Sstevel@tonic-gate * 44867c478bd9Sstevel@tonic-gate * RERRNORM - persistent read errors 44877c478bd9Sstevel@tonic-gate * RERRNONPERSIST - non-persistent read errors 44887c478bd9Sstevel@tonic-gate * WERRNORM - persistent write errors 44897c478bd9Sstevel@tonic-gate * WERRNONPERSIST - non-persistent write errors 44907c478bd9Sstevel@tonic-gate */ 44917c478bd9Sstevel@tonic-gate if (arg & ~(RERRMASK | WERRMASK)) 44927c478bd9Sstevel@tonic-gate return (EINVAL); 44937c478bd9Sstevel@tonic-gate 44947c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 44957c478bd9Sstevel@tonic-gate switch (arg & RERRMASK) { 44967c478bd9Sstevel@tonic-gate case RERRNORM: 44977c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRDERRNONPERSIST; 44987c478bd9Sstevel@tonic-gate break; 44997c478bd9Sstevel@tonic-gate case RERRNONPERSIST: 45007c478bd9Sstevel@tonic-gate stp->sd_flag |= STRDERRNONPERSIST; 45017c478bd9Sstevel@tonic-gate break; 45027c478bd9Sstevel@tonic-gate } 45037c478bd9Sstevel@tonic-gate switch (arg & WERRMASK) { 45047c478bd9Sstevel@tonic-gate case WERRNORM: 45057c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STWRERRNONPERSIST; 45067c478bd9Sstevel@tonic-gate break; 45077c478bd9Sstevel@tonic-gate case WERRNONPERSIST: 45087c478bd9Sstevel@tonic-gate stp->sd_flag |= STWRERRNONPERSIST; 45097c478bd9Sstevel@tonic-gate break; 45107c478bd9Sstevel@tonic-gate } 45117c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 45127c478bd9Sstevel@tonic-gate return (0); 45137c478bd9Sstevel@tonic-gate 45147c478bd9Sstevel@tonic-gate case I_GERROPT: 45157c478bd9Sstevel@tonic-gate /* 45167c478bd9Sstevel@tonic-gate * Get error option and return the value 45177c478bd9Sstevel@tonic-gate * to spot pointed to by arg 45187c478bd9Sstevel@tonic-gate */ 45197c478bd9Sstevel@tonic-gate { 45207c478bd9Sstevel@tonic-gate int erropt = 0; 45217c478bd9Sstevel@tonic-gate 45227c478bd9Sstevel@tonic-gate erropt |= (stp->sd_flag & STRDERRNONPERSIST) ? RERRNONPERSIST : 45237c478bd9Sstevel@tonic-gate RERRNORM; 45247c478bd9Sstevel@tonic-gate erropt |= (stp->sd_flag & STWRERRNONPERSIST) ? WERRNONPERSIST : 45257c478bd9Sstevel@tonic-gate WERRNORM; 45267c478bd9Sstevel@tonic-gate return (strcopyout(&erropt, (void *)arg, sizeof (int), 45277c478bd9Sstevel@tonic-gate copyflag)); 45287c478bd9Sstevel@tonic-gate } 45297c478bd9Sstevel@tonic-gate 45307c478bd9Sstevel@tonic-gate case I_SETSIG: 45317c478bd9Sstevel@tonic-gate /* 45327c478bd9Sstevel@tonic-gate * Register the calling proc to receive the SIGPOLL 45337c478bd9Sstevel@tonic-gate * signal based on the events given in arg. If 45347c478bd9Sstevel@tonic-gate * arg is zero, remove the proc from register list. 45357c478bd9Sstevel@tonic-gate */ 45367c478bd9Sstevel@tonic-gate { 45377c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp; 45387c478bd9Sstevel@tonic-gate struct pid *pidp; 45397c478bd9Sstevel@tonic-gate 45407c478bd9Sstevel@tonic-gate pssp = NULL; 45417c478bd9Sstevel@tonic-gate pidp = curproc->p_pidp; 45427c478bd9Sstevel@tonic-gate /* 45437c478bd9Sstevel@tonic-gate * Hold sd_lock to prevent traversal of sd_siglist while 45447c478bd9Sstevel@tonic-gate * it is modified. 45457c478bd9Sstevel@tonic-gate */ 45467c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 45477c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp && (ssp->ss_pidp != pidp); 45487c478bd9Sstevel@tonic-gate pssp = ssp, ssp = ssp->ss_next) 45497c478bd9Sstevel@tonic-gate ; 45507c478bd9Sstevel@tonic-gate 45517c478bd9Sstevel@tonic-gate if (arg) { 45527c478bd9Sstevel@tonic-gate if (arg & ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR| 45537c478bd9Sstevel@tonic-gate S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) { 45547c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 45557c478bd9Sstevel@tonic-gate return (EINVAL); 45567c478bd9Sstevel@tonic-gate } 45577c478bd9Sstevel@tonic-gate if ((arg & S_BANDURG) && !(arg & S_RDBAND)) { 45587c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 45597c478bd9Sstevel@tonic-gate return (EINVAL); 45607c478bd9Sstevel@tonic-gate } 45617c478bd9Sstevel@tonic-gate 45627c478bd9Sstevel@tonic-gate /* 45637c478bd9Sstevel@tonic-gate * If proc not already registered, add it 45647c478bd9Sstevel@tonic-gate * to list. 45657c478bd9Sstevel@tonic-gate */ 45667c478bd9Sstevel@tonic-gate if (!ssp) { 45677c478bd9Sstevel@tonic-gate ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP); 45687c478bd9Sstevel@tonic-gate ssp->ss_pidp = pidp; 45697c478bd9Sstevel@tonic-gate ssp->ss_pid = pidp->pid_id; 45707c478bd9Sstevel@tonic-gate ssp->ss_next = NULL; 45717c478bd9Sstevel@tonic-gate if (pssp) 45727c478bd9Sstevel@tonic-gate pssp->ss_next = ssp; 45737c478bd9Sstevel@tonic-gate else 45747c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp; 45757c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 45767c478bd9Sstevel@tonic-gate PID_HOLD(pidp); 45777c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 45787c478bd9Sstevel@tonic-gate } 45797c478bd9Sstevel@tonic-gate 45807c478bd9Sstevel@tonic-gate /* 45817c478bd9Sstevel@tonic-gate * Set events. 45827c478bd9Sstevel@tonic-gate */ 45837c478bd9Sstevel@tonic-gate ssp->ss_events = (int)arg; 45847c478bd9Sstevel@tonic-gate } else { 45857c478bd9Sstevel@tonic-gate /* 45867c478bd9Sstevel@tonic-gate * Remove proc from register list. 45877c478bd9Sstevel@tonic-gate */ 45887c478bd9Sstevel@tonic-gate if (ssp) { 45897c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 45907c478bd9Sstevel@tonic-gate PID_RELE(pidp); 45917c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 45927c478bd9Sstevel@tonic-gate if (pssp) 45937c478bd9Sstevel@tonic-gate pssp->ss_next = ssp->ss_next; 45947c478bd9Sstevel@tonic-gate else 45957c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp->ss_next; 45967c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t)); 45977c478bd9Sstevel@tonic-gate } else { 45987c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 45997c478bd9Sstevel@tonic-gate return (EINVAL); 46007c478bd9Sstevel@tonic-gate } 46017c478bd9Sstevel@tonic-gate } 46027c478bd9Sstevel@tonic-gate 46037c478bd9Sstevel@tonic-gate /* 46047c478bd9Sstevel@tonic-gate * Recalculate OR of sig events. 46057c478bd9Sstevel@tonic-gate */ 46067c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 46077c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 46087c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events; 46097c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 46107c478bd9Sstevel@tonic-gate return (0); 46117c478bd9Sstevel@tonic-gate } 46127c478bd9Sstevel@tonic-gate 46137c478bd9Sstevel@tonic-gate case I_GETSIG: 46147c478bd9Sstevel@tonic-gate /* 46157c478bd9Sstevel@tonic-gate * Return (in arg) the current registration of events 46167c478bd9Sstevel@tonic-gate * for which the calling proc is to be signaled. 46177c478bd9Sstevel@tonic-gate */ 46187c478bd9Sstevel@tonic-gate { 46197c478bd9Sstevel@tonic-gate struct strsig *ssp; 46207c478bd9Sstevel@tonic-gate struct pid *pidp; 46217c478bd9Sstevel@tonic-gate 46227c478bd9Sstevel@tonic-gate pidp = curproc->p_pidp; 46237c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 46247c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 46257c478bd9Sstevel@tonic-gate if (ssp->ss_pidp == pidp) { 46267c478bd9Sstevel@tonic-gate error = strcopyout(&ssp->ss_events, (void *)arg, 46277c478bd9Sstevel@tonic-gate sizeof (int), copyflag); 46287c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 46297c478bd9Sstevel@tonic-gate return (error); 46307c478bd9Sstevel@tonic-gate } 46317c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 46327c478bd9Sstevel@tonic-gate return (EINVAL); 46337c478bd9Sstevel@tonic-gate } 46347c478bd9Sstevel@tonic-gate 46357c478bd9Sstevel@tonic-gate case I_ESETSIG: 46367c478bd9Sstevel@tonic-gate /* 46377c478bd9Sstevel@tonic-gate * Register the ss_pid to receive the SIGPOLL 46387c478bd9Sstevel@tonic-gate * signal based on the events is ss_events arg. If 46397c478bd9Sstevel@tonic-gate * ss_events is zero, remove the proc from register list. 46407c478bd9Sstevel@tonic-gate */ 46417c478bd9Sstevel@tonic-gate { 46427c478bd9Sstevel@tonic-gate struct strsig *ssp, *pssp; 46437c478bd9Sstevel@tonic-gate struct proc *proc; 46447c478bd9Sstevel@tonic-gate struct pid *pidp; 46457c478bd9Sstevel@tonic-gate pid_t pid; 46467c478bd9Sstevel@tonic-gate struct strsigset ss; 46477c478bd9Sstevel@tonic-gate 46487c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag); 46497c478bd9Sstevel@tonic-gate if (error) 46507c478bd9Sstevel@tonic-gate return (error); 46517c478bd9Sstevel@tonic-gate 46527c478bd9Sstevel@tonic-gate pid = ss.ss_pid; 46537c478bd9Sstevel@tonic-gate 46547c478bd9Sstevel@tonic-gate if (ss.ss_events != 0) { 46557c478bd9Sstevel@tonic-gate /* 46567c478bd9Sstevel@tonic-gate * Permissions check by sending signal 0. 46577c478bd9Sstevel@tonic-gate * Note that when kill fails it does a set_errno 46587c478bd9Sstevel@tonic-gate * causing the system call to fail. 46597c478bd9Sstevel@tonic-gate */ 46607c478bd9Sstevel@tonic-gate error = kill(pid, 0); 46617c478bd9Sstevel@tonic-gate if (error) { 46627c478bd9Sstevel@tonic-gate return (error); 46637c478bd9Sstevel@tonic-gate } 46647c478bd9Sstevel@tonic-gate } 46657c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 46667c478bd9Sstevel@tonic-gate if (pid == 0) 46677c478bd9Sstevel@tonic-gate proc = curproc; 46687c478bd9Sstevel@tonic-gate else if (pid < 0) 46697c478bd9Sstevel@tonic-gate proc = pgfind(-pid); 46707c478bd9Sstevel@tonic-gate else 46717c478bd9Sstevel@tonic-gate proc = prfind(pid); 46727c478bd9Sstevel@tonic-gate if (proc == NULL) { 46737c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 46747c478bd9Sstevel@tonic-gate return (ESRCH); 46757c478bd9Sstevel@tonic-gate } 46767c478bd9Sstevel@tonic-gate if (pid < 0) 46777c478bd9Sstevel@tonic-gate pidp = proc->p_pgidp; 46787c478bd9Sstevel@tonic-gate else 46797c478bd9Sstevel@tonic-gate pidp = proc->p_pidp; 46807c478bd9Sstevel@tonic-gate ASSERT(pidp); 46817c478bd9Sstevel@tonic-gate /* 46827c478bd9Sstevel@tonic-gate * Get a hold on the pid structure while referencing it. 46837c478bd9Sstevel@tonic-gate * There is a separate PID_HOLD should it be inserted 46847c478bd9Sstevel@tonic-gate * in the list below. 46857c478bd9Sstevel@tonic-gate */ 46867c478bd9Sstevel@tonic-gate PID_HOLD(pidp); 46877c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 46887c478bd9Sstevel@tonic-gate 46897c478bd9Sstevel@tonic-gate pssp = NULL; 46907c478bd9Sstevel@tonic-gate /* 46917c478bd9Sstevel@tonic-gate * Hold sd_lock to prevent traversal of sd_siglist while 46927c478bd9Sstevel@tonic-gate * it is modified. 46937c478bd9Sstevel@tonic-gate */ 46947c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 46957c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp && (ssp->ss_pid != pid); 46967c478bd9Sstevel@tonic-gate pssp = ssp, ssp = ssp->ss_next) 46977c478bd9Sstevel@tonic-gate ; 46987c478bd9Sstevel@tonic-gate 46997c478bd9Sstevel@tonic-gate if (ss.ss_events) { 47007c478bd9Sstevel@tonic-gate if (ss.ss_events & 47017c478bd9Sstevel@tonic-gate ~(S_INPUT|S_HIPRI|S_MSG|S_HANGUP|S_ERROR| 47027c478bd9Sstevel@tonic-gate S_RDNORM|S_WRNORM|S_RDBAND|S_WRBAND|S_BANDURG)) { 47037c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 47047c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47057c478bd9Sstevel@tonic-gate PID_RELE(pidp); 47067c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47077c478bd9Sstevel@tonic-gate return (EINVAL); 47087c478bd9Sstevel@tonic-gate } 47097c478bd9Sstevel@tonic-gate if ((ss.ss_events & S_BANDURG) && 47107c478bd9Sstevel@tonic-gate !(ss.ss_events & S_RDBAND)) { 47117c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 47127c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47137c478bd9Sstevel@tonic-gate PID_RELE(pidp); 47147c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47157c478bd9Sstevel@tonic-gate return (EINVAL); 47167c478bd9Sstevel@tonic-gate } 47177c478bd9Sstevel@tonic-gate 47187c478bd9Sstevel@tonic-gate /* 47197c478bd9Sstevel@tonic-gate * If proc not already registered, add it 47207c478bd9Sstevel@tonic-gate * to list. 47217c478bd9Sstevel@tonic-gate */ 47227c478bd9Sstevel@tonic-gate if (!ssp) { 47237c478bd9Sstevel@tonic-gate ssp = kmem_alloc(sizeof (strsig_t), KM_SLEEP); 47247c478bd9Sstevel@tonic-gate ssp->ss_pidp = pidp; 47257c478bd9Sstevel@tonic-gate ssp->ss_pid = pid; 47267c478bd9Sstevel@tonic-gate ssp->ss_next = NULL; 47277c478bd9Sstevel@tonic-gate if (pssp) 47287c478bd9Sstevel@tonic-gate pssp->ss_next = ssp; 47297c478bd9Sstevel@tonic-gate else 47307c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp; 47317c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47327c478bd9Sstevel@tonic-gate PID_HOLD(pidp); 47337c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47347c478bd9Sstevel@tonic-gate } 47357c478bd9Sstevel@tonic-gate 47367c478bd9Sstevel@tonic-gate /* 47377c478bd9Sstevel@tonic-gate * Set events. 47387c478bd9Sstevel@tonic-gate */ 47397c478bd9Sstevel@tonic-gate ssp->ss_events = ss.ss_events; 47407c478bd9Sstevel@tonic-gate } else { 47417c478bd9Sstevel@tonic-gate /* 47427c478bd9Sstevel@tonic-gate * Remove proc from register list. 47437c478bd9Sstevel@tonic-gate */ 47447c478bd9Sstevel@tonic-gate if (ssp) { 47457c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47467c478bd9Sstevel@tonic-gate PID_RELE(pidp); 47477c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47487c478bd9Sstevel@tonic-gate if (pssp) 47497c478bd9Sstevel@tonic-gate pssp->ss_next = ssp->ss_next; 47507c478bd9Sstevel@tonic-gate else 47517c478bd9Sstevel@tonic-gate stp->sd_siglist = ssp->ss_next; 47527c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t)); 47537c478bd9Sstevel@tonic-gate } else { 47547c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 47557c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47567c478bd9Sstevel@tonic-gate PID_RELE(pidp); 47577c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47587c478bd9Sstevel@tonic-gate return (EINVAL); 47597c478bd9Sstevel@tonic-gate } 47607c478bd9Sstevel@tonic-gate } 47617c478bd9Sstevel@tonic-gate 47627c478bd9Sstevel@tonic-gate /* 47637c478bd9Sstevel@tonic-gate * Recalculate OR of sig events. 47647c478bd9Sstevel@tonic-gate */ 47657c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 47667c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 47677c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events; 47687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 47697c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47707c478bd9Sstevel@tonic-gate PID_RELE(pidp); 47717c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 47727c478bd9Sstevel@tonic-gate return (0); 47737c478bd9Sstevel@tonic-gate } 47747c478bd9Sstevel@tonic-gate 47757c478bd9Sstevel@tonic-gate case I_EGETSIG: 47767c478bd9Sstevel@tonic-gate /* 47777c478bd9Sstevel@tonic-gate * Return (in arg) the current registration of events 47787c478bd9Sstevel@tonic-gate * for which the calling proc is to be signaled. 47797c478bd9Sstevel@tonic-gate */ 47807c478bd9Sstevel@tonic-gate { 47817c478bd9Sstevel@tonic-gate struct strsig *ssp; 47827c478bd9Sstevel@tonic-gate struct proc *proc; 47837c478bd9Sstevel@tonic-gate pid_t pid; 47847c478bd9Sstevel@tonic-gate struct pid *pidp; 47857c478bd9Sstevel@tonic-gate struct strsigset ss; 47867c478bd9Sstevel@tonic-gate 47877c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &ss, sizeof (ss), copyflag); 47887c478bd9Sstevel@tonic-gate if (error) 47897c478bd9Sstevel@tonic-gate return (error); 47907c478bd9Sstevel@tonic-gate 47917c478bd9Sstevel@tonic-gate pid = ss.ss_pid; 47927c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 47937c478bd9Sstevel@tonic-gate if (pid == 0) 47947c478bd9Sstevel@tonic-gate proc = curproc; 47957c478bd9Sstevel@tonic-gate else if (pid < 0) 47967c478bd9Sstevel@tonic-gate proc = pgfind(-pid); 47977c478bd9Sstevel@tonic-gate else 47987c478bd9Sstevel@tonic-gate proc = prfind(pid); 47997c478bd9Sstevel@tonic-gate if (proc == NULL) { 48007c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 48017c478bd9Sstevel@tonic-gate return (ESRCH); 48027c478bd9Sstevel@tonic-gate } 48037c478bd9Sstevel@tonic-gate if (pid < 0) 48047c478bd9Sstevel@tonic-gate pidp = proc->p_pgidp; 48057c478bd9Sstevel@tonic-gate else 48067c478bd9Sstevel@tonic-gate pidp = proc->p_pidp; 48077c478bd9Sstevel@tonic-gate 48087c478bd9Sstevel@tonic-gate /* Prevent the pidp from being reassigned */ 48097c478bd9Sstevel@tonic-gate PID_HOLD(pidp); 48107c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 48117c478bd9Sstevel@tonic-gate 48127c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 48137c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 48147c478bd9Sstevel@tonic-gate if (ssp->ss_pid == pid) { 48157c478bd9Sstevel@tonic-gate ss.ss_pid = ssp->ss_pid; 48167c478bd9Sstevel@tonic-gate ss.ss_events = ssp->ss_events; 48177c478bd9Sstevel@tonic-gate error = strcopyout(&ss, (void *)arg, 48187c478bd9Sstevel@tonic-gate sizeof (struct strsigset), copyflag); 48197c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 48207c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 48217c478bd9Sstevel@tonic-gate PID_RELE(pidp); 48227c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 48237c478bd9Sstevel@tonic-gate return (error); 48247c478bd9Sstevel@tonic-gate } 48257c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 48267c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 48277c478bd9Sstevel@tonic-gate PID_RELE(pidp); 48287c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 48297c478bd9Sstevel@tonic-gate return (EINVAL); 48307c478bd9Sstevel@tonic-gate } 48317c478bd9Sstevel@tonic-gate 48327c478bd9Sstevel@tonic-gate case I_PEEK: 48337c478bd9Sstevel@tonic-gate { 48347c478bd9Sstevel@tonic-gate STRUCT_DECL(strpeek, strpeek); 48357c478bd9Sstevel@tonic-gate size_t n; 48367c478bd9Sstevel@tonic-gate mblk_t *fmp, *tmp_mp = NULL; 48377c478bd9Sstevel@tonic-gate 48387c478bd9Sstevel@tonic-gate STRUCT_INIT(strpeek, flag); 48397c478bd9Sstevel@tonic-gate 48407c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strpeek), 48417c478bd9Sstevel@tonic-gate STRUCT_SIZE(strpeek), copyflag); 48427c478bd9Sstevel@tonic-gate if (error) 48437c478bd9Sstevel@tonic-gate return (error); 48447c478bd9Sstevel@tonic-gate 48457c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(rdq)); 48467c478bd9Sstevel@tonic-gate /* 48477c478bd9Sstevel@tonic-gate * Skip the invalid messages 48487c478bd9Sstevel@tonic-gate */ 48497c478bd9Sstevel@tonic-gate for (mp = rdq->q_first; mp != NULL; mp = mp->b_next) 48507c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type != M_SIG) 48517c478bd9Sstevel@tonic-gate break; 48527c478bd9Sstevel@tonic-gate 48537c478bd9Sstevel@tonic-gate /* 48547c478bd9Sstevel@tonic-gate * If user has requested to peek at a high priority message 48557c478bd9Sstevel@tonic-gate * and first message is not, return 0 48567c478bd9Sstevel@tonic-gate */ 48577c478bd9Sstevel@tonic-gate if (mp != NULL) { 48587c478bd9Sstevel@tonic-gate if ((STRUCT_FGET(strpeek, flags) & RS_HIPRI) && 48597c478bd9Sstevel@tonic-gate queclass(mp) == QNORM) { 48607c478bd9Sstevel@tonic-gate *rvalp = 0; 48617c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 48627c478bd9Sstevel@tonic-gate return (0); 48637c478bd9Sstevel@tonic-gate } 48647c478bd9Sstevel@tonic-gate } else if (stp->sd_struiordq == NULL || 48657c478bd9Sstevel@tonic-gate (STRUCT_FGET(strpeek, flags) & RS_HIPRI)) { 48667c478bd9Sstevel@tonic-gate /* 48677c478bd9Sstevel@tonic-gate * No mblks to look at at the streamhead and 48687c478bd9Sstevel@tonic-gate * 1). This isn't a synch stream or 48697c478bd9Sstevel@tonic-gate * 2). This is a synch stream but caller wants high 48707c478bd9Sstevel@tonic-gate * priority messages which is not supported by 48717c478bd9Sstevel@tonic-gate * the synch stream. (it only supports QNORM) 48727c478bd9Sstevel@tonic-gate */ 48737c478bd9Sstevel@tonic-gate *rvalp = 0; 48747c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 48757c478bd9Sstevel@tonic-gate return (0); 48767c478bd9Sstevel@tonic-gate } 48777c478bd9Sstevel@tonic-gate 48787c478bd9Sstevel@tonic-gate fmp = mp; 48797c478bd9Sstevel@tonic-gate 48807c478bd9Sstevel@tonic-gate if (mp && mp->b_datap->db_type == M_PASSFP) { 48817c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 48827c478bd9Sstevel@tonic-gate return (EBADMSG); 48837c478bd9Sstevel@tonic-gate } 48847c478bd9Sstevel@tonic-gate 48857c478bd9Sstevel@tonic-gate ASSERT(mp == NULL || mp->b_datap->db_type == M_PCPROTO || 48867c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PROTO || 48877c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_DATA); 48887c478bd9Sstevel@tonic-gate 48897c478bd9Sstevel@tonic-gate if (mp && mp->b_datap->db_type == M_PCPROTO) { 48907c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, flags, RS_HIPRI); 48917c478bd9Sstevel@tonic-gate } else { 48927c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, flags, 0); 48937c478bd9Sstevel@tonic-gate } 48947c478bd9Sstevel@tonic-gate 48957c478bd9Sstevel@tonic-gate 48967c478bd9Sstevel@tonic-gate if (mp && ((tmp_mp = dupmsg(mp)) == NULL)) { 48977c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 48987c478bd9Sstevel@tonic-gate return (ENOSR); 48997c478bd9Sstevel@tonic-gate } 49007c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(rdq)); 49017c478bd9Sstevel@tonic-gate 49027c478bd9Sstevel@tonic-gate /* 49037c478bd9Sstevel@tonic-gate * set mp = tmp_mp, so that I_PEEK processing can continue. 49047c478bd9Sstevel@tonic-gate * tmp_mp is used to free the dup'd message. 49057c478bd9Sstevel@tonic-gate */ 49067c478bd9Sstevel@tonic-gate mp = tmp_mp; 49077c478bd9Sstevel@tonic-gate 49087c478bd9Sstevel@tonic-gate uio.uio_fmode = 0; 49097c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED; 49107c478bd9Sstevel@tonic-gate uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE : 49117c478bd9Sstevel@tonic-gate UIO_SYSSPACE; 49127c478bd9Sstevel@tonic-gate uio.uio_limit = 0; 49137c478bd9Sstevel@tonic-gate /* 49147c478bd9Sstevel@tonic-gate * First process PROTO blocks, if any. 49157c478bd9Sstevel@tonic-gate * If user doesn't want to get ctl info by setting maxlen <= 0, 49167c478bd9Sstevel@tonic-gate * then set len to -1/0 and skip control blocks part. 49177c478bd9Sstevel@tonic-gate */ 49187c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, ctlbuf.maxlen) < 0) 49197c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, -1); 49207c478bd9Sstevel@tonic-gate else if (STRUCT_FGET(strpeek, ctlbuf.maxlen) == 0) 49217c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, 0); 49227c478bd9Sstevel@tonic-gate else { 49237c478bd9Sstevel@tonic-gate int ctl_part = 0; 49247c478bd9Sstevel@tonic-gate 49257c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strpeek, ctlbuf.buf); 49267c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strpeek, ctlbuf.maxlen); 49277c478bd9Sstevel@tonic-gate uio.uio_iov = &iov; 49287c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len; 49297c478bd9Sstevel@tonic-gate uio.uio_loffset = 0; 49307c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1; 49317c478bd9Sstevel@tonic-gate while (mp && mp->b_datap->db_type != M_DATA && 49327c478bd9Sstevel@tonic-gate uio.uio_resid >= 0) { 49337c478bd9Sstevel@tonic-gate ASSERT(STRUCT_FGET(strpeek, flags) == 0 ? 49347c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PROTO : 49357c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_PCPROTO); 49367c478bd9Sstevel@tonic-gate 49377c478bd9Sstevel@tonic-gate if ((n = MIN(uio.uio_resid, 49387c478bd9Sstevel@tonic-gate mp->b_wptr - mp->b_rptr)) != 0 && 49397c478bd9Sstevel@tonic-gate (error = uiomove((char *)mp->b_rptr, n, 49407c478bd9Sstevel@tonic-gate UIO_READ, &uio)) != 0) { 49417c478bd9Sstevel@tonic-gate freemsg(tmp_mp); 49427c478bd9Sstevel@tonic-gate return (error); 49437c478bd9Sstevel@tonic-gate } 49447c478bd9Sstevel@tonic-gate ctl_part = 1; 49457c478bd9Sstevel@tonic-gate mp = mp->b_cont; 49467c478bd9Sstevel@tonic-gate } 49477c478bd9Sstevel@tonic-gate /* No ctl message */ 49487c478bd9Sstevel@tonic-gate if (ctl_part == 0) 49497c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, -1); 49507c478bd9Sstevel@tonic-gate else 49517c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, ctlbuf.len, 49527c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, ctlbuf.maxlen) - 49537c478bd9Sstevel@tonic-gate uio.uio_resid); 49547c478bd9Sstevel@tonic-gate } 49557c478bd9Sstevel@tonic-gate 49567c478bd9Sstevel@tonic-gate /* 49577c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any. 49587c478bd9Sstevel@tonic-gate * If user doesn't want to get data info by setting maxlen <= 0, 49597c478bd9Sstevel@tonic-gate * then set len to -1/0 and skip data blocks part. 49607c478bd9Sstevel@tonic-gate */ 49617c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, databuf.maxlen) < 0) 49627c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1); 49637c478bd9Sstevel@tonic-gate else if (STRUCT_FGET(strpeek, databuf.maxlen) == 0) 49647c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, 0); 49657c478bd9Sstevel@tonic-gate else { 49667c478bd9Sstevel@tonic-gate int data_part = 0; 49677c478bd9Sstevel@tonic-gate 49687c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strpeek, databuf.buf); 49697c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strpeek, databuf.maxlen); 49707c478bd9Sstevel@tonic-gate uio.uio_iov = &iov; 49717c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len; 49727c478bd9Sstevel@tonic-gate uio.uio_loffset = 0; 49737c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1; 49747c478bd9Sstevel@tonic-gate while (mp && uio.uio_resid) { 49757c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type == M_DATA) { 49767c478bd9Sstevel@tonic-gate if ((n = MIN(uio.uio_resid, 49777c478bd9Sstevel@tonic-gate mp->b_wptr - mp->b_rptr)) != 0 && 49787c478bd9Sstevel@tonic-gate (error = uiomove((char *)mp->b_rptr, 49797c478bd9Sstevel@tonic-gate n, UIO_READ, &uio)) != 0) { 49807c478bd9Sstevel@tonic-gate freemsg(tmp_mp); 49817c478bd9Sstevel@tonic-gate return (error); 49827c478bd9Sstevel@tonic-gate } 49837c478bd9Sstevel@tonic-gate data_part = 1; 49847c478bd9Sstevel@tonic-gate } 49857c478bd9Sstevel@tonic-gate ASSERT(data_part == 0 || 49867c478bd9Sstevel@tonic-gate mp->b_datap->db_type == M_DATA); 49877c478bd9Sstevel@tonic-gate mp = mp->b_cont; 49887c478bd9Sstevel@tonic-gate } 49897c478bd9Sstevel@tonic-gate /* No data message */ 49907c478bd9Sstevel@tonic-gate if (data_part == 0) 49917c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1); 49927c478bd9Sstevel@tonic-gate else 49937c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, 49947c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, databuf.maxlen) - 49957c478bd9Sstevel@tonic-gate uio.uio_resid); 49967c478bd9Sstevel@tonic-gate } 49977c478bd9Sstevel@tonic-gate freemsg(tmp_mp); 49987c478bd9Sstevel@tonic-gate 49997c478bd9Sstevel@tonic-gate /* 50007c478bd9Sstevel@tonic-gate * It is a synch stream and user wants to get 50017c478bd9Sstevel@tonic-gate * data (maxlen > 0). 50027c478bd9Sstevel@tonic-gate * uio setup is done by the codes that process DATA 50037c478bd9Sstevel@tonic-gate * blocks above. 50047c478bd9Sstevel@tonic-gate */ 50057c478bd9Sstevel@tonic-gate if ((fmp == NULL) && STRUCT_FGET(strpeek, databuf.maxlen) > 0) { 50067c478bd9Sstevel@tonic-gate infod_t infod; 50077c478bd9Sstevel@tonic-gate 50087c478bd9Sstevel@tonic-gate infod.d_cmd = INFOD_COPYOUT; 50097c478bd9Sstevel@tonic-gate infod.d_res = 0; 50107c478bd9Sstevel@tonic-gate infod.d_uiop = &uio; 50117c478bd9Sstevel@tonic-gate error = infonext(rdq, &infod); 50127c478bd9Sstevel@tonic-gate if (error == EINVAL || error == EBUSY) 50137c478bd9Sstevel@tonic-gate error = 0; 50147c478bd9Sstevel@tonic-gate if (error) 50157c478bd9Sstevel@tonic-gate return (error); 50167c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, STRUCT_FGET(strpeek, 50177c478bd9Sstevel@tonic-gate databuf.maxlen) - uio.uio_resid); 50187c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, databuf.len) == 0) { 50197c478bd9Sstevel@tonic-gate /* 50207c478bd9Sstevel@tonic-gate * No data found by the infonext(). 50217c478bd9Sstevel@tonic-gate */ 50227c478bd9Sstevel@tonic-gate STRUCT_FSET(strpeek, databuf.len, -1); 50237c478bd9Sstevel@tonic-gate } 50247c478bd9Sstevel@tonic-gate } 50257c478bd9Sstevel@tonic-gate error = strcopyout(STRUCT_BUF(strpeek), (void *)arg, 50267c478bd9Sstevel@tonic-gate STRUCT_SIZE(strpeek), copyflag); 50277c478bd9Sstevel@tonic-gate if (error) { 50287c478bd9Sstevel@tonic-gate return (error); 50297c478bd9Sstevel@tonic-gate } 50307c478bd9Sstevel@tonic-gate /* 50317c478bd9Sstevel@tonic-gate * If there is no message retrieved, set return code to 0 50327c478bd9Sstevel@tonic-gate * otherwise, set it to 1. 50337c478bd9Sstevel@tonic-gate */ 50347c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strpeek, ctlbuf.len) == -1 && 50357c478bd9Sstevel@tonic-gate STRUCT_FGET(strpeek, databuf.len) == -1) 50367c478bd9Sstevel@tonic-gate *rvalp = 0; 50377c478bd9Sstevel@tonic-gate else 50387c478bd9Sstevel@tonic-gate *rvalp = 1; 50397c478bd9Sstevel@tonic-gate return (0); 50407c478bd9Sstevel@tonic-gate } 50417c478bd9Sstevel@tonic-gate 50427c478bd9Sstevel@tonic-gate case I_FDINSERT: 50437c478bd9Sstevel@tonic-gate { 50447c478bd9Sstevel@tonic-gate STRUCT_DECL(strfdinsert, strfdinsert); 50457c478bd9Sstevel@tonic-gate struct file *resftp; 50467c478bd9Sstevel@tonic-gate struct stdata *resstp; 50477c478bd9Sstevel@tonic-gate t_uscalar_t ival; 50487c478bd9Sstevel@tonic-gate ssize_t msgsize; 50497c478bd9Sstevel@tonic-gate struct strbuf mctl; 50507c478bd9Sstevel@tonic-gate 50517c478bd9Sstevel@tonic-gate STRUCT_INIT(strfdinsert, flag); 50527c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 50537c478bd9Sstevel@tonic-gate return (ENXIO); 50547c478bd9Sstevel@tonic-gate /* 50557c478bd9Sstevel@tonic-gate * STRDERR, STWRERR and STPLEX tested above. 50567c478bd9Sstevel@tonic-gate */ 50577c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strfdinsert), 50587c478bd9Sstevel@tonic-gate STRUCT_SIZE(strfdinsert), copyflag); 50597c478bd9Sstevel@tonic-gate if (error) 50607c478bd9Sstevel@tonic-gate return (error); 50617c478bd9Sstevel@tonic-gate 50627c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, offset) < 0 || 50637c478bd9Sstevel@tonic-gate (STRUCT_FGET(strfdinsert, offset) % 50647c478bd9Sstevel@tonic-gate sizeof (t_uscalar_t)) != 0) 50657c478bd9Sstevel@tonic-gate return (EINVAL); 50667c478bd9Sstevel@tonic-gate if ((resftp = getf(STRUCT_FGET(strfdinsert, fildes))) != NULL) { 50677c478bd9Sstevel@tonic-gate if ((resstp = resftp->f_vnode->v_stream) == NULL) { 50687c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 50697c478bd9Sstevel@tonic-gate return (EINVAL); 50707c478bd9Sstevel@tonic-gate } 50717c478bd9Sstevel@tonic-gate } else 50727c478bd9Sstevel@tonic-gate return (EINVAL); 50737c478bd9Sstevel@tonic-gate 50747c478bd9Sstevel@tonic-gate mutex_enter(&resstp->sd_lock); 50757c478bd9Sstevel@tonic-gate if (resstp->sd_flag & (STRDERR|STWRERR|STRHUP|STPLEX)) { 50767c478bd9Sstevel@tonic-gate error = strgeterr(resstp, 50777c478bd9Sstevel@tonic-gate STRDERR|STWRERR|STRHUP|STPLEX, 0); 50787c478bd9Sstevel@tonic-gate if (error != 0) { 50797c478bd9Sstevel@tonic-gate mutex_exit(&resstp->sd_lock); 50807c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 50817c478bd9Sstevel@tonic-gate return (error); 50827c478bd9Sstevel@tonic-gate } 50837c478bd9Sstevel@tonic-gate } 50847c478bd9Sstevel@tonic-gate mutex_exit(&resstp->sd_lock); 50857c478bd9Sstevel@tonic-gate 50867c478bd9Sstevel@tonic-gate #ifdef _ILP32 50877c478bd9Sstevel@tonic-gate { 50887c478bd9Sstevel@tonic-gate queue_t *q; 50897c478bd9Sstevel@tonic-gate queue_t *mate = NULL; 50907c478bd9Sstevel@tonic-gate 50917c478bd9Sstevel@tonic-gate /* get read queue of stream terminus */ 50927c478bd9Sstevel@tonic-gate claimstr(resstp->sd_wrq); 50937c478bd9Sstevel@tonic-gate for (q = resstp->sd_wrq->q_next; q->q_next != NULL; 50947c478bd9Sstevel@tonic-gate q = q->q_next) 50957c478bd9Sstevel@tonic-gate if (!STRMATED(resstp) && STREAM(q) != resstp && 50967c478bd9Sstevel@tonic-gate mate == NULL) { 50977c478bd9Sstevel@tonic-gate ASSERT(q->q_qinfo->qi_srvp); 50987c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(q)->q_qinfo->qi_srvp); 50997c478bd9Sstevel@tonic-gate claimstr(q); 51007c478bd9Sstevel@tonic-gate mate = q; 51017c478bd9Sstevel@tonic-gate } 51027c478bd9Sstevel@tonic-gate q = _RD(q); 51037c478bd9Sstevel@tonic-gate if (mate) 51047c478bd9Sstevel@tonic-gate releasestr(mate); 51057c478bd9Sstevel@tonic-gate releasestr(resstp->sd_wrq); 51067c478bd9Sstevel@tonic-gate ival = (t_uscalar_t)q; 51077c478bd9Sstevel@tonic-gate } 51087c478bd9Sstevel@tonic-gate #else 51097c478bd9Sstevel@tonic-gate ival = (t_uscalar_t)getminor(resftp->f_vnode->v_rdev); 51107c478bd9Sstevel@tonic-gate #endif /* _ILP32 */ 51117c478bd9Sstevel@tonic-gate 51127c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, ctlbuf.len) < 51137c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, offset) + sizeof (t_uscalar_t)) { 51147c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51157c478bd9Sstevel@tonic-gate return (EINVAL); 51167c478bd9Sstevel@tonic-gate } 51177c478bd9Sstevel@tonic-gate 51187c478bd9Sstevel@tonic-gate /* 51197c478bd9Sstevel@tonic-gate * Check for legal flag value. 51207c478bd9Sstevel@tonic-gate */ 51217c478bd9Sstevel@tonic-gate if (STRUCT_FGET(strfdinsert, flags) & ~RS_HIPRI) { 51227c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51237c478bd9Sstevel@tonic-gate return (EINVAL); 51247c478bd9Sstevel@tonic-gate } 51257c478bd9Sstevel@tonic-gate 51267c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */ 51277c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(stp->sd_wrq)); 51287c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz; 51297c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz; 51307c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(stp->sd_wrq)); 51317c478bd9Sstevel@tonic-gate 51327c478bd9Sstevel@tonic-gate /* 51337c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within 51347c478bd9Sstevel@tonic-gate * the limits of the max and min receive packet sizes 51357c478bd9Sstevel@tonic-gate * and do not exceed system limit. A negative data 51367c478bd9Sstevel@tonic-gate * length means that no data part is to be sent. 51377c478bd9Sstevel@tonic-gate */ 51387c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ)); 51397c478bd9Sstevel@tonic-gate if (rmax == 0) { 51407c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51417c478bd9Sstevel@tonic-gate return (ERANGE); 51427c478bd9Sstevel@tonic-gate } 51437c478bd9Sstevel@tonic-gate if ((msgsize = STRUCT_FGET(strfdinsert, databuf.len)) < 0) 51447c478bd9Sstevel@tonic-gate msgsize = 0; 51457c478bd9Sstevel@tonic-gate if ((msgsize < rmin) || 51467c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ)) || 51477c478bd9Sstevel@tonic-gate (STRUCT_FGET(strfdinsert, ctlbuf.len) > strctlsz)) { 51487c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51497c478bd9Sstevel@tonic-gate return (ERANGE); 51507c478bd9Sstevel@tonic-gate } 51517c478bd9Sstevel@tonic-gate 51527c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 51537c478bd9Sstevel@tonic-gate while (!(STRUCT_FGET(strfdinsert, flags) & RS_HIPRI) && 51547c478bd9Sstevel@tonic-gate !canputnext(stp->sd_wrq)) { 51557c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, 51567c478bd9Sstevel@tonic-gate flag, -1, &done)) != 0 || done) { 51577c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 51587c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51597c478bd9Sstevel@tonic-gate return (error); 51607c478bd9Sstevel@tonic-gate } 51619acbbeafSnn35248 if ((error = i_straccess(stp, access)) != 0) { 51627c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 51637c478bd9Sstevel@tonic-gate releasef( 51647c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, fildes)); 51657c478bd9Sstevel@tonic-gate return (error); 51667c478bd9Sstevel@tonic-gate } 51677c478bd9Sstevel@tonic-gate } 51687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 51697c478bd9Sstevel@tonic-gate 51707c478bd9Sstevel@tonic-gate /* 51717c478bd9Sstevel@tonic-gate * Copy strfdinsert.ctlbuf into native form of 51727c478bd9Sstevel@tonic-gate * ctlbuf to pass down into strmakemsg(). 51737c478bd9Sstevel@tonic-gate */ 51747c478bd9Sstevel@tonic-gate mctl.maxlen = STRUCT_FGET(strfdinsert, ctlbuf.maxlen); 51757c478bd9Sstevel@tonic-gate mctl.len = STRUCT_FGET(strfdinsert, ctlbuf.len); 51767c478bd9Sstevel@tonic-gate mctl.buf = STRUCT_FGETP(strfdinsert, ctlbuf.buf); 51777c478bd9Sstevel@tonic-gate 51787c478bd9Sstevel@tonic-gate iov.iov_base = STRUCT_FGETP(strfdinsert, databuf.buf); 51797c478bd9Sstevel@tonic-gate iov.iov_len = STRUCT_FGET(strfdinsert, databuf.len); 51807c478bd9Sstevel@tonic-gate uio.uio_iov = &iov; 51817c478bd9Sstevel@tonic-gate uio.uio_iovcnt = 1; 51827c478bd9Sstevel@tonic-gate uio.uio_loffset = 0; 51837c478bd9Sstevel@tonic-gate uio.uio_segflg = (copyflag == U_TO_K) ? UIO_USERSPACE : 51847c478bd9Sstevel@tonic-gate UIO_SYSSPACE; 51857c478bd9Sstevel@tonic-gate uio.uio_fmode = 0; 51867c478bd9Sstevel@tonic-gate uio.uio_extflg = UIO_COPY_CACHED; 51877c478bd9Sstevel@tonic-gate uio.uio_resid = iov.iov_len; 51887c478bd9Sstevel@tonic-gate if ((error = strmakemsg(&mctl, 51897c478bd9Sstevel@tonic-gate &msgsize, &uio, stp, 51907c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, flags), &mp)) != 0 || !mp) { 51917c478bd9Sstevel@tonic-gate STRUCT_FSET(strfdinsert, databuf.len, msgsize); 51927c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 51937c478bd9Sstevel@tonic-gate return (error); 51947c478bd9Sstevel@tonic-gate } 51957c478bd9Sstevel@tonic-gate 51967c478bd9Sstevel@tonic-gate STRUCT_FSET(strfdinsert, databuf.len, msgsize); 51977c478bd9Sstevel@tonic-gate 51987c478bd9Sstevel@tonic-gate /* 51997c478bd9Sstevel@tonic-gate * Place the possibly reencoded queue pointer 'offset' bytes 52007c478bd9Sstevel@tonic-gate * from the start of the control portion of the message. 52017c478bd9Sstevel@tonic-gate */ 52027c478bd9Sstevel@tonic-gate *((t_uscalar_t *)(mp->b_rptr + 52037c478bd9Sstevel@tonic-gate STRUCT_FGET(strfdinsert, offset))) = ival; 52047c478bd9Sstevel@tonic-gate 52057c478bd9Sstevel@tonic-gate /* 52067c478bd9Sstevel@tonic-gate * Put message downstream. 52077c478bd9Sstevel@tonic-gate */ 52087c478bd9Sstevel@tonic-gate stream_willservice(stp); 52097c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, mp); 52107c478bd9Sstevel@tonic-gate stream_runservice(stp); 52117c478bd9Sstevel@tonic-gate releasef(STRUCT_FGET(strfdinsert, fildes)); 52127c478bd9Sstevel@tonic-gate return (error); 52137c478bd9Sstevel@tonic-gate } 52147c478bd9Sstevel@tonic-gate 52157c478bd9Sstevel@tonic-gate case I_SENDFD: 52167c478bd9Sstevel@tonic-gate { 52177c478bd9Sstevel@tonic-gate struct file *fp; 52187c478bd9Sstevel@tonic-gate 52197c478bd9Sstevel@tonic-gate if ((fp = getf((int)arg)) == NULL) 52207c478bd9Sstevel@tonic-gate return (EBADF); 52217c478bd9Sstevel@tonic-gate error = do_sendfp(stp, fp, crp); 52227c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 52237c478bd9Sstevel@tonic-gate if (audit_active) { 52247c478bd9Sstevel@tonic-gate audit_fdsend((int)arg, fp, error); 52257c478bd9Sstevel@tonic-gate } 52267c478bd9Sstevel@tonic-gate #endif 52277c478bd9Sstevel@tonic-gate releasef((int)arg); 52287c478bd9Sstevel@tonic-gate return (error); 52297c478bd9Sstevel@tonic-gate } 52307c478bd9Sstevel@tonic-gate 52317c478bd9Sstevel@tonic-gate case I_RECVFD: 52327c478bd9Sstevel@tonic-gate case I_E_RECVFD: 52337c478bd9Sstevel@tonic-gate { 52347c478bd9Sstevel@tonic-gate struct k_strrecvfd *srf; 52357c478bd9Sstevel@tonic-gate int i, fd; 52367c478bd9Sstevel@tonic-gate 52377c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 52387c478bd9Sstevel@tonic-gate while (!(mp = getq(rdq))) { 52397c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRHUP|STREOF)) { 52407c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52417c478bd9Sstevel@tonic-gate return (ENXIO); 52427c478bd9Sstevel@tonic-gate } 52437c478bd9Sstevel@tonic-gate if ((error = strwaitq(stp, GETWAIT, (ssize_t)0, 52447c478bd9Sstevel@tonic-gate flag, -1, &done)) != 0 || done) { 52457c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52467c478bd9Sstevel@tonic-gate return (error); 52477c478bd9Sstevel@tonic-gate } 52489acbbeafSnn35248 if ((error = i_straccess(stp, access)) != 0) { 52497c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52507c478bd9Sstevel@tonic-gate return (error); 52517c478bd9Sstevel@tonic-gate } 52527c478bd9Sstevel@tonic-gate } 52537c478bd9Sstevel@tonic-gate if (mp->b_datap->db_type != M_PASSFP) { 52547c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band); 52557c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52567c478bd9Sstevel@tonic-gate return (EBADMSG); 52577c478bd9Sstevel@tonic-gate } 52587c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52597c478bd9Sstevel@tonic-gate 52607c478bd9Sstevel@tonic-gate srf = (struct k_strrecvfd *)mp->b_rptr; 52617c478bd9Sstevel@tonic-gate if ((fd = ufalloc(0)) == -1) { 52627c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 52637c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band); 52647c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52657c478bd9Sstevel@tonic-gate return (EMFILE); 52667c478bd9Sstevel@tonic-gate } 52677c478bd9Sstevel@tonic-gate if (cmd == I_RECVFD) { 52687c478bd9Sstevel@tonic-gate struct o_strrecvfd ostrfd; 52697c478bd9Sstevel@tonic-gate 52707c478bd9Sstevel@tonic-gate /* check to see if uid/gid values are too large. */ 52717c478bd9Sstevel@tonic-gate 52727c478bd9Sstevel@tonic-gate if (srf->uid > (o_uid_t)USHRT_MAX || 52737c478bd9Sstevel@tonic-gate srf->gid > (o_gid_t)USHRT_MAX) { 52747c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 52757c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band); 52767c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 52777c478bd9Sstevel@tonic-gate setf(fd, NULL); /* release fd entry */ 52787c478bd9Sstevel@tonic-gate return (EOVERFLOW); 52797c478bd9Sstevel@tonic-gate } 52807c478bd9Sstevel@tonic-gate 52817c478bd9Sstevel@tonic-gate ostrfd.fd = fd; 52827c478bd9Sstevel@tonic-gate ostrfd.uid = (o_uid_t)srf->uid; 52837c478bd9Sstevel@tonic-gate ostrfd.gid = (o_gid_t)srf->gid; 52847c478bd9Sstevel@tonic-gate 52857c478bd9Sstevel@tonic-gate /* Null the filler bits */ 52867c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) 52877c478bd9Sstevel@tonic-gate ostrfd.fill[i] = 0; 52887c478bd9Sstevel@tonic-gate 52897c478bd9Sstevel@tonic-gate error = strcopyout(&ostrfd, (void *)arg, 52907c478bd9Sstevel@tonic-gate sizeof (struct o_strrecvfd), copyflag); 52917c478bd9Sstevel@tonic-gate } else { /* I_E_RECVFD */ 52927c478bd9Sstevel@tonic-gate struct strrecvfd strfd; 52937c478bd9Sstevel@tonic-gate 52947c478bd9Sstevel@tonic-gate strfd.fd = fd; 52957c478bd9Sstevel@tonic-gate strfd.uid = srf->uid; 52967c478bd9Sstevel@tonic-gate strfd.gid = srf->gid; 52977c478bd9Sstevel@tonic-gate 52987c478bd9Sstevel@tonic-gate /* null the filler bits */ 52997c478bd9Sstevel@tonic-gate for (i = 0; i < 8; i++) 53007c478bd9Sstevel@tonic-gate strfd.fill[i] = 0; 53017c478bd9Sstevel@tonic-gate 53027c478bd9Sstevel@tonic-gate error = strcopyout(&strfd, (void *)arg, 53037c478bd9Sstevel@tonic-gate sizeof (struct strrecvfd), copyflag); 53047c478bd9Sstevel@tonic-gate } 53057c478bd9Sstevel@tonic-gate 53067c478bd9Sstevel@tonic-gate if (error) { 53077c478bd9Sstevel@tonic-gate setf(fd, NULL); /* release fd entry */ 53087c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 53097c478bd9Sstevel@tonic-gate putback(stp, rdq, mp, mp->b_band); 53107c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 53117c478bd9Sstevel@tonic-gate return (error); 53127c478bd9Sstevel@tonic-gate } 53137c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 53147c478bd9Sstevel@tonic-gate if (audit_active) { 53157c478bd9Sstevel@tonic-gate audit_fdrecv(fd, srf->fp); 53167c478bd9Sstevel@tonic-gate } 53177c478bd9Sstevel@tonic-gate #endif 53187c478bd9Sstevel@tonic-gate 53197c478bd9Sstevel@tonic-gate /* 53207c478bd9Sstevel@tonic-gate * Always increment f_count since the freemsg() below will 53217c478bd9Sstevel@tonic-gate * always call free_passfp() which performs a closef(). 53227c478bd9Sstevel@tonic-gate */ 53237c478bd9Sstevel@tonic-gate mutex_enter(&srf->fp->f_tlock); 53247c478bd9Sstevel@tonic-gate srf->fp->f_count++; 53257c478bd9Sstevel@tonic-gate mutex_exit(&srf->fp->f_tlock); 53267c478bd9Sstevel@tonic-gate setf(fd, srf->fp); 53277c478bd9Sstevel@tonic-gate freemsg(mp); 53287c478bd9Sstevel@tonic-gate return (0); 53297c478bd9Sstevel@tonic-gate } 53307c478bd9Sstevel@tonic-gate 53317c478bd9Sstevel@tonic-gate case I_SWROPT: 53327c478bd9Sstevel@tonic-gate /* 53337c478bd9Sstevel@tonic-gate * Set/clear the write options. arg is a bit 53347c478bd9Sstevel@tonic-gate * mask with any of the following bits set... 53357c478bd9Sstevel@tonic-gate * SNDZERO - send zero length message 53367c478bd9Sstevel@tonic-gate * SNDPIPE - send sigpipe to process if 53377c478bd9Sstevel@tonic-gate * sd_werror is set and process is 53387c478bd9Sstevel@tonic-gate * doing a write or putmsg. 53397c478bd9Sstevel@tonic-gate * The new stream head write options should reflect 53407c478bd9Sstevel@tonic-gate * what is in arg. 53417c478bd9Sstevel@tonic-gate */ 53427c478bd9Sstevel@tonic-gate if (arg & ~(SNDZERO|SNDPIPE)) 53437c478bd9Sstevel@tonic-gate return (EINVAL); 53447c478bd9Sstevel@tonic-gate 53457c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 53467c478bd9Sstevel@tonic-gate stp->sd_wput_opt &= ~(SW_SIGPIPE|SW_SNDZERO); 53477c478bd9Sstevel@tonic-gate if (arg & SNDZERO) 53487c478bd9Sstevel@tonic-gate stp->sd_wput_opt |= SW_SNDZERO; 53497c478bd9Sstevel@tonic-gate if (arg & SNDPIPE) 53507c478bd9Sstevel@tonic-gate stp->sd_wput_opt |= SW_SIGPIPE; 53517c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 53527c478bd9Sstevel@tonic-gate return (0); 53537c478bd9Sstevel@tonic-gate 53547c478bd9Sstevel@tonic-gate case I_GWROPT: 53557c478bd9Sstevel@tonic-gate { 53567c478bd9Sstevel@tonic-gate int wropt = 0; 53577c478bd9Sstevel@tonic-gate 53587c478bd9Sstevel@tonic-gate if (stp->sd_wput_opt & SW_SNDZERO) 53597c478bd9Sstevel@tonic-gate wropt |= SNDZERO; 53607c478bd9Sstevel@tonic-gate if (stp->sd_wput_opt & SW_SIGPIPE) 53617c478bd9Sstevel@tonic-gate wropt |= SNDPIPE; 53627c478bd9Sstevel@tonic-gate return (strcopyout(&wropt, (void *)arg, sizeof (wropt), 53637c478bd9Sstevel@tonic-gate copyflag)); 53647c478bd9Sstevel@tonic-gate } 53657c478bd9Sstevel@tonic-gate 53667c478bd9Sstevel@tonic-gate case I_LIST: 53677c478bd9Sstevel@tonic-gate /* 53687c478bd9Sstevel@tonic-gate * Returns all the modules found on this stream, 53697c478bd9Sstevel@tonic-gate * upto the driver. If argument is NULL, return the 53707c478bd9Sstevel@tonic-gate * number of modules (including driver). If argument 53717c478bd9Sstevel@tonic-gate * is not NULL, copy the names into the structure 53727c478bd9Sstevel@tonic-gate * provided. 53737c478bd9Sstevel@tonic-gate */ 53747c478bd9Sstevel@tonic-gate 53757c478bd9Sstevel@tonic-gate { 53767c478bd9Sstevel@tonic-gate queue_t *q; 53777c478bd9Sstevel@tonic-gate int num_modules, space_allocated; 53787c478bd9Sstevel@tonic-gate STRUCT_DECL(str_list, strlist); 53797c478bd9Sstevel@tonic-gate struct str_mlist *mlist_ptr; 53807c478bd9Sstevel@tonic-gate 53817c478bd9Sstevel@tonic-gate if (arg == NULL) { /* Return number of modules plus driver */ 53827c478bd9Sstevel@tonic-gate q = stp->sd_wrq; 53837c478bd9Sstevel@tonic-gate if (stp->sd_vnode->v_type == VFIFO) { 53847c478bd9Sstevel@tonic-gate *rvalp = stp->sd_pushcnt; 53857c478bd9Sstevel@tonic-gate } else { 53867c478bd9Sstevel@tonic-gate *rvalp = stp->sd_pushcnt + 1; 53877c478bd9Sstevel@tonic-gate } 53887c478bd9Sstevel@tonic-gate } else { 53897c478bd9Sstevel@tonic-gate STRUCT_INIT(strlist, flag); 53907c478bd9Sstevel@tonic-gate 53917c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, STRUCT_BUF(strlist), 53927c478bd9Sstevel@tonic-gate STRUCT_SIZE(strlist), copyflag); 53937c478bd9Sstevel@tonic-gate if (error) 53947c478bd9Sstevel@tonic-gate return (error); 53957c478bd9Sstevel@tonic-gate 53967c478bd9Sstevel@tonic-gate space_allocated = STRUCT_FGET(strlist, sl_nmods); 53977c478bd9Sstevel@tonic-gate if ((space_allocated) <= 0) 53987c478bd9Sstevel@tonic-gate return (EINVAL); 53997c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq); 54007c478bd9Sstevel@tonic-gate q = stp->sd_wrq; 54017c478bd9Sstevel@tonic-gate num_modules = 0; 54027c478bd9Sstevel@tonic-gate while (_SAMESTR(q) && (space_allocated != 0)) { 54037c478bd9Sstevel@tonic-gate char *name = 54047c478bd9Sstevel@tonic-gate q->q_next->q_qinfo->qi_minfo->mi_idname; 54057c478bd9Sstevel@tonic-gate 54067c478bd9Sstevel@tonic-gate mlist_ptr = STRUCT_FGETP(strlist, sl_modlist); 54077c478bd9Sstevel@tonic-gate 54087c478bd9Sstevel@tonic-gate error = strcopyout(name, mlist_ptr, 54097c478bd9Sstevel@tonic-gate strlen(name) + 1, copyflag); 54107c478bd9Sstevel@tonic-gate 54117c478bd9Sstevel@tonic-gate if (error) { 54127c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 54137c478bd9Sstevel@tonic-gate return (error); 54147c478bd9Sstevel@tonic-gate } 54157c478bd9Sstevel@tonic-gate q = q->q_next; 54167c478bd9Sstevel@tonic-gate space_allocated--; 54177c478bd9Sstevel@tonic-gate num_modules++; 54187c478bd9Sstevel@tonic-gate mlist_ptr = 54197c478bd9Sstevel@tonic-gate (struct str_mlist *)((uintptr_t)mlist_ptr + 54207c478bd9Sstevel@tonic-gate sizeof (struct str_mlist)); 54217c478bd9Sstevel@tonic-gate STRUCT_FSETP(strlist, sl_modlist, mlist_ptr); 54227c478bd9Sstevel@tonic-gate } 54237c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 54247c478bd9Sstevel@tonic-gate error = strcopyout(&num_modules, (void *)arg, 54257c478bd9Sstevel@tonic-gate sizeof (int), copyflag); 54267c478bd9Sstevel@tonic-gate } 54277c478bd9Sstevel@tonic-gate return (error); 54287c478bd9Sstevel@tonic-gate } 54297c478bd9Sstevel@tonic-gate 54307c478bd9Sstevel@tonic-gate case I_CKBAND: 54317c478bd9Sstevel@tonic-gate { 54327c478bd9Sstevel@tonic-gate queue_t *q; 54337c478bd9Sstevel@tonic-gate qband_t *qbp; 54347c478bd9Sstevel@tonic-gate 54357c478bd9Sstevel@tonic-gate if ((arg < 0) || (arg >= NBAND)) 54367c478bd9Sstevel@tonic-gate return (EINVAL); 54377c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 54387c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q)); 54397c478bd9Sstevel@tonic-gate if (arg > (int)q->q_nband) { 54407c478bd9Sstevel@tonic-gate *rvalp = 0; 54417c478bd9Sstevel@tonic-gate } else { 54427c478bd9Sstevel@tonic-gate if (arg == 0) { 54437c478bd9Sstevel@tonic-gate if (q->q_first) 54447c478bd9Sstevel@tonic-gate *rvalp = 1; 54457c478bd9Sstevel@tonic-gate else 54467c478bd9Sstevel@tonic-gate *rvalp = 0; 54477c478bd9Sstevel@tonic-gate } else { 54487c478bd9Sstevel@tonic-gate qbp = q->q_bandp; 54497c478bd9Sstevel@tonic-gate while (--arg > 0) 54507c478bd9Sstevel@tonic-gate qbp = qbp->qb_next; 54517c478bd9Sstevel@tonic-gate if (qbp->qb_first) 54527c478bd9Sstevel@tonic-gate *rvalp = 1; 54537c478bd9Sstevel@tonic-gate else 54547c478bd9Sstevel@tonic-gate *rvalp = 0; 54557c478bd9Sstevel@tonic-gate } 54567c478bd9Sstevel@tonic-gate } 54577c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q)); 54587c478bd9Sstevel@tonic-gate return (0); 54597c478bd9Sstevel@tonic-gate } 54607c478bd9Sstevel@tonic-gate 54617c478bd9Sstevel@tonic-gate case I_GETBAND: 54627c478bd9Sstevel@tonic-gate { 54637c478bd9Sstevel@tonic-gate int intpri; 54647c478bd9Sstevel@tonic-gate queue_t *q; 54657c478bd9Sstevel@tonic-gate 54667c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 54677c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q)); 54687c478bd9Sstevel@tonic-gate mp = q->q_first; 54697c478bd9Sstevel@tonic-gate if (!mp) { 54707c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q)); 54717c478bd9Sstevel@tonic-gate return (ENODATA); 54727c478bd9Sstevel@tonic-gate } 54737c478bd9Sstevel@tonic-gate intpri = (int)mp->b_band; 54747c478bd9Sstevel@tonic-gate error = strcopyout(&intpri, (void *)arg, sizeof (int), 54757c478bd9Sstevel@tonic-gate copyflag); 54767c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q)); 54777c478bd9Sstevel@tonic-gate return (error); 54787c478bd9Sstevel@tonic-gate } 54797c478bd9Sstevel@tonic-gate 54807c478bd9Sstevel@tonic-gate case I_ATMARK: 54817c478bd9Sstevel@tonic-gate { 54827c478bd9Sstevel@tonic-gate queue_t *q; 54837c478bd9Sstevel@tonic-gate 54847c478bd9Sstevel@tonic-gate if (arg & ~(ANYMARK|LASTMARK)) 54857c478bd9Sstevel@tonic-gate return (EINVAL); 54867c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 54877c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 54887c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STRATMARK) && (arg == ANYMARK)) { 54897c478bd9Sstevel@tonic-gate *rvalp = 1; 54907c478bd9Sstevel@tonic-gate } else { 54917c478bd9Sstevel@tonic-gate mutex_enter(QLOCK(q)); 54927c478bd9Sstevel@tonic-gate mp = q->q_first; 54937c478bd9Sstevel@tonic-gate 54947c478bd9Sstevel@tonic-gate if (mp == NULL) 54957c478bd9Sstevel@tonic-gate *rvalp = 0; 54967c478bd9Sstevel@tonic-gate else if ((arg == ANYMARK) && (mp->b_flag & MSGMARK)) 54977c478bd9Sstevel@tonic-gate *rvalp = 1; 54987c478bd9Sstevel@tonic-gate else if ((arg == LASTMARK) && (mp == stp->sd_mark)) 54997c478bd9Sstevel@tonic-gate *rvalp = 1; 55007c478bd9Sstevel@tonic-gate else 55017c478bd9Sstevel@tonic-gate *rvalp = 0; 55027c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(q)); 55037c478bd9Sstevel@tonic-gate } 55047c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 55057c478bd9Sstevel@tonic-gate return (0); 55067c478bd9Sstevel@tonic-gate } 55077c478bd9Sstevel@tonic-gate 55087c478bd9Sstevel@tonic-gate case I_CANPUT: 55097c478bd9Sstevel@tonic-gate { 55107c478bd9Sstevel@tonic-gate char band; 55117c478bd9Sstevel@tonic-gate 55127c478bd9Sstevel@tonic-gate if ((arg < 0) || (arg >= NBAND)) 55137c478bd9Sstevel@tonic-gate return (EINVAL); 55147c478bd9Sstevel@tonic-gate band = (char)arg; 55157c478bd9Sstevel@tonic-gate *rvalp = bcanputnext(stp->sd_wrq, band); 55167c478bd9Sstevel@tonic-gate return (0); 55177c478bd9Sstevel@tonic-gate } 55187c478bd9Sstevel@tonic-gate 55197c478bd9Sstevel@tonic-gate case I_SETCLTIME: 55207c478bd9Sstevel@tonic-gate { 55217c478bd9Sstevel@tonic-gate int closetime; 55227c478bd9Sstevel@tonic-gate 55237c478bd9Sstevel@tonic-gate error = strcopyin((void *)arg, &closetime, sizeof (int), 55247c478bd9Sstevel@tonic-gate copyflag); 55257c478bd9Sstevel@tonic-gate if (error) 55267c478bd9Sstevel@tonic-gate return (error); 55277c478bd9Sstevel@tonic-gate if (closetime < 0) 55287c478bd9Sstevel@tonic-gate return (EINVAL); 55297c478bd9Sstevel@tonic-gate 55307c478bd9Sstevel@tonic-gate stp->sd_closetime = closetime; 55317c478bd9Sstevel@tonic-gate return (0); 55327c478bd9Sstevel@tonic-gate } 55337c478bd9Sstevel@tonic-gate 55347c478bd9Sstevel@tonic-gate case I_GETCLTIME: 55357c478bd9Sstevel@tonic-gate { 55367c478bd9Sstevel@tonic-gate int closetime; 55377c478bd9Sstevel@tonic-gate 55387c478bd9Sstevel@tonic-gate closetime = stp->sd_closetime; 55397c478bd9Sstevel@tonic-gate return (strcopyout(&closetime, (void *)arg, sizeof (int), 55407c478bd9Sstevel@tonic-gate copyflag)); 55417c478bd9Sstevel@tonic-gate } 55427c478bd9Sstevel@tonic-gate 55437c478bd9Sstevel@tonic-gate case TIOCGSID: 55447c478bd9Sstevel@tonic-gate { 55457c478bd9Sstevel@tonic-gate pid_t sid; 55467c478bd9Sstevel@tonic-gate 55479acbbeafSnn35248 mutex_enter(&stp->sd_lock); 55487c478bd9Sstevel@tonic-gate if (stp->sd_sidp == NULL) { 55499acbbeafSnn35248 mutex_exit(&stp->sd_lock); 55507c478bd9Sstevel@tonic-gate return (ENOTTY); 55517c478bd9Sstevel@tonic-gate } 55527c478bd9Sstevel@tonic-gate sid = stp->sd_sidp->pid_id; 55539acbbeafSnn35248 mutex_exit(&stp->sd_lock); 55547c478bd9Sstevel@tonic-gate return (strcopyout(&sid, (void *)arg, sizeof (pid_t), 55557c478bd9Sstevel@tonic-gate copyflag)); 55567c478bd9Sstevel@tonic-gate } 55577c478bd9Sstevel@tonic-gate 55587c478bd9Sstevel@tonic-gate case TIOCSPGRP: 55597c478bd9Sstevel@tonic-gate { 55607c478bd9Sstevel@tonic-gate pid_t pgrp; 55617c478bd9Sstevel@tonic-gate proc_t *q; 55627c478bd9Sstevel@tonic-gate pid_t sid, fg_pgid, bg_pgid; 55637c478bd9Sstevel@tonic-gate 55647c478bd9Sstevel@tonic-gate if (error = strcopyin((void *)arg, &pgrp, sizeof (pid_t), 55657c478bd9Sstevel@tonic-gate copyflag)) 55667c478bd9Sstevel@tonic-gate return (error); 55677c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 55687c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 55697c478bd9Sstevel@tonic-gate if (stp->sd_sidp != ttoproc(curthread)->p_sessp->s_sidp) { 55707c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 55717c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 55727c478bd9Sstevel@tonic-gate return (ENOTTY); 55737c478bd9Sstevel@tonic-gate } 55747c478bd9Sstevel@tonic-gate if (pgrp == stp->sd_pgidp->pid_id) { 55757c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 55767c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 55777c478bd9Sstevel@tonic-gate return (0); 55787c478bd9Sstevel@tonic-gate } 55797c478bd9Sstevel@tonic-gate if (pgrp <= 0 || pgrp >= maxpid) { 55807c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 55817c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 55827c478bd9Sstevel@tonic-gate return (EINVAL); 55837c478bd9Sstevel@tonic-gate } 55847c478bd9Sstevel@tonic-gate if ((q = pgfind(pgrp)) == NULL || 55857c478bd9Sstevel@tonic-gate q->p_sessp != ttoproc(curthread)->p_sessp) { 55867c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 55877c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 55887c478bd9Sstevel@tonic-gate return (EPERM); 55897c478bd9Sstevel@tonic-gate } 55907c478bd9Sstevel@tonic-gate sid = stp->sd_sidp->pid_id; 55917c478bd9Sstevel@tonic-gate fg_pgid = q->p_pgrp; 55927c478bd9Sstevel@tonic-gate bg_pgid = stp->sd_pgidp->pid_id; 55937c478bd9Sstevel@tonic-gate CL_SET_PROCESS_GROUP(curthread, sid, bg_pgid, fg_pgid); 55947c478bd9Sstevel@tonic-gate PID_RELE(stp->sd_pgidp); 55959acbbeafSnn35248 ctty_clear_sighuped(); 55967c478bd9Sstevel@tonic-gate stp->sd_pgidp = q->p_pgidp; 55977c478bd9Sstevel@tonic-gate PID_HOLD(stp->sd_pgidp); 55987c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 55997c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 56007c478bd9Sstevel@tonic-gate return (0); 56017c478bd9Sstevel@tonic-gate } 56027c478bd9Sstevel@tonic-gate 56037c478bd9Sstevel@tonic-gate case TIOCGPGRP: 56047c478bd9Sstevel@tonic-gate { 56057c478bd9Sstevel@tonic-gate pid_t pgrp; 56067c478bd9Sstevel@tonic-gate 56079acbbeafSnn35248 mutex_enter(&stp->sd_lock); 56087c478bd9Sstevel@tonic-gate if (stp->sd_sidp == NULL) { 56099acbbeafSnn35248 mutex_exit(&stp->sd_lock); 56107c478bd9Sstevel@tonic-gate return (ENOTTY); 56117c478bd9Sstevel@tonic-gate } 56127c478bd9Sstevel@tonic-gate pgrp = stp->sd_pgidp->pid_id; 56139acbbeafSnn35248 mutex_exit(&stp->sd_lock); 56147c478bd9Sstevel@tonic-gate return (strcopyout(&pgrp, (void *)arg, sizeof (pid_t), 56157c478bd9Sstevel@tonic-gate copyflag)); 56167c478bd9Sstevel@tonic-gate } 56177c478bd9Sstevel@tonic-gate 56189acbbeafSnn35248 case TIOCSCTTY: 56199acbbeafSnn35248 { 56209acbbeafSnn35248 return (strctty(stp)); 56219acbbeafSnn35248 } 56229acbbeafSnn35248 56239acbbeafSnn35248 case TIOCNOTTY: 56249acbbeafSnn35248 { 56259acbbeafSnn35248 /* freectty() always assumes curproc. */ 56269acbbeafSnn35248 if (freectty(B_FALSE) != 0) 56279acbbeafSnn35248 return (0); 56289acbbeafSnn35248 return (ENOTTY); 56299acbbeafSnn35248 } 56309acbbeafSnn35248 56317c478bd9Sstevel@tonic-gate case FIONBIO: 56327c478bd9Sstevel@tonic-gate case FIOASYNC: 56337c478bd9Sstevel@tonic-gate return (0); /* handled by the upper layer */ 56347c478bd9Sstevel@tonic-gate } 56357c478bd9Sstevel@tonic-gate } 56367c478bd9Sstevel@tonic-gate 56377c478bd9Sstevel@tonic-gate /* 56387c478bd9Sstevel@tonic-gate * Custom free routine used for M_PASSFP messages. 56397c478bd9Sstevel@tonic-gate */ 56407c478bd9Sstevel@tonic-gate static void 56417c478bd9Sstevel@tonic-gate free_passfp(struct k_strrecvfd *srf) 56427c478bd9Sstevel@tonic-gate { 56437c478bd9Sstevel@tonic-gate (void) closef(srf->fp); 56447c478bd9Sstevel@tonic-gate kmem_free(srf, sizeof (struct k_strrecvfd) + sizeof (frtn_t)); 56457c478bd9Sstevel@tonic-gate } 56467c478bd9Sstevel@tonic-gate 56477c478bd9Sstevel@tonic-gate /* ARGSUSED */ 56487c478bd9Sstevel@tonic-gate int 56497c478bd9Sstevel@tonic-gate do_sendfp(struct stdata *stp, struct file *fp, struct cred *cr) 56507c478bd9Sstevel@tonic-gate { 56517c478bd9Sstevel@tonic-gate queue_t *qp, *nextqp; 56527c478bd9Sstevel@tonic-gate struct k_strrecvfd *srf; 56537c478bd9Sstevel@tonic-gate mblk_t *mp; 56547c478bd9Sstevel@tonic-gate frtn_t *frtnp; 56557c478bd9Sstevel@tonic-gate size_t bufsize; 56567c478bd9Sstevel@tonic-gate queue_t *mate = NULL; 56577c478bd9Sstevel@tonic-gate syncq_t *sq = NULL; 56587c478bd9Sstevel@tonic-gate int retval = 0; 56597c478bd9Sstevel@tonic-gate 56607c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRHUP) 56617c478bd9Sstevel@tonic-gate return (ENXIO); 56627c478bd9Sstevel@tonic-gate 56637c478bd9Sstevel@tonic-gate claimstr(stp->sd_wrq); 56647c478bd9Sstevel@tonic-gate 56657c478bd9Sstevel@tonic-gate /* Fastpath, we have a pipe, and we are already mated, use it. */ 56667c478bd9Sstevel@tonic-gate if (STRMATED(stp)) { 56677c478bd9Sstevel@tonic-gate qp = _RD(stp->sd_mate->sd_wrq); 56687c478bd9Sstevel@tonic-gate claimstr(qp); 56697c478bd9Sstevel@tonic-gate mate = qp; 56707c478bd9Sstevel@tonic-gate } else { /* Not already mated. */ 56717c478bd9Sstevel@tonic-gate 56727c478bd9Sstevel@tonic-gate /* 56737c478bd9Sstevel@tonic-gate * Walk the stream to the end of this one. 56747c478bd9Sstevel@tonic-gate * assumes that the claimstr() will prevent 56757c478bd9Sstevel@tonic-gate * plumbing between the stream head and the 56767c478bd9Sstevel@tonic-gate * driver from changing 56777c478bd9Sstevel@tonic-gate */ 56787c478bd9Sstevel@tonic-gate qp = stp->sd_wrq; 56797c478bd9Sstevel@tonic-gate 56807c478bd9Sstevel@tonic-gate /* 56817c478bd9Sstevel@tonic-gate * Loop until we reach the end of this stream. 56827c478bd9Sstevel@tonic-gate * On completion, qp points to the write queue 56837c478bd9Sstevel@tonic-gate * at the end of the stream, or the read queue 56847c478bd9Sstevel@tonic-gate * at the stream head if this is a fifo. 56857c478bd9Sstevel@tonic-gate */ 56867c478bd9Sstevel@tonic-gate while (((qp = qp->q_next) != NULL) && _SAMESTR(qp)) 56877c478bd9Sstevel@tonic-gate ; 56887c478bd9Sstevel@tonic-gate 56897c478bd9Sstevel@tonic-gate /* 56907c478bd9Sstevel@tonic-gate * Just in case we get a q_next which is NULL, but 56917c478bd9Sstevel@tonic-gate * not at the end of the stream. This is actually 56927c478bd9Sstevel@tonic-gate * broken, so we set an assert to catch it in 56937c478bd9Sstevel@tonic-gate * debug, and set an error and return if not debug. 56947c478bd9Sstevel@tonic-gate */ 56957c478bd9Sstevel@tonic-gate ASSERT(qp); 56967c478bd9Sstevel@tonic-gate if (qp == NULL) { 56977c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 56987c478bd9Sstevel@tonic-gate return (EINVAL); 56997c478bd9Sstevel@tonic-gate } 57007c478bd9Sstevel@tonic-gate 57017c478bd9Sstevel@tonic-gate /* 57027c478bd9Sstevel@tonic-gate * Enter the syncq for the driver, so (hopefully) 57037c478bd9Sstevel@tonic-gate * the queue values will not change on us. 57047c478bd9Sstevel@tonic-gate * XXXX - This will only prevent the race IFF only 57057c478bd9Sstevel@tonic-gate * the write side modifies the q_next member, and 57067c478bd9Sstevel@tonic-gate * the put procedure is protected by at least 57077c478bd9Sstevel@tonic-gate * MT_PERQ. 57087c478bd9Sstevel@tonic-gate */ 57097c478bd9Sstevel@tonic-gate if ((sq = qp->q_syncq) != NULL) 57107c478bd9Sstevel@tonic-gate entersq(sq, SQ_PUT); 57117c478bd9Sstevel@tonic-gate 57127c478bd9Sstevel@tonic-gate /* Now get the q_next value from this qp. */ 57137c478bd9Sstevel@tonic-gate nextqp = qp->q_next; 57147c478bd9Sstevel@tonic-gate 57157c478bd9Sstevel@tonic-gate /* 57167c478bd9Sstevel@tonic-gate * If nextqp exists and the other stream is different 57177c478bd9Sstevel@tonic-gate * from this one claim the stream, set the mate, and 57187c478bd9Sstevel@tonic-gate * get the read queue at the stream head of the other 57197c478bd9Sstevel@tonic-gate * stream. Assumes that nextqp was at least valid when 57207c478bd9Sstevel@tonic-gate * we got it. Hopefully the entersq of the driver 57217c478bd9Sstevel@tonic-gate * will prevent it from changing on us. 57227c478bd9Sstevel@tonic-gate */ 57237c478bd9Sstevel@tonic-gate if ((nextqp != NULL) && (STREAM(nextqp) != stp)) { 57247c478bd9Sstevel@tonic-gate ASSERT(qp->q_qinfo->qi_srvp); 57257c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(qp)->q_qinfo->qi_srvp); 57267c478bd9Sstevel@tonic-gate ASSERT(_OTHERQ(qp->q_next)->q_qinfo->qi_srvp); 57277c478bd9Sstevel@tonic-gate claimstr(nextqp); 57287c478bd9Sstevel@tonic-gate 57297c478bd9Sstevel@tonic-gate /* Make sure we still have a q_next */ 57307c478bd9Sstevel@tonic-gate if (nextqp != qp->q_next) { 57317c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 57327c478bd9Sstevel@tonic-gate releasestr(nextqp); 57337c478bd9Sstevel@tonic-gate return (EINVAL); 57347c478bd9Sstevel@tonic-gate } 57357c478bd9Sstevel@tonic-gate 57367c478bd9Sstevel@tonic-gate qp = _RD(STREAM(nextqp)->sd_wrq); 57377c478bd9Sstevel@tonic-gate mate = qp; 57387c478bd9Sstevel@tonic-gate } 57397c478bd9Sstevel@tonic-gate /* If we entered the synq above, leave it. */ 57407c478bd9Sstevel@tonic-gate if (sq != NULL) 57417c478bd9Sstevel@tonic-gate leavesq(sq, SQ_PUT); 57427c478bd9Sstevel@tonic-gate } /* STRMATED(STP) */ 57437c478bd9Sstevel@tonic-gate 57447c478bd9Sstevel@tonic-gate /* XXX prevents substitution of the ops vector */ 57457c478bd9Sstevel@tonic-gate if (qp->q_qinfo != &strdata && qp->q_qinfo != &fifo_strdata) { 57467c478bd9Sstevel@tonic-gate retval = EINVAL; 57477c478bd9Sstevel@tonic-gate goto out; 57487c478bd9Sstevel@tonic-gate } 57497c478bd9Sstevel@tonic-gate 57507c478bd9Sstevel@tonic-gate if (qp->q_flag & QFULL) { 57517c478bd9Sstevel@tonic-gate retval = EAGAIN; 57527c478bd9Sstevel@tonic-gate goto out; 57537c478bd9Sstevel@tonic-gate } 57547c478bd9Sstevel@tonic-gate 57557c478bd9Sstevel@tonic-gate /* 57567c478bd9Sstevel@tonic-gate * Since M_PASSFP messages include a file descriptor, we use 57577c478bd9Sstevel@tonic-gate * esballoc() and specify a custom free routine (free_passfp()) that 57587c478bd9Sstevel@tonic-gate * will close the descriptor as part of freeing the message. For 57597c478bd9Sstevel@tonic-gate * convenience, we stash the frtn_t right after the data block. 57607c478bd9Sstevel@tonic-gate */ 57617c478bd9Sstevel@tonic-gate bufsize = sizeof (struct k_strrecvfd) + sizeof (frtn_t); 57627c478bd9Sstevel@tonic-gate srf = kmem_alloc(bufsize, KM_NOSLEEP); 57637c478bd9Sstevel@tonic-gate if (srf == NULL) { 57647c478bd9Sstevel@tonic-gate retval = EAGAIN; 57657c478bd9Sstevel@tonic-gate goto out; 57667c478bd9Sstevel@tonic-gate } 57677c478bd9Sstevel@tonic-gate 57687c478bd9Sstevel@tonic-gate frtnp = (frtn_t *)(srf + 1); 57697c478bd9Sstevel@tonic-gate frtnp->free_arg = (caddr_t)srf; 57707c478bd9Sstevel@tonic-gate frtnp->free_func = free_passfp; 57717c478bd9Sstevel@tonic-gate 57727c478bd9Sstevel@tonic-gate mp = esballoc((uchar_t *)srf, bufsize, BPRI_MED, frtnp); 57737c478bd9Sstevel@tonic-gate if (mp == NULL) { 57747c478bd9Sstevel@tonic-gate kmem_free(srf, bufsize); 57757c478bd9Sstevel@tonic-gate retval = EAGAIN; 57767c478bd9Sstevel@tonic-gate goto out; 57777c478bd9Sstevel@tonic-gate } 57787c478bd9Sstevel@tonic-gate mp->b_wptr += sizeof (struct k_strrecvfd); 57797c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_PASSFP; 57807c478bd9Sstevel@tonic-gate 57817c478bd9Sstevel@tonic-gate srf->fp = fp; 57827c478bd9Sstevel@tonic-gate srf->uid = crgetuid(curthread->t_cred); 57837c478bd9Sstevel@tonic-gate srf->gid = crgetgid(curthread->t_cred); 57847c478bd9Sstevel@tonic-gate mutex_enter(&fp->f_tlock); 57857c478bd9Sstevel@tonic-gate fp->f_count++; 57867c478bd9Sstevel@tonic-gate mutex_exit(&fp->f_tlock); 57877c478bd9Sstevel@tonic-gate 57887c478bd9Sstevel@tonic-gate put(qp, mp); 57897c478bd9Sstevel@tonic-gate out: 57907c478bd9Sstevel@tonic-gate releasestr(stp->sd_wrq); 57917c478bd9Sstevel@tonic-gate if (mate) 57927c478bd9Sstevel@tonic-gate releasestr(mate); 57937c478bd9Sstevel@tonic-gate return (retval); 57947c478bd9Sstevel@tonic-gate } 57957c478bd9Sstevel@tonic-gate 57967c478bd9Sstevel@tonic-gate /* 57977c478bd9Sstevel@tonic-gate * Send an ioctl message downstream and wait for acknowledgement. 57987c478bd9Sstevel@tonic-gate * flags may be set to either U_TO_K or K_TO_K and a combination 57997c478bd9Sstevel@tonic-gate * of STR_NOERROR or STR_NOSIG 58007c478bd9Sstevel@tonic-gate * STR_NOSIG: Signals are essentially ignored or held and have 58017c478bd9Sstevel@tonic-gate * no effect for the duration of the call. 58027c478bd9Sstevel@tonic-gate * STR_NOERROR: Ignores stream head read, write and hup errors. 58037c478bd9Sstevel@tonic-gate * Additionally, if an existing ioctl times out, it is assumed 58047c478bd9Sstevel@tonic-gate * lost and and this ioctl will continue as if the previous ioctl had 58057c478bd9Sstevel@tonic-gate * finished. ETIME may be returned if this ioctl times out (i.e. 58067c478bd9Sstevel@tonic-gate * ic_timout is not INFTIM). Non-stream head errors may be returned if 58077c478bd9Sstevel@tonic-gate * the ioc_error indicates that the driver/module had problems, 58087c478bd9Sstevel@tonic-gate * an EFAULT was found when accessing user data, a lack of 58097c478bd9Sstevel@tonic-gate * resources, etc. 58107c478bd9Sstevel@tonic-gate */ 58117c478bd9Sstevel@tonic-gate int 58127c478bd9Sstevel@tonic-gate strdoioctl( 58137c478bd9Sstevel@tonic-gate struct stdata *stp, 58147c478bd9Sstevel@tonic-gate struct strioctl *strioc, 58157c478bd9Sstevel@tonic-gate int fflags, /* file flags with model info */ 58167c478bd9Sstevel@tonic-gate int flag, 58177c478bd9Sstevel@tonic-gate cred_t *crp, 58187c478bd9Sstevel@tonic-gate int *rvalp) 58197c478bd9Sstevel@tonic-gate { 58207c478bd9Sstevel@tonic-gate mblk_t *bp; 58217c478bd9Sstevel@tonic-gate struct iocblk *iocbp; 58227c478bd9Sstevel@tonic-gate struct copyreq *reqp; 58237c478bd9Sstevel@tonic-gate struct copyresp *resp; 58247c478bd9Sstevel@tonic-gate int id; 58257c478bd9Sstevel@tonic-gate int transparent = 0; 58267c478bd9Sstevel@tonic-gate int error = 0; 58277c478bd9Sstevel@tonic-gate int len = 0; 58287c478bd9Sstevel@tonic-gate caddr_t taddr; 58297c478bd9Sstevel@tonic-gate int copyflag = (flag & (U_TO_K | K_TO_K)); 58307c478bd9Sstevel@tonic-gate int sigflag = (flag & STR_NOSIG); 58317c478bd9Sstevel@tonic-gate int errs; 58327c478bd9Sstevel@tonic-gate uint_t waitflags; 58337c478bd9Sstevel@tonic-gate 58347c478bd9Sstevel@tonic-gate ASSERT(copyflag == U_TO_K || copyflag == K_TO_K); 58357c478bd9Sstevel@tonic-gate ASSERT((fflags & FMODELS) != 0); 58367c478bd9Sstevel@tonic-gate 58377c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, 58387c478bd9Sstevel@tonic-gate TR_STRDOIOCTL, 58397c478bd9Sstevel@tonic-gate "strdoioctl:stp %p strioc %p", stp, strioc); 58407c478bd9Sstevel@tonic-gate if (strioc->ic_len == TRANSPARENT) { /* send arg in M_DATA block */ 58417c478bd9Sstevel@tonic-gate transparent = 1; 58427c478bd9Sstevel@tonic-gate strioc->ic_len = sizeof (intptr_t); 58437c478bd9Sstevel@tonic-gate } 58447c478bd9Sstevel@tonic-gate 58457c478bd9Sstevel@tonic-gate if (strioc->ic_len < 0 || (strmsgsz > 0 && strioc->ic_len > strmsgsz)) 58467c478bd9Sstevel@tonic-gate return (EINVAL); 58477c478bd9Sstevel@tonic-gate 58487c478bd9Sstevel@tonic-gate if ((bp = allocb_cred_wait(sizeof (union ioctypes), sigflag, &error, 58497c478bd9Sstevel@tonic-gate crp)) == NULL) 58507c478bd9Sstevel@tonic-gate return (error); 58517c478bd9Sstevel@tonic-gate 58527c478bd9Sstevel@tonic-gate bzero(bp->b_wptr, sizeof (union ioctypes)); 58537c478bd9Sstevel@tonic-gate 58547c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_wptr; 58557c478bd9Sstevel@tonic-gate iocbp->ioc_count = strioc->ic_len; 58567c478bd9Sstevel@tonic-gate iocbp->ioc_cmd = strioc->ic_cmd; 58577c478bd9Sstevel@tonic-gate iocbp->ioc_flag = (fflags & FMODELS); 58587c478bd9Sstevel@tonic-gate 58597c478bd9Sstevel@tonic-gate crhold(crp); 58607c478bd9Sstevel@tonic-gate iocbp->ioc_cr = crp; 58617c478bd9Sstevel@tonic-gate DB_TYPE(bp) = M_IOCTL; 58627c478bd9Sstevel@tonic-gate DB_CPID(bp) = curproc->p_pid; 58637c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (struct iocblk); 58647c478bd9Sstevel@tonic-gate 58657c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR) 58667c478bd9Sstevel@tonic-gate errs = STPLEX; 58677c478bd9Sstevel@tonic-gate else 58687c478bd9Sstevel@tonic-gate errs = STRHUP|STRDERR|STWRERR|STPLEX; 58697c478bd9Sstevel@tonic-gate 58707c478bd9Sstevel@tonic-gate /* 58717c478bd9Sstevel@tonic-gate * If there is data to copy into ioctl block, do so. 58727c478bd9Sstevel@tonic-gate */ 58737c478bd9Sstevel@tonic-gate if (iocbp->ioc_count > 0) { 58747c478bd9Sstevel@tonic-gate if (transparent) 58757c478bd9Sstevel@tonic-gate /* 58767c478bd9Sstevel@tonic-gate * Note: STR_NOERROR does not have an effect 58777c478bd9Sstevel@tonic-gate * in putiocd() 58787c478bd9Sstevel@tonic-gate */ 58797c478bd9Sstevel@tonic-gate id = K_TO_K | sigflag; 58807c478bd9Sstevel@tonic-gate else 58817c478bd9Sstevel@tonic-gate id = flag; 58827c478bd9Sstevel@tonic-gate if ((error = putiocd(bp, strioc->ic_dp, id, crp)) != 0) { 58837c478bd9Sstevel@tonic-gate freemsg(bp); 58847c478bd9Sstevel@tonic-gate crfree(crp); 58857c478bd9Sstevel@tonic-gate return (error); 58867c478bd9Sstevel@tonic-gate } 58877c478bd9Sstevel@tonic-gate 58887c478bd9Sstevel@tonic-gate /* 58897c478bd9Sstevel@tonic-gate * We could have slept copying in user pages. 58907c478bd9Sstevel@tonic-gate * Recheck the stream head state (the other end 58917c478bd9Sstevel@tonic-gate * of a pipe could have gone away). 58927c478bd9Sstevel@tonic-gate */ 58937c478bd9Sstevel@tonic-gate if (stp->sd_flag & errs) { 58947c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 58957c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0); 58967c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 58977c478bd9Sstevel@tonic-gate if (error != 0) { 58987c478bd9Sstevel@tonic-gate freemsg(bp); 58997c478bd9Sstevel@tonic-gate crfree(crp); 59007c478bd9Sstevel@tonic-gate return (error); 59017c478bd9Sstevel@tonic-gate } 59027c478bd9Sstevel@tonic-gate } 59037c478bd9Sstevel@tonic-gate } 59047c478bd9Sstevel@tonic-gate if (transparent) 59057c478bd9Sstevel@tonic-gate iocbp->ioc_count = TRANSPARENT; 59067c478bd9Sstevel@tonic-gate 59077c478bd9Sstevel@tonic-gate /* 59087c478bd9Sstevel@tonic-gate * Block for up to STRTIMOUT milliseconds if there is an outstanding 59097c478bd9Sstevel@tonic-gate * ioctl for this stream already running. All processes 59107c478bd9Sstevel@tonic-gate * sleeping here will be awakened as a result of an ACK 59117c478bd9Sstevel@tonic-gate * or NAK being received for the outstanding ioctl, or 59127c478bd9Sstevel@tonic-gate * as a result of the timer expiring on the outstanding 59137c478bd9Sstevel@tonic-gate * ioctl (a failure), or as a result of any waiting 59147c478bd9Sstevel@tonic-gate * process's timer expiring (also a failure). 59157c478bd9Sstevel@tonic-gate */ 59167c478bd9Sstevel@tonic-gate 59177c478bd9Sstevel@tonic-gate error = 0; 59187c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 59197c478bd9Sstevel@tonic-gate while (stp->sd_flag & (IOCWAIT | IOCWAITNE)) { 59207c478bd9Sstevel@tonic-gate clock_t cv_rval; 59217c478bd9Sstevel@tonic-gate 59227c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR, 59237c478bd9Sstevel@tonic-gate TR_STRDOIOCTL_WAIT, 59247c478bd9Sstevel@tonic-gate "strdoioctl sleeps - IOCWAIT"); 59257c478bd9Sstevel@tonic-gate cv_rval = str_cv_wait(&stp->sd_iocmonitor, &stp->sd_lock, 59267c478bd9Sstevel@tonic-gate STRTIMOUT, sigflag); 59277c478bd9Sstevel@tonic-gate if (cv_rval <= 0) { 59287c478bd9Sstevel@tonic-gate if (cv_rval == 0) { 59297c478bd9Sstevel@tonic-gate error = EINTR; 59307c478bd9Sstevel@tonic-gate } else { 59317c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR) { 59327c478bd9Sstevel@tonic-gate /* 59337c478bd9Sstevel@tonic-gate * Terminating current ioctl in 59347c478bd9Sstevel@tonic-gate * progress -- assume it got lost and 59357c478bd9Sstevel@tonic-gate * wake up the other thread so that the 59367c478bd9Sstevel@tonic-gate * operation completes. 59377c478bd9Sstevel@tonic-gate */ 59387c478bd9Sstevel@tonic-gate if (!(stp->sd_flag & IOCWAITNE)) { 59397c478bd9Sstevel@tonic-gate stp->sd_flag |= IOCWAITNE; 59407c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_monitor); 59417c478bd9Sstevel@tonic-gate } 59427c478bd9Sstevel@tonic-gate /* 59437c478bd9Sstevel@tonic-gate * Otherwise, there's a running 59447c478bd9Sstevel@tonic-gate * STR_NOERROR -- we have no choice 59457c478bd9Sstevel@tonic-gate * here but to wait forever (or until 59467c478bd9Sstevel@tonic-gate * interrupted). 59477c478bd9Sstevel@tonic-gate */ 59487c478bd9Sstevel@tonic-gate } else { 59497c478bd9Sstevel@tonic-gate /* 59507c478bd9Sstevel@tonic-gate * pending ioctl has caused 59517c478bd9Sstevel@tonic-gate * us to time out 59527c478bd9Sstevel@tonic-gate */ 59537c478bd9Sstevel@tonic-gate error = ETIME; 59547c478bd9Sstevel@tonic-gate } 59557c478bd9Sstevel@tonic-gate } 59567c478bd9Sstevel@tonic-gate } else if ((stp->sd_flag & errs)) { 59577c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0); 59587c478bd9Sstevel@tonic-gate } 59597c478bd9Sstevel@tonic-gate if (error) { 59607c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 59617c478bd9Sstevel@tonic-gate freemsg(bp); 59627c478bd9Sstevel@tonic-gate crfree(crp); 59637c478bd9Sstevel@tonic-gate return (error); 59647c478bd9Sstevel@tonic-gate } 59657c478bd9Sstevel@tonic-gate } 59667c478bd9Sstevel@tonic-gate 59677c478bd9Sstevel@tonic-gate /* 59687c478bd9Sstevel@tonic-gate * Have control of ioctl mechanism. 59697c478bd9Sstevel@tonic-gate * Send down ioctl packet and wait for response. 59707c478bd9Sstevel@tonic-gate */ 59717c478bd9Sstevel@tonic-gate if (stp->sd_iocblk != (mblk_t *)-1) { 59727c478bd9Sstevel@tonic-gate freemsg(stp->sd_iocblk); 59737c478bd9Sstevel@tonic-gate } 59747c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL; 59757c478bd9Sstevel@tonic-gate 59767c478bd9Sstevel@tonic-gate /* 59777c478bd9Sstevel@tonic-gate * If this is marked with 'noerror' (internal; mostly 59787c478bd9Sstevel@tonic-gate * I_{P,}{UN,}LINK), then make sure nobody else is able to get 59797c478bd9Sstevel@tonic-gate * in here by setting IOCWAITNE. 59807c478bd9Sstevel@tonic-gate */ 59817c478bd9Sstevel@tonic-gate waitflags = IOCWAIT; 59827c478bd9Sstevel@tonic-gate if (flag & STR_NOERROR) 59837c478bd9Sstevel@tonic-gate waitflags |= IOCWAITNE; 59847c478bd9Sstevel@tonic-gate 59857c478bd9Sstevel@tonic-gate stp->sd_flag |= waitflags; 59867c478bd9Sstevel@tonic-gate 59877c478bd9Sstevel@tonic-gate /* 59887c478bd9Sstevel@tonic-gate * Assign sequence number. 59897c478bd9Sstevel@tonic-gate */ 59907c478bd9Sstevel@tonic-gate iocbp->ioc_id = stp->sd_iocid = getiocseqno(); 59917c478bd9Sstevel@tonic-gate 59927c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 59937c478bd9Sstevel@tonic-gate 59947c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 59957c478bd9Sstevel@tonic-gate TR_STRDOIOCTL_PUT, "strdoioctl put: stp %p", stp); 59967c478bd9Sstevel@tonic-gate stream_willservice(stp); 59977c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp); 59987c478bd9Sstevel@tonic-gate stream_runservice(stp); 59997c478bd9Sstevel@tonic-gate 60007c478bd9Sstevel@tonic-gate /* 60017c478bd9Sstevel@tonic-gate * Timed wait for acknowledgment. The wait time is limited by the 60027c478bd9Sstevel@tonic-gate * timeout value, which must be a positive integer (number of 6003c28749e9Skais * milliseconds) to wait, or 0 (use default value of STRTIMOUT 60047c478bd9Sstevel@tonic-gate * milliseconds), or -1 (wait forever). This will be awakened 60057c478bd9Sstevel@tonic-gate * either by an ACK/NAK message arriving, the timer expiring, or 60067c478bd9Sstevel@tonic-gate * the timer expiring on another ioctl waiting for control of the 60077c478bd9Sstevel@tonic-gate * mechanism. 60087c478bd9Sstevel@tonic-gate */ 60097c478bd9Sstevel@tonic-gate waitioc: 60107c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 60117c478bd9Sstevel@tonic-gate 60127c478bd9Sstevel@tonic-gate 60137c478bd9Sstevel@tonic-gate /* 60147c478bd9Sstevel@tonic-gate * If the reply has already arrived, don't sleep. If awakened from 60157c478bd9Sstevel@tonic-gate * the sleep, fail only if the reply has not arrived by then. 60167c478bd9Sstevel@tonic-gate * Otherwise, process the reply. 60177c478bd9Sstevel@tonic-gate */ 60187c478bd9Sstevel@tonic-gate while (!stp->sd_iocblk) { 60197c478bd9Sstevel@tonic-gate clock_t cv_rval; 60207c478bd9Sstevel@tonic-gate 60217c478bd9Sstevel@tonic-gate if (stp->sd_flag & errs) { 60227c478bd9Sstevel@tonic-gate error = strgeterr(stp, errs, 0); 60237c478bd9Sstevel@tonic-gate if (error != 0) { 60247c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 60257c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 60267c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 60277c478bd9Sstevel@tonic-gate crfree(crp); 60287c478bd9Sstevel@tonic-gate return (error); 60297c478bd9Sstevel@tonic-gate } 60307c478bd9Sstevel@tonic-gate } 60317c478bd9Sstevel@tonic-gate 60327c478bd9Sstevel@tonic-gate TRACE_0(TR_FAC_STREAMS_FR, 60337c478bd9Sstevel@tonic-gate TR_STRDOIOCTL_WAIT2, 60347c478bd9Sstevel@tonic-gate "strdoioctl sleeps awaiting reply"); 60357c478bd9Sstevel@tonic-gate ASSERT(error == 0); 60367c478bd9Sstevel@tonic-gate 60377c478bd9Sstevel@tonic-gate cv_rval = str_cv_wait(&stp->sd_monitor, &stp->sd_lock, 60387c478bd9Sstevel@tonic-gate (strioc->ic_timout ? 60397c478bd9Sstevel@tonic-gate strioc->ic_timout * 1000 : STRTIMOUT), sigflag); 60407c478bd9Sstevel@tonic-gate 60417c478bd9Sstevel@tonic-gate /* 60427c478bd9Sstevel@tonic-gate * There are four possible cases here: interrupt, timeout, 60437c478bd9Sstevel@tonic-gate * wakeup by IOCWAITNE (above), or wakeup by strrput_nondata (a 60447c478bd9Sstevel@tonic-gate * valid M_IOCTL reply). 60457c478bd9Sstevel@tonic-gate * 60467c478bd9Sstevel@tonic-gate * If we've been awakened by a STR_NOERROR ioctl on some other 60477c478bd9Sstevel@tonic-gate * thread, then sd_iocblk will still be NULL, and IOCWAITNE 60487c478bd9Sstevel@tonic-gate * will be set. Pretend as if we just timed out. Note that 60497c478bd9Sstevel@tonic-gate * this other thread waited at least STRTIMOUT before trying to 60507c478bd9Sstevel@tonic-gate * awaken our thread, so this is indistinguishable (even for 60517c478bd9Sstevel@tonic-gate * INFTIM) from the case where we failed with ETIME waiting on 60527c478bd9Sstevel@tonic-gate * IOCWAIT in the prior loop. 60537c478bd9Sstevel@tonic-gate */ 60547c478bd9Sstevel@tonic-gate if (cv_rval > 0 && !(flag & STR_NOERROR) && 60557c478bd9Sstevel@tonic-gate stp->sd_iocblk == NULL && (stp->sd_flag & IOCWAITNE)) { 60567c478bd9Sstevel@tonic-gate cv_rval = -1; 60577c478bd9Sstevel@tonic-gate } 60587c478bd9Sstevel@tonic-gate 60597c478bd9Sstevel@tonic-gate /* 60607c478bd9Sstevel@tonic-gate * note: STR_NOERROR does not protect 60617c478bd9Sstevel@tonic-gate * us here.. use ic_timout < 0 60627c478bd9Sstevel@tonic-gate */ 60637c478bd9Sstevel@tonic-gate if (cv_rval <= 0) { 60647c478bd9Sstevel@tonic-gate if (cv_rval == 0) { 60657c478bd9Sstevel@tonic-gate error = EINTR; 60667c478bd9Sstevel@tonic-gate } else { 60677c478bd9Sstevel@tonic-gate error = ETIME; 60687c478bd9Sstevel@tonic-gate } 60697c478bd9Sstevel@tonic-gate /* 60707c478bd9Sstevel@tonic-gate * A message could have come in after we were scheduled 60717c478bd9Sstevel@tonic-gate * but before we were actually run. 60727c478bd9Sstevel@tonic-gate */ 60737c478bd9Sstevel@tonic-gate bp = stp->sd_iocblk; 60747c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL; 60757c478bd9Sstevel@tonic-gate if (bp != NULL) { 60767c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_COPYIN) || 60777c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_COPYOUT)) { 60787c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 60797c478bd9Sstevel@tonic-gate if (bp->b_cont) { 60807c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 60817c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 60827c478bd9Sstevel@tonic-gate } 60837c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA; 60847c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + 60857c478bd9Sstevel@tonic-gate sizeof (struct copyresp); 60867c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr; 60877c478bd9Sstevel@tonic-gate resp->cp_rval = 60887c478bd9Sstevel@tonic-gate (caddr_t)1; /* failure */ 60897c478bd9Sstevel@tonic-gate stream_willservice(stp); 60907c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp); 60917c478bd9Sstevel@tonic-gate stream_runservice(stp); 60927c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 60937c478bd9Sstevel@tonic-gate } else { 60947c478bd9Sstevel@tonic-gate freemsg(bp); 60957c478bd9Sstevel@tonic-gate } 60967c478bd9Sstevel@tonic-gate } 60977c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 60987c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 60997c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 61007c478bd9Sstevel@tonic-gate crfree(crp); 61017c478bd9Sstevel@tonic-gate return (error); 61027c478bd9Sstevel@tonic-gate } 61037c478bd9Sstevel@tonic-gate } 61047c478bd9Sstevel@tonic-gate bp = stp->sd_iocblk; 61057c478bd9Sstevel@tonic-gate /* 61067c478bd9Sstevel@tonic-gate * Note: it is strictly impossible to get here with sd_iocblk set to 61077c478bd9Sstevel@tonic-gate * -1. This is because the initial loop above doesn't allow any new 61087c478bd9Sstevel@tonic-gate * ioctls into the fray until all others have passed this point. 61097c478bd9Sstevel@tonic-gate */ 61107c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp != (mblk_t *)-1); 61117c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, 61127c478bd9Sstevel@tonic-gate TR_STRDOIOCTL_ACK, "strdoioctl got reply: bp %p", bp); 61137c478bd9Sstevel@tonic-gate if ((bp->b_datap->db_type == M_IOCACK) || 61147c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_IOCNAK)) { 61157c478bd9Sstevel@tonic-gate /* for detection of duplicate ioctl replies */ 61167c478bd9Sstevel@tonic-gate stp->sd_iocblk = (mblk_t *)-1; 61177c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 61187c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 61197c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 61207c478bd9Sstevel@tonic-gate } else { 61217c478bd9Sstevel@tonic-gate /* 61227c478bd9Sstevel@tonic-gate * flags not cleared here because we're still doing 61237c478bd9Sstevel@tonic-gate * copy in/out for ioctl. 61247c478bd9Sstevel@tonic-gate */ 61257c478bd9Sstevel@tonic-gate stp->sd_iocblk = NULL; 61267c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 61277c478bd9Sstevel@tonic-gate } 61287c478bd9Sstevel@tonic-gate 61297c478bd9Sstevel@tonic-gate 61307c478bd9Sstevel@tonic-gate /* 61317c478bd9Sstevel@tonic-gate * Have received acknowledgment. 61327c478bd9Sstevel@tonic-gate */ 61337c478bd9Sstevel@tonic-gate 61347c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) { 61357c478bd9Sstevel@tonic-gate case M_IOCACK: 61367c478bd9Sstevel@tonic-gate /* 61377c478bd9Sstevel@tonic-gate * Positive ack. 61387c478bd9Sstevel@tonic-gate */ 61397c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr; 61407c478bd9Sstevel@tonic-gate 61417c478bd9Sstevel@tonic-gate /* 61427c478bd9Sstevel@tonic-gate * Set error if indicated. 61437c478bd9Sstevel@tonic-gate */ 61447c478bd9Sstevel@tonic-gate if (iocbp->ioc_error) { 61457c478bd9Sstevel@tonic-gate error = iocbp->ioc_error; 61467c478bd9Sstevel@tonic-gate break; 61477c478bd9Sstevel@tonic-gate } 61487c478bd9Sstevel@tonic-gate 61497c478bd9Sstevel@tonic-gate /* 61507c478bd9Sstevel@tonic-gate * Set return value. 61517c478bd9Sstevel@tonic-gate */ 61527c478bd9Sstevel@tonic-gate *rvalp = iocbp->ioc_rval; 61537c478bd9Sstevel@tonic-gate 61547c478bd9Sstevel@tonic-gate /* 61557c478bd9Sstevel@tonic-gate * Data may have been returned in ACK message (ioc_count > 0). 61567c478bd9Sstevel@tonic-gate * If so, copy it out to the user's buffer. 61577c478bd9Sstevel@tonic-gate */ 61587c478bd9Sstevel@tonic-gate if (iocbp->ioc_count && !transparent) { 61597c478bd9Sstevel@tonic-gate if (error = getiocd(bp, strioc->ic_dp, copyflag)) 61607c478bd9Sstevel@tonic-gate break; 61617c478bd9Sstevel@tonic-gate } 61627c478bd9Sstevel@tonic-gate if (!transparent) { 61637c478bd9Sstevel@tonic-gate if (len) /* an M_COPYOUT was used with I_STR */ 61647c478bd9Sstevel@tonic-gate strioc->ic_len = len; 61657c478bd9Sstevel@tonic-gate else 61667c478bd9Sstevel@tonic-gate strioc->ic_len = (int)iocbp->ioc_count; 61677c478bd9Sstevel@tonic-gate } 61687c478bd9Sstevel@tonic-gate break; 61697c478bd9Sstevel@tonic-gate 61707c478bd9Sstevel@tonic-gate case M_IOCNAK: 61717c478bd9Sstevel@tonic-gate /* 61727c478bd9Sstevel@tonic-gate * Negative ack. 61737c478bd9Sstevel@tonic-gate * 61747c478bd9Sstevel@tonic-gate * The only thing to do is set error as specified 61757c478bd9Sstevel@tonic-gate * in neg ack packet. 61767c478bd9Sstevel@tonic-gate */ 61777c478bd9Sstevel@tonic-gate iocbp = (struct iocblk *)bp->b_rptr; 61787c478bd9Sstevel@tonic-gate 61797c478bd9Sstevel@tonic-gate error = (iocbp->ioc_error ? iocbp->ioc_error : EINVAL); 61807c478bd9Sstevel@tonic-gate break; 61817c478bd9Sstevel@tonic-gate 61827c478bd9Sstevel@tonic-gate case M_COPYIN: 61837c478bd9Sstevel@tonic-gate /* 61847c478bd9Sstevel@tonic-gate * Driver or module has requested user ioctl data. 61857c478bd9Sstevel@tonic-gate */ 61867c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr; 61877c478bd9Sstevel@tonic-gate 61887c478bd9Sstevel@tonic-gate /* 61897c478bd9Sstevel@tonic-gate * M_COPYIN should *never* have a message attached, though 61907c478bd9Sstevel@tonic-gate * it's harmless if it does -- thus, panic on a DEBUG 61917c478bd9Sstevel@tonic-gate * kernel and just free it on a non-DEBUG build. 61927c478bd9Sstevel@tonic-gate */ 61937c478bd9Sstevel@tonic-gate ASSERT(bp->b_cont == NULL); 61947c478bd9Sstevel@tonic-gate if (bp->b_cont != NULL) { 61957c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 61967c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 61977c478bd9Sstevel@tonic-gate } 61987c478bd9Sstevel@tonic-gate 61997c478bd9Sstevel@tonic-gate error = putiocd(bp, reqp->cq_addr, flag, crp); 62007c478bd9Sstevel@tonic-gate if (error && bp->b_cont) { 62017c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 62027c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 62037c478bd9Sstevel@tonic-gate } 62047c478bd9Sstevel@tonic-gate 62057c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp); 62067c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA; 62077c478bd9Sstevel@tonic-gate 62087c478bd9Sstevel@tonic-gate mblk_setcred(bp, crp); 62097c478bd9Sstevel@tonic-gate DB_CPID(bp) = curproc->p_pid; 62107c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr; 62117c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)(uintptr_t)error; 62127c478bd9Sstevel@tonic-gate resp->cp_flag = (fflags & FMODELS); 62137c478bd9Sstevel@tonic-gate 62147c478bd9Sstevel@tonic-gate stream_willservice(stp); 62157c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp); 62167c478bd9Sstevel@tonic-gate stream_runservice(stp); 62177c478bd9Sstevel@tonic-gate 62187c478bd9Sstevel@tonic-gate if (error) { 62197c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 62207c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 62217c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 62227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 62237c478bd9Sstevel@tonic-gate crfree(crp); 62247c478bd9Sstevel@tonic-gate return (error); 62257c478bd9Sstevel@tonic-gate } 62267c478bd9Sstevel@tonic-gate 62277c478bd9Sstevel@tonic-gate goto waitioc; 62287c478bd9Sstevel@tonic-gate 62297c478bd9Sstevel@tonic-gate case M_COPYOUT: 62307c478bd9Sstevel@tonic-gate /* 62317c478bd9Sstevel@tonic-gate * Driver or module has ioctl data for a user. 62327c478bd9Sstevel@tonic-gate */ 62337c478bd9Sstevel@tonic-gate reqp = (struct copyreq *)bp->b_rptr; 62347c478bd9Sstevel@tonic-gate ASSERT(bp->b_cont != NULL); 62357c478bd9Sstevel@tonic-gate 62367c478bd9Sstevel@tonic-gate /* 62377c478bd9Sstevel@tonic-gate * Always (transparent or non-transparent ) 62387c478bd9Sstevel@tonic-gate * use the address specified in the request 62397c478bd9Sstevel@tonic-gate */ 62407c478bd9Sstevel@tonic-gate taddr = reqp->cq_addr; 62417c478bd9Sstevel@tonic-gate if (!transparent) 62427c478bd9Sstevel@tonic-gate len = (int)reqp->cq_size; 62437c478bd9Sstevel@tonic-gate 62447c478bd9Sstevel@tonic-gate /* copyout data to the provided address */ 62457c478bd9Sstevel@tonic-gate error = getiocd(bp, taddr, copyflag); 62467c478bd9Sstevel@tonic-gate 62477c478bd9Sstevel@tonic-gate freemsg(bp->b_cont); 62487c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 62497c478bd9Sstevel@tonic-gate 62507c478bd9Sstevel@tonic-gate bp->b_wptr = bp->b_rptr + sizeof (struct copyresp); 62517c478bd9Sstevel@tonic-gate bp->b_datap->db_type = M_IOCDATA; 62527c478bd9Sstevel@tonic-gate 62537c478bd9Sstevel@tonic-gate mblk_setcred(bp, crp); 62547c478bd9Sstevel@tonic-gate DB_CPID(bp) = curproc->p_pid; 62557c478bd9Sstevel@tonic-gate resp = (struct copyresp *)bp->b_rptr; 62567c478bd9Sstevel@tonic-gate resp->cp_rval = (caddr_t)(uintptr_t)error; 62577c478bd9Sstevel@tonic-gate resp->cp_flag = (fflags & FMODELS); 62587c478bd9Sstevel@tonic-gate 62597c478bd9Sstevel@tonic-gate stream_willservice(stp); 62607c478bd9Sstevel@tonic-gate putnext(stp->sd_wrq, bp); 62617c478bd9Sstevel@tonic-gate stream_runservice(stp); 62627c478bd9Sstevel@tonic-gate 62637c478bd9Sstevel@tonic-gate if (error) { 62647c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 62657c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 62667c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 62677c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 62687c478bd9Sstevel@tonic-gate crfree(crp); 62697c478bd9Sstevel@tonic-gate return (error); 62707c478bd9Sstevel@tonic-gate } 62717c478bd9Sstevel@tonic-gate goto waitioc; 62727c478bd9Sstevel@tonic-gate 62737c478bd9Sstevel@tonic-gate default: 62747c478bd9Sstevel@tonic-gate ASSERT(0); 62757c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 62767c478bd9Sstevel@tonic-gate stp->sd_flag &= ~waitflags; 62777c478bd9Sstevel@tonic-gate cv_broadcast(&stp->sd_iocmonitor); 62787c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 62797c478bd9Sstevel@tonic-gate break; 62807c478bd9Sstevel@tonic-gate } 62817c478bd9Sstevel@tonic-gate 62827c478bd9Sstevel@tonic-gate freemsg(bp); 62837c478bd9Sstevel@tonic-gate crfree(crp); 62847c478bd9Sstevel@tonic-gate return (error); 62857c478bd9Sstevel@tonic-gate } 62867c478bd9Sstevel@tonic-gate 62877c478bd9Sstevel@tonic-gate /* 62887c478bd9Sstevel@tonic-gate * For the SunOS keyboard driver. 62897c478bd9Sstevel@tonic-gate * Return the next available "ioctl" sequence number. 62907c478bd9Sstevel@tonic-gate * Exported, so that streams modules can send "ioctl" messages 62917c478bd9Sstevel@tonic-gate * downstream from their open routine. 62927c478bd9Sstevel@tonic-gate */ 62937c478bd9Sstevel@tonic-gate int 62947c478bd9Sstevel@tonic-gate getiocseqno(void) 62957c478bd9Sstevel@tonic-gate { 62967c478bd9Sstevel@tonic-gate int i; 62977c478bd9Sstevel@tonic-gate 62987c478bd9Sstevel@tonic-gate mutex_enter(&strresources); 62997c478bd9Sstevel@tonic-gate i = ++ioc_id; 63007c478bd9Sstevel@tonic-gate mutex_exit(&strresources); 63017c478bd9Sstevel@tonic-gate return (i); 63027c478bd9Sstevel@tonic-gate } 63037c478bd9Sstevel@tonic-gate 63047c478bd9Sstevel@tonic-gate /* 63057c478bd9Sstevel@tonic-gate * Get the next message from the read queue. If the message is 63067c478bd9Sstevel@tonic-gate * priority, STRPRI will have been set by strrput(). This flag 63077c478bd9Sstevel@tonic-gate * should be reset only when the entire message at the front of the 63087c478bd9Sstevel@tonic-gate * queue as been consumed. 63097c478bd9Sstevel@tonic-gate * 63107c478bd9Sstevel@tonic-gate * NOTE: strgetmsg and kstrgetmsg have much of the logic in common. 63117c478bd9Sstevel@tonic-gate */ 63127c478bd9Sstevel@tonic-gate int 63137c478bd9Sstevel@tonic-gate strgetmsg( 63147c478bd9Sstevel@tonic-gate struct vnode *vp, 63157c478bd9Sstevel@tonic-gate struct strbuf *mctl, 63167c478bd9Sstevel@tonic-gate struct strbuf *mdata, 63177c478bd9Sstevel@tonic-gate unsigned char *prip, 63187c478bd9Sstevel@tonic-gate int *flagsp, 63197c478bd9Sstevel@tonic-gate int fmode, 63207c478bd9Sstevel@tonic-gate rval_t *rvp) 63217c478bd9Sstevel@tonic-gate { 63227c478bd9Sstevel@tonic-gate struct stdata *stp; 63237c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp; 63247c478bd9Sstevel@tonic-gate mblk_t *savemp = NULL; 63257c478bd9Sstevel@tonic-gate mblk_t *savemptail = NULL; 63267c478bd9Sstevel@tonic-gate uint_t old_sd_flag; 63277c478bd9Sstevel@tonic-gate int flg; 63287c478bd9Sstevel@tonic-gate int more = 0; 63297c478bd9Sstevel@tonic-gate int error = 0; 63307c478bd9Sstevel@tonic-gate char first = 1; 63317c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */ 63327c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */ 63337c478bd9Sstevel@tonic-gate unsigned char pri = 0; 63347c478bd9Sstevel@tonic-gate queue_t *q; 63357c478bd9Sstevel@tonic-gate int pr = 0; /* Partial read successful */ 63367c478bd9Sstevel@tonic-gate struct uio uios; 63377c478bd9Sstevel@tonic-gate struct uio *uiop = &uios; 63387c478bd9Sstevel@tonic-gate struct iovec iovs; 63397c478bd9Sstevel@tonic-gate unsigned char type; 63407c478bd9Sstevel@tonic-gate 63417c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRGETMSG_ENTER, 63427c478bd9Sstevel@tonic-gate "strgetmsg:%p", vp); 63437c478bd9Sstevel@tonic-gate 63447c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 63457c478bd9Sstevel@tonic-gate stp = vp->v_stream; 63467c478bd9Sstevel@tonic-gate rvp->r_val1 = 0; 63477c478bd9Sstevel@tonic-gate 63487c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 63499acbbeafSnn35248 63509acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 63517c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 63527c478bd9Sstevel@tonic-gate return (error); 63537c478bd9Sstevel@tonic-gate } 63547c478bd9Sstevel@tonic-gate 63559acbbeafSnn35248 if (stp->sd_flag & (STRDERR|STPLEX)) { 63569acbbeafSnn35248 error = strgeterr(stp, STRDERR|STPLEX, 0); 63579acbbeafSnn35248 if (error != 0) { 63589acbbeafSnn35248 mutex_exit(&stp->sd_lock); 63599acbbeafSnn35248 return (error); 63609acbbeafSnn35248 } 63619acbbeafSnn35248 } 63629acbbeafSnn35248 mutex_exit(&stp->sd_lock); 63639acbbeafSnn35248 63647c478bd9Sstevel@tonic-gate switch (*flagsp) { 63657c478bd9Sstevel@tonic-gate case MSG_HIPRI: 63667c478bd9Sstevel@tonic-gate if (*prip != 0) 63677c478bd9Sstevel@tonic-gate return (EINVAL); 63687c478bd9Sstevel@tonic-gate break; 63697c478bd9Sstevel@tonic-gate 63707c478bd9Sstevel@tonic-gate case MSG_ANY: 63717c478bd9Sstevel@tonic-gate case MSG_BAND: 63727c478bd9Sstevel@tonic-gate break; 63737c478bd9Sstevel@tonic-gate 63747c478bd9Sstevel@tonic-gate default: 63757c478bd9Sstevel@tonic-gate return (EINVAL); 63767c478bd9Sstevel@tonic-gate } 63777c478bd9Sstevel@tonic-gate /* 63787c478bd9Sstevel@tonic-gate * Setup uio and iov for data part 63797c478bd9Sstevel@tonic-gate */ 63807c478bd9Sstevel@tonic-gate iovs.iov_base = mdata->buf; 63817c478bd9Sstevel@tonic-gate iovs.iov_len = mdata->maxlen; 63827c478bd9Sstevel@tonic-gate uios.uio_iov = &iovs; 63837c478bd9Sstevel@tonic-gate uios.uio_iovcnt = 1; 63847c478bd9Sstevel@tonic-gate uios.uio_loffset = 0; 63857c478bd9Sstevel@tonic-gate uios.uio_segflg = UIO_USERSPACE; 63867c478bd9Sstevel@tonic-gate uios.uio_fmode = 0; 63877c478bd9Sstevel@tonic-gate uios.uio_extflg = UIO_COPY_CACHED; 63887c478bd9Sstevel@tonic-gate uios.uio_resid = mdata->maxlen; 63897c478bd9Sstevel@tonic-gate uios.uio_offset = 0; 63907c478bd9Sstevel@tonic-gate 63917c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 63927c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 63937c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag; 63947c478bd9Sstevel@tonic-gate mark = 0; 63957c478bd9Sstevel@tonic-gate for (;;) { 63967c478bd9Sstevel@tonic-gate int done = 0; 63977c478bd9Sstevel@tonic-gate mblk_t *q_first = q->q_first; 63987c478bd9Sstevel@tonic-gate 63997c478bd9Sstevel@tonic-gate /* 64007c478bd9Sstevel@tonic-gate * Get the next message of appropriate priority 64017c478bd9Sstevel@tonic-gate * from the stream head. If the caller is interested 64027c478bd9Sstevel@tonic-gate * in band or hipri messages, then they should already 64037c478bd9Sstevel@tonic-gate * be enqueued at the stream head. On the other hand 64047c478bd9Sstevel@tonic-gate * if the caller wants normal (band 0) messages, they 64057c478bd9Sstevel@tonic-gate * might be deferred in a synchronous stream and they 64067c478bd9Sstevel@tonic-gate * will need to be pulled up. 64077c478bd9Sstevel@tonic-gate * 64087c478bd9Sstevel@tonic-gate * After we have dequeued a message, we might find that 64097c478bd9Sstevel@tonic-gate * it was a deferred M_SIG that was enqueued at the 64107c478bd9Sstevel@tonic-gate * stream head. It must now be posted as part of the 64117c478bd9Sstevel@tonic-gate * read by calling strsignal_nolock(). 64127c478bd9Sstevel@tonic-gate * 64137c478bd9Sstevel@tonic-gate * Also note that strrput does not enqueue an M_PCSIG, 64147c478bd9Sstevel@tonic-gate * and there cannot be more than one hipri message, 64157c478bd9Sstevel@tonic-gate * so there was no need to have the M_PCSIG case. 64167c478bd9Sstevel@tonic-gate * 64177c478bd9Sstevel@tonic-gate * At some time it might be nice to try and wrap the 64187c478bd9Sstevel@tonic-gate * functionality of kstrgetmsg() and strgetmsg() into 64197c478bd9Sstevel@tonic-gate * a common routine so to reduce the amount of replicated 64207c478bd9Sstevel@tonic-gate * code (since they are extremely similar). 64217c478bd9Sstevel@tonic-gate */ 64227c478bd9Sstevel@tonic-gate if (!(*flagsp & (MSG_HIPRI|MSG_BAND))) { 64237c478bd9Sstevel@tonic-gate /* Asking for normal, band0 data */ 64247c478bd9Sstevel@tonic-gate bp = strget(stp, q, uiop, first, &error); 64257c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 64267c478bd9Sstevel@tonic-gate if (bp != NULL) { 64277c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_SIG) { 64287c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, 64297c478bd9Sstevel@tonic-gate (int32_t)bp->b_band); 64307c478bd9Sstevel@tonic-gate continue; 64317c478bd9Sstevel@tonic-gate } else { 64327c478bd9Sstevel@tonic-gate break; 64337c478bd9Sstevel@tonic-gate } 64347c478bd9Sstevel@tonic-gate } 64357c478bd9Sstevel@tonic-gate if (error != 0) { 64367c478bd9Sstevel@tonic-gate goto getmout; 64377c478bd9Sstevel@tonic-gate } 64387c478bd9Sstevel@tonic-gate 64397c478bd9Sstevel@tonic-gate /* 64407c478bd9Sstevel@tonic-gate * We can't depend on the value of STRPRI here because 64417c478bd9Sstevel@tonic-gate * the stream head may be in transit. Therefore, we 64427c478bd9Sstevel@tonic-gate * must look at the type of the first message to 64437c478bd9Sstevel@tonic-gate * determine if a high priority messages is waiting 64447c478bd9Sstevel@tonic-gate */ 64457c478bd9Sstevel@tonic-gate } else if ((*flagsp & MSG_HIPRI) && q_first != NULL && 64467c478bd9Sstevel@tonic-gate q_first->b_datap->db_type >= QPCTL && 64477c478bd9Sstevel@tonic-gate (bp = getq_noenab(q)) != NULL) { 64487c478bd9Sstevel@tonic-gate /* Asked for HIPRI and got one */ 64497c478bd9Sstevel@tonic-gate ASSERT(bp->b_datap->db_type >= QPCTL); 64507c478bd9Sstevel@tonic-gate break; 64517c478bd9Sstevel@tonic-gate } else if ((*flagsp & MSG_BAND) && q_first != NULL && 64527c478bd9Sstevel@tonic-gate ((q_first->b_band >= *prip) || 64537c478bd9Sstevel@tonic-gate q_first->b_datap->db_type >= QPCTL) && 64547c478bd9Sstevel@tonic-gate (bp = getq_noenab(q)) != NULL) { 64557c478bd9Sstevel@tonic-gate /* 64567c478bd9Sstevel@tonic-gate * Asked for at least band "prip" and got either at 64577c478bd9Sstevel@tonic-gate * least that band or a hipri message. 64587c478bd9Sstevel@tonic-gate */ 64597c478bd9Sstevel@tonic-gate ASSERT(bp->b_band >= *prip || 64607c478bd9Sstevel@tonic-gate bp->b_datap->db_type >= QPCTL); 64617c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_SIG) { 64627c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, 64637c478bd9Sstevel@tonic-gate (int32_t)bp->b_band); 64647c478bd9Sstevel@tonic-gate continue; 64657c478bd9Sstevel@tonic-gate } else { 64667c478bd9Sstevel@tonic-gate break; 64677c478bd9Sstevel@tonic-gate } 64687c478bd9Sstevel@tonic-gate } 64697c478bd9Sstevel@tonic-gate 64707c478bd9Sstevel@tonic-gate /* No data. Time to sleep? */ 64717c478bd9Sstevel@tonic-gate qbackenable(q, 0); 64727c478bd9Sstevel@tonic-gate 64737c478bd9Sstevel@tonic-gate /* 64747c478bd9Sstevel@tonic-gate * If STRHUP or STREOF, return 0 length control and data. 64757c478bd9Sstevel@tonic-gate * If resid is 0, then a read(fd,buf,0) was done. Do not 64767c478bd9Sstevel@tonic-gate * sleep to satisfy this request because by default we have 64777c478bd9Sstevel@tonic-gate * zero bytes to return. 64787c478bd9Sstevel@tonic-gate */ 64797c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRHUP|STREOF)) || (mctl->maxlen == 0 && 64807c478bd9Sstevel@tonic-gate mdata->maxlen == 0)) { 64817c478bd9Sstevel@tonic-gate mctl->len = mdata->len = 0; 64827c478bd9Sstevel@tonic-gate *flagsp = 0; 64837c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 64847c478bd9Sstevel@tonic-gate return (0); 64857c478bd9Sstevel@tonic-gate } 64867c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_WAIT, 64877c478bd9Sstevel@tonic-gate "strgetmsg calls strwaitq:%p, %p", 64887c478bd9Sstevel@tonic-gate vp, uiop); 64897c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, GETWAIT, (ssize_t)0, fmode, -1, 64907c478bd9Sstevel@tonic-gate &done)) != 0) || done) { 64917c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_DONE, 64927c478bd9Sstevel@tonic-gate "strgetmsg error or done:%p, %p", 64937c478bd9Sstevel@tonic-gate vp, uiop); 64947c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 64957c478bd9Sstevel@tonic-gate return (error); 64967c478bd9Sstevel@tonic-gate } 64977c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRGETMSG_AWAKE, 64987c478bd9Sstevel@tonic-gate "strgetmsg awakes:%p, %p", vp, uiop); 64999acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 65007c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 65017c478bd9Sstevel@tonic-gate return (error); 65027c478bd9Sstevel@tonic-gate } 65037c478bd9Sstevel@tonic-gate first = 0; 65047c478bd9Sstevel@tonic-gate } 65057c478bd9Sstevel@tonic-gate ASSERT(bp != NULL); 65067c478bd9Sstevel@tonic-gate /* 65077c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not completely 65087c478bd9Sstevel@tonic-gate * consumed this information will be put in the mblk 65097c478bd9Sstevel@tonic-gate * that is putback. 65107c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed 65117c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if 65127c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is 65137c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set. 65147c478bd9Sstevel@tonic-gate */ 65157c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT); 65167c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) != 65177c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT)); 65187c478bd9Sstevel@tonic-gate if (mark != 0 && bp == stp->sd_mark) { 65197c478bd9Sstevel@tonic-gate mark |= _LASTMARK; 65207c478bd9Sstevel@tonic-gate stp->sd_mark = NULL; 65217c478bd9Sstevel@tonic-gate } 65227c478bd9Sstevel@tonic-gate /* 65237c478bd9Sstevel@tonic-gate * keep track of the original message type and priority 65247c478bd9Sstevel@tonic-gate */ 65257c478bd9Sstevel@tonic-gate pri = bp->b_band; 65267c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type; 65277c478bd9Sstevel@tonic-gate if (type == M_PASSFP) { 65287c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL)) 65297c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 65307c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK; 65317c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 65327c478bd9Sstevel@tonic-gate qbackenable(q, pri); 65337c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 65347c478bd9Sstevel@tonic-gate return (EBADMSG); 65357c478bd9Sstevel@tonic-gate } 65367c478bd9Sstevel@tonic-gate ASSERT(type != M_SIG); 65377c478bd9Sstevel@tonic-gate 65387c478bd9Sstevel@tonic-gate /* 65397c478bd9Sstevel@tonic-gate * Set this flag so strrput will not generate signals. Need to 65407c478bd9Sstevel@tonic-gate * make sure this flag is cleared before leaving this routine 65417c478bd9Sstevel@tonic-gate * else signals will stop being sent. 65427c478bd9Sstevel@tonic-gate */ 65437c478bd9Sstevel@tonic-gate stp->sd_flag |= STRGETINPROG; 65447c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 65457c478bd9Sstevel@tonic-gate 65467c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 65477c478bd9Sstevel@tonic-gate stream_runservice(stp); 65487c478bd9Sstevel@tonic-gate 65497c478bd9Sstevel@tonic-gate /* 65507c478bd9Sstevel@tonic-gate * Set HIPRI flag if message is priority. 65517c478bd9Sstevel@tonic-gate */ 65527c478bd9Sstevel@tonic-gate if (type >= QPCTL) 65537c478bd9Sstevel@tonic-gate flg = MSG_HIPRI; 65547c478bd9Sstevel@tonic-gate else 65557c478bd9Sstevel@tonic-gate flg = MSG_BAND; 65567c478bd9Sstevel@tonic-gate 65577c478bd9Sstevel@tonic-gate /* 65587c478bd9Sstevel@tonic-gate * First process PROTO or PCPROTO blocks, if any. 65597c478bd9Sstevel@tonic-gate */ 65607c478bd9Sstevel@tonic-gate if (mctl->maxlen >= 0 && type != M_DATA) { 65617c478bd9Sstevel@tonic-gate size_t n, bcnt; 65627c478bd9Sstevel@tonic-gate char *ubuf; 65637c478bd9Sstevel@tonic-gate 65647c478bd9Sstevel@tonic-gate bcnt = mctl->maxlen; 65657c478bd9Sstevel@tonic-gate ubuf = mctl->buf; 65667c478bd9Sstevel@tonic-gate while (bp != NULL && bp->b_datap->db_type != M_DATA) { 65677c478bd9Sstevel@tonic-gate if ((n = MIN(bcnt, bp->b_wptr - bp->b_rptr)) != 0 && 65687c478bd9Sstevel@tonic-gate copyout(bp->b_rptr, ubuf, n)) { 65697c478bd9Sstevel@tonic-gate error = EFAULT; 65707c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 65717c478bd9Sstevel@tonic-gate /* 65727c478bd9Sstevel@tonic-gate * clear stream head pri flag based on 65737c478bd9Sstevel@tonic-gate * first message type 65747c478bd9Sstevel@tonic-gate */ 65757c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 65767c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 65777c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 65787c478bd9Sstevel@tonic-gate } 65797c478bd9Sstevel@tonic-gate more = 0; 65807c478bd9Sstevel@tonic-gate freemsg(bp); 65817c478bd9Sstevel@tonic-gate goto getmout; 65827c478bd9Sstevel@tonic-gate } 65837c478bd9Sstevel@tonic-gate ubuf += n; 65847c478bd9Sstevel@tonic-gate bp->b_rptr += n; 65857c478bd9Sstevel@tonic-gate if (bp->b_rptr >= bp->b_wptr) { 65867c478bd9Sstevel@tonic-gate nbp = bp; 65877c478bd9Sstevel@tonic-gate bp = bp->b_cont; 65887c478bd9Sstevel@tonic-gate freeb(nbp); 65897c478bd9Sstevel@tonic-gate } 65907c478bd9Sstevel@tonic-gate ASSERT(n <= bcnt); 65917c478bd9Sstevel@tonic-gate bcnt -= n; 65927c478bd9Sstevel@tonic-gate if (bcnt == 0) 65937c478bd9Sstevel@tonic-gate break; 65947c478bd9Sstevel@tonic-gate } 65957c478bd9Sstevel@tonic-gate mctl->len = mctl->maxlen - bcnt; 65967c478bd9Sstevel@tonic-gate } else 65977c478bd9Sstevel@tonic-gate mctl->len = -1; 65987c478bd9Sstevel@tonic-gate 65997c478bd9Sstevel@tonic-gate if (bp && bp->b_datap->db_type != M_DATA) { 66007c478bd9Sstevel@tonic-gate /* 66017c478bd9Sstevel@tonic-gate * More PROTO blocks in msg. 66027c478bd9Sstevel@tonic-gate */ 66037c478bd9Sstevel@tonic-gate more |= MORECTL; 66047c478bd9Sstevel@tonic-gate savemp = bp; 66057c478bd9Sstevel@tonic-gate while (bp && bp->b_datap->db_type != M_DATA) { 66067c478bd9Sstevel@tonic-gate savemptail = bp; 66077c478bd9Sstevel@tonic-gate bp = bp->b_cont; 66087c478bd9Sstevel@tonic-gate } 66097c478bd9Sstevel@tonic-gate savemptail->b_cont = NULL; 66107c478bd9Sstevel@tonic-gate } 66117c478bd9Sstevel@tonic-gate 66127c478bd9Sstevel@tonic-gate /* 66137c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any. 66147c478bd9Sstevel@tonic-gate */ 66157c478bd9Sstevel@tonic-gate if (mdata->maxlen >= 0 && bp) { 66167c478bd9Sstevel@tonic-gate /* 66177c478bd9Sstevel@tonic-gate * struiocopyout will consume a potential zero-length 66187c478bd9Sstevel@tonic-gate * M_DATA even if uio_resid is zero. 66197c478bd9Sstevel@tonic-gate */ 66207c478bd9Sstevel@tonic-gate size_t oldresid = uiop->uio_resid; 66217c478bd9Sstevel@tonic-gate 66227c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error); 66237c478bd9Sstevel@tonic-gate if (error != 0) { 66247c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 66257c478bd9Sstevel@tonic-gate /* 66267c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 66277c478bd9Sstevel@tonic-gate * first message 66287c478bd9Sstevel@tonic-gate */ 66297c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 66307c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 66317c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 66327c478bd9Sstevel@tonic-gate } 66337c478bd9Sstevel@tonic-gate more = 0; 66347c478bd9Sstevel@tonic-gate freemsg(savemp); 66357c478bd9Sstevel@tonic-gate goto getmout; 66367c478bd9Sstevel@tonic-gate } 66377c478bd9Sstevel@tonic-gate /* 66387c478bd9Sstevel@tonic-gate * (pr == 1) indicates a partial read. 66397c478bd9Sstevel@tonic-gate */ 66407c478bd9Sstevel@tonic-gate if (oldresid > uiop->uio_resid) 66417c478bd9Sstevel@tonic-gate pr = 1; 66427c478bd9Sstevel@tonic-gate mdata->len = mdata->maxlen - uiop->uio_resid; 66437c478bd9Sstevel@tonic-gate } else 66447c478bd9Sstevel@tonic-gate mdata->len = -1; 66457c478bd9Sstevel@tonic-gate 66467c478bd9Sstevel@tonic-gate if (bp) { /* more data blocks in msg */ 66477c478bd9Sstevel@tonic-gate more |= MOREDATA; 66487c478bd9Sstevel@tonic-gate if (savemp) 66497c478bd9Sstevel@tonic-gate savemptail->b_cont = bp; 66507c478bd9Sstevel@tonic-gate else 66517c478bd9Sstevel@tonic-gate savemp = bp; 66527c478bd9Sstevel@tonic-gate } 66537c478bd9Sstevel@tonic-gate 66547c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 66557c478bd9Sstevel@tonic-gate if (savemp) { 66567c478bd9Sstevel@tonic-gate if (pr && (savemp->b_datap->db_type == M_DATA) && 66577c478bd9Sstevel@tonic-gate msgnodata(savemp)) { 66587c478bd9Sstevel@tonic-gate /* 66597c478bd9Sstevel@tonic-gate * Avoid queuing a zero-length tail part of 66607c478bd9Sstevel@tonic-gate * a message. pr=1 indicates that we read some of 66617c478bd9Sstevel@tonic-gate * the message. 66627c478bd9Sstevel@tonic-gate */ 66637c478bd9Sstevel@tonic-gate freemsg(savemp); 66647c478bd9Sstevel@tonic-gate more &= ~MOREDATA; 66657c478bd9Sstevel@tonic-gate /* 66667c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 66677c478bd9Sstevel@tonic-gate * first message 66687c478bd9Sstevel@tonic-gate */ 66697c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 66707c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 66717c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 66727c478bd9Sstevel@tonic-gate } 66737c478bd9Sstevel@tonic-gate } else { 66747c478bd9Sstevel@tonic-gate savemp->b_band = pri; 66757c478bd9Sstevel@tonic-gate /* 66767c478bd9Sstevel@tonic-gate * If the first message was HIPRI and the one we're 66777c478bd9Sstevel@tonic-gate * putting back isn't, then clear STRPRI, otherwise 66787c478bd9Sstevel@tonic-gate * set STRPRI again. Note that we must set STRPRI 66797c478bd9Sstevel@tonic-gate * again since the flush logic in strrput_nondata() 66807c478bd9Sstevel@tonic-gate * may have cleared it while we had sd_lock dropped. 66817c478bd9Sstevel@tonic-gate */ 66827c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 66837c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 66847c478bd9Sstevel@tonic-gate if (queclass(savemp) < QPCTL) 66857c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 66867c478bd9Sstevel@tonic-gate else 66877c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI; 66887c478bd9Sstevel@tonic-gate } else if (queclass(savemp) >= QPCTL) { 66897c478bd9Sstevel@tonic-gate /* 66907c478bd9Sstevel@tonic-gate * The first message was not a HIPRI message, 66917c478bd9Sstevel@tonic-gate * but the one we are about to putback is. 66927c478bd9Sstevel@tonic-gate * For simplicitly, we do not allow for HIPRI 66937c478bd9Sstevel@tonic-gate * messages to be embedded in the message 66947c478bd9Sstevel@tonic-gate * body, so just force it to same type as 66957c478bd9Sstevel@tonic-gate * first message. 66967c478bd9Sstevel@tonic-gate */ 66977c478bd9Sstevel@tonic-gate ASSERT(type == M_DATA || type == M_PROTO); 66987c478bd9Sstevel@tonic-gate ASSERT(savemp->b_datap->db_type == M_PCPROTO); 66997c478bd9Sstevel@tonic-gate savemp->b_datap->db_type = type; 67007c478bd9Sstevel@tonic-gate } 67017c478bd9Sstevel@tonic-gate if (mark != 0) { 67027c478bd9Sstevel@tonic-gate savemp->b_flag |= mark & ~_LASTMARK; 67037c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && 67047c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL)) { 67057c478bd9Sstevel@tonic-gate /* 67067c478bd9Sstevel@tonic-gate * If another marked message arrived 67077c478bd9Sstevel@tonic-gate * while sd_lock was not held sd_mark 67087c478bd9Sstevel@tonic-gate * would be non-NULL. 67097c478bd9Sstevel@tonic-gate */ 67107c478bd9Sstevel@tonic-gate stp->sd_mark = savemp; 67117c478bd9Sstevel@tonic-gate } 67127c478bd9Sstevel@tonic-gate } 67137c478bd9Sstevel@tonic-gate putback(stp, q, savemp, pri); 67147c478bd9Sstevel@tonic-gate } 67157c478bd9Sstevel@tonic-gate } else { 67167c478bd9Sstevel@tonic-gate /* 67177c478bd9Sstevel@tonic-gate * The complete message was consumed. 67187c478bd9Sstevel@tonic-gate * 67197c478bd9Sstevel@tonic-gate * If another M_PCPROTO arrived while sd_lock was not held 67207c478bd9Sstevel@tonic-gate * it would have been discarded since STRPRI was still set. 67217c478bd9Sstevel@tonic-gate * 67227c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information 67237c478bd9Sstevel@tonic-gate * to the stream head just in case 67247c478bd9Sstevel@tonic-gate * the read queue becomes empty. 67257c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 67267c478bd9Sstevel@tonic-gate * first message 67277c478bd9Sstevel@tonic-gate * 67287c478bd9Sstevel@tonic-gate * If the stream head was at the mark 67297c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above 67307c478bd9Sstevel@tonic-gate * and some data was consumed then we have 67317c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is 67327c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in 67337c478bd9Sstevel@tonic-gate * strrput during the copyout above causing 67347c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that 67357c478bd9Sstevel@tonic-gate * flag. 67367c478bd9Sstevel@tonic-gate */ 67377c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 67387c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 67397c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 67407c478bd9Sstevel@tonic-gate } 67417c478bd9Sstevel@tonic-gate if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) { 67427c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) { 67437c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK; 67447c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK; 67457c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) { 67467c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 67477c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK; 67487c478bd9Sstevel@tonic-gate } else { 67497c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(STRATMARK|STRNOTATMARK); 67507c478bd9Sstevel@tonic-gate } 67517c478bd9Sstevel@tonic-gate } else if (pr && (old_sd_flag & STRATMARK)) { 67527c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 67537c478bd9Sstevel@tonic-gate } 67547c478bd9Sstevel@tonic-gate } 67557c478bd9Sstevel@tonic-gate 67567c478bd9Sstevel@tonic-gate *flagsp = flg; 67577c478bd9Sstevel@tonic-gate *prip = pri; 67587c478bd9Sstevel@tonic-gate 67597c478bd9Sstevel@tonic-gate /* 67607c478bd9Sstevel@tonic-gate * Getmsg cleanup processing - if the state of the queue has changed 67617c478bd9Sstevel@tonic-gate * some signals may need to be sent and/or poll awakened. 67627c478bd9Sstevel@tonic-gate */ 67637c478bd9Sstevel@tonic-gate getmout: 67647c478bd9Sstevel@tonic-gate qbackenable(q, pri); 67657c478bd9Sstevel@tonic-gate 67667c478bd9Sstevel@tonic-gate /* 67677c478bd9Sstevel@tonic-gate * We dropped the stream head lock above. Send all M_SIG messages 67687c478bd9Sstevel@tonic-gate * before processing stream head for SIGPOLL messages. 67697c478bd9Sstevel@tonic-gate */ 67707c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 67717c478bd9Sstevel@tonic-gate while ((bp = q->q_first) != NULL && 67727c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_SIG)) { 67737c478bd9Sstevel@tonic-gate /* 67747c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the read queue can not 67757c478bd9Sstevel@tonic-gate * change. 67767c478bd9Sstevel@tonic-gate */ 67777c478bd9Sstevel@tonic-gate bp = getq(q); 67787c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG); 67797c478bd9Sstevel@tonic-gate 67807c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, (int32_t)bp->b_band); 67817c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 67827c478bd9Sstevel@tonic-gate freemsg(bp); 67837c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 67847c478bd9Sstevel@tonic-gate stream_runservice(stp); 67857c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 67867c478bd9Sstevel@tonic-gate } 67877c478bd9Sstevel@tonic-gate 67887c478bd9Sstevel@tonic-gate /* 67897c478bd9Sstevel@tonic-gate * stream head cannot change while we make the determination 67907c478bd9Sstevel@tonic-gate * whether or not to send a signal. Drop the flag to allow strrput 67917c478bd9Sstevel@tonic-gate * to send firstmsgsigs again. 67927c478bd9Sstevel@tonic-gate */ 67937c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRGETINPROG; 67947c478bd9Sstevel@tonic-gate 67957c478bd9Sstevel@tonic-gate /* 67967c478bd9Sstevel@tonic-gate * If the type of message at the front of the queue changed 67977c478bd9Sstevel@tonic-gate * due to the receive the appropriate signals and pollwakeup events 67987c478bd9Sstevel@tonic-gate * are generated. The type of changes are: 67997c478bd9Sstevel@tonic-gate * Processed a hipri message, q_first is not hipri. 68007c478bd9Sstevel@tonic-gate * Processed a band X message, and q_first is band Y. 68017c478bd9Sstevel@tonic-gate * The generated signals and pollwakeups are identical to what 68027c478bd9Sstevel@tonic-gate * strrput() generates should the message that is now on q_first 68037c478bd9Sstevel@tonic-gate * arrive to an empty read queue. 68047c478bd9Sstevel@tonic-gate * 68057c478bd9Sstevel@tonic-gate * Note: only strrput will send a signal for a hipri message. 68067c478bd9Sstevel@tonic-gate */ 68077c478bd9Sstevel@tonic-gate if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) { 68087c478bd9Sstevel@tonic-gate strsigset_t signals = 0; 68097c478bd9Sstevel@tonic-gate strpollset_t pollwakeups = 0; 68107c478bd9Sstevel@tonic-gate 68117c478bd9Sstevel@tonic-gate if (flg & MSG_HIPRI) { 68127c478bd9Sstevel@tonic-gate /* 68137c478bd9Sstevel@tonic-gate * Removed a hipri message. Regular data at 68147c478bd9Sstevel@tonic-gate * the front of the queue. 68157c478bd9Sstevel@tonic-gate */ 68167c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 68177c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDNORM; 68187c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 68197c478bd9Sstevel@tonic-gate } else { 68207c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDBAND; 68217c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 68227c478bd9Sstevel@tonic-gate } 68237c478bd9Sstevel@tonic-gate } else if (pri != bp->b_band) { 68247c478bd9Sstevel@tonic-gate /* 68257c478bd9Sstevel@tonic-gate * The band is different for the new q_first. 68267c478bd9Sstevel@tonic-gate */ 68277c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 68287c478bd9Sstevel@tonic-gate signals = S_RDNORM; 68297c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 68307c478bd9Sstevel@tonic-gate } else { 68317c478bd9Sstevel@tonic-gate signals = S_RDBAND; 68327c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 68337c478bd9Sstevel@tonic-gate } 68347c478bd9Sstevel@tonic-gate } 68357c478bd9Sstevel@tonic-gate 68367c478bd9Sstevel@tonic-gate if (pollwakeups != 0) { 68377c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) { 68387c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN)) 68397c478bd9Sstevel@tonic-gate goto no_pollwake; 68407c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN; 68417c478bd9Sstevel@tonic-gate } 68427c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 68437c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups); 68447c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 68457c478bd9Sstevel@tonic-gate } 68467c478bd9Sstevel@tonic-gate no_pollwake: 68477c478bd9Sstevel@tonic-gate 68487c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals) 68497c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, bp->b_band, 0); 68507c478bd9Sstevel@tonic-gate } 68517c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 68527c478bd9Sstevel@tonic-gate 68537c478bd9Sstevel@tonic-gate rvp->r_val1 = more; 68547c478bd9Sstevel@tonic-gate return (error); 68557c478bd9Sstevel@tonic-gate #undef _LASTMARK 68567c478bd9Sstevel@tonic-gate } 68577c478bd9Sstevel@tonic-gate 68587c478bd9Sstevel@tonic-gate /* 68597c478bd9Sstevel@tonic-gate * Get the next message from the read queue. If the message is 68607c478bd9Sstevel@tonic-gate * priority, STRPRI will have been set by strrput(). This flag 68617c478bd9Sstevel@tonic-gate * should be reset only when the entire message at the front of the 68627c478bd9Sstevel@tonic-gate * queue as been consumed. 68637c478bd9Sstevel@tonic-gate * 68647c478bd9Sstevel@tonic-gate * If uiop is NULL all data is returned in mctlp. 68657c478bd9Sstevel@tonic-gate * Note that a NULL uiop implies that FNDELAY and FNONBLOCK are assumed 68667c478bd9Sstevel@tonic-gate * not enabled. 68677c478bd9Sstevel@tonic-gate * The timeout parameter is in milliseconds; -1 for infinity. 68687c478bd9Sstevel@tonic-gate * This routine handles the consolidation private flags: 68697c478bd9Sstevel@tonic-gate * MSG_IGNERROR Ignore any stream head error except STPLEX. 68707c478bd9Sstevel@tonic-gate * MSG_DELAYERROR Defer the error check until the queue is empty. 68717c478bd9Sstevel@tonic-gate * MSG_HOLDSIG Hold signals while waiting for data. 68727c478bd9Sstevel@tonic-gate * MSG_IPEEK Only peek at messages. 68737c478bd9Sstevel@tonic-gate * MSG_DISCARDTAIL Discard the tail M_DATA part of the message 68747c478bd9Sstevel@tonic-gate * that doesn't fit. 68757c478bd9Sstevel@tonic-gate * MSG_NOMARK If the message is marked leave it on the queue. 68767c478bd9Sstevel@tonic-gate * 68777c478bd9Sstevel@tonic-gate * NOTE: strgetmsg and kstrgetmsg have much of the logic in common. 68787c478bd9Sstevel@tonic-gate */ 68797c478bd9Sstevel@tonic-gate int 68807c478bd9Sstevel@tonic-gate kstrgetmsg( 68817c478bd9Sstevel@tonic-gate struct vnode *vp, 68827c478bd9Sstevel@tonic-gate mblk_t **mctlp, 68837c478bd9Sstevel@tonic-gate struct uio *uiop, 68847c478bd9Sstevel@tonic-gate unsigned char *prip, 68857c478bd9Sstevel@tonic-gate int *flagsp, 68867c478bd9Sstevel@tonic-gate clock_t timout, 68877c478bd9Sstevel@tonic-gate rval_t *rvp) 68887c478bd9Sstevel@tonic-gate { 68897c478bd9Sstevel@tonic-gate struct stdata *stp; 68907c478bd9Sstevel@tonic-gate mblk_t *bp, *nbp; 68917c478bd9Sstevel@tonic-gate mblk_t *savemp = NULL; 68927c478bd9Sstevel@tonic-gate mblk_t *savemptail = NULL; 68937c478bd9Sstevel@tonic-gate int flags; 68947c478bd9Sstevel@tonic-gate uint_t old_sd_flag; 68957c478bd9Sstevel@tonic-gate int flg; 68967c478bd9Sstevel@tonic-gate int more = 0; 68977c478bd9Sstevel@tonic-gate int error = 0; 68987c478bd9Sstevel@tonic-gate char first = 1; 68997c478bd9Sstevel@tonic-gate uint_t mark; /* Contains MSG*MARK and _LASTMARK */ 69007c478bd9Sstevel@tonic-gate #define _LASTMARK 0x8000 /* Distinct from MSG*MARK */ 69017c478bd9Sstevel@tonic-gate unsigned char pri = 0; 69027c478bd9Sstevel@tonic-gate queue_t *q; 69037c478bd9Sstevel@tonic-gate int pr = 0; /* Partial read successful */ 69047c478bd9Sstevel@tonic-gate unsigned char type; 69057c478bd9Sstevel@tonic-gate 69067c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_ENTER, 69077c478bd9Sstevel@tonic-gate "kstrgetmsg:%p", vp); 69087c478bd9Sstevel@tonic-gate 69097c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 69107c478bd9Sstevel@tonic-gate stp = vp->v_stream; 69117c478bd9Sstevel@tonic-gate rvp->r_val1 = 0; 69127c478bd9Sstevel@tonic-gate 69139acbbeafSnn35248 mutex_enter(&stp->sd_lock); 69149acbbeafSnn35248 69159acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 69169acbbeafSnn35248 mutex_exit(&stp->sd_lock); 69177c478bd9Sstevel@tonic-gate return (error); 69189acbbeafSnn35248 } 69197c478bd9Sstevel@tonic-gate 69207c478bd9Sstevel@tonic-gate flags = *flagsp; 69217c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRDERR|STPLEX)) { 69227c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STPLEX) || 69237c478bd9Sstevel@tonic-gate (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == 0) { 69247c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 69257c478bd9Sstevel@tonic-gate (flags & MSG_IPEEK)); 69269acbbeafSnn35248 if (error != 0) { 69277c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 69287c478bd9Sstevel@tonic-gate return (error); 69297c478bd9Sstevel@tonic-gate } 69307c478bd9Sstevel@tonic-gate } 69319acbbeafSnn35248 } 69329acbbeafSnn35248 mutex_exit(&stp->sd_lock); 69337c478bd9Sstevel@tonic-gate 69347c478bd9Sstevel@tonic-gate switch (flags & (MSG_HIPRI|MSG_ANY|MSG_BAND)) { 69357c478bd9Sstevel@tonic-gate case MSG_HIPRI: 69367c478bd9Sstevel@tonic-gate if (*prip != 0) 69377c478bd9Sstevel@tonic-gate return (EINVAL); 69387c478bd9Sstevel@tonic-gate break; 69397c478bd9Sstevel@tonic-gate 69407c478bd9Sstevel@tonic-gate case MSG_ANY: 69417c478bd9Sstevel@tonic-gate case MSG_BAND: 69427c478bd9Sstevel@tonic-gate break; 69437c478bd9Sstevel@tonic-gate 69447c478bd9Sstevel@tonic-gate default: 69457c478bd9Sstevel@tonic-gate return (EINVAL); 69467c478bd9Sstevel@tonic-gate } 69477c478bd9Sstevel@tonic-gate 69487c478bd9Sstevel@tonic-gate retry: 69497c478bd9Sstevel@tonic-gate q = _RD(stp->sd_wrq); 69507c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 69517c478bd9Sstevel@tonic-gate old_sd_flag = stp->sd_flag; 69527c478bd9Sstevel@tonic-gate mark = 0; 69537c478bd9Sstevel@tonic-gate for (;;) { 69547c478bd9Sstevel@tonic-gate int done = 0; 69557c478bd9Sstevel@tonic-gate int waitflag; 69567c478bd9Sstevel@tonic-gate int fmode; 69577c478bd9Sstevel@tonic-gate mblk_t *q_first = q->q_first; 69587c478bd9Sstevel@tonic-gate 69597c478bd9Sstevel@tonic-gate /* 69607c478bd9Sstevel@tonic-gate * This section of the code operates just like the code 69617c478bd9Sstevel@tonic-gate * in strgetmsg(). There is a comment there about what 69627c478bd9Sstevel@tonic-gate * is going on here. 69637c478bd9Sstevel@tonic-gate */ 69647c478bd9Sstevel@tonic-gate if (!(flags & (MSG_HIPRI|MSG_BAND))) { 69657c478bd9Sstevel@tonic-gate /* Asking for normal, band0 data */ 69667c478bd9Sstevel@tonic-gate bp = strget(stp, q, uiop, first, &error); 69677c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 69687c478bd9Sstevel@tonic-gate if (bp != NULL) { 69697c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_SIG) { 69707c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, 69717c478bd9Sstevel@tonic-gate (int32_t)bp->b_band); 69727c478bd9Sstevel@tonic-gate continue; 69737c478bd9Sstevel@tonic-gate } else { 69747c478bd9Sstevel@tonic-gate break; 69757c478bd9Sstevel@tonic-gate } 69767c478bd9Sstevel@tonic-gate } 69777c478bd9Sstevel@tonic-gate if (error != 0) { 69787c478bd9Sstevel@tonic-gate goto getmout; 69797c478bd9Sstevel@tonic-gate } 69807c478bd9Sstevel@tonic-gate /* 69817c478bd9Sstevel@tonic-gate * We can't depend on the value of STRPRI here because 69827c478bd9Sstevel@tonic-gate * the stream head may be in transit. Therefore, we 69837c478bd9Sstevel@tonic-gate * must look at the type of the first message to 69847c478bd9Sstevel@tonic-gate * determine if a high priority messages is waiting 69857c478bd9Sstevel@tonic-gate */ 69867c478bd9Sstevel@tonic-gate } else if ((flags & MSG_HIPRI) && q_first != NULL && 69877c478bd9Sstevel@tonic-gate q_first->b_datap->db_type >= QPCTL && 69887c478bd9Sstevel@tonic-gate (bp = getq_noenab(q)) != NULL) { 69897c478bd9Sstevel@tonic-gate ASSERT(bp->b_datap->db_type >= QPCTL); 69907c478bd9Sstevel@tonic-gate break; 69917c478bd9Sstevel@tonic-gate } else if ((flags & MSG_BAND) && q_first != NULL && 69927c478bd9Sstevel@tonic-gate ((q_first->b_band >= *prip) || 69937c478bd9Sstevel@tonic-gate q_first->b_datap->db_type >= QPCTL) && 69947c478bd9Sstevel@tonic-gate (bp = getq_noenab(q)) != NULL) { 69957c478bd9Sstevel@tonic-gate /* 69967c478bd9Sstevel@tonic-gate * Asked for at least band "prip" and got either at 69977c478bd9Sstevel@tonic-gate * least that band or a hipri message. 69987c478bd9Sstevel@tonic-gate */ 69997c478bd9Sstevel@tonic-gate ASSERT(bp->b_band >= *prip || 70007c478bd9Sstevel@tonic-gate bp->b_datap->db_type >= QPCTL); 70017c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_SIG) { 70027c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, 70037c478bd9Sstevel@tonic-gate (int32_t)bp->b_band); 70047c478bd9Sstevel@tonic-gate continue; 70057c478bd9Sstevel@tonic-gate } else { 70067c478bd9Sstevel@tonic-gate break; 70077c478bd9Sstevel@tonic-gate } 70087c478bd9Sstevel@tonic-gate } 70097c478bd9Sstevel@tonic-gate 70107c478bd9Sstevel@tonic-gate /* No data. Time to sleep? */ 70117c478bd9Sstevel@tonic-gate qbackenable(q, 0); 70127c478bd9Sstevel@tonic-gate 70137c478bd9Sstevel@tonic-gate /* 70147c478bd9Sstevel@tonic-gate * Delayed error notification? 70157c478bd9Sstevel@tonic-gate */ 70167c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRDERR|STPLEX)) && 70177c478bd9Sstevel@tonic-gate (flags & (MSG_IGNERROR|MSG_DELAYERROR)) == MSG_DELAYERROR) { 70187c478bd9Sstevel@tonic-gate error = strgeterr(stp, STRDERR|STPLEX, 70197c478bd9Sstevel@tonic-gate (flags & MSG_IPEEK)); 70207c478bd9Sstevel@tonic-gate if (error != 0) { 70217c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 70227c478bd9Sstevel@tonic-gate return (error); 70237c478bd9Sstevel@tonic-gate } 70247c478bd9Sstevel@tonic-gate } 70257c478bd9Sstevel@tonic-gate 70267c478bd9Sstevel@tonic-gate /* 70277c478bd9Sstevel@tonic-gate * If STRHUP or STREOF, return 0 length control and data. 70287c478bd9Sstevel@tonic-gate * If a read(fd,buf,0) has been done, do not sleep, just 70297c478bd9Sstevel@tonic-gate * return. 70307c478bd9Sstevel@tonic-gate * 70317c478bd9Sstevel@tonic-gate * If mctlp == NULL and uiop == NULL, then the code will 70327c478bd9Sstevel@tonic-gate * do the strwaitq. This is an understood way of saying 70337c478bd9Sstevel@tonic-gate * sleep "polling" until a message is received. 70347c478bd9Sstevel@tonic-gate */ 70357c478bd9Sstevel@tonic-gate if ((stp->sd_flag & (STRHUP|STREOF)) || 70367c478bd9Sstevel@tonic-gate (uiop != NULL && uiop->uio_resid == 0)) { 70377c478bd9Sstevel@tonic-gate if (mctlp != NULL) 70387c478bd9Sstevel@tonic-gate *mctlp = NULL; 70397c478bd9Sstevel@tonic-gate *flagsp = 0; 70407c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 70417c478bd9Sstevel@tonic-gate return (0); 70427c478bd9Sstevel@tonic-gate } 70437c478bd9Sstevel@tonic-gate 70447c478bd9Sstevel@tonic-gate waitflag = GETWAIT; 70457c478bd9Sstevel@tonic-gate if (flags & 70467c478bd9Sstevel@tonic-gate (MSG_HOLDSIG|MSG_IGNERROR|MSG_IPEEK|MSG_DELAYERROR)) { 70477c478bd9Sstevel@tonic-gate if (flags & MSG_HOLDSIG) 70487c478bd9Sstevel@tonic-gate waitflag |= STR_NOSIG; 70497c478bd9Sstevel@tonic-gate if (flags & MSG_IGNERROR) 70507c478bd9Sstevel@tonic-gate waitflag |= STR_NOERROR; 70517c478bd9Sstevel@tonic-gate if (flags & MSG_IPEEK) 70527c478bd9Sstevel@tonic-gate waitflag |= STR_PEEK; 70537c478bd9Sstevel@tonic-gate if (flags & MSG_DELAYERROR) 70547c478bd9Sstevel@tonic-gate waitflag |= STR_DELAYERR; 70557c478bd9Sstevel@tonic-gate } 70567c478bd9Sstevel@tonic-gate if (uiop != NULL) 70577c478bd9Sstevel@tonic-gate fmode = uiop->uio_fmode; 70587c478bd9Sstevel@tonic-gate else 70597c478bd9Sstevel@tonic-gate fmode = 0; 70607c478bd9Sstevel@tonic-gate 70617c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_WAIT, 70627c478bd9Sstevel@tonic-gate "kstrgetmsg calls strwaitq:%p, %p", 70637c478bd9Sstevel@tonic-gate vp, uiop); 70647c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, waitflag, (ssize_t)0, 70657c478bd9Sstevel@tonic-gate fmode, timout, &done)) != 0) || done) { 70667c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_DONE, 70677c478bd9Sstevel@tonic-gate "kstrgetmsg error or done:%p, %p", 70687c478bd9Sstevel@tonic-gate vp, uiop); 70697c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 70707c478bd9Sstevel@tonic-gate return (error); 70717c478bd9Sstevel@tonic-gate } 70727c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRGETMSG_AWAKE, 70737c478bd9Sstevel@tonic-gate "kstrgetmsg awakes:%p, %p", vp, uiop); 70749acbbeafSnn35248 if ((error = i_straccess(stp, JCREAD)) != 0) { 70757c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 70767c478bd9Sstevel@tonic-gate return (error); 70777c478bd9Sstevel@tonic-gate } 70787c478bd9Sstevel@tonic-gate first = 0; 70797c478bd9Sstevel@tonic-gate } 70807c478bd9Sstevel@tonic-gate ASSERT(bp != NULL); 70817c478bd9Sstevel@tonic-gate /* 70827c478bd9Sstevel@tonic-gate * Extract any mark information. If the message is not completely 70837c478bd9Sstevel@tonic-gate * consumed this information will be put in the mblk 70847c478bd9Sstevel@tonic-gate * that is putback. 70857c478bd9Sstevel@tonic-gate * If MSGMARKNEXT is set and the message is completely consumed 70867c478bd9Sstevel@tonic-gate * the STRATMARK flag will be set below. Likewise, if 70877c478bd9Sstevel@tonic-gate * MSGNOTMARKNEXT is set and the message is 70887c478bd9Sstevel@tonic-gate * completely consumed STRNOTATMARK will be set. 70897c478bd9Sstevel@tonic-gate */ 70907c478bd9Sstevel@tonic-gate mark = bp->b_flag & (MSGMARK | MSGMARKNEXT | MSGNOTMARKNEXT); 70917c478bd9Sstevel@tonic-gate ASSERT((mark & (MSGMARKNEXT|MSGNOTMARKNEXT)) != 70927c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT)); 70937c478bd9Sstevel@tonic-gate pri = bp->b_band; 70947c478bd9Sstevel@tonic-gate if (mark != 0) { 70957c478bd9Sstevel@tonic-gate /* 70967c478bd9Sstevel@tonic-gate * If the caller doesn't want the mark return. 70977c478bd9Sstevel@tonic-gate * Used to implement MSG_WAITALL in sockets. 70987c478bd9Sstevel@tonic-gate */ 70997c478bd9Sstevel@tonic-gate if (flags & MSG_NOMARK) { 71007c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 71017c478bd9Sstevel@tonic-gate qbackenable(q, pri); 71027c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 71037c478bd9Sstevel@tonic-gate return (EWOULDBLOCK); 71047c478bd9Sstevel@tonic-gate } 71057c478bd9Sstevel@tonic-gate if (bp == stp->sd_mark) { 71067c478bd9Sstevel@tonic-gate mark |= _LASTMARK; 71077c478bd9Sstevel@tonic-gate stp->sd_mark = NULL; 71087c478bd9Sstevel@tonic-gate } 71097c478bd9Sstevel@tonic-gate } 71107c478bd9Sstevel@tonic-gate 71117c478bd9Sstevel@tonic-gate /* 71127c478bd9Sstevel@tonic-gate * keep track of the first message type 71137c478bd9Sstevel@tonic-gate */ 71147c478bd9Sstevel@tonic-gate type = bp->b_datap->db_type; 71157c478bd9Sstevel@tonic-gate 71167c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_PASSFP) { 71177c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL)) 71187c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 71197c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK; 71207c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 71217c478bd9Sstevel@tonic-gate qbackenable(q, pri); 71227c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 71237c478bd9Sstevel@tonic-gate return (EBADMSG); 71247c478bd9Sstevel@tonic-gate } 71257c478bd9Sstevel@tonic-gate ASSERT(type != M_SIG); 71267c478bd9Sstevel@tonic-gate 71277c478bd9Sstevel@tonic-gate if (flags & MSG_IPEEK) { 71287c478bd9Sstevel@tonic-gate /* 71297c478bd9Sstevel@tonic-gate * Clear any struioflag - we do the uiomove over again 71307c478bd9Sstevel@tonic-gate * when peeking since it simplifies the code. 71317c478bd9Sstevel@tonic-gate * 71327c478bd9Sstevel@tonic-gate * Dup the message and put the original back on the queue. 71337c478bd9Sstevel@tonic-gate * If dupmsg() fails, try again with copymsg() to see if 71347c478bd9Sstevel@tonic-gate * there is indeed a shortage of memory. dupmsg() may fail 71357c478bd9Sstevel@tonic-gate * if db_ref in any of the messages reaches its limit. 71367c478bd9Sstevel@tonic-gate */ 71377c478bd9Sstevel@tonic-gate if ((nbp = dupmsg(bp)) == NULL && (nbp = copymsg(bp)) == NULL) { 71387c478bd9Sstevel@tonic-gate /* 71397c478bd9Sstevel@tonic-gate * Restore the state of the stream head since we 71407c478bd9Sstevel@tonic-gate * need to drop sd_lock (strwaitbuf is sleeping). 71417c478bd9Sstevel@tonic-gate */ 71427c478bd9Sstevel@tonic-gate size_t size = msgdsize(bp); 71437c478bd9Sstevel@tonic-gate 71447c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL)) 71457c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 71467c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK; 71477c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 71487c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 71497c478bd9Sstevel@tonic-gate error = strwaitbuf(size, BPRI_HI); 71507c478bd9Sstevel@tonic-gate if (error) { 71517c478bd9Sstevel@tonic-gate /* 71527c478bd9Sstevel@tonic-gate * There is no net change to the queue thus 71537c478bd9Sstevel@tonic-gate * no need to qbackenable. 71547c478bd9Sstevel@tonic-gate */ 71557c478bd9Sstevel@tonic-gate return (error); 71567c478bd9Sstevel@tonic-gate } 71577c478bd9Sstevel@tonic-gate goto retry; 71587c478bd9Sstevel@tonic-gate } 71597c478bd9Sstevel@tonic-gate 71607c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && (stp->sd_mark == NULL)) 71617c478bd9Sstevel@tonic-gate stp->sd_mark = bp; 71627c478bd9Sstevel@tonic-gate bp->b_flag |= mark & ~_LASTMARK; 71637c478bd9Sstevel@tonic-gate putback(stp, q, bp, pri); 71647c478bd9Sstevel@tonic-gate bp = nbp; 71657c478bd9Sstevel@tonic-gate } 71667c478bd9Sstevel@tonic-gate 71677c478bd9Sstevel@tonic-gate /* 71687c478bd9Sstevel@tonic-gate * Set this flag so strrput will not generate signals. Need to 71697c478bd9Sstevel@tonic-gate * make sure this flag is cleared before leaving this routine 71707c478bd9Sstevel@tonic-gate * else signals will stop being sent. 71717c478bd9Sstevel@tonic-gate */ 71727c478bd9Sstevel@tonic-gate stp->sd_flag |= STRGETINPROG; 71737c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 71747c478bd9Sstevel@tonic-gate 7175c28749e9Skais if ((stp->sd_rputdatafunc != NULL) && (DB_TYPE(bp) == M_DATA) && 7176c28749e9Skais (!(DB_FLAGS(bp) & DBLK_COOKED))) { 7177c28749e9Skais 7178c28749e9Skais bp = (stp->sd_rputdatafunc)( 7179c28749e9Skais stp->sd_vnode, bp, NULL, 7180c28749e9Skais NULL, NULL, NULL); 7181c28749e9Skais 7182c28749e9Skais if (bp == NULL) 7183c28749e9Skais goto retry; 7184c28749e9Skais 7185c28749e9Skais DB_FLAGS(bp) |= DBLK_COOKED; 7186c28749e9Skais } 7187c28749e9Skais 71887c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 71897c478bd9Sstevel@tonic-gate stream_runservice(stp); 71907c478bd9Sstevel@tonic-gate 71917c478bd9Sstevel@tonic-gate /* 71927c478bd9Sstevel@tonic-gate * Set HIPRI flag if message is priority. 71937c478bd9Sstevel@tonic-gate */ 71947c478bd9Sstevel@tonic-gate if (type >= QPCTL) 71957c478bd9Sstevel@tonic-gate flg = MSG_HIPRI; 71967c478bd9Sstevel@tonic-gate else 71977c478bd9Sstevel@tonic-gate flg = MSG_BAND; 71987c478bd9Sstevel@tonic-gate 71997c478bd9Sstevel@tonic-gate /* 72007c478bd9Sstevel@tonic-gate * First process PROTO or PCPROTO blocks, if any. 72017c478bd9Sstevel@tonic-gate */ 72027c478bd9Sstevel@tonic-gate if (mctlp != NULL && type != M_DATA) { 72037c478bd9Sstevel@tonic-gate mblk_t *nbp; 72047c478bd9Sstevel@tonic-gate 72057c478bd9Sstevel@tonic-gate *mctlp = bp; 72067c478bd9Sstevel@tonic-gate while (bp->b_cont && bp->b_cont->b_datap->db_type != M_DATA) 72077c478bd9Sstevel@tonic-gate bp = bp->b_cont; 72087c478bd9Sstevel@tonic-gate nbp = bp->b_cont; 72097c478bd9Sstevel@tonic-gate bp->b_cont = NULL; 72107c478bd9Sstevel@tonic-gate bp = nbp; 72117c478bd9Sstevel@tonic-gate } 72127c478bd9Sstevel@tonic-gate 72137c478bd9Sstevel@tonic-gate if (bp && bp->b_datap->db_type != M_DATA) { 72147c478bd9Sstevel@tonic-gate /* 72157c478bd9Sstevel@tonic-gate * More PROTO blocks in msg. Will only happen if mctlp is NULL. 72167c478bd9Sstevel@tonic-gate */ 72177c478bd9Sstevel@tonic-gate more |= MORECTL; 72187c478bd9Sstevel@tonic-gate savemp = bp; 72197c478bd9Sstevel@tonic-gate while (bp && bp->b_datap->db_type != M_DATA) { 72207c478bd9Sstevel@tonic-gate savemptail = bp; 72217c478bd9Sstevel@tonic-gate bp = bp->b_cont; 72227c478bd9Sstevel@tonic-gate } 72237c478bd9Sstevel@tonic-gate savemptail->b_cont = NULL; 72247c478bd9Sstevel@tonic-gate } 72257c478bd9Sstevel@tonic-gate 72267c478bd9Sstevel@tonic-gate /* 72277c478bd9Sstevel@tonic-gate * Now process DATA blocks, if any. 72287c478bd9Sstevel@tonic-gate */ 72297c478bd9Sstevel@tonic-gate if (uiop == NULL) { 72307c478bd9Sstevel@tonic-gate /* Append data to tail of mctlp */ 72317c478bd9Sstevel@tonic-gate if (mctlp != NULL) { 72327c478bd9Sstevel@tonic-gate mblk_t **mpp = mctlp; 72337c478bd9Sstevel@tonic-gate 72347c478bd9Sstevel@tonic-gate while (*mpp != NULL) 72357c478bd9Sstevel@tonic-gate mpp = &((*mpp)->b_cont); 72367c478bd9Sstevel@tonic-gate *mpp = bp; 72377c478bd9Sstevel@tonic-gate bp = NULL; 72387c478bd9Sstevel@tonic-gate } 72397c478bd9Sstevel@tonic-gate } else if (uiop->uio_resid >= 0 && bp) { 72407c478bd9Sstevel@tonic-gate size_t oldresid = uiop->uio_resid; 72417c478bd9Sstevel@tonic-gate 72427c478bd9Sstevel@tonic-gate /* 72437c478bd9Sstevel@tonic-gate * If a streams message is likely to consist 72447c478bd9Sstevel@tonic-gate * of many small mblks, it is pulled up into 72457c478bd9Sstevel@tonic-gate * one continuous chunk of memory. 72467c478bd9Sstevel@tonic-gate * see longer comment at top of page 72477c478bd9Sstevel@tonic-gate * by mblk_pull_len declaration. 72487c478bd9Sstevel@tonic-gate */ 72497c478bd9Sstevel@tonic-gate 72507c478bd9Sstevel@tonic-gate if (MBLKL(bp) < mblk_pull_len) { 72517c478bd9Sstevel@tonic-gate (void) pullupmsg(bp, -1); 72527c478bd9Sstevel@tonic-gate } 72537c478bd9Sstevel@tonic-gate 72547c478bd9Sstevel@tonic-gate bp = struiocopyout(bp, uiop, &error); 72557c478bd9Sstevel@tonic-gate if (error != 0) { 72567c478bd9Sstevel@tonic-gate if (mctlp != NULL) { 72577c478bd9Sstevel@tonic-gate freemsg(*mctlp); 72587c478bd9Sstevel@tonic-gate *mctlp = NULL; 72597c478bd9Sstevel@tonic-gate } else 72607c478bd9Sstevel@tonic-gate freemsg(savemp); 72617c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 72627c478bd9Sstevel@tonic-gate /* 72637c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 72647c478bd9Sstevel@tonic-gate * first message 72657c478bd9Sstevel@tonic-gate */ 72667c478bd9Sstevel@tonic-gate if (!(flags & MSG_IPEEK) && (type >= QPCTL)) { 72677c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 72687c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 72697c478bd9Sstevel@tonic-gate } 72707c478bd9Sstevel@tonic-gate more = 0; 72717c478bd9Sstevel@tonic-gate goto getmout; 72727c478bd9Sstevel@tonic-gate } 72737c478bd9Sstevel@tonic-gate /* 72747c478bd9Sstevel@tonic-gate * (pr == 1) indicates a partial read. 72757c478bd9Sstevel@tonic-gate */ 72767c478bd9Sstevel@tonic-gate if (oldresid > uiop->uio_resid) 72777c478bd9Sstevel@tonic-gate pr = 1; 72787c478bd9Sstevel@tonic-gate } 72797c478bd9Sstevel@tonic-gate 72807c478bd9Sstevel@tonic-gate if (bp) { /* more data blocks in msg */ 72817c478bd9Sstevel@tonic-gate more |= MOREDATA; 72827c478bd9Sstevel@tonic-gate if (savemp) 72837c478bd9Sstevel@tonic-gate savemptail->b_cont = bp; 72847c478bd9Sstevel@tonic-gate else 72857c478bd9Sstevel@tonic-gate savemp = bp; 72867c478bd9Sstevel@tonic-gate } 72877c478bd9Sstevel@tonic-gate 72887c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 72897c478bd9Sstevel@tonic-gate if (savemp) { 72907c478bd9Sstevel@tonic-gate if (flags & (MSG_IPEEK|MSG_DISCARDTAIL)) { 72917c478bd9Sstevel@tonic-gate /* 72927c478bd9Sstevel@tonic-gate * When MSG_DISCARDTAIL is set or 72937c478bd9Sstevel@tonic-gate * when peeking discard any tail. When peeking this 72947c478bd9Sstevel@tonic-gate * is the tail of the dup that was copied out - the 72957c478bd9Sstevel@tonic-gate * message has already been putback on the queue. 72967c478bd9Sstevel@tonic-gate * Return MOREDATA to the caller even though the data 72977c478bd9Sstevel@tonic-gate * is discarded. This is used by sockets (to 72987c478bd9Sstevel@tonic-gate * set MSG_TRUNC). 72997c478bd9Sstevel@tonic-gate */ 73007c478bd9Sstevel@tonic-gate freemsg(savemp); 73017c478bd9Sstevel@tonic-gate if (!(flags & MSG_IPEEK) && (type >= QPCTL)) { 73027c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 73037c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 73047c478bd9Sstevel@tonic-gate } 73057c478bd9Sstevel@tonic-gate } else if (pr && (savemp->b_datap->db_type == M_DATA) && 73067c478bd9Sstevel@tonic-gate msgnodata(savemp)) { 73077c478bd9Sstevel@tonic-gate /* 73087c478bd9Sstevel@tonic-gate * Avoid queuing a zero-length tail part of 73097c478bd9Sstevel@tonic-gate * a message. pr=1 indicates that we read some of 73107c478bd9Sstevel@tonic-gate * the message. 73117c478bd9Sstevel@tonic-gate */ 73127c478bd9Sstevel@tonic-gate freemsg(savemp); 73137c478bd9Sstevel@tonic-gate more &= ~MOREDATA; 73147c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 73157c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 73167c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 73177c478bd9Sstevel@tonic-gate } 73187c478bd9Sstevel@tonic-gate } else { 73197c478bd9Sstevel@tonic-gate savemp->b_band = pri; 73207c478bd9Sstevel@tonic-gate /* 73217c478bd9Sstevel@tonic-gate * If the first message was HIPRI and the one we're 73227c478bd9Sstevel@tonic-gate * putting back isn't, then clear STRPRI, otherwise 73237c478bd9Sstevel@tonic-gate * set STRPRI again. Note that we must set STRPRI 73247c478bd9Sstevel@tonic-gate * again since the flush logic in strrput_nondata() 73257c478bd9Sstevel@tonic-gate * may have cleared it while we had sd_lock dropped. 73267c478bd9Sstevel@tonic-gate */ 73277c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 73287c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 73297c478bd9Sstevel@tonic-gate if (queclass(savemp) < QPCTL) 73307c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 73317c478bd9Sstevel@tonic-gate else 73327c478bd9Sstevel@tonic-gate stp->sd_flag |= STRPRI; 73337c478bd9Sstevel@tonic-gate } else if (queclass(savemp) >= QPCTL) { 73347c478bd9Sstevel@tonic-gate /* 73357c478bd9Sstevel@tonic-gate * The first message was not a HIPRI message, 73367c478bd9Sstevel@tonic-gate * but the one we are about to putback is. 73377c478bd9Sstevel@tonic-gate * For simplicitly, we do not allow for HIPRI 73387c478bd9Sstevel@tonic-gate * messages to be embedded in the message 73397c478bd9Sstevel@tonic-gate * body, so just force it to same type as 73407c478bd9Sstevel@tonic-gate * first message. 73417c478bd9Sstevel@tonic-gate */ 73427c478bd9Sstevel@tonic-gate ASSERT(type == M_DATA || type == M_PROTO); 73437c478bd9Sstevel@tonic-gate ASSERT(savemp->b_datap->db_type == M_PCPROTO); 73447c478bd9Sstevel@tonic-gate savemp->b_datap->db_type = type; 73457c478bd9Sstevel@tonic-gate } 73467c478bd9Sstevel@tonic-gate if (mark != 0) { 73477c478bd9Sstevel@tonic-gate if ((mark & _LASTMARK) && 73487c478bd9Sstevel@tonic-gate (stp->sd_mark == NULL)) { 73497c478bd9Sstevel@tonic-gate /* 73507c478bd9Sstevel@tonic-gate * If another marked message arrived 73517c478bd9Sstevel@tonic-gate * while sd_lock was not held sd_mark 73527c478bd9Sstevel@tonic-gate * would be non-NULL. 73537c478bd9Sstevel@tonic-gate */ 73547c478bd9Sstevel@tonic-gate stp->sd_mark = savemp; 73557c478bd9Sstevel@tonic-gate } 73567c478bd9Sstevel@tonic-gate savemp->b_flag |= mark & ~_LASTMARK; 73577c478bd9Sstevel@tonic-gate } 73587c478bd9Sstevel@tonic-gate putback(stp, q, savemp, pri); 73597c478bd9Sstevel@tonic-gate } 73607c478bd9Sstevel@tonic-gate } else if (!(flags & MSG_IPEEK)) { 73617c478bd9Sstevel@tonic-gate /* 73627c478bd9Sstevel@tonic-gate * The complete message was consumed. 73637c478bd9Sstevel@tonic-gate * 73647c478bd9Sstevel@tonic-gate * If another M_PCPROTO arrived while sd_lock was not held 73657c478bd9Sstevel@tonic-gate * it would have been discarded since STRPRI was still set. 73667c478bd9Sstevel@tonic-gate * 73677c478bd9Sstevel@tonic-gate * Move the MSG*MARKNEXT information 73687c478bd9Sstevel@tonic-gate * to the stream head just in case 73697c478bd9Sstevel@tonic-gate * the read queue becomes empty. 73707c478bd9Sstevel@tonic-gate * clear stream head hi pri flag based on 73717c478bd9Sstevel@tonic-gate * first message 73727c478bd9Sstevel@tonic-gate * 73737c478bd9Sstevel@tonic-gate * If the stream head was at the mark 73747c478bd9Sstevel@tonic-gate * (STRATMARK) before we dropped sd_lock above 73757c478bd9Sstevel@tonic-gate * and some data was consumed then we have 73767c478bd9Sstevel@tonic-gate * moved past the mark thus STRATMARK is 73777c478bd9Sstevel@tonic-gate * cleared. However, if a message arrived in 73787c478bd9Sstevel@tonic-gate * strrput during the copyout above causing 73797c478bd9Sstevel@tonic-gate * STRATMARK to be set we can not clear that 73807c478bd9Sstevel@tonic-gate * flag. 73817c478bd9Sstevel@tonic-gate * XXX A "perimeter" would help by single-threading strrput, 73827c478bd9Sstevel@tonic-gate * strread, strgetmsg and kstrgetmsg. 73837c478bd9Sstevel@tonic-gate */ 73847c478bd9Sstevel@tonic-gate if (type >= QPCTL) { 73857c478bd9Sstevel@tonic-gate ASSERT(type == M_PCPROTO); 73867c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRPRI; 73877c478bd9Sstevel@tonic-gate } 73887c478bd9Sstevel@tonic-gate if (mark & (MSGMARKNEXT|MSGNOTMARKNEXT|MSGMARK)) { 73897c478bd9Sstevel@tonic-gate if (mark & MSGMARKNEXT) { 73907c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK; 73917c478bd9Sstevel@tonic-gate stp->sd_flag |= STRATMARK; 73927c478bd9Sstevel@tonic-gate } else if (mark & MSGNOTMARKNEXT) { 73937c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 73947c478bd9Sstevel@tonic-gate stp->sd_flag |= STRNOTATMARK; 73957c478bd9Sstevel@tonic-gate } else { 73967c478bd9Sstevel@tonic-gate stp->sd_flag &= ~(STRATMARK|STRNOTATMARK); 73977c478bd9Sstevel@tonic-gate } 73987c478bd9Sstevel@tonic-gate } else if (pr && (old_sd_flag & STRATMARK)) { 73997c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 74007c478bd9Sstevel@tonic-gate } 74017c478bd9Sstevel@tonic-gate } 74027c478bd9Sstevel@tonic-gate 74037c478bd9Sstevel@tonic-gate *flagsp = flg; 74047c478bd9Sstevel@tonic-gate *prip = pri; 74057c478bd9Sstevel@tonic-gate 74067c478bd9Sstevel@tonic-gate /* 74077c478bd9Sstevel@tonic-gate * Getmsg cleanup processing - if the state of the queue has changed 74087c478bd9Sstevel@tonic-gate * some signals may need to be sent and/or poll awakened. 74097c478bd9Sstevel@tonic-gate */ 74107c478bd9Sstevel@tonic-gate getmout: 74117c478bd9Sstevel@tonic-gate qbackenable(q, pri); 74127c478bd9Sstevel@tonic-gate 74137c478bd9Sstevel@tonic-gate /* 74147c478bd9Sstevel@tonic-gate * We dropped the stream head lock above. Send all M_SIG messages 74157c478bd9Sstevel@tonic-gate * before processing stream head for SIGPOLL messages. 74167c478bd9Sstevel@tonic-gate */ 74177c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 74187c478bd9Sstevel@tonic-gate while ((bp = q->q_first) != NULL && 74197c478bd9Sstevel@tonic-gate (bp->b_datap->db_type == M_SIG)) { 74207c478bd9Sstevel@tonic-gate /* 74217c478bd9Sstevel@tonic-gate * sd_lock is held so the content of the read queue can not 74227c478bd9Sstevel@tonic-gate * change. 74237c478bd9Sstevel@tonic-gate */ 74247c478bd9Sstevel@tonic-gate bp = getq(q); 74257c478bd9Sstevel@tonic-gate ASSERT(bp != NULL && bp->b_datap->db_type == M_SIG); 74267c478bd9Sstevel@tonic-gate 74277c478bd9Sstevel@tonic-gate strsignal_nolock(stp, *bp->b_rptr, (int32_t)bp->b_band); 74287c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 74297c478bd9Sstevel@tonic-gate freemsg(bp); 74307c478bd9Sstevel@tonic-gate if (STREAM_NEEDSERVICE(stp)) 74317c478bd9Sstevel@tonic-gate stream_runservice(stp); 74327c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 74337c478bd9Sstevel@tonic-gate } 74347c478bd9Sstevel@tonic-gate 74357c478bd9Sstevel@tonic-gate /* 74367c478bd9Sstevel@tonic-gate * stream head cannot change while we make the determination 74377c478bd9Sstevel@tonic-gate * whether or not to send a signal. Drop the flag to allow strrput 74387c478bd9Sstevel@tonic-gate * to send firstmsgsigs again. 74397c478bd9Sstevel@tonic-gate */ 74407c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRGETINPROG; 74417c478bd9Sstevel@tonic-gate 74427c478bd9Sstevel@tonic-gate /* 74437c478bd9Sstevel@tonic-gate * If the type of message at the front of the queue changed 74447c478bd9Sstevel@tonic-gate * due to the receive the appropriate signals and pollwakeup events 74457c478bd9Sstevel@tonic-gate * are generated. The type of changes are: 74467c478bd9Sstevel@tonic-gate * Processed a hipri message, q_first is not hipri. 74477c478bd9Sstevel@tonic-gate * Processed a band X message, and q_first is band Y. 74487c478bd9Sstevel@tonic-gate * The generated signals and pollwakeups are identical to what 74497c478bd9Sstevel@tonic-gate * strrput() generates should the message that is now on q_first 74507c478bd9Sstevel@tonic-gate * arrive to an empty read queue. 74517c478bd9Sstevel@tonic-gate * 74527c478bd9Sstevel@tonic-gate * Note: only strrput will send a signal for a hipri message. 74537c478bd9Sstevel@tonic-gate */ 74547c478bd9Sstevel@tonic-gate if ((bp = q->q_first) != NULL && !(stp->sd_flag & STRPRI)) { 74557c478bd9Sstevel@tonic-gate strsigset_t signals = 0; 74567c478bd9Sstevel@tonic-gate strpollset_t pollwakeups = 0; 74577c478bd9Sstevel@tonic-gate 74587c478bd9Sstevel@tonic-gate if (flg & MSG_HIPRI) { 74597c478bd9Sstevel@tonic-gate /* 74607c478bd9Sstevel@tonic-gate * Removed a hipri message. Regular data at 74617c478bd9Sstevel@tonic-gate * the front of the queue. 74627c478bd9Sstevel@tonic-gate */ 74637c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 74647c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDNORM; 74657c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 74667c478bd9Sstevel@tonic-gate } else { 74677c478bd9Sstevel@tonic-gate signals = S_INPUT | S_RDBAND; 74687c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 74697c478bd9Sstevel@tonic-gate } 74707c478bd9Sstevel@tonic-gate } else if (pri != bp->b_band) { 74717c478bd9Sstevel@tonic-gate /* 74727c478bd9Sstevel@tonic-gate * The band is different for the new q_first. 74737c478bd9Sstevel@tonic-gate */ 74747c478bd9Sstevel@tonic-gate if (bp->b_band == 0) { 74757c478bd9Sstevel@tonic-gate signals = S_RDNORM; 74767c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDNORM; 74777c478bd9Sstevel@tonic-gate } else { 74787c478bd9Sstevel@tonic-gate signals = S_RDBAND; 74797c478bd9Sstevel@tonic-gate pollwakeups = POLLIN | POLLRDBAND; 74807c478bd9Sstevel@tonic-gate } 74817c478bd9Sstevel@tonic-gate } 74827c478bd9Sstevel@tonic-gate 74837c478bd9Sstevel@tonic-gate if (pollwakeups != 0) { 74847c478bd9Sstevel@tonic-gate if (pollwakeups == (POLLIN | POLLRDNORM)) { 74857c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN)) 74867c478bd9Sstevel@tonic-gate goto no_pollwake; 74877c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN; 74887c478bd9Sstevel@tonic-gate } 74897c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 74907c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollwakeups); 74917c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 74927c478bd9Sstevel@tonic-gate } 74937c478bd9Sstevel@tonic-gate no_pollwake: 74947c478bd9Sstevel@tonic-gate 74957c478bd9Sstevel@tonic-gate if (stp->sd_sigflags & signals) 74967c478bd9Sstevel@tonic-gate strsendsig(stp->sd_siglist, signals, bp->b_band, 0); 74977c478bd9Sstevel@tonic-gate } 74987c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 74997c478bd9Sstevel@tonic-gate 75007c478bd9Sstevel@tonic-gate rvp->r_val1 = more; 75017c478bd9Sstevel@tonic-gate return (error); 75027c478bd9Sstevel@tonic-gate #undef _LASTMARK 75037c478bd9Sstevel@tonic-gate } 75047c478bd9Sstevel@tonic-gate 75057c478bd9Sstevel@tonic-gate /* 75067c478bd9Sstevel@tonic-gate * Put a message downstream. 75077c478bd9Sstevel@tonic-gate * 75087c478bd9Sstevel@tonic-gate * NOTE: strputmsg and kstrputmsg have much of the logic in common. 75097c478bd9Sstevel@tonic-gate */ 75107c478bd9Sstevel@tonic-gate int 75117c478bd9Sstevel@tonic-gate strputmsg( 75127c478bd9Sstevel@tonic-gate struct vnode *vp, 75137c478bd9Sstevel@tonic-gate struct strbuf *mctl, 75147c478bd9Sstevel@tonic-gate struct strbuf *mdata, 75157c478bd9Sstevel@tonic-gate unsigned char pri, 75167c478bd9Sstevel@tonic-gate int flag, 75177c478bd9Sstevel@tonic-gate int fmode) 75187c478bd9Sstevel@tonic-gate { 75197c478bd9Sstevel@tonic-gate struct stdata *stp; 75207c478bd9Sstevel@tonic-gate queue_t *wqp; 75217c478bd9Sstevel@tonic-gate mblk_t *mp; 75227c478bd9Sstevel@tonic-gate ssize_t msgsize; 75237c478bd9Sstevel@tonic-gate ssize_t rmin, rmax; 75247c478bd9Sstevel@tonic-gate int error; 75257c478bd9Sstevel@tonic-gate struct uio uios; 75267c478bd9Sstevel@tonic-gate struct uio *uiop = &uios; 75277c478bd9Sstevel@tonic-gate struct iovec iovs; 75287c478bd9Sstevel@tonic-gate int xpg4 = 0; 75297c478bd9Sstevel@tonic-gate 75307c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 75317c478bd9Sstevel@tonic-gate stp = vp->v_stream; 75327c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq; 75337c478bd9Sstevel@tonic-gate 75347c478bd9Sstevel@tonic-gate /* 75357c478bd9Sstevel@tonic-gate * If it is an XPG4 application, we need to send 75367c478bd9Sstevel@tonic-gate * SIGPIPE below 75377c478bd9Sstevel@tonic-gate */ 75387c478bd9Sstevel@tonic-gate 75397c478bd9Sstevel@tonic-gate xpg4 = (flag & MSG_XPG4) ? 1 : 0; 75407c478bd9Sstevel@tonic-gate flag &= ~MSG_XPG4; 75417c478bd9Sstevel@tonic-gate 75427c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 75437c478bd9Sstevel@tonic-gate if (audit_active) 75447c478bd9Sstevel@tonic-gate audit_strputmsg(vp, mctl, mdata, pri, flag, fmode); 75457c478bd9Sstevel@tonic-gate #endif 75467c478bd9Sstevel@tonic-gate 75477c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 75489acbbeafSnn35248 75499acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 75507c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 75517c478bd9Sstevel@tonic-gate return (error); 75527c478bd9Sstevel@tonic-gate } 75537c478bd9Sstevel@tonic-gate 75549acbbeafSnn35248 if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) { 75559acbbeafSnn35248 error = strwriteable(stp, B_FALSE, xpg4); 75569acbbeafSnn35248 if (error != 0) { 75579acbbeafSnn35248 mutex_exit(&stp->sd_lock); 75589acbbeafSnn35248 return (error); 75599acbbeafSnn35248 } 75609acbbeafSnn35248 } 75619acbbeafSnn35248 75629acbbeafSnn35248 mutex_exit(&stp->sd_lock); 75639acbbeafSnn35248 75647c478bd9Sstevel@tonic-gate /* 75657c478bd9Sstevel@tonic-gate * Check for legal flag value. 75667c478bd9Sstevel@tonic-gate */ 75677c478bd9Sstevel@tonic-gate switch (flag) { 75687c478bd9Sstevel@tonic-gate case MSG_HIPRI: 75697c478bd9Sstevel@tonic-gate if ((mctl->len < 0) || (pri != 0)) 75707c478bd9Sstevel@tonic-gate return (EINVAL); 75717c478bd9Sstevel@tonic-gate break; 75727c478bd9Sstevel@tonic-gate case MSG_BAND: 75737c478bd9Sstevel@tonic-gate break; 75747c478bd9Sstevel@tonic-gate 75757c478bd9Sstevel@tonic-gate default: 75767c478bd9Sstevel@tonic-gate return (EINVAL); 75777c478bd9Sstevel@tonic-gate } 75787c478bd9Sstevel@tonic-gate 75797c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_IN, 75807c478bd9Sstevel@tonic-gate "strputmsg in:stp %p", stp); 75817c478bd9Sstevel@tonic-gate 75827c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */ 75837c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz; 75847c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz; 75857c478bd9Sstevel@tonic-gate 75867c478bd9Sstevel@tonic-gate /* 75877c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within the 75887c478bd9Sstevel@tonic-gate * limits of the max and min receive packet sizes and do 75897c478bd9Sstevel@tonic-gate * not exceed system limit. 75907c478bd9Sstevel@tonic-gate */ 75917c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ)); 75927c478bd9Sstevel@tonic-gate if (rmax == 0) { 75937c478bd9Sstevel@tonic-gate return (ERANGE); 75947c478bd9Sstevel@tonic-gate } 75957c478bd9Sstevel@tonic-gate /* 75967c478bd9Sstevel@tonic-gate * Use the MAXIMUM of sd_maxblk and q_maxpsz. 75977c478bd9Sstevel@tonic-gate * Needed to prevent partial failures in the strmakedata loop. 75987c478bd9Sstevel@tonic-gate */ 75997c478bd9Sstevel@tonic-gate if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk) 76007c478bd9Sstevel@tonic-gate rmax = stp->sd_maxblk; 76017c478bd9Sstevel@tonic-gate 76027c478bd9Sstevel@tonic-gate if ((msgsize = mdata->len) < 0) { 76037c478bd9Sstevel@tonic-gate msgsize = 0; 76047c478bd9Sstevel@tonic-gate rmin = 0; /* no range check for NULL data part */ 76057c478bd9Sstevel@tonic-gate } 76067c478bd9Sstevel@tonic-gate if ((msgsize < rmin) || 76077c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ)) || 76087c478bd9Sstevel@tonic-gate (mctl->len > strctlsz)) { 76097c478bd9Sstevel@tonic-gate return (ERANGE); 76107c478bd9Sstevel@tonic-gate } 76117c478bd9Sstevel@tonic-gate 76127c478bd9Sstevel@tonic-gate /* 76137c478bd9Sstevel@tonic-gate * Setup uio and iov for data part 76147c478bd9Sstevel@tonic-gate */ 76157c478bd9Sstevel@tonic-gate iovs.iov_base = mdata->buf; 76167c478bd9Sstevel@tonic-gate iovs.iov_len = msgsize; 76177c478bd9Sstevel@tonic-gate uios.uio_iov = &iovs; 76187c478bd9Sstevel@tonic-gate uios.uio_iovcnt = 1; 76197c478bd9Sstevel@tonic-gate uios.uio_loffset = 0; 76207c478bd9Sstevel@tonic-gate uios.uio_segflg = UIO_USERSPACE; 76217c478bd9Sstevel@tonic-gate uios.uio_fmode = fmode; 76227c478bd9Sstevel@tonic-gate uios.uio_extflg = UIO_COPY_DEFAULT; 76237c478bd9Sstevel@tonic-gate uios.uio_resid = msgsize; 76247c478bd9Sstevel@tonic-gate uios.uio_offset = 0; 76257c478bd9Sstevel@tonic-gate 76267c478bd9Sstevel@tonic-gate /* Ignore flow control in strput for HIPRI */ 76277c478bd9Sstevel@tonic-gate if (flag & MSG_HIPRI) 76287c478bd9Sstevel@tonic-gate flag |= MSG_IGNFLOW; 76297c478bd9Sstevel@tonic-gate 76307c478bd9Sstevel@tonic-gate for (;;) { 76317c478bd9Sstevel@tonic-gate int done = 0; 76327c478bd9Sstevel@tonic-gate 76337c478bd9Sstevel@tonic-gate /* 76347c478bd9Sstevel@tonic-gate * strput will always free the ctl mblk - even when strput 76357c478bd9Sstevel@tonic-gate * fails. 76367c478bd9Sstevel@tonic-gate */ 76377c478bd9Sstevel@tonic-gate if ((error = strmakectl(mctl, flag, fmode, &mp)) != 0) { 76387c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT, 76397c478bd9Sstevel@tonic-gate "strputmsg out:stp %p out %d error %d", 76407c478bd9Sstevel@tonic-gate stp, 1, error); 76417c478bd9Sstevel@tonic-gate return (error); 76427c478bd9Sstevel@tonic-gate } 76437c478bd9Sstevel@tonic-gate /* 76447c478bd9Sstevel@tonic-gate * Verify that the whole message can be transferred by 76457c478bd9Sstevel@tonic-gate * strput. 76467c478bd9Sstevel@tonic-gate */ 76477c478bd9Sstevel@tonic-gate ASSERT(stp->sd_maxblk == INFPSZ || 76487c478bd9Sstevel@tonic-gate stp->sd_maxblk >= mdata->len); 76497c478bd9Sstevel@tonic-gate 76507c478bd9Sstevel@tonic-gate msgsize = mdata->len; 76517c478bd9Sstevel@tonic-gate error = strput(stp, mp, uiop, &msgsize, 0, pri, flag); 76527c478bd9Sstevel@tonic-gate mdata->len = msgsize; 76537c478bd9Sstevel@tonic-gate 76547c478bd9Sstevel@tonic-gate if (error == 0) 76557c478bd9Sstevel@tonic-gate break; 76567c478bd9Sstevel@tonic-gate 76577c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK) 76587c478bd9Sstevel@tonic-gate goto out; 76597c478bd9Sstevel@tonic-gate 76607c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 76617c478bd9Sstevel@tonic-gate /* 76627c478bd9Sstevel@tonic-gate * Check for a missed wakeup. 76637c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across 76647c478bd9Sstevel@tonic-gate * the canputnext. 76657c478bd9Sstevel@tonic-gate */ 76667c478bd9Sstevel@tonic-gate if (bcanputnext(wqp, pri)) { 76677c478bd9Sstevel@tonic-gate /* Try again */ 76687c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 76697c478bd9Sstevel@tonic-gate continue; 76707c478bd9Sstevel@tonic-gate } 76717c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAIT, 76727c478bd9Sstevel@tonic-gate "strputmsg wait:stp %p waits pri %d", stp, pri); 76737c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, WRITEWAIT, (ssize_t)0, fmode, -1, 76747c478bd9Sstevel@tonic-gate &done)) != 0) || done) { 76757c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 76767c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT, 76777c478bd9Sstevel@tonic-gate "strputmsg out:q %p out %d error %d", 76787c478bd9Sstevel@tonic-gate stp, 0, error); 76797c478bd9Sstevel@tonic-gate return (error); 76807c478bd9Sstevel@tonic-gate } 76817c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_STRPUTMSG_WAKE, 76827c478bd9Sstevel@tonic-gate "strputmsg wake:stp %p wakes", stp); 76839acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 76847c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 76857c478bd9Sstevel@tonic-gate return (error); 76867c478bd9Sstevel@tonic-gate } 76879acbbeafSnn35248 mutex_exit(&stp->sd_lock); 76889acbbeafSnn35248 } 76897c478bd9Sstevel@tonic-gate out: 76907c478bd9Sstevel@tonic-gate /* 76917c478bd9Sstevel@tonic-gate * For historic reasons, applications expect EAGAIN 76927c478bd9Sstevel@tonic-gate * when data mblk could not be allocated. so change 76937c478bd9Sstevel@tonic-gate * ENOMEM back to EAGAIN 76947c478bd9Sstevel@tonic-gate */ 76957c478bd9Sstevel@tonic-gate if (error == ENOMEM) 76967c478bd9Sstevel@tonic-gate error = EAGAIN; 76977c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_STRPUTMSG_OUT, 76987c478bd9Sstevel@tonic-gate "strputmsg out:stp %p out %d error %d", stp, 2, error); 76997c478bd9Sstevel@tonic-gate return (error); 77007c478bd9Sstevel@tonic-gate } 77017c478bd9Sstevel@tonic-gate 77027c478bd9Sstevel@tonic-gate /* 77037c478bd9Sstevel@tonic-gate * Put a message downstream. 77047c478bd9Sstevel@tonic-gate * Can send only an M_PROTO/M_PCPROTO by passing in a NULL uiop. 77057c478bd9Sstevel@tonic-gate * The fmode flag (NDELAY, NONBLOCK) is the or of the flags in the uio 77067c478bd9Sstevel@tonic-gate * and the fmode parameter. 77077c478bd9Sstevel@tonic-gate * 77087c478bd9Sstevel@tonic-gate * This routine handles the consolidation private flags: 77097c478bd9Sstevel@tonic-gate * MSG_IGNERROR Ignore any stream head error except STPLEX. 77107c478bd9Sstevel@tonic-gate * MSG_HOLDSIG Hold signals while waiting for data. 77117c478bd9Sstevel@tonic-gate * MSG_IGNFLOW Don't check streams flow control. 77127c478bd9Sstevel@tonic-gate * 77137c478bd9Sstevel@tonic-gate * NOTE: strputmsg and kstrputmsg have much of the logic in common. 77147c478bd9Sstevel@tonic-gate */ 77157c478bd9Sstevel@tonic-gate int 77167c478bd9Sstevel@tonic-gate kstrputmsg( 77177c478bd9Sstevel@tonic-gate struct vnode *vp, 77187c478bd9Sstevel@tonic-gate mblk_t *mctl, 77197c478bd9Sstevel@tonic-gate struct uio *uiop, 77207c478bd9Sstevel@tonic-gate ssize_t msgsize, 77217c478bd9Sstevel@tonic-gate unsigned char pri, 77227c478bd9Sstevel@tonic-gate int flag, 77237c478bd9Sstevel@tonic-gate int fmode) 77247c478bd9Sstevel@tonic-gate { 77257c478bd9Sstevel@tonic-gate struct stdata *stp; 77267c478bd9Sstevel@tonic-gate queue_t *wqp; 77277c478bd9Sstevel@tonic-gate ssize_t rmin, rmax; 77287c478bd9Sstevel@tonic-gate int error; 77297c478bd9Sstevel@tonic-gate 77307c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 77317c478bd9Sstevel@tonic-gate stp = vp->v_stream; 77327c478bd9Sstevel@tonic-gate wqp = stp->sd_wrq; 77337c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 77347c478bd9Sstevel@tonic-gate if (audit_active) 77357c478bd9Sstevel@tonic-gate audit_strputmsg(vp, NULL, NULL, pri, flag, fmode); 77367c478bd9Sstevel@tonic-gate #endif 7737e4506d67Smeem if (mctl == NULL) 7738e4506d67Smeem return (EINVAL); 77397c478bd9Sstevel@tonic-gate 77409acbbeafSnn35248 mutex_enter(&stp->sd_lock); 77419acbbeafSnn35248 77429acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 77439acbbeafSnn35248 mutex_exit(&stp->sd_lock); 77447c478bd9Sstevel@tonic-gate freemsg(mctl); 77457c478bd9Sstevel@tonic-gate return (error); 77467c478bd9Sstevel@tonic-gate } 77477c478bd9Sstevel@tonic-gate 77487c478bd9Sstevel@tonic-gate if ((stp->sd_flag & STPLEX) || !(flag & MSG_IGNERROR)) { 77497c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) { 77507c478bd9Sstevel@tonic-gate error = strwriteable(stp, B_FALSE, B_TRUE); 77517c478bd9Sstevel@tonic-gate if (error != 0) { 77529acbbeafSnn35248 mutex_exit(&stp->sd_lock); 77537c478bd9Sstevel@tonic-gate freemsg(mctl); 77547c478bd9Sstevel@tonic-gate return (error); 77557c478bd9Sstevel@tonic-gate } 77567c478bd9Sstevel@tonic-gate } 77577c478bd9Sstevel@tonic-gate } 77587c478bd9Sstevel@tonic-gate 77599acbbeafSnn35248 mutex_exit(&stp->sd_lock); 77609acbbeafSnn35248 77617c478bd9Sstevel@tonic-gate /* 77627c478bd9Sstevel@tonic-gate * Check for legal flag value. 77637c478bd9Sstevel@tonic-gate */ 77647c478bd9Sstevel@tonic-gate switch (flag & (MSG_HIPRI|MSG_BAND|MSG_ANY)) { 77657c478bd9Sstevel@tonic-gate case MSG_HIPRI: 7766e4506d67Smeem if (pri != 0) { 77677c478bd9Sstevel@tonic-gate freemsg(mctl); 77687c478bd9Sstevel@tonic-gate return (EINVAL); 77697c478bd9Sstevel@tonic-gate } 77707c478bd9Sstevel@tonic-gate break; 77717c478bd9Sstevel@tonic-gate case MSG_BAND: 77727c478bd9Sstevel@tonic-gate break; 77737c478bd9Sstevel@tonic-gate default: 77747c478bd9Sstevel@tonic-gate freemsg(mctl); 77757c478bd9Sstevel@tonic-gate return (EINVAL); 77767c478bd9Sstevel@tonic-gate } 77777c478bd9Sstevel@tonic-gate 77787c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_IN, 77797c478bd9Sstevel@tonic-gate "kstrputmsg in:stp %p", stp); 77807c478bd9Sstevel@tonic-gate 77817c478bd9Sstevel@tonic-gate /* get these values from those cached in the stream head */ 77827c478bd9Sstevel@tonic-gate rmin = stp->sd_qn_minpsz; 77837c478bd9Sstevel@tonic-gate rmax = stp->sd_qn_maxpsz; 77847c478bd9Sstevel@tonic-gate 77857c478bd9Sstevel@tonic-gate /* 77867c478bd9Sstevel@tonic-gate * Make sure ctl and data sizes together fall within the 77877c478bd9Sstevel@tonic-gate * limits of the max and min receive packet sizes and do 77887c478bd9Sstevel@tonic-gate * not exceed system limit. 77897c478bd9Sstevel@tonic-gate */ 77907c478bd9Sstevel@tonic-gate ASSERT((rmax >= 0) || (rmax == INFPSZ)); 77917c478bd9Sstevel@tonic-gate if (rmax == 0) { 77927c478bd9Sstevel@tonic-gate freemsg(mctl); 77937c478bd9Sstevel@tonic-gate return (ERANGE); 77947c478bd9Sstevel@tonic-gate } 77957c478bd9Sstevel@tonic-gate /* 77967c478bd9Sstevel@tonic-gate * Use the MAXIMUM of sd_maxblk and q_maxpsz. 77977c478bd9Sstevel@tonic-gate * Needed to prevent partial failures in the strmakedata loop. 77987c478bd9Sstevel@tonic-gate */ 77997c478bd9Sstevel@tonic-gate if (stp->sd_maxblk != INFPSZ && rmax != INFPSZ && rmax < stp->sd_maxblk) 78007c478bd9Sstevel@tonic-gate rmax = stp->sd_maxblk; 78017c478bd9Sstevel@tonic-gate 78027c478bd9Sstevel@tonic-gate if (uiop == NULL) { 78037c478bd9Sstevel@tonic-gate msgsize = -1; 78047c478bd9Sstevel@tonic-gate rmin = -1; /* no range check for NULL data part */ 78057c478bd9Sstevel@tonic-gate } else { 78067c478bd9Sstevel@tonic-gate /* Use uio flags as well as the fmode parameter flags */ 78077c478bd9Sstevel@tonic-gate fmode |= uiop->uio_fmode; 78087c478bd9Sstevel@tonic-gate 78097c478bd9Sstevel@tonic-gate if ((msgsize < rmin) || 78107c478bd9Sstevel@tonic-gate ((msgsize > rmax) && (rmax != INFPSZ))) { 78117c478bd9Sstevel@tonic-gate freemsg(mctl); 78127c478bd9Sstevel@tonic-gate return (ERANGE); 78137c478bd9Sstevel@tonic-gate } 78147c478bd9Sstevel@tonic-gate } 78157c478bd9Sstevel@tonic-gate 78167c478bd9Sstevel@tonic-gate /* Ignore flow control in strput for HIPRI */ 78177c478bd9Sstevel@tonic-gate if (flag & MSG_HIPRI) 78187c478bd9Sstevel@tonic-gate flag |= MSG_IGNFLOW; 78197c478bd9Sstevel@tonic-gate 78207c478bd9Sstevel@tonic-gate for (;;) { 78217c478bd9Sstevel@tonic-gate int done = 0; 78227c478bd9Sstevel@tonic-gate int waitflag; 78237c478bd9Sstevel@tonic-gate mblk_t *mp; 78247c478bd9Sstevel@tonic-gate 78257c478bd9Sstevel@tonic-gate /* 78267c478bd9Sstevel@tonic-gate * strput will always free the ctl mblk - even when strput 78277c478bd9Sstevel@tonic-gate * fails. If MSG_IGNFLOW is set then any error returned 78287c478bd9Sstevel@tonic-gate * will cause us to break the loop, so we don't need a copy 78297c478bd9Sstevel@tonic-gate * of the message. If MSG_IGNFLOW is not set, then we can 78307c478bd9Sstevel@tonic-gate * get hit by flow control and be forced to try again. In 78317c478bd9Sstevel@tonic-gate * this case we need to have a copy of the message. We 78327c478bd9Sstevel@tonic-gate * do this using copymsg since the message may get modified 78337c478bd9Sstevel@tonic-gate * by something below us. 78347c478bd9Sstevel@tonic-gate * 78357c478bd9Sstevel@tonic-gate * We've observed that many TPI providers do not check db_ref 78367c478bd9Sstevel@tonic-gate * on the control messages but blindly reuse them for the 78377c478bd9Sstevel@tonic-gate * T_OK_ACK/T_ERROR_ACK. Thus using copymsg is more 78387c478bd9Sstevel@tonic-gate * friendly to such providers than using dupmsg. Also, note 78397c478bd9Sstevel@tonic-gate * that sockfs uses MSG_IGNFLOW for all TPI control messages. 78407c478bd9Sstevel@tonic-gate * Only data messages are subject to flow control, hence 78417c478bd9Sstevel@tonic-gate * subject to this copymsg. 78427c478bd9Sstevel@tonic-gate */ 78437c478bd9Sstevel@tonic-gate if (flag & MSG_IGNFLOW) { 78447c478bd9Sstevel@tonic-gate mp = mctl; 78457c478bd9Sstevel@tonic-gate mctl = NULL; 78467c478bd9Sstevel@tonic-gate } else { 78477c478bd9Sstevel@tonic-gate do { 78487c478bd9Sstevel@tonic-gate /* 78497c478bd9Sstevel@tonic-gate * If a message has a free pointer, the message 78507c478bd9Sstevel@tonic-gate * must be dupmsg to maintain this pointer. 78517c478bd9Sstevel@tonic-gate * Code using this facility must be sure 78527c478bd9Sstevel@tonic-gate * that modules below will not change the 78537c478bd9Sstevel@tonic-gate * contents of the dblk without checking db_ref 78547c478bd9Sstevel@tonic-gate * first. If db_ref is > 1, then the module 78557c478bd9Sstevel@tonic-gate * needs to do a copymsg first. Otherwise, 78567c478bd9Sstevel@tonic-gate * the contents of the dblk may become 78577c478bd9Sstevel@tonic-gate * inconsistent because the freesmg/freeb below 78587c478bd9Sstevel@tonic-gate * may end up calling atomic_add_32_nv. 78597c478bd9Sstevel@tonic-gate * The atomic_add_32_nv in freeb (accessing 78607c478bd9Sstevel@tonic-gate * all of db_ref, db_type, db_flags, and 78617c478bd9Sstevel@tonic-gate * db_struioflag) does not prevent other threads 78627c478bd9Sstevel@tonic-gate * from concurrently trying to modify e.g. 78637c478bd9Sstevel@tonic-gate * db_type. 78647c478bd9Sstevel@tonic-gate */ 78657c478bd9Sstevel@tonic-gate if (mctl->b_datap->db_frtnp != NULL) 78667c478bd9Sstevel@tonic-gate mp = dupmsg(mctl); 78677c478bd9Sstevel@tonic-gate else 78687c478bd9Sstevel@tonic-gate mp = copymsg(mctl); 78697c478bd9Sstevel@tonic-gate 7870e4506d67Smeem if (mp != NULL) 78717c478bd9Sstevel@tonic-gate break; 78727c478bd9Sstevel@tonic-gate 78737c478bd9Sstevel@tonic-gate error = strwaitbuf(msgdsize(mctl), BPRI_MED); 78747c478bd9Sstevel@tonic-gate if (error) { 78757c478bd9Sstevel@tonic-gate freemsg(mctl); 78767c478bd9Sstevel@tonic-gate return (error); 78777c478bd9Sstevel@tonic-gate } 78787c478bd9Sstevel@tonic-gate } while (mp == NULL); 78797c478bd9Sstevel@tonic-gate } 78807c478bd9Sstevel@tonic-gate /* 78817c478bd9Sstevel@tonic-gate * Verify that all of msgsize can be transferred by 78827c478bd9Sstevel@tonic-gate * strput. 78837c478bd9Sstevel@tonic-gate */ 7884e4506d67Smeem ASSERT(stp->sd_maxblk == INFPSZ || stp->sd_maxblk >= msgsize); 78857c478bd9Sstevel@tonic-gate error = strput(stp, mp, uiop, &msgsize, 0, pri, flag); 78867c478bd9Sstevel@tonic-gate if (error == 0) 78877c478bd9Sstevel@tonic-gate break; 78887c478bd9Sstevel@tonic-gate 78897c478bd9Sstevel@tonic-gate if (error != EWOULDBLOCK) 78907c478bd9Sstevel@tonic-gate goto out; 78917c478bd9Sstevel@tonic-gate 78927c478bd9Sstevel@tonic-gate /* 78937c478bd9Sstevel@tonic-gate * IF MSG_IGNFLOW is set we should have broken out of loop 78947c478bd9Sstevel@tonic-gate * above. 78957c478bd9Sstevel@tonic-gate */ 78967c478bd9Sstevel@tonic-gate ASSERT(!(flag & MSG_IGNFLOW)); 78977c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 78987c478bd9Sstevel@tonic-gate /* 78997c478bd9Sstevel@tonic-gate * Check for a missed wakeup. 79007c478bd9Sstevel@tonic-gate * Needed since strput did not hold sd_lock across 79017c478bd9Sstevel@tonic-gate * the canputnext. 79027c478bd9Sstevel@tonic-gate */ 79037c478bd9Sstevel@tonic-gate if (bcanputnext(wqp, pri)) { 79047c478bd9Sstevel@tonic-gate /* Try again */ 79057c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 79067c478bd9Sstevel@tonic-gate continue; 79077c478bd9Sstevel@tonic-gate } 79087c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAIT, 79097c478bd9Sstevel@tonic-gate "kstrputmsg wait:stp %p waits pri %d", stp, pri); 79107c478bd9Sstevel@tonic-gate 79117c478bd9Sstevel@tonic-gate waitflag = WRITEWAIT; 79127c478bd9Sstevel@tonic-gate if (flag & (MSG_HOLDSIG|MSG_IGNERROR)) { 79137c478bd9Sstevel@tonic-gate if (flag & MSG_HOLDSIG) 79147c478bd9Sstevel@tonic-gate waitflag |= STR_NOSIG; 79157c478bd9Sstevel@tonic-gate if (flag & MSG_IGNERROR) 79167c478bd9Sstevel@tonic-gate waitflag |= STR_NOERROR; 79177c478bd9Sstevel@tonic-gate } 79187c478bd9Sstevel@tonic-gate if (((error = strwaitq(stp, waitflag, 79197c478bd9Sstevel@tonic-gate (ssize_t)0, fmode, -1, &done)) != 0) || done) { 79207c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 79217c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT, 79227c478bd9Sstevel@tonic-gate "kstrputmsg out:stp %p out %d error %d", 79237c478bd9Sstevel@tonic-gate stp, 0, error); 79247c478bd9Sstevel@tonic-gate freemsg(mctl); 79257c478bd9Sstevel@tonic-gate return (error); 79267c478bd9Sstevel@tonic-gate } 79277c478bd9Sstevel@tonic-gate TRACE_1(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_WAKE, 79287c478bd9Sstevel@tonic-gate "kstrputmsg wake:stp %p wakes", stp); 79299acbbeafSnn35248 if ((error = i_straccess(stp, JCWRITE)) != 0) { 79307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 79317c478bd9Sstevel@tonic-gate freemsg(mctl); 79327c478bd9Sstevel@tonic-gate return (error); 79337c478bd9Sstevel@tonic-gate } 79349acbbeafSnn35248 mutex_exit(&stp->sd_lock); 79357c478bd9Sstevel@tonic-gate } 79367c478bd9Sstevel@tonic-gate out: 79377c478bd9Sstevel@tonic-gate freemsg(mctl); 79387c478bd9Sstevel@tonic-gate /* 79397c478bd9Sstevel@tonic-gate * For historic reasons, applications expect EAGAIN 79407c478bd9Sstevel@tonic-gate * when data mblk could not be allocated. so change 79417c478bd9Sstevel@tonic-gate * ENOMEM back to EAGAIN 79427c478bd9Sstevel@tonic-gate */ 79437c478bd9Sstevel@tonic-gate if (error == ENOMEM) 79447c478bd9Sstevel@tonic-gate error = EAGAIN; 79457c478bd9Sstevel@tonic-gate TRACE_3(TR_FAC_STREAMS_FR, TR_KSTRPUTMSG_OUT, 79467c478bd9Sstevel@tonic-gate "kstrputmsg out:stp %p out %d error %d", stp, 2, error); 79477c478bd9Sstevel@tonic-gate return (error); 79487c478bd9Sstevel@tonic-gate } 79497c478bd9Sstevel@tonic-gate 79507c478bd9Sstevel@tonic-gate /* 79517c478bd9Sstevel@tonic-gate * Determines whether the necessary conditions are set on a stream 79527c478bd9Sstevel@tonic-gate * for it to be readable, writeable, or have exceptions. 79537c478bd9Sstevel@tonic-gate * 79547c478bd9Sstevel@tonic-gate * strpoll handles the consolidation private events: 79557c478bd9Sstevel@tonic-gate * POLLNOERR Do not return POLLERR even if there are stream 79567c478bd9Sstevel@tonic-gate * head errors. 79577c478bd9Sstevel@tonic-gate * Used by sockfs. 79587c478bd9Sstevel@tonic-gate * POLLRDDATA Do not return POLLIN unless at least one message on 79597c478bd9Sstevel@tonic-gate * the queue contains one or more M_DATA mblks. Thus 79607c478bd9Sstevel@tonic-gate * when this flag is set a queue with only 79617c478bd9Sstevel@tonic-gate * M_PROTO/M_PCPROTO mblks does not return POLLIN. 79627c478bd9Sstevel@tonic-gate * Used by sockfs to ignore T_EXDATA_IND messages. 79637c478bd9Sstevel@tonic-gate * 79647c478bd9Sstevel@tonic-gate * Note: POLLRDDATA assumes that synch streams only return messages with 79657c478bd9Sstevel@tonic-gate * an M_DATA attached (i.e. not messages consisting of only 79667c478bd9Sstevel@tonic-gate * an M_PROTO/M_PCPROTO part). 79677c478bd9Sstevel@tonic-gate */ 79687c478bd9Sstevel@tonic-gate int 79697c478bd9Sstevel@tonic-gate strpoll( 79707c478bd9Sstevel@tonic-gate struct stdata *stp, 79717c478bd9Sstevel@tonic-gate short events_arg, 79727c478bd9Sstevel@tonic-gate int anyyet, 79737c478bd9Sstevel@tonic-gate short *reventsp, 79747c478bd9Sstevel@tonic-gate struct pollhead **phpp) 79757c478bd9Sstevel@tonic-gate { 79767c478bd9Sstevel@tonic-gate int events = (ushort_t)events_arg; 79777c478bd9Sstevel@tonic-gate int retevents = 0; 79787c478bd9Sstevel@tonic-gate mblk_t *mp; 79797c478bd9Sstevel@tonic-gate qband_t *qbp; 79807c478bd9Sstevel@tonic-gate long sd_flags = stp->sd_flag; 79817c478bd9Sstevel@tonic-gate int headlocked = 0; 79827c478bd9Sstevel@tonic-gate 79837c478bd9Sstevel@tonic-gate /* 79847c478bd9Sstevel@tonic-gate * For performance, a single 'if' tests for most possible edge 79857c478bd9Sstevel@tonic-gate * conditions in one shot 79867c478bd9Sstevel@tonic-gate */ 79877c478bd9Sstevel@tonic-gate if (sd_flags & (STPLEX | STRDERR | STWRERR)) { 79887c478bd9Sstevel@tonic-gate if (sd_flags & STPLEX) { 79897c478bd9Sstevel@tonic-gate *reventsp = POLLNVAL; 79907c478bd9Sstevel@tonic-gate return (EINVAL); 79917c478bd9Sstevel@tonic-gate } 79927c478bd9Sstevel@tonic-gate if (((events & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) && 79937c478bd9Sstevel@tonic-gate (sd_flags & STRDERR)) || 79947c478bd9Sstevel@tonic-gate ((events & (POLLOUT | POLLWRNORM | POLLWRBAND)) && 79957c478bd9Sstevel@tonic-gate (sd_flags & STWRERR))) { 79967c478bd9Sstevel@tonic-gate if (!(events & POLLNOERR)) { 79977c478bd9Sstevel@tonic-gate *reventsp = POLLERR; 79987c478bd9Sstevel@tonic-gate return (0); 79997c478bd9Sstevel@tonic-gate } 80007c478bd9Sstevel@tonic-gate } 80017c478bd9Sstevel@tonic-gate } 80027c478bd9Sstevel@tonic-gate if (sd_flags & STRHUP) { 80037c478bd9Sstevel@tonic-gate retevents |= POLLHUP; 80047c478bd9Sstevel@tonic-gate } else if (events & (POLLWRNORM | POLLWRBAND)) { 80057c478bd9Sstevel@tonic-gate queue_t *tq; 80067c478bd9Sstevel@tonic-gate queue_t *qp = stp->sd_wrq; 80077c478bd9Sstevel@tonic-gate 80087c478bd9Sstevel@tonic-gate claimstr(qp); 80097c478bd9Sstevel@tonic-gate /* Find next module forward that has a service procedure */ 80107c478bd9Sstevel@tonic-gate tq = qp->q_next->q_nfsrv; 80117c478bd9Sstevel@tonic-gate ASSERT(tq != NULL); 80127c478bd9Sstevel@tonic-gate 80137c478bd9Sstevel@tonic-gate polllock(&stp->sd_pollist, QLOCK(tq)); 80147c478bd9Sstevel@tonic-gate if (events & POLLWRNORM) { 80157c478bd9Sstevel@tonic-gate queue_t *sqp; 80167c478bd9Sstevel@tonic-gate 80177c478bd9Sstevel@tonic-gate if (tq->q_flag & QFULL) 80187c478bd9Sstevel@tonic-gate /* ensure backq svc procedure runs */ 80197c478bd9Sstevel@tonic-gate tq->q_flag |= QWANTW; 80207c478bd9Sstevel@tonic-gate else if ((sqp = stp->sd_struiowrq) != NULL) { 80217c478bd9Sstevel@tonic-gate /* Check sync stream barrier write q */ 80227c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq)); 80237c478bd9Sstevel@tonic-gate polllock(&stp->sd_pollist, QLOCK(sqp)); 80247c478bd9Sstevel@tonic-gate if (sqp->q_flag & QFULL) 80257c478bd9Sstevel@tonic-gate /* ensure pollwakeup() is done */ 80267c478bd9Sstevel@tonic-gate sqp->q_flag |= QWANTWSYNC; 80277c478bd9Sstevel@tonic-gate else 80287c478bd9Sstevel@tonic-gate retevents |= POLLOUT; 80297c478bd9Sstevel@tonic-gate /* More write events to process ??? */ 80307c478bd9Sstevel@tonic-gate if (! (events & POLLWRBAND)) { 80317c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(sqp)); 80327c478bd9Sstevel@tonic-gate releasestr(qp); 80337c478bd9Sstevel@tonic-gate goto chkrd; 80347c478bd9Sstevel@tonic-gate } 80357c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(sqp)); 80367c478bd9Sstevel@tonic-gate polllock(&stp->sd_pollist, QLOCK(tq)); 80377c478bd9Sstevel@tonic-gate } else 80387c478bd9Sstevel@tonic-gate retevents |= POLLOUT; 80397c478bd9Sstevel@tonic-gate } 80407c478bd9Sstevel@tonic-gate if (events & POLLWRBAND) { 80417c478bd9Sstevel@tonic-gate qbp = tq->q_bandp; 80427c478bd9Sstevel@tonic-gate if (qbp) { 80437c478bd9Sstevel@tonic-gate while (qbp) { 80447c478bd9Sstevel@tonic-gate if (qbp->qb_flag & QB_FULL) 80457c478bd9Sstevel@tonic-gate qbp->qb_flag |= QB_WANTW; 80467c478bd9Sstevel@tonic-gate else 80477c478bd9Sstevel@tonic-gate retevents |= POLLWRBAND; 80487c478bd9Sstevel@tonic-gate qbp = qbp->qb_next; 80497c478bd9Sstevel@tonic-gate } 80507c478bd9Sstevel@tonic-gate } else { 80517c478bd9Sstevel@tonic-gate retevents |= POLLWRBAND; 80527c478bd9Sstevel@tonic-gate } 80537c478bd9Sstevel@tonic-gate } 80547c478bd9Sstevel@tonic-gate mutex_exit(QLOCK(tq)); 80557c478bd9Sstevel@tonic-gate releasestr(qp); 80567c478bd9Sstevel@tonic-gate } 80577c478bd9Sstevel@tonic-gate chkrd: 80587c478bd9Sstevel@tonic-gate if (sd_flags & STRPRI) { 80597c478bd9Sstevel@tonic-gate retevents |= (events & POLLPRI); 80607c478bd9Sstevel@tonic-gate } else if (events & (POLLRDNORM | POLLRDBAND | POLLIN)) { 80617c478bd9Sstevel@tonic-gate queue_t *qp = _RD(stp->sd_wrq); 80627c478bd9Sstevel@tonic-gate int normevents = (events & (POLLIN | POLLRDNORM)); 80637c478bd9Sstevel@tonic-gate 80647c478bd9Sstevel@tonic-gate /* 80657c478bd9Sstevel@tonic-gate * Note: Need to do polllock() here since ps_lock may be 80667c478bd9Sstevel@tonic-gate * held. See bug 4191544. 80677c478bd9Sstevel@tonic-gate */ 80687c478bd9Sstevel@tonic-gate polllock(&stp->sd_pollist, &stp->sd_lock); 80697c478bd9Sstevel@tonic-gate headlocked = 1; 80707c478bd9Sstevel@tonic-gate mp = qp->q_first; 80717c478bd9Sstevel@tonic-gate while (mp) { 80727c478bd9Sstevel@tonic-gate /* 80737c478bd9Sstevel@tonic-gate * For POLLRDDATA we scan b_cont and b_next until we 80747c478bd9Sstevel@tonic-gate * find an M_DATA. 80757c478bd9Sstevel@tonic-gate */ 80767c478bd9Sstevel@tonic-gate if ((events & POLLRDDATA) && 80777c478bd9Sstevel@tonic-gate mp->b_datap->db_type != M_DATA) { 80787c478bd9Sstevel@tonic-gate mblk_t *nmp = mp->b_cont; 80797c478bd9Sstevel@tonic-gate 80807c478bd9Sstevel@tonic-gate while (nmp != NULL && 80817c478bd9Sstevel@tonic-gate nmp->b_datap->db_type != M_DATA) 80827c478bd9Sstevel@tonic-gate nmp = nmp->b_cont; 80837c478bd9Sstevel@tonic-gate if (nmp == NULL) { 80847c478bd9Sstevel@tonic-gate mp = mp->b_next; 80857c478bd9Sstevel@tonic-gate continue; 80867c478bd9Sstevel@tonic-gate } 80877c478bd9Sstevel@tonic-gate } 80887c478bd9Sstevel@tonic-gate if (mp->b_band == 0) 80897c478bd9Sstevel@tonic-gate retevents |= normevents; 80907c478bd9Sstevel@tonic-gate else 80917c478bd9Sstevel@tonic-gate retevents |= (events & (POLLIN | POLLRDBAND)); 80927c478bd9Sstevel@tonic-gate break; 80937c478bd9Sstevel@tonic-gate } 80947c478bd9Sstevel@tonic-gate if (! (retevents & normevents) && 80957c478bd9Sstevel@tonic-gate (stp->sd_wakeq & RSLEEP)) { 80967c478bd9Sstevel@tonic-gate /* 80977c478bd9Sstevel@tonic-gate * Sync stream barrier read queue has data. 80987c478bd9Sstevel@tonic-gate */ 80997c478bd9Sstevel@tonic-gate retevents |= normevents; 81007c478bd9Sstevel@tonic-gate } 81017c478bd9Sstevel@tonic-gate /* Treat eof as normal data */ 81027c478bd9Sstevel@tonic-gate if (sd_flags & STREOF) 81037c478bd9Sstevel@tonic-gate retevents |= normevents; 81047c478bd9Sstevel@tonic-gate } 81057c478bd9Sstevel@tonic-gate 81067c478bd9Sstevel@tonic-gate *reventsp = (short)retevents; 81077c478bd9Sstevel@tonic-gate if (retevents) { 81087c478bd9Sstevel@tonic-gate if (headlocked) 81097c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 81107c478bd9Sstevel@tonic-gate return (0); 81117c478bd9Sstevel@tonic-gate } 81127c478bd9Sstevel@tonic-gate 81137c478bd9Sstevel@tonic-gate /* 81147c478bd9Sstevel@tonic-gate * If poll() has not found any events yet, set up event cell 81157c478bd9Sstevel@tonic-gate * to wake up the poll if a requested event occurs on this 81167c478bd9Sstevel@tonic-gate * stream. Check for collisions with outstanding poll requests. 81177c478bd9Sstevel@tonic-gate */ 81187c478bd9Sstevel@tonic-gate if (!anyyet) { 81197c478bd9Sstevel@tonic-gate *phpp = &stp->sd_pollist; 81207c478bd9Sstevel@tonic-gate if (headlocked == 0) { 81217c478bd9Sstevel@tonic-gate polllock(&stp->sd_pollist, &stp->sd_lock); 81227c478bd9Sstevel@tonic-gate headlocked = 1; 81237c478bd9Sstevel@tonic-gate } 81247c478bd9Sstevel@tonic-gate stp->sd_rput_opt |= SR_POLLIN; 81257c478bd9Sstevel@tonic-gate } 81267c478bd9Sstevel@tonic-gate if (headlocked) 81277c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 81287c478bd9Sstevel@tonic-gate return (0); 81297c478bd9Sstevel@tonic-gate } 81307c478bd9Sstevel@tonic-gate 81317c478bd9Sstevel@tonic-gate /* 81327c478bd9Sstevel@tonic-gate * The purpose of putback() is to assure sleeping polls/reads 81337c478bd9Sstevel@tonic-gate * are awakened when there are no new messages arriving at the, 81347c478bd9Sstevel@tonic-gate * stream head, and a message is placed back on the read queue. 81357c478bd9Sstevel@tonic-gate * 81367c478bd9Sstevel@tonic-gate * sd_lock must be held when messages are placed back on stream 81377c478bd9Sstevel@tonic-gate * head. (getq() holds sd_lock when it removes messages from 81387c478bd9Sstevel@tonic-gate * the queue) 81397c478bd9Sstevel@tonic-gate */ 81407c478bd9Sstevel@tonic-gate 81417c478bd9Sstevel@tonic-gate static void 81427c478bd9Sstevel@tonic-gate putback(struct stdata *stp, queue_t *q, mblk_t *bp, int band) 81437c478bd9Sstevel@tonic-gate { 81447c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&stp->sd_lock)); 81457c478bd9Sstevel@tonic-gate (void) putbq(q, bp); 81467c478bd9Sstevel@tonic-gate /* 81477c478bd9Sstevel@tonic-gate * A message may have come in when the sd_lock was dropped in the 81487c478bd9Sstevel@tonic-gate * calling routine. If this is the case and STR*ATMARK info was 81497c478bd9Sstevel@tonic-gate * received, need to move that from the stream head to the q_last 81507c478bd9Sstevel@tonic-gate * so that SIOCATMARK can return the proper value. 81517c478bd9Sstevel@tonic-gate */ 81527c478bd9Sstevel@tonic-gate if (stp->sd_flag & (STRATMARK | STRNOTATMARK)) { 81537c478bd9Sstevel@tonic-gate unsigned short *flagp = &q->q_last->b_flag; 81547c478bd9Sstevel@tonic-gate uint_t b_flag = (uint_t)*flagp; 81557c478bd9Sstevel@tonic-gate 81567c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRATMARK) { 81577c478bd9Sstevel@tonic-gate b_flag &= ~MSGNOTMARKNEXT; 81587c478bd9Sstevel@tonic-gate b_flag |= MSGMARKNEXT; 81597c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRATMARK; 81607c478bd9Sstevel@tonic-gate } else { 81617c478bd9Sstevel@tonic-gate b_flag &= ~MSGMARKNEXT; 81627c478bd9Sstevel@tonic-gate b_flag |= MSGNOTMARKNEXT; 81637c478bd9Sstevel@tonic-gate stp->sd_flag &= ~STRNOTATMARK; 81647c478bd9Sstevel@tonic-gate } 81657c478bd9Sstevel@tonic-gate *flagp = (unsigned short) b_flag; 81667c478bd9Sstevel@tonic-gate } 81677c478bd9Sstevel@tonic-gate 81687c478bd9Sstevel@tonic-gate #ifdef DEBUG 81697c478bd9Sstevel@tonic-gate /* 81707c478bd9Sstevel@tonic-gate * Make sure that the flags are not messed up. 81717c478bd9Sstevel@tonic-gate */ 81727c478bd9Sstevel@tonic-gate { 81737c478bd9Sstevel@tonic-gate mblk_t *mp; 81747c478bd9Sstevel@tonic-gate mp = q->q_last; 81757c478bd9Sstevel@tonic-gate while (mp != NULL) { 81767c478bd9Sstevel@tonic-gate ASSERT((mp->b_flag & (MSGMARKNEXT|MSGNOTMARKNEXT)) != 81777c478bd9Sstevel@tonic-gate (MSGMARKNEXT|MSGNOTMARKNEXT)); 81787c478bd9Sstevel@tonic-gate mp = mp->b_cont; 81797c478bd9Sstevel@tonic-gate } 81807c478bd9Sstevel@tonic-gate } 81817c478bd9Sstevel@tonic-gate #endif 81827c478bd9Sstevel@tonic-gate if (q->q_first == bp) { 81837c478bd9Sstevel@tonic-gate short pollevents; 81847c478bd9Sstevel@tonic-gate 81857c478bd9Sstevel@tonic-gate if (stp->sd_flag & RSLEEP) { 81867c478bd9Sstevel@tonic-gate stp->sd_flag &= ~RSLEEP; 81877c478bd9Sstevel@tonic-gate cv_broadcast(&q->q_wait); 81887c478bd9Sstevel@tonic-gate } 81897c478bd9Sstevel@tonic-gate if (stp->sd_flag & STRPRI) { 81907c478bd9Sstevel@tonic-gate pollevents = POLLPRI; 81917c478bd9Sstevel@tonic-gate } else { 81927c478bd9Sstevel@tonic-gate if (band == 0) { 81937c478bd9Sstevel@tonic-gate if (!(stp->sd_rput_opt & SR_POLLIN)) 81947c478bd9Sstevel@tonic-gate return; 81957c478bd9Sstevel@tonic-gate stp->sd_rput_opt &= ~SR_POLLIN; 81967c478bd9Sstevel@tonic-gate pollevents = POLLIN | POLLRDNORM; 81977c478bd9Sstevel@tonic-gate } else { 81987c478bd9Sstevel@tonic-gate pollevents = POLLIN | POLLRDBAND; 81997c478bd9Sstevel@tonic-gate } 82007c478bd9Sstevel@tonic-gate } 82017c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 82027c478bd9Sstevel@tonic-gate pollwakeup(&stp->sd_pollist, pollevents); 82037c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 82047c478bd9Sstevel@tonic-gate } 82057c478bd9Sstevel@tonic-gate } 82067c478bd9Sstevel@tonic-gate 82077c478bd9Sstevel@tonic-gate /* 82087c478bd9Sstevel@tonic-gate * Return the held vnode attached to the stream head of a 82097c478bd9Sstevel@tonic-gate * given queue 82107c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure 82117c478bd9Sstevel@tonic-gate * that the queue does not go away (e.g. pop). 82127c478bd9Sstevel@tonic-gate */ 82137c478bd9Sstevel@tonic-gate vnode_t * 82147c478bd9Sstevel@tonic-gate strq2vp(queue_t *qp) 82157c478bd9Sstevel@tonic-gate { 82167c478bd9Sstevel@tonic-gate vnode_t *vp; 82177c478bd9Sstevel@tonic-gate vp = STREAM(qp)->sd_vnode; 82187c478bd9Sstevel@tonic-gate ASSERT(vp != NULL); 82197c478bd9Sstevel@tonic-gate VN_HOLD(vp); 82207c478bd9Sstevel@tonic-gate return (vp); 82217c478bd9Sstevel@tonic-gate } 82227c478bd9Sstevel@tonic-gate 82237c478bd9Sstevel@tonic-gate /* 82247c478bd9Sstevel@tonic-gate * return the stream head write queue for the given vp 82257c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure 82267c478bd9Sstevel@tonic-gate * that the stream or vnode do not close. 82277c478bd9Sstevel@tonic-gate */ 82287c478bd9Sstevel@tonic-gate queue_t * 82297c478bd9Sstevel@tonic-gate strvp2wq(vnode_t *vp) 82307c478bd9Sstevel@tonic-gate { 82317c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream != NULL); 82327c478bd9Sstevel@tonic-gate return (vp->v_stream->sd_wrq); 82337c478bd9Sstevel@tonic-gate } 82347c478bd9Sstevel@tonic-gate 82357c478bd9Sstevel@tonic-gate /* 82367c478bd9Sstevel@tonic-gate * pollwakeup stream head 82377c478bd9Sstevel@tonic-gate * It is the responsibility of the calling routine to ensure 82387c478bd9Sstevel@tonic-gate * that the stream or vnode do not close. 82397c478bd9Sstevel@tonic-gate */ 82407c478bd9Sstevel@tonic-gate void 82417c478bd9Sstevel@tonic-gate strpollwakeup(vnode_t *vp, short event) 82427c478bd9Sstevel@tonic-gate { 82437c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 82447c478bd9Sstevel@tonic-gate pollwakeup(&vp->v_stream->sd_pollist, event); 82457c478bd9Sstevel@tonic-gate } 82467c478bd9Sstevel@tonic-gate 82477c478bd9Sstevel@tonic-gate /* 82487c478bd9Sstevel@tonic-gate * Mate the stream heads of two vnodes together. If the two vnodes are the 82497c478bd9Sstevel@tonic-gate * same, we just make the write-side point at the read-side -- otherwise, 82507c478bd9Sstevel@tonic-gate * we do a full mate. Only works on vnodes associated with streams that are 82517c478bd9Sstevel@tonic-gate * still being built and thus have only a stream head. 82527c478bd9Sstevel@tonic-gate */ 82537c478bd9Sstevel@tonic-gate void 82547c478bd9Sstevel@tonic-gate strmate(vnode_t *vp1, vnode_t *vp2) 82557c478bd9Sstevel@tonic-gate { 82567c478bd9Sstevel@tonic-gate queue_t *wrq1 = strvp2wq(vp1); 82577c478bd9Sstevel@tonic-gate queue_t *wrq2 = strvp2wq(vp2); 82587c478bd9Sstevel@tonic-gate 82597c478bd9Sstevel@tonic-gate /* 82607c478bd9Sstevel@tonic-gate * Verify that there are no modules on the stream yet. We also 82617c478bd9Sstevel@tonic-gate * rely on the stream head always having a service procedure to 82627c478bd9Sstevel@tonic-gate * avoid tweaking q_nfsrv. 82637c478bd9Sstevel@tonic-gate */ 82647c478bd9Sstevel@tonic-gate ASSERT(wrq1->q_next == NULL && wrq2->q_next == NULL); 82657c478bd9Sstevel@tonic-gate ASSERT(wrq1->q_qinfo->qi_srvp != NULL); 82667c478bd9Sstevel@tonic-gate ASSERT(wrq2->q_qinfo->qi_srvp != NULL); 82677c478bd9Sstevel@tonic-gate 82687c478bd9Sstevel@tonic-gate /* 82697c478bd9Sstevel@tonic-gate * If the queues are the same, just twist; otherwise do a full mate. 82707c478bd9Sstevel@tonic-gate */ 82717c478bd9Sstevel@tonic-gate if (wrq1 == wrq2) { 82727c478bd9Sstevel@tonic-gate wrq1->q_next = _RD(wrq1); 82737c478bd9Sstevel@tonic-gate } else { 82747c478bd9Sstevel@tonic-gate wrq1->q_next = _RD(wrq2); 82757c478bd9Sstevel@tonic-gate wrq2->q_next = _RD(wrq1); 82767c478bd9Sstevel@tonic-gate STREAM(wrq1)->sd_mate = STREAM(wrq2); 82777c478bd9Sstevel@tonic-gate STREAM(wrq1)->sd_flag |= STRMATE; 82787c478bd9Sstevel@tonic-gate STREAM(wrq2)->sd_mate = STREAM(wrq1); 82797c478bd9Sstevel@tonic-gate STREAM(wrq2)->sd_flag |= STRMATE; 82807c478bd9Sstevel@tonic-gate } 82817c478bd9Sstevel@tonic-gate } 82827c478bd9Sstevel@tonic-gate 82837c478bd9Sstevel@tonic-gate /* 82847c478bd9Sstevel@tonic-gate * XXX will go away when console is correctly fixed. 82857c478bd9Sstevel@tonic-gate * Clean up the console PIDS, from previous I_SETSIG, 82867c478bd9Sstevel@tonic-gate * called only for cnopen which never calls strclean(). 82877c478bd9Sstevel@tonic-gate */ 82887c478bd9Sstevel@tonic-gate void 82897c478bd9Sstevel@tonic-gate str_cn_clean(struct vnode *vp) 82907c478bd9Sstevel@tonic-gate { 82917c478bd9Sstevel@tonic-gate strsig_t *ssp, *pssp, *tssp; 82927c478bd9Sstevel@tonic-gate struct stdata *stp; 82937c478bd9Sstevel@tonic-gate struct pid *pidp; 82947c478bd9Sstevel@tonic-gate int update = 0; 82957c478bd9Sstevel@tonic-gate 82967c478bd9Sstevel@tonic-gate ASSERT(vp->v_stream); 82977c478bd9Sstevel@tonic-gate stp = vp->v_stream; 82987c478bd9Sstevel@tonic-gate pssp = NULL; 82997c478bd9Sstevel@tonic-gate mutex_enter(&stp->sd_lock); 83007c478bd9Sstevel@tonic-gate ssp = stp->sd_siglist; 83017c478bd9Sstevel@tonic-gate while (ssp) { 83027c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 83037c478bd9Sstevel@tonic-gate pidp = ssp->ss_pidp; 83047c478bd9Sstevel@tonic-gate /* 83057c478bd9Sstevel@tonic-gate * Get rid of PID if the proc is gone. 83067c478bd9Sstevel@tonic-gate */ 83077c478bd9Sstevel@tonic-gate if (pidp->pid_prinactive) { 83087c478bd9Sstevel@tonic-gate tssp = ssp->ss_next; 83097c478bd9Sstevel@tonic-gate if (pssp) 83107c478bd9Sstevel@tonic-gate pssp->ss_next = tssp; 83117c478bd9Sstevel@tonic-gate else 83127c478bd9Sstevel@tonic-gate stp->sd_siglist = tssp; 83137c478bd9Sstevel@tonic-gate ASSERT(pidp->pid_ref <= 1); 83147c478bd9Sstevel@tonic-gate PID_RELE(ssp->ss_pidp); 83157c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 83167c478bd9Sstevel@tonic-gate kmem_free(ssp, sizeof (strsig_t)); 83177c478bd9Sstevel@tonic-gate update = 1; 83187c478bd9Sstevel@tonic-gate ssp = tssp; 83197c478bd9Sstevel@tonic-gate continue; 83207c478bd9Sstevel@tonic-gate } else 83217c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 83227c478bd9Sstevel@tonic-gate pssp = ssp; 83237c478bd9Sstevel@tonic-gate ssp = ssp->ss_next; 83247c478bd9Sstevel@tonic-gate } 83257c478bd9Sstevel@tonic-gate if (update) { 83267c478bd9Sstevel@tonic-gate stp->sd_sigflags = 0; 83277c478bd9Sstevel@tonic-gate for (ssp = stp->sd_siglist; ssp; ssp = ssp->ss_next) 83287c478bd9Sstevel@tonic-gate stp->sd_sigflags |= ssp->ss_events; 83297c478bd9Sstevel@tonic-gate } 83307c478bd9Sstevel@tonic-gate mutex_exit(&stp->sd_lock); 83317c478bd9Sstevel@tonic-gate } 83327c478bd9Sstevel@tonic-gate 83337c478bd9Sstevel@tonic-gate /* 83347c478bd9Sstevel@tonic-gate * Return B_TRUE if there is data in the message, B_FALSE otherwise. 83357c478bd9Sstevel@tonic-gate */ 83367c478bd9Sstevel@tonic-gate static boolean_t 83377c478bd9Sstevel@tonic-gate msghasdata(mblk_t *bp) 83387c478bd9Sstevel@tonic-gate { 83397c478bd9Sstevel@tonic-gate for (; bp; bp = bp->b_cont) 83407c478bd9Sstevel@tonic-gate if (bp->b_datap->db_type == M_DATA) { 83417c478bd9Sstevel@tonic-gate ASSERT(bp->b_wptr >= bp->b_rptr); 83427c478bd9Sstevel@tonic-gate if (bp->b_wptr > bp->b_rptr) 83437c478bd9Sstevel@tonic-gate return (B_TRUE); 83447c478bd9Sstevel@tonic-gate } 83457c478bd9Sstevel@tonic-gate return (B_FALSE); 83467c478bd9Sstevel@tonic-gate } 8347