common/io/tty_pty.c

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved. The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

/*
 * PTY - Stream "pseudo-tty" device.  For each "controller" side
 * it connects to a "slave" side.
 */


#include <sys/param.h>
#include <sys/systm.h>
#include <sys/filio.h>
#include <sys/ioccom.h>
#include <sys/termios.h>
#include <sys/termio.h>
#include <sys/ttold.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/tty.h>
#include <sys/user.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/vnode.h>	/* 1/0 on the vomit meter */
#include <sys/proc.h>
#include <sys/uio.h>
#include <sys/errno.h>
#include <sys/strsubr.h>
#include <sys/poll.h>
#include <sys/sysmacros.h>
#include <sys/debug.h>
#include <sys/procset.h>
#include <sys/cred.h>
#include <sys/ptyvar.h>
#include <sys/suntty.h>
#include <sys/stat.h>

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

extern int npty;	/* number of pseudo-ttys configured in */
extern struct pty *pty_softc;
extern struct pollhead	ptcph;	/* poll head for ptcpoll() use */

int ptcopen(dev_t *, int, int, struct cred *);
int ptcclose(dev_t, int, int, struct cred *);
int ptcwrite(dev_t, struct uio *, struct cred *);
int ptcread(dev_t, struct uio *, struct cred *);
int ptcioctl(dev_t, int, intptr_t, int, struct cred *, int *);
int ptcpoll(dev_t, short, int, short *, struct pollhead **);

static int ptc_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int ptc_attach(dev_info_t *, ddi_attach_cmd_t);
static dev_info_t *ptc_dip;	/* for dev-to-dip conversions */

static void ptc_init(void), ptc_uninit(void);

static int makemsg(ssize_t count, struct uio *uiop,
    struct pty *pty, mblk_t **mpp);

struct cb_ops	ptc_cb_ops = {
	ptcopen,		/* open */
	ptcclose,		/* close */
	nodev,			/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	ptcread,		/* read */
	ptcwrite,		/* write */
	ptcioctl, 		/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev,			/* segmap */
	ptcpoll,		/* poll */
	ddi_prop_op,		/* prop_op */
	0,			/* streamtab */
	D_NEW | D_MP		/* Driver compatibility flag */
};

struct dev_ops	ptc_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* refcnt */
	ptc_info,		/* info */
	nulldev,		/* identify */
	nulldev,		/* probe */
	ptc_attach,		/* attach */
	nodev,			/* detach */
	nodev,			/* reset */
	&ptc_cb_ops,		/* driver operations */
	(struct bus_ops *)0,	/* bus operations */
	NULL,			/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/modctl.h>

extern int dseekneg_flag;
extern struct mod_ops mod_driverops;
extern struct dev_ops ptc_ops;

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
	&mod_driverops, /* Type of module.  This one is a pseudo driver */
	"tty pseudo driver control 'ptc'",
	&ptc_ops,	/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};

int
_init()
{
	int rc;

	if ((rc = mod_install(&modlinkage)) == 0)
		ptc_init();
	return (rc);
}


int
_fini()
{
	int rc;

	if ((rc = mod_remove(&modlinkage)) == 0)
		ptc_uninit();
	return (rc);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

static char	*pty_banks = PTY_BANKS;
static char	*pty_digits = PTY_DIGITS;

/* ARGSUSED */
static int
ptc_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
	char	name[8];
	int	pty_num;
	char	*pty_digit = pty_digits;
	char	*pty_bank = pty_banks;

	for (pty_num = 0; pty_num < npty; pty_num++) {
		(void) sprintf(name, "pty%c%c", *pty_bank, *pty_digit);
		if (ddi_create_minor_node(devi, name, S_IFCHR,
		    pty_num, DDI_PSEUDO, NULL) == DDI_FAILURE) {
			ddi_remove_minor_node(devi, NULL);
			return (-1);
		}
		if (*(++pty_digit) == '\0') {
			pty_digit = pty_digits;
			if (*(++pty_bank) == '\0')
				break;
		}
	}
	ptc_dip = devi;
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
ptc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	int error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (ptc_dip == NULL) {
			*result = (void *)NULL;
			error = DDI_FAILURE;
		} else {
			*result = (void *) ptc_dip;
			error = DDI_SUCCESS;
		}
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}

