/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>

#include <sys/sysmacros.h>

#include <sys/param.h>

#include <sys/errno.h>

#include <sys/signal.h>

#include <sys/stat.h>

#include <sys/proc.h>

#include <sys/cred.h>

#include <sys/user.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/stream.h>

#include <sys/strsubr.h>

#include <sys/stropts.h>

#include <sys/tihdr.h>

#include <sys/var.h>

#include <sys/poll.h>

#include <sys/termio.h>

#include <sys/ttold.h>

#include <sys/systm.h>

#include <sys/uio.h>

#include <sys/cmn_err.h>

#include <sys/sad.h>

#include <sys/priocntl.h>

#include <sys/jioctl.h>

#include <sys/procset.h>

#include <sys/session.h>

#include <sys/kmem.h>

#include <sys/filio.h>

#include <sys/vtrace.h>

#include <sys/debug.h>

#include <sys/strredir.h>

#include <sys/fs/fifonode.h>

#include <sys/fs/snode.h>

#include <sys/strlog.h>

#include <sys/strsun.h>

#include <sys/project.h>

#include <sys/kbio.h>

#include <sys/msio.h>

#include <sys/tty.h>

#include <sys/ptyvar.h>

#include <sys/vuid_event.h>

#include <sys/modctl.h>

#include <sys/sunddi.h>

#include <sys/sunldi_impl.h>

#include <sys/autoconf.h>

#include <sys/policy.h>

/*

 * what is mblk_pull_len?

 *

 * If a streams message consists of many short messages,

 * a performance degradation occurs from copyout overhead.

 * To decrease the per mblk overhead, messages that are

 * likely to consist of many small mblks are pulled up into

 * one continuous chunk of memory.

 *

 * To avoid the processing overhead of examining every

 * mblk, a quick heuristic is used. If the first mblk in

 * the message is shorter than mblk_pull_len, it is likely

 * that the rest of the mblk will be short.

 *

 * This heuristic was decided upon after performance tests

 * indicated that anything more complex slowed down the main

 * code path.

 */

#define	MBLK_PULL_LEN 64

uint32_t mblk_pull_len = MBLK_PULL_LEN;

/*

 * The sgttyb_handling flag controls the handling of the old BSD

 * TIOCGETP, TIOCSETP, and TIOCSETN ioctls as follows:

 *

 * 0 - Emit no warnings at all and retain old, broken behavior.

 * 1 - Emit no warnings and silently handle new semantics.

 * 2 - Send cmn_err(CE_NOTE) when either TIOCSETP or TIOCSETN is used

 *     (once per system invocation).  Handle with new semantics.

 * 3 - Send SIGSYS when any TIOCGETP, TIOCSETP, or TIOCSETN call is

 *     made (so that offenders drop core and are easy to debug).

 *

 * The "new semantics" are that TIOCGETP returns B38400 for

 * sg_[io]speed if the corresponding value is over B38400, and that

 * TIOCSET[PN] accept B38400 in these cases to mean "retain current

 * bit rate."

 */

int sgttyb_handling = 1;

static boolean_t sgttyb_complaint;

/* don't push drcompat module by default on Style-2 streams */

static int push_drcompat = 0;

/*

 * id value used to distinguish between different ioctl messages

 */

static uint32_t ioc_id;

static void putback(struct stdata *, queue_t *, mblk_t *, int);

static void strcleanall(struct vnode *);

static int strwsrv(queue_t *);

/*

 * qinit and module_info structures for stream head read and write queues

 */

struct module_info strm_info = { 0, "strrhead", 0, INFPSZ, STRHIGH, STRLOW };

struct module_info stwm_info = { 0, "strwhead", 0, 0, 0, 0 };

struct qinit strdata = { strrput, NULL, NULL, NULL, NULL, &strm_info };

struct qinit stwdata = { NULL, strwsrv, NULL, NULL, NULL, &stwm_info };

struct module_info fiform_info = { 0, "fifostrrhead", 0, PIPE_BUF, FIFOHIWAT,

    FIFOLOWAT };

struct module_info fifowm_info = { 0, "fifostrwhead", 0, 0, 0, 0 };

struct qinit fifo_strdata = { strrput, NULL, NULL, NULL, NULL, &fiform_info };

struct qinit fifo_stwdata = { NULL, strwsrv, NULL, NULL, NULL, &fifowm_info };

extern kmutex_t	strresources;	/* protects global resources */

extern kmutex_t muxifier;	/* single-threads multiplexor creation */

kmutex_t sad_lock;		/* protects sad drivers autopush */

static boolean_t msghasdata(mblk_t *bp);

#define	msgnodata(bp) (!msghasdata(bp))

/*

 * Stream head locking notes:

 *	There are four monitors associated with the stream head:

 *	1. v_stream monitor: in stropen() and strclose() v_lock

 *		is held while the association of vnode and stream

 *		head is established or tested for.

 *	2. open/close/push/pop monitor: sd_lock is held while each

 *		thread bids for exclusive access to this monitor

 *		for opening or closing a stream.  In addition, this

 *		monitor is entered during pushes and pops.  This

 *		guarantees that during plumbing operations there

 *		is only one thread trying to change the plumbing.

 *		Any other threads present in the stream are only

 *		using the plumbing.

 *	3. read/write monitor: in the case of read, a thread holds

 *		sd_lock while trying to get data from the stream

 *		head queue.  if there is none to fulfill a read

 *		request, it sets RSLEEP and calls cv_wait_sig() down

 *		in strwaitq() to await the arrival of new data.

 *		when new data arrives in strrput(), sd_lock is acquired

 *		before testing for RSLEEP and calling cv_broadcast().

 *		the behavior of strwrite(), strwsrv(), and WSLEEP

 *		mirror this.

 *	4. ioctl monitor: sd_lock is gotten to ensure that only one

 *		thread is doing an ioctl at a time.

 */

static int

push_mod(queue_t *qp, dev_t *devp, struct stdata *stp, const char *name,

    int anchor, cred_t *crp)

{

	int error;

	fmodsw_impl_t *fp;

	if (stp->sd_flag & (STRHUP|STRDERR|STWRERR)) {

		error = (stp->sd_flag & STRHUP) ? ENXIO : EIO;

		return (error);

	}

	if (stp->sd_pushcnt >= nstrpush) {

		return (EINVAL);

	}

	if ((fp = fmodsw_find(name, FMODSW_HOLD | FMODSW_LOAD)) == NULL) {

		stp->sd_flag |= STREOPENFAIL;

		return (EINVAL);

	}

	/*

	 * push new module and call its open routine via qattach

	 */

	if ((error = qattach(qp, devp, 0, crp, fp, B_FALSE)) != 0)

		return (error);

	/*

	 * Check to see if caller wants a STREAMS anchor

	 * put at this place in the stream, and add if so.

	 */

	mutex_enter(&stp->sd_lock);

	if (anchor == stp->sd_pushcnt)

		stp->sd_anchor = stp->sd_pushcnt;

	mutex_exit(&stp->sd_lock);

	return (0);

}

/*

 * Open a stream device.

 */

int

stropen(vnode_t *vp, dev_t *devp, int flag, cred_t *crp)