static void
ptc_init(void)
{
	minor_t dev;

	for (dev = 0; dev < npty; dev++) {
		cv_init(&pty_softc[dev].pt_cv_flags, NULL, CV_DEFAULT, NULL);
		cv_init(&pty_softc[dev].pt_cv_readq, NULL, CV_DEFAULT, NULL);
		cv_init(&pty_softc[dev].pt_cv_writeq, NULL, CV_DEFAULT, NULL);
		mutex_init(&pty_softc[dev].ptc_lock, NULL, MUTEX_DEFAULT, NULL);
	}
}

static void
ptc_uninit(void)
{
	minor_t dev;

	for (dev = 0; dev < npty; dev++) {
		cv_destroy(&pty_softc[dev].pt_cv_flags);
		cv_destroy(&pty_softc[dev].pt_cv_readq);
		cv_destroy(&pty_softc[dev].pt_cv_writeq);
		mutex_destroy(&pty_softc[dev].ptc_lock);
	}
}

/*
 * Controller side.  This is not, alas, a streams device; there are too
 * many old features that we must support and that don't work well
 * with streams.
 */

/*ARGSUSED*/
int
ptcopen(dev_t *devp, int flag, int otyp, struct cred *cred)
{
	dev_t dev = *devp;
	struct pty *pty;
	queue_t *q;

	if (getminor(dev) >= npty) {
		return (ENXIO);
	}
	pty = &pty_softc[getminor(dev)];
	mutex_enter(&pty->ptc_lock);
	if (pty->pt_flags & PF_CARR_ON) {
		mutex_exit(&pty->ptc_lock);
		return (EIO);	/* controller is exclusive use */
				/* XXX - should be EBUSY! */
	}
	if (pty->pt_flags & PF_WOPEN) {
		pty->pt_flags &= ~PF_WOPEN;
		cv_broadcast(&pty->pt_cv_flags);
	}

	if ((q = pty->pt_ttycommon.t_readq) != NULL) {
		/*
		 * Send an un-hangup to the slave, since "carrier" is
		 * coming back up.  Make sure we're doing canonicalization.
		 */
		(void) putctl(q, M_UNHANGUP);
		(void) putctl1(q, M_CTL, MC_DOCANON);
	}
	pty->pt_flags |= PF_CARR_ON;
	pty->pt_send = 0;
	pty->pt_ucntl = 0;

	mutex_exit(&pty->ptc_lock);
	return (0);
}

/*ARGSUSED1*/
int
ptcclose(dev_t dev, int flag, int otyp, struct cred *cred)
{
	struct pty *pty;
	mblk_t *bp;
	queue_t *q;

	pty = &pty_softc[getminor(dev)];

	mutex_enter(&pty->ptc_lock);
	if ((q = pty->pt_ttycommon.t_readq) != NULL) {
		/*
		 * Send a hangup to the slave, since "carrier" is dropping.
		 */
		(void) putctl(q, M_HANGUP);
	}

	/*
	 * Clear out all the controller-side state.  This also
	 * clears PF_CARR_ON, which is correct because the
	 * "carrier" is dropping since the controller process
	 * is going away.
	 */
	pty->pt_flags &= (PF_WOPEN|PF_STOPPED|PF_NOSTOP);
	while ((bp = pty->pt_stuffqfirst) != NULL) {
		if ((pty->pt_stuffqfirst = bp->b_next) == NULL)
			pty->pt_stuffqlast = NULL;
		else
			pty->pt_stuffqfirst->b_prev = NULL;
		pty->pt_stuffqlen--;
		bp->b_next = bp->b_prev = NULL;
		freemsg(bp);
	}
	mutex_exit(&pty->ptc_lock);
	return (0);
}

int
ptcread(dev_t dev, struct uio *uio, struct cred *cred)
{
	struct pty *pty = &pty_softc[getminor(dev)];
	mblk_t *bp, *nbp;
	queue_t *q;
	unsigned char tmp;
	ssize_t cc;
	int error;
	off_t off;

#ifdef lint
	cred = cred;
#endif

	off = uio->uio_offset;

	mutex_enter(&pty->ptc_lock);

	for (;;) {
		while (pty->pt_flags & PF_READ) {
			pty->pt_flags |= PF_WREAD;
			cv_wait(&pty->pt_cv_flags, &pty->ptc_lock);
		}
		pty->pt_flags |= PF_READ;

		/*
		 * If there's a TIOCPKT packet waiting, pass it back.
		 */
		while (pty->pt_flags&(PF_PKT|PF_UCNTL) && pty->pt_send) {
			tmp = pty->pt_send;
			pty->pt_send = 0;
			mutex_exit(&pty->ptc_lock);
			error = ureadc((int)tmp, uio);
			uio->uio_offset = off;
			mutex_enter(&pty->ptc_lock);
			if (error) {
				pty->pt_send |= tmp;
				goto out;
			}
			if (pty->pt_send == 0)
				goto out;
		}

		/*
		 * If there's a user-control packet waiting, pass the
		 * "ioctl" code back.
		 */
		while ((pty->pt_flags & (PF_UCNTL|PF_43UCNTL)) &&
		    pty->pt_ucntl) {
			tmp = pty->pt_ucntl;
			pty->pt_ucntl = 0;
			mutex_exit(&pty->ptc_lock);
			error = ureadc((int)tmp, uio);
			uio->uio_offset = off;
			mutex_enter(&pty->ptc_lock);
			if (error) {
				if (pty->pt_ucntl == 0)
					pty->pt_ucntl = tmp;
				goto out;
			}
			if (pty->pt_ucntl == 0)
				goto out;
		}

		/*
		 * If there's any data waiting, pass it back.
		 */
		if ((q = pty->pt_ttycommon.t_writeq) != NULL &&
		    q->q_first != NULL &&
		    !(pty->pt_flags & PF_STOPPED)) {
			if (pty->pt_flags & (PF_PKT|PF_UCNTL|PF_43UCNTL)) {
				/*
				 * We're about to begin a move in packet or
				 * user-control mode; precede the data with a
				 * data header.
				 */
				mutex_exit(&pty->ptc_lock);
				error = ureadc(TIOCPKT_DATA, uio);
				uio->uio_offset = off;
				mutex_enter(&pty->ptc_lock);
				if (error != 0)
					goto out;
				if ((q = pty->pt_ttycommon.t_writeq) == NULL)
					goto out;
			}
			if ((bp = getq(q)) == NULL)
				goto out;
			while (uio->uio_resid > 0) {
				while ((cc = bp->b_wptr - bp->b_rptr) == 0) {
					nbp = bp->b_cont;
					freeb(bp);
					if ((bp = nbp) == NULL) {
						if ((q == NULL) ||
						    (bp = getq(q)) == NULL)
							goto out;
					}
				}
				cc = MIN(cc, uio->uio_resid);
				mutex_exit(&pty->ptc_lock);
				error = uiomove((caddr_t)bp->b_rptr,
				    cc, UIO_READ, uio);
				uio->uio_offset = off;
				mutex_enter(&pty->ptc_lock);
				if (error != 0) {
					freemsg(bp);
					goto out;
				}
				q = pty->pt_ttycommon.t_writeq;
				bp->b_rptr += cc;
			}
			/*
			 * Strip off zero-length blocks from the front of
			 * what we're putting back on the queue.
			 */
			while ((bp->b_wptr - bp->b_rptr) == 0) {
				nbp = bp->b_cont;
				freeb(bp);
				if ((bp = nbp) == NULL)
					goto out;	/* nothing left */
			}
			if (q != NULL)
				(void) putbq(q, bp);
			else
				freemsg(bp);
			goto out;
		}

		/*
		 * If there's any TIOCSTI-stuffed characters, pass
		 * them back.  (They currently arrive after all output;
		 * is this correct?)
		 */
		if (pty->pt_flags&PF_UCNTL && pty->pt_stuffqfirst != NULL) {
			mutex_exit(&pty->ptc_lock);
			error = ureadc(TIOCSTI&0xff, uio);
			mutex_enter(&pty->ptc_lock);
			while (error == 0 &&
			    (bp = pty->pt_stuffqfirst) != NULL &&
			    uio->uio_resid > 0) {
				pty->pt_stuffqlen--;
				if ((pty->pt_stuffqfirst = bp->b_next) == NULL)
					pty->pt_stuffqlast = NULL;
				else
					pty->pt_stuffqfirst->b_prev = NULL;
				mutex_exit(&pty->ptc_lock);
				error = ureadc((int)*bp->b_rptr, uio);
				bp->b_next = bp->b_prev = NULL;
				freemsg(bp);
				mutex_enter(&pty->ptc_lock);
			}
			uio->uio_offset = off;
			goto out;
		}

		/*
		 * There's no data available.
		 * We want to block until the slave is open, and there's
		 * something to read; but if we lost the slave or we're NBIO,
		 * then return the appropriate error instead.  POSIX-style
		 * non-block has top billing and gives -1 with errno = EAGAIN,
		 * BSD-style comes next and gives -1 with errno = EWOULDBLOCK,
		 * SVID-style comes last and gives 0.
		 */
		if (pty->pt_flags & PF_SLAVEGONE) {
			error = EIO;
			goto out;
		}
		if (uio->uio_fmode & FNONBLOCK) {
			error = EAGAIN;
			goto out;
		}
		if (pty->pt_flags & PF_NBIO) {
			error = EWOULDBLOCK;
			goto out;
		}
		if (uio->uio_fmode & FNDELAY)
			goto out;

		if (pty->pt_flags & PF_WREAD)
			cv_broadcast(&pty->pt_cv_flags);

		pty->pt_flags &= ~(PF_READ | PF_WREAD);


		if (!cv_wait_sig(&pty->pt_cv_writeq, &pty->ptc_lock)) {
			mutex_exit(&pty->ptc_lock);
			return (EINTR);
		}
	}

out:
	if (pty->pt_flags & PF_WREAD)
		cv_broadcast(&pty->pt_cv_flags);

	pty->pt_flags &= ~(PF_READ | PF_WREAD);

	mutex_exit(&pty->ptc_lock);
	return (error);
}