{

	struct stdata *stp;

	queue_t *qp;

	int s;

	dev_t dummydev;

	struct autopush *ap;

	int error = 0;

	ssize_t	rmin, rmax;

	int cloneopen;

	queue_t *brq;

	major_t major;

#ifdef C2_AUDIT

	if (audit_active)

		audit_stropen(vp, devp, flag, crp);

#endif

	/*

	 * If the stream already exists, wait for any open in progress

	 * to complete, then call the open function of each module and

	 * driver in the stream.  Otherwise create the stream.

	 */

	TRACE_1(TR_FAC_STREAMS_FR, TR_STROPEN, "stropen:%p", vp);

retry:

	mutex_enter(&vp->v_lock);

	if ((stp = vp->v_stream) != NULL) {

		/*

		 * Waiting for stream to be created to device

		 * due to another open.

		 */

	    mutex_exit(&vp->v_lock);

	    if (STRMATED(stp)) {

		struct stdata *strmatep = stp->sd_mate;

		STRLOCKMATES(stp);

		if (strmatep->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {

			if (flag & (FNDELAY|FNONBLOCK)) {

				error = EAGAIN;

				mutex_exit(&strmatep->sd_lock);

				goto ckreturn;

			}

			mutex_exit(&stp->sd_lock);

			if (!cv_wait_sig(&strmatep->sd_monitor,

			    &strmatep->sd_lock)) {

				error = EINTR;

				mutex_exit(&strmatep->sd_lock);

				mutex_enter(&stp->sd_lock);

				goto ckreturn;

			}

			mutex_exit(&strmatep->sd_lock);

			goto retry;

		}

		if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {

			if (flag & (FNDELAY|FNONBLOCK)) {

				error = EAGAIN;

				mutex_exit(&strmatep->sd_lock);

				goto ckreturn;

			}

			mutex_exit(&strmatep->sd_lock);

			if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) {

				error = EINTR;

				goto ckreturn;

			}

			mutex_exit(&stp->sd_lock);

			goto retry;

		}

		if (stp->sd_flag & (STRDERR|STWRERR)) {

			error = EIO;

			mutex_exit(&strmatep->sd_lock);

			goto ckreturn;

		}

		stp->sd_flag |= STWOPEN;

		STRUNLOCKMATES(stp);

	    } else {

		mutex_enter(&stp->sd_lock);

		if (stp->sd_flag & (STWOPEN|STRCLOSE|STRPLUMB)) {

			if (flag & (FNDELAY|FNONBLOCK)) {

				error = EAGAIN;

				goto ckreturn;

			}

			if (!cv_wait_sig(&stp->sd_monitor, &stp->sd_lock)) {

				error = EINTR;

				goto ckreturn;

			}

			mutex_exit(&stp->sd_lock);

			goto retry;  /* could be clone! */

		}

		if (stp->sd_flag & (STRDERR|STWRERR)) {

			error = EIO;

			goto ckreturn;

		}

		stp->sd_flag |= STWOPEN;

		mutex_exit(&stp->sd_lock);

	    }

		/*

		 * Open all modules and devices down stream to notify

		 * that another user is streaming.  For modules, set the

		 * last argument to MODOPEN and do not pass any open flags.

		 * Ignore dummydev since this is not the first open.

		 */

	    claimstr(stp->sd_wrq);

	    qp = stp->sd_wrq;

	    while (_SAMESTR(qp)) {

		qp = qp->q_next;

		if ((error = qreopen(_RD(qp), devp, flag, crp)) != 0)

			break;

	    }

	    releasestr(stp->sd_wrq);

	    mutex_enter(&stp->sd_lock);

	    stp->sd_flag &= ~(STRHUP|STWOPEN|STRDERR|STWRERR);

	    stp->sd_rerror = 0;

	    stp->sd_werror = 0;

ckreturn:

	    cv_broadcast(&stp->sd_monitor);

	    mutex_exit(&stp->sd_lock);

	    return (error);

	}

	/*

	 * This vnode isn't streaming.  SPECFS already

	 * checked for multiple vnodes pointing to the

	 * same stream, so create a stream to the driver.

	 */

	qp = allocq();

	stp = shalloc(qp);

	/*

	 * Initialize stream head.  shalloc() has given us

	 * exclusive access, and we have the vnode locked;

	 * we can do whatever we want with stp.

	 */

	stp->sd_flag = STWOPEN;

	stp->sd_siglist = NULL;

	stp->sd_pollist.ph_list = NULL;

	stp->sd_sigflags = 0;

	stp->sd_mark = NULL;

	stp->sd_closetime = STRTIMOUT;

	stp->sd_sidp = NULL;

	stp->sd_pgidp = NULL;

	stp->sd_vnode = vp;

	stp->sd_rerror = 0;

	stp->sd_werror = 0;

	stp->sd_wroff = 0;

	stp->sd_iocblk = NULL;

	stp->sd_pushcnt = 0;

	stp->sd_qn_minpsz = 0;

	stp->sd_qn_maxpsz = INFPSZ - 1;	/* used to check for initialization */

	stp->sd_maxblk = INFPSZ;

	qp->q_ptr = _WR(qp)->q_ptr = stp;

	STREAM(qp) = STREAM(_WR(qp)) = stp;

	vp->v_stream = stp;

	mutex_exit(&vp->v_lock);

	if (vp->v_type == VFIFO) {

		stp->sd_flag |= OLDNDELAY;

		/*

		 * This means, both for pipes and fifos

		 * strwrite will send SIGPIPE if the other

		 * end is closed. For putmsg it depends

		 * on whether it is a XPG4_2 application

		 * or not

		 */

		stp->sd_wput_opt = SW_SIGPIPE;

		/* setq might sleep in kmem_alloc - avoid holding locks. */

		setq(qp, &fifo_strdata, &fifo_stwdata, NULL, QMTSAFE,

		    SQ_CI|SQ_CO, B_FALSE);

		set_qend(qp);

		stp->sd_strtab = fifo_getinfo();

		_WR(qp)->q_nfsrv = _WR(qp);

		qp->q_nfsrv = qp;

		/*

		 * Wake up others that are waiting for stream to be created.

		 */

		mutex_enter(&stp->sd_lock);

		/*

		 * nothing is be pushed on stream yet, so

		 * optimized stream head packetsizes are just that

		 * of the read queue

		 */

		stp->sd_qn_minpsz = qp->q_minpsz;

		stp->sd_qn_maxpsz = qp->q_maxpsz;

		stp->sd_flag &= ~STWOPEN;

		goto fifo_opendone;

	}

	/* setq might sleep in kmem_alloc - avoid holding locks. */

	setq(qp, &strdata, &stwdata, NULL, QMTSAFE, SQ_CI|SQ_CO, B_FALSE);

	set_qend(qp);

	/*

	 * Open driver and create stream to it (via qattach).

	 */

	cloneopen = (getmajor(*devp) == clone_major);

	if ((error = qattach(qp, devp, flag, crp, NULL, B_FALSE)) != 0) {

		mutex_enter(&vp->v_lock);

		vp->v_stream = NULL;

		mutex_exit(&vp->v_lock);

		mutex_enter(&stp->sd_lock);

		cv_broadcast(&stp->sd_monitor);

		mutex_exit(&stp->sd_lock);

		freeq(_RD(qp));

		shfree(stp);

		return (error);

	}

	/*

	 * Set sd_strtab after open in order to handle clonable drivers

	 */

	stp->sd_strtab = STREAMSTAB(getmajor(*devp));

	/*

	 * Historical note: dummydev used to be be prior to the initial

	 * open (via qattach above), which made the value seen

	 * inconsistent between an I_PUSH and an autopush of a module.

	 */

	dummydev = *devp;

	/*

	 * For clone open of old style (Q not associated) network driver,

	 * push DRMODNAME module to handle DL_ATTACH/DL_DETACH

	 */

	brq = _RD(_WR(qp)->q_next);

	major = getmajor(*devp);

	if (push_drcompat && cloneopen && NETWORK_DRV(major) &&

	    ((brq->q_flag & _QASSOCIATED) == 0)) {

		if (push_mod(qp, &dummydev, stp, DRMODNAME, 0, crp) != 0)

			cmn_err(CE_WARN, "cannot push " DRMODNAME

			    " streams module");

	}

	/*

	 * check for autopush

	 */

	mutex_enter(&sad_lock);

	ap = strphash(getemajor(*devp));

#define	DEVT(ap)	makedevice(ap->ap_major, ap->ap_minor)

#define	DEVLT(ap)	makedevice(ap->ap_major, ap->ap_lastminor)

	while (ap) {

		if (ap->ap_major == (getemajor(*devp))) {

			if (ap->ap_type == SAP_ALL)

				break;

			else if ((ap->ap_type == SAP_ONE) &&

			    (getminor(DEVT(ap)) == getminor(*devp)))

				break;

			else if (ap->ap_type == SAP_RANGE &&

			    getminor(*devp) >= getminor(DEVT(ap)) &&

			    getminor(*devp) <= getminor(DEVLT(ap)))

				break;

		}

		ap = ap->ap_nextp;

	}

	if (ap == NULL) {

		mutex_exit(&sad_lock);

		goto opendone;

	}

	ap->ap_cnt++;

	mutex_exit(&sad_lock);

	for (s = 0; s < ap->ap_npush; s++) {

		error = push_mod(qp, &dummydev, stp, ap->ap_list[s],

		    ap->ap_anchor, crp);

		if (error != 0)

			break;

	}

	mutex_enter(&sad_lock);

	if (--(ap->ap_cnt) <= 0)

		ap_free(ap);

	mutex_exit(&sad_lock);

	/*

	 * let specfs know that open failed part way through

	 */

	if (error) {

		mutex_enter(&stp->sd_lock);

		stp->sd_flag |= STREOPENFAIL;

		mutex_exit(&stp->sd_lock);

	}

opendone:

	/*

	 * Wake up others that are waiting for stream to be created.

	 */

	mutex_enter(&stp->sd_lock);

	stp->sd_flag &= ~STWOPEN;

	/*

	 * As a performance concern we are caching the values of

	 * q_minpsz and q_maxpsz of the module below the stream

	 * head in the stream head.

	 */

	mutex_enter(QLOCK(stp->sd_wrq->q_next));

	rmin = stp->sd_wrq->q_next->q_minpsz;

	rmax = stp->sd_wrq->q_next->q_maxpsz;

	mutex_exit(QLOCK(stp->sd_wrq->q_next));

	/* do this processing here as a performance concern */