int
ptcwrite(dev_t dev, struct uio *uio, struct cred *cred)
{
	struct pty *pty = &pty_softc[getminor(dev)];
	queue_t *q;
	int written;
	mblk_t *mp;
	int fmode = 0;
	int error = 0;

	off_t off;
	off = uio->uio_offset;

#ifdef lint
	cred = cred;
#endif


	mutex_enter(&pty->ptc_lock);

again:
	while (pty->pt_flags & PF_WRITE) {
		pty->pt_flags |= PF_WWRITE;
		cv_wait(&pty->pt_cv_flags, &pty->ptc_lock);
	}

	pty->pt_flags |= PF_WRITE;

	if ((q = pty->pt_ttycommon.t_readq) == NULL) {

		/*
		 * Wait for slave to open.
		 */
		if (pty->pt_flags & PF_SLAVEGONE) {
			error = EIO;
			goto out;
		}
		if (uio->uio_fmode & FNONBLOCK) {
			error = EAGAIN;
			goto out;
		}
		if (pty->pt_flags & PF_NBIO) {
			error = EWOULDBLOCK;
			goto out;
		}
		if (uio->uio_fmode & FNDELAY)
			goto out;

		if (pty->pt_flags & PF_WWRITE)
			cv_broadcast(&pty->pt_cv_flags);

		pty->pt_flags &= ~(PF_WRITE | PF_WWRITE);

		if (!cv_wait_sig(&pty->pt_cv_readq, &pty->ptc_lock)) {
			mutex_exit(&pty->ptc_lock);
			return (EINTR);
		}

		goto again;
	}

	/*
	 * If in remote mode, even zero-length writes generate messages.
	 */
	written = 0;
	if ((pty->pt_flags & PF_REMOTE) || uio->uio_resid > 0) {
		do {
			while (!canput(q)) {
				/*
				 * Wait for slave's read queue to unclog.
				 */
				if (pty->pt_flags & PF_SLAVEGONE) {
					error = EIO;
					goto out;
				}
				if (uio->uio_fmode & FNONBLOCK) {
					if (!written)
						error = EAGAIN;
					goto out;
				}
				if (pty->pt_flags & PF_NBIO) {
					if (!written)
						error = EWOULDBLOCK;
					goto out;
				}
				if (uio->uio_fmode & FNDELAY)
					goto out;

				if (pty->pt_flags & PF_WWRITE)
					cv_broadcast(&pty->pt_cv_flags);

				pty->pt_flags &= ~(PF_WRITE | PF_WWRITE);

				if (!cv_wait_sig(&pty->pt_cv_readq,
				    &pty->ptc_lock)) {
					mutex_exit(&pty->ptc_lock);
					return (EINTR);
				}

				while (pty->pt_flags & PF_WRITE) {
					pty->pt_flags |= PF_WWRITE;
					cv_wait(&pty->pt_cv_flags,
					    &pty->ptc_lock);
				}

				pty->pt_flags |= PF_WRITE;
			}

			if ((pty->pt_flags & PF_NBIO) &&
			    !(uio->uio_fmode & FNONBLOCK)) {
				fmode = uio->uio_fmode;
				uio->uio_fmode |= FNONBLOCK;
			}

			error = makemsg(uio->uio_resid, uio, pty, &mp);
			uio->uio_offset = off;
			if (fmode)
				uio->uio_fmode = fmode;
			if (error != 0) {
				if (error != EAGAIN && error != EWOULDBLOCK)
					goto out;
				if (uio->uio_fmode & FNONBLOCK) {
					if (!written)
						error = EAGAIN;
					goto out;
				}
				if (pty->pt_flags & PF_NBIO) {
					if (!written)
						error = EWOULDBLOCK;
					goto out;
				}
				if (uio->uio_fmode & FNDELAY)
					goto out;
				cmn_err(CE_PANIC,
				    "ptcwrite: non null return from"
				    " makemsg");
			}

			/*
			 * Check again for safety; since "uiomove" can take a
			 * page fault, there's no guarantee that "pt_flags"
			 * didn't change while it was happening.
			 */
			if ((q = pty->pt_ttycommon.t_readq) == NULL) {
				if (mp)
					freemsg(mp);
				error = EIO;
				goto out;
			}
			if (mp)
				(void) putq(q, mp);
			written = 1;
		} while (uio->uio_resid > 0);
	}
out:
	if (pty->pt_flags & PF_WWRITE)
		cv_broadcast(&pty->pt_cv_flags);

	pty->pt_flags &= ~(PF_WRITE | PF_WWRITE);

	mutex_exit(&pty->ptc_lock);
	return (error);
}

#define	copy_in(data, d_arg) \
	if (copyin((caddr_t)data, &d_arg, sizeof (int)) != 0) \
		return (EFAULT)

#define	copy_out(d_arg, data) \
	if (copyout(&d_arg, (caddr_t)data, sizeof (int)) != 0) \
		return (EFAULT)

int
ptcioctl(dev_t dev, int cmd, intptr_t data, int flag, struct cred *cred,
    int *rvalp)
{
	struct pty *pty = &pty_softc[getminor(dev)];
	queue_t *q;
	struct ttysize tty_arg;
	struct winsize win_arg;
	int d_arg;
	int err;

	switch (cmd) {

	case TIOCPKT:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg) {
			if (pty->pt_flags & (PF_UCNTL|PF_43UCNTL)) {
				mutex_exit(&pty->ptc_lock);
				return (EINVAL);
			}
			pty->pt_flags |= PF_PKT;
		} else
			pty->pt_flags &= ~PF_PKT;
		mutex_exit(&pty->ptc_lock);
		break;

	case TIOCUCNTL:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg) {
			if (pty->pt_flags & (PF_PKT|PF_UCNTL)) {
				mutex_exit(&pty->ptc_lock);
				return (EINVAL);
			}
			pty->pt_flags |= PF_43UCNTL;
		} else
			pty->pt_flags &= ~PF_43UCNTL;
		mutex_exit(&pty->ptc_lock);
		break;

	case TIOCTCNTL:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg) {
			if (pty->pt_flags & PF_PKT) {
				mutex_exit(&pty->ptc_lock);
				return (EINVAL);
			}
			pty->pt_flags |= PF_UCNTL;
		} else
			pty->pt_flags &= ~PF_UCNTL;
		mutex_exit(&pty->ptc_lock);
		break;

	case TIOCREMOTE:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg) {
			if ((q = pty->pt_ttycommon.t_readq) != NULL)
				(void) putctl1(q, M_CTL, MC_NOCANON);
			pty->pt_flags |= PF_REMOTE;
		} else {
			if ((q = pty->pt_ttycommon.t_readq) != NULL)
				(void) putctl1(q, M_CTL, MC_DOCANON);
			pty->pt_flags &= ~PF_REMOTE;
		}
		mutex_exit(&pty->ptc_lock);
		break;

	case TIOCSIGNAL:
		/*
		 * Blast a M_PCSIG message up the slave stream; the
		 * signal number is the argument to the "ioctl".
		 */
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if ((q = pty->pt_ttycommon.t_readq) != NULL)
			(void) putctl1(q, M_PCSIG, (int)d_arg);
		mutex_exit(&pty->ptc_lock);
		break;

	case FIONBIO:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg)
			pty->pt_flags |= PF_NBIO;
		else
			pty->pt_flags &= ~PF_NBIO;
		mutex_exit(&pty->ptc_lock);
		break;

	case FIOASYNC:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		if (d_arg)
			pty->pt_flags |= PF_ASYNC;
		else
			pty->pt_flags &= ~PF_ASYNC;
		mutex_exit(&pty->ptc_lock);
		break;

	/*
	 * These, at least, can work on the controller-side process
	 * group.
	 */
	case FIOGETOWN:
		mutex_enter(&pty->ptc_lock);
		d_arg = -pty->pt_pgrp;
		mutex_exit(&pty->ptc_lock);
		copy_out(d_arg, data);
		break;

	case FIOSETOWN:
		copy_in(data, d_arg);
		mutex_enter(&pty->ptc_lock);
		pty->pt_pgrp = (short)(-d_arg);
		mutex_exit(&pty->ptc_lock);
		break;

	case FIONREAD: {
		/*
		 * Return the total number of bytes of data in all messages
		 * in slave write queue, which is master read queue, unless a
		 * special message would be read.
		 */
		mblk_t *mp;
		size_t count = 0;

		mutex_enter(&pty->ptc_lock);
		if (pty->pt_flags&(PF_PKT|PF_UCNTL) && pty->pt_send)
			count = 1;	/* will return 1 byte */
		else if ((pty->pt_flags & (PF_UCNTL|PF_43UCNTL)) &&
		    pty->pt_ucntl)
			count = 1;	/* will return 1 byte */
		else if ((q = pty->pt_ttycommon.t_writeq) != NULL &&
		    q->q_first != NULL && !(pty->pt_flags & PF_STOPPED)) {
			/*
			 * Will return whatever data is queued up.
			 */
			for (mp = q->q_first; mp != NULL; mp = mp->b_next)
				count += msgdsize(mp);
		} else if ((pty->pt_flags & PF_UCNTL) &&
		    pty->pt_stuffqfirst != NULL) {
			/*
			 * Will return STI'ed data.
			 */
			count = pty->pt_stuffqlen + 1;
		}

		/*
		 * Under LP64 we could have more than INT_MAX bytes to report,
		 * but the interface is defined in terms of int, so we cap it.
		 */
		d_arg = MIN(count, INT_MAX);
		mutex_exit(&pty->ptc_lock);
		copy_out(d_arg, data);
		break;
	}

	case TIOCSWINSZ:
		/*
		 * Unfortunately, TIOCSWINSZ and the old TIOCSSIZE "ioctl"s
		 * share the same code.  If the upper 16 bits of the number
		 * of lines is non-zero, it was probably a TIOCSWINSZ,
		 * with both "ws_row" and "ws_col" non-zero.
		 */
		if (copyin((caddr_t)data,
		    &tty_arg, sizeof (struct ttysize)) != 0)
			return (EFAULT);

		if ((tty_arg.ts_lines & 0xffff0000) != 0) {
			/*
			 * It's a TIOCSWINSZ.
			 */
			win_arg = *(struct winsize *)&tty_arg;

			mutex_enter(&pty->ptc_lock);
			/*
			 * If the window size changed, send a SIGWINCH.
			 */
			if (bcmp(&pty->pt_ttycommon.t_size,
			    &win_arg, sizeof (struct winsize))) {
				pty->pt_ttycommon.t_size = win_arg;
				if ((q = pty->pt_ttycommon.t_readq) != NULL)
					(void) putctl1(q, M_PCSIG, SIGWINCH);
			}
			mutex_exit(&pty->ptc_lock);
			break;
		}
		/* FALLTHROUGH */

	case TIOCSSIZE:
		if (copyin((caddr_t)data,
		    &tty_arg, sizeof (struct ttysize)) != 0)
			return (EFAULT);
		mutex_enter(&pty->ptc_lock);
		pty->pt_ttycommon.t_size.ws_row = (ushort_t)tty_arg.ts_lines;
		pty->pt_ttycommon.t_size.ws_col = (ushort_t)tty_arg.ts_cols;
		pty->pt_ttycommon.t_size.ws_xpixel = 0;
		pty->pt_ttycommon.t_size.ws_ypixel = 0;
		mutex_exit(&pty->ptc_lock);
		break;

	case TIOCGWINSZ:
		mutex_enter(&pty->ptc_lock);
		win_arg = pty->pt_ttycommon.t_size;
		mutex_exit(&pty->ptc_lock);
		if (copyout(&win_arg, (caddr_t)data,
		    sizeof (struct winsize)) != 0)
			return (EFAULT);
		break;

	case TIOCGSIZE:
		mutex_enter(&pty->ptc_lock);
		tty_arg.ts_lines = pty->pt_ttycommon.t_size.ws_row;
		tty_arg.ts_cols = pty->pt_ttycommon.t_size.ws_col;
		mutex_exit(&pty->ptc_lock);
		if (copyout(&tty_arg, (caddr_t)data,
		    sizeof (struct ttysize)) != 0)
			return (EFAULT);
		break;

	/*
	 * XXX These should not be here.  The only reason why an
	 * "ioctl" on the controller side should get the
	 * slave side's process group is so that the process on
	 * the controller side can send a signal to the slave
	 * side's process group; however, this is better done
	 * with TIOCSIGNAL, both because it doesn't require us
	 * to know about the slave side's process group and because
	 * the controller side process may not have permission to
	 * send that signal to the entire process group.
	 *
	 * However, since vanilla 4BSD doesn't provide TIOCSIGNAL,
	 * we can't just get rid of them.
	 */
	case TIOCGPGRP:
	case TIOCSPGRP:
	/*
	 * This is amazingly disgusting, but the stupid semantics of
	 * 4BSD pseudo-ttys makes us do it.  If we do one of these guys
	 * on the controller side, it really applies to the slave-side
	 * stream.  It should NEVER have been possible to do ANY sort
	 * of tty operations on the controller side, but it's too late
	 * to fix that now.  However, we won't waste our time implementing
	 * anything that the original pseudo-tty driver didn't handle.
	 */
	case TIOCGETP:
	case TIOCSETP:
	case TIOCSETN:
	case TIOCGETC:
	case TIOCSETC:
	case TIOCGLTC:
	case TIOCSLTC:
	case TIOCLGET:
	case TIOCLSET:
	case TIOCLBIS:
	case TIOCLBIC:
		mutex_enter(&pty->ptc_lock);
		if (pty->pt_vnode == NULL) {
			mutex_exit(&pty->ptc_lock);
			return (EIO);
		}
		pty->pt_flags |= PF_IOCTL;
		mutex_exit(&pty->ptc_lock);
		err = strioctl(pty->pt_vnode, cmd, data, flag,
		    U_TO_K, cred, rvalp);
		mutex_enter(&pty->ptc_lock);
		if (pty->pt_flags & PF_WAIT)
			cv_signal(&pty->pt_cv_flags);
		pty->pt_flags &= ~(PF_IOCTL|PF_WAIT);
		mutex_exit(&pty->ptc_lock);
		return (err);

	default:
		return (ENOTTY);
	}

	return (0);
}


int
ptcpoll(dev_t dev,
	short events,
	int anyyet,
	short *reventsp,
	struct pollhead **phpp)
{
	struct pty *pty = &pty_softc[getminor(dev)];
	pollhead_t *php = &ptcph;
	queue_t *q;
	int pos = 0;

#ifdef lint
	anyyet = anyyet;
#endif
	polllock(php, &pty->ptc_lock);

	ASSERT(MUTEX_HELD(&pty->ptc_lock));

	*reventsp = 0;
	if (pty->pt_flags & PF_SLAVEGONE) {
		if (events & (POLLIN|POLLRDNORM))
			*reventsp |= (events & (POLLIN|POLLRDNORM));
		if (events & (POLLOUT|POLLWRNORM))
			*reventsp |= (events & (POLLOUT|POLLWRNORM));
		mutex_exit(&pty->ptc_lock);
		/*
		 * A non NULL pollhead pointer should be returned in case
		 * user polls for 0 events.
		 */
		*phpp = !anyyet && !*reventsp ? php : (struct pollhead *)NULL;
		return (0);
	}
	if (events & (POLLIN|POLLRDNORM)) {
		if ((q = pty->pt_ttycommon.t_writeq) != NULL &&
		    q->q_first != NULL && !(pty->pt_flags & PF_STOPPED)) {
			/*
			 * Regular data is available.
			 */
			*reventsp |= (events & (POLLIN|POLLRDNORM));
			pos++;
		}
		if (pty->pt_flags & (PF_PKT|PF_UCNTL) && pty->pt_send) {
			/*
			 * A control packet is available.
			 */
			*reventsp |= (events & (POLLIN|POLLRDNORM));
			pos++;
		}
		if ((pty->pt_flags & PF_UCNTL) &&
		    (pty->pt_ucntl || pty->pt_stuffqfirst != NULL)) {
			/*
			 * "ioctl" or TIOCSTI data is available.
			 */
			*reventsp |= (events & (POLLIN|POLLRDNORM));
			pos++;
		}
		if ((pty->pt_flags & PF_43UCNTL) && pty->pt_ucntl) {
			*reventsp |= (events & (POLLIN|POLLRDNORM));
			pos++;
		}
	}
	if (events & (POLLOUT|POLLWRNORM)) {
		if ((q = pty->pt_ttycommon.t_readq) != NULL &&
		    canput(q)) {
			*reventsp |= (events & (POLLOUT|POLLWRNORM));
			pos++;
		}
	}
	if (events & POLLERR) {
		*reventsp |= POLLERR;
		pos++;
	}
	if (events == 0) {	/* "exceptional conditions" */
		if (((pty->pt_flags & (PF_PKT|PF_UCNTL)) && pty->pt_send) ||
		    ((pty->pt_flags & PF_UCNTL) &&
		    (pty->pt_ucntl || pty->pt_stuffqfirst != NULL))) {
			pos++;
		}
		if ((pty->pt_flags & PF_43UCNTL) && pty->pt_ucntl) {
			pos++;
		}
	}

	/*
	 * Arrange to have poll waken up when event occurs.
	 * if (!anyyet)
	 */
	if (!pos) {
		*phpp = php;
		*reventsp = 0;
	}

	mutex_exit(&pty->ptc_lock);
	return (0);
}

void
gsignal(int pid, int sig)
{
	procset_t set;
	sigsend_t v;

	bzero(&v, sizeof (v));
	v.sig = sig;
	v.perm = 0;
	v.checkperm = 1;
	v.value.sival_ptr = NULL;

	setprocset(&set, POP_AND, P_PGID, -pid, P_ALL, P_MYID);
	(void) sigsendset(&set, &v);
}

static int
makemsg(ssize_t count, struct uio *uiop, struct pty *pty, mblk_t **mpp)
{
	int pri = BPRI_LO;
	int error;
	mblk_t *bp = NULL;

	ASSERT(MUTEX_HELD(&pty->ptc_lock));

	*mpp = NULL;

	/*
	 * Create data part of message, if any.
	 */
	if (count >= 0) {
		if ((bp = allocb(count, pri)) == NULL)
			return (ENOSR);

		mutex_exit(&pty->ptc_lock);
		error = uiomove((caddr_t)bp->b_wptr, count, UIO_WRITE, uiop);
		mutex_enter(&pty->ptc_lock);
		if (error) {
			freeb(bp);
			return (error);
		}

		bp->b_wptr += count;
	}

	*mpp = bp;
	return (0);
}