OpenSolaris_b135/uts/common/io/tty_pts.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.
* This is the "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/strsun.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/policy.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
extern void gsignal(int pid, int sig);
extern int npty; /* number of pseudo-ttys configured in */
extern struct pty *pty_softc;
extern struct pollhead ptcph; /* poll head for ptcpoll() use */
#define IFLAGS (CS7|CREAD|PARENB)
/*
* Most of these should be "void", but the people who defined the "streams"
* data structure for S5 didn't understand data types.
*/
/*
* Slave side. This is a streams device.
*/
static int ptslopen(queue_t *, dev_t *, int flag, int, cred_t *);
static int ptslclose(queue_t *, int, cred_t *);
static int ptslrserv(queue_t *);
/*
* To save instructions, since STREAMS ignores the return value
* from this function, it is defined as void here. Kind of icky, but...
*/
static void ptslwput(queue_t *q, mblk_t *mp);
static struct module_info ptslm_info = {
0,
"ptys",
0,
INFPSZ,
2048,
200
};
static struct qinit ptslrinit = {
putq,
ptslrserv,
ptslopen,
ptslclose,
NULL,
&ptslm_info,
NULL
};
static struct qinit ptslwinit = {
(int (*)())ptslwput,
NULL,
NULL,
NULL,
NULL,
&ptslm_info,
NULL
};
struct streamtab ptysinfo = {
&ptslrinit,
&ptslwinit,
NULL,
NULL
};
static void ptslreioctl(void *);
static void ptslioctl(struct pty *, queue_t *, mblk_t *);
static void pt_sendstop(struct pty *);
static void ptcpollwakeup(struct pty *, int);
static int ptsl_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int ptsl_attach(dev_info_t *, ddi_attach_cmd_t);
static dev_info_t *ptsl_dip; /* for dev-to-dip conversions */
DDI_DEFINE_STREAM_OPS(ptsl_ops, nulldev, nulldev,
ptsl_attach, nodev, nodev, ptsl_info, D_MP, &ptysinfo,
ddi_quiesce_not_supported);
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/modctl.h>
char _depends_on[] = "drv/ptc";
/*
* Module linkage information for the kernel.
*/
static struct modldrv modldrv = {
&mod_driverops, /* Type of module. This one is a pseudo driver */
"tty pseudo driver slave 'ptsl'",
&ptsl_ops, /* driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (mod_remove(&modlinkage));
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
static char *tty_banks = PTY_BANKS;
static char *tty_digits = PTY_DIGITS;
/* ARGSUSED */
static int
ptsl_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
char name[8];
int tty_num;
char *tty_digit = tty_digits;
char *tty_bank = tty_banks;
for (tty_num = 0; tty_num < npty; tty_num++) {
(void) sprintf(name, "tty%c%c", *tty_bank, *tty_digit);
if (ddi_create_minor_node(devi, name, S_IFCHR,
tty_num, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (-1);
}
if (*(++tty_digit) == '\0') {
tty_digit = tty_digits;
if (*(++tty_bank) == '\0')
break;
}
}
ptsl_dip = devi;
return (DDI_SUCCESS);
}
/* ARGSUSED */
static int
ptsl_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
void **result)
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
if (ptsl_dip == NULL) {
error = DDI_FAILURE;
} else {
*result = (void *)ptsl_dip;
error = DDI_SUCCESS;
}
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)0;
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
/*
* Open the slave side of a pty.
*/
/*ARGSUSED*/
static int
ptslopen(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *cred)
{
minor_t unit;
dev_t dev = *devp;
struct pty *pty;
unit = getminor(dev);
if (unit >= npty)
return (ENXIO);
pty = &pty_softc[unit];
mutex_enter(&pty->ptc_lock);
/*
* Block waiting for controller to open, unless this is a no-delay
* open.
*/
again:
if (pty->pt_ttycommon.t_writeq == NULL) {
pty->pt_ttycommon.t_iflag = 0;
pty->pt_ttycommon.t_cflag = (B38400 << IBSHIFT)|B38400|IFLAGS;
pty->pt_ttycommon.t_iocpending = NULL;
pty->pt_wbufcid = 0;
pty->pt_ttycommon.t_size.ws_row = 0;
pty->pt_ttycommon.t_size.ws_col = 0;
pty->pt_ttycommon.t_size.ws_xpixel = 0;
pty->pt_ttycommon.t_size.ws_ypixel = 0;
} else if ((pty->pt_ttycommon.t_flags & TS_XCLUDE) &&
secpolicy_excl_open(cred) != 0) {
mutex_exit(&pty->ptc_lock);
return (EBUSY);
}
if (!(flag & (FNONBLOCK|FNDELAY)) &&
!(pty->pt_ttycommon.t_cflag & CLOCAL)) {
if (!(pty->pt_flags & PF_CARR_ON)) {
pty->pt_flags |= PF_WOPEN;
if (!cv_wait_sig(&pty->pt_cv_flags, &pty->ptc_lock)) {
pty->pt_flags &= ~PF_WOPEN;
mutex_exit(&pty->ptc_lock);
return (EINTR);
}
goto again;
}
}
pty->pt_sdev = dev;
q->q_ptr = WR(q)->q_ptr = pty;
pty->pt_flags &= ~PF_SLAVEGONE;
pty->pt_ttycommon.t_readq = pty->pt_ttycommon.t_writeq = NULL;
/*
* Slave is ready to accept messages but master still can't send
* messages to the slave queue since it is not plumbed
* yet. So do qprocson() and finish slave initialization.
*/
mutex_exit(&pty->ptc_lock);
qprocson(q);
/*
* Now it is safe to send messages to q, so wakeup master possibly
* waiting for slave queue to finish open.
*/
mutex_enter(&pty->ptc_lock);
/*
* queue has already been setup with a pointer to
* the stream head that is being referenced
*/
pty->pt_vnode = strq2vp(q);
VN_RELE(pty->pt_vnode);
pty->pt_ttycommon.t_readq = q;
pty->pt_ttycommon.t_writeq = WR(q);
/* tell master device that slave is ready for writing */
if (pty->pt_flags & PF_CARR_ON)
cv_broadcast(&pty->pt_cv_readq);
mutex_exit(&pty->ptc_lock);
return (0);
}
static int
ptslclose(queue_t *q, int flag, cred_t *cred)
{
struct pty *pty;
bufcall_id_t pt_wbufcid = 0;
#ifdef lint
flag = flag;
cred = cred;
#endif
if ((pty = (struct pty *)q->q_ptr) == NULL)
return (ENODEV); /* already been closed once */
/*
* Prevent the queues from being uses by master device.
* This should be done before qprocsoff or writer may attempt
* to use the slave queue after qprocsoff removed it from the stream and
* before entering mutex_enter().
*/
mutex_enter(&pty->ptc_lock);
pty->pt_ttycommon.t_readq = NULL;
pty->pt_ttycommon.t_writeq = NULL;
while (pty->pt_flags & PF_IOCTL) {
pty->pt_flags |= PF_WAIT;
cv_wait(&pty->pt_cv_flags, &pty->ptc_lock);
}
pty->pt_vnode = NULL;
mutex_exit(&pty->ptc_lock);
qprocsoff(q);
mutex_enter(&pty->ptc_lock);
/*
* ptc_lock mutex is not dropped across
* the call to the routine ttycommon_close
*/
ttycommon_close(&pty->pt_ttycommon);
/*
* Cancel outstanding "bufcall" request.
*/
if (pty->pt_wbufcid) {
pt_wbufcid = pty->pt_wbufcid;
pty->pt_wbufcid = 0;
}
/*
* Clear out all the slave-side state.
*/
pty->pt_flags &= ~(PF_WOPEN|PF_STOPPED|PF_NOSTOP);
if (pty->pt_flags & PF_CARR_ON) {
pty->pt_flags |= PF_SLAVEGONE; /* let the controller know */
ptcpollwakeup(pty, 0); /* wake up readers/selectors */
ptcpollwakeup(pty, FWRITE); /* wake up writers/selectors */
cv_broadcast(&pty->pt_cv_flags);
}
pty->pt_sdev = 0;
q->q_ptr = WR(q)->q_ptr = NULL;
mutex_exit(&pty->ptc_lock);
if (pt_wbufcid)
unbufcall(pt_wbufcid);
return (0);
}
/*
* Put procedure for write queue.
* Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here;
* queue up M_DATA messages for processing by the controller "read"
* routine; discard everything else.
*/
static void
ptslwput(queue_t *q, mblk_t *mp)
{
struct pty *pty;
mblk_t *bp;
pty = (struct pty *)q->q_ptr;
mutex_enter(&pty->ptc_lock);
switch (mp->b_datap->db_type) {
case M_STOP:
if (!(pty->pt_flags & PF_STOPPED)) {
pty->pt_flags |= PF_STOPPED;
pty->pt_send |= TIOCPKT_STOP;
ptcpollwakeup(pty, 0);
}
freemsg(mp);
break;
case M_START:
if (pty->pt_flags & PF_STOPPED) {
pty->pt_flags &= ~PF_STOPPED;
pty->pt_send = TIOCPKT_START;
ptcpollwakeup(pty, 0);
}
ptcpollwakeup(pty, FREAD); /* permit controller to read */
freemsg(mp);
break;
case M_IOCTL:
ptslioctl(pty, q, mp);
break;
case M_FLUSH:
if (*mp->b_rptr & FLUSHW) {
/*
* Set the "flush write" flag, so that we
* notify the controller if they're in packet
* or user control mode.
*/
if (!(pty->pt_send & TIOCPKT_FLUSHWRITE)) {
pty->pt_send |= TIOCPKT_FLUSHWRITE;
ptcpollwakeup(pty, 0);
}
/*
* Flush our write queue.
*/
flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */
*mp->b_rptr &= ~FLUSHW; /* it has been flushed */
}
if (*mp->b_rptr & FLUSHR) {
/*
* Set the "flush read" flag, so that we
* notify the controller if they're in packet
* mode.
*/
if (!(pty->pt_send & TIOCPKT_FLUSHREAD)) {
pty->pt_send |= TIOCPKT_FLUSHREAD;
ptcpollwakeup(pty, 0);
}
flushq(RD(q), FLUSHDATA);
mutex_exit(&pty->ptc_lock);
qreply(q, mp); /* give the read queues a crack at it */
return;
} else
freemsg(mp);
break;
case M_DATA:
/*
* Throw away any leading zero-length blocks, and queue it up
* for the controller to read.
*/
if (pty->pt_flags & PF_CARR_ON) {
bp = mp;
while ((bp->b_wptr - bp->b_rptr) == 0) {
mp = bp->b_cont;
freeb(bp);
if (mp == NULL) {
mutex_exit(&pty->ptc_lock);
return; /* damp squib of a message */
}
bp = mp;
}
(void) putq(q, mp);
ptcpollwakeup(pty, FREAD); /* soup's on! */
} else
freemsg(mp); /* nobody listening */
break;
case M_CTL:
if ((*(int *)mp->b_rptr) == MC_CANONQUERY) {
/*
* We're being asked whether we do canonicalization
* or not. Send a reply back up indicating whether
* we do or not.
*/
(void) putctl1(RD(q), M_CTL,
(pty->pt_flags & PF_REMOTE) ?
MC_NOCANON : MC_DOCANON);
}
freemsg(mp);
break;
default:
/*
* "No, I don't want a subscription to Chain Store Age,
* thank you anyway."
*/
freemsg(mp);
break;
}
mutex_exit(&pty->ptc_lock);
}
/*
* Retry an "ioctl", now that "bufcall" claims we may be able to allocate
* the buffer we need.
*/
static void
ptslreioctl(void *arg)
{
struct pty *pty = arg;
queue_t *q;
mblk_t *mp;
mutex_enter(&pty->ptc_lock);
/*
* The bufcall is no longer pending.
*/
if (pty->pt_wbufcid == 0) {
mutex_exit(&pty->ptc_lock);
return;
}
pty->pt_wbufcid = 0;
if ((q = pty->pt_ttycommon.t_writeq) == NULL) {
mutex_exit(&pty->ptc_lock);
return;
}
if ((mp = pty->pt_ttycommon.t_iocpending) != NULL) {
/* It's not pending any more. */
pty->pt_ttycommon.t_iocpending = NULL;
ptslioctl(pty, q, mp);
}
mutex_exit(&pty->ptc_lock);
}
/*
* Process an "ioctl" message sent down to us.
* Drops pty's ptc_lock mutex and then reacquire
*/
static void
ptslioctl(struct pty *pty, queue_t *q, mblk_t *mp)
{
struct iocblk *iocp;
int cmd;
size_t datasize;
int error = 0;
ASSERT(MUTEX_HELD(&pty->ptc_lock));
iocp = (struct iocblk *)mp->b_rptr;
cmd = iocp->ioc_cmd;
switch (cmd) {
case TIOCSTI: {
/*
* The permission checking has already been done at the stream
* head, since it has to be done in the context of the process
* doing the call.
*/
mblk_t *bp;
error = miocpullup(mp, sizeof (char));
if (error != 0)
goto out;
/*
* Simulate typing of a character at the terminal.
*/
if ((bp = allocb(1, BPRI_MED)) != NULL) {
*bp->b_wptr++ = *mp->b_cont->b_rptr;
if (!(pty->pt_flags & PF_REMOTE)) {
if (!canput(pty->pt_ttycommon.t_readq)) {
mutex_exit(&pty->ptc_lock);
ttycommon_qfull(&pty->pt_ttycommon, q);
mutex_enter(&pty->ptc_lock);
freemsg(bp);
error = EAGAIN;
goto out;
} else
(void) putq(
pty->pt_ttycommon.t_readq, bp);
} else {
if (pty->pt_flags & PF_UCNTL) {
/*
* XXX - flow control; don't overflow
* this "queue".
*/
if (pty->pt_stuffqfirst != NULL) {
pty->pt_stuffqlast->b_next = bp;
bp->b_prev = pty->pt_stuffqlast;
} else {
pty->pt_stuffqfirst = bp;
bp->b_prev = NULL;
}
bp->b_next = NULL;
pty->pt_stuffqlast = bp;
pty->pt_stuffqlen++;
ptcpollwakeup(pty, 0);
}
}
} else {
error = EAGAIN;
goto out;
}
/*
* Turn the ioctl message into an ioctl ACK message.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
goto out;
}
case TIOCSSIZE: {
tty_common_t *tc = &pty->pt_ttycommon;
struct ttysize *tp;
error = miocpullup(mp, sizeof (struct ttysize));
if (error != 0)
goto out;
/*
* Set the window size, but don't send a SIGWINCH.
*/
tp = (struct ttysize *)mp->b_cont->b_rptr;
tc->t_size.ws_row = tp->ts_lines;
tc->t_size.ws_col = tp->ts_cols;
tc->t_size.ws_xpixel = 0;
tc->t_size.ws_ypixel = 0;
/*
* Send an ACK back.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
goto out;
}
case TIOCGSIZE: {
tty_common_t *tc = &pty->pt_ttycommon;
mblk_t *datap;
struct ttysize *tp;
if ((datap = allocb(sizeof (struct ttysize),
BPRI_HI)) == NULL) {
if (pty->pt_wbufcid) {
if (pty->pt_ttycommon.t_iocpending)
freemsg(pty->pt_ttycommon.t_iocpending);
pty->pt_ttycommon.t_iocpending = mp;
return;
}
pty->pt_wbufcid = bufcall(sizeof (struct ttysize),
BPRI_HI, ptslreioctl, pty);
if (pty->pt_wbufcid == 0) {
error = ENOMEM;
goto out;
}
pty->pt_ttycommon.t_iocpending = mp;
return;
}
/*
* Return the current size.
*/
tp = (struct ttysize *)datap->b_wptr;
tp->ts_lines = tc->t_size.ws_row;
tp->ts_cols = tc->t_size.ws_col;
datap->b_wptr += sizeof (struct ttysize);
iocp->ioc_count = sizeof (struct ttysize);
if (mp->b_cont != NULL)
freemsg(mp->b_cont);
mp->b_cont = datap;
mp->b_datap->db_type = M_IOCACK;
goto out;
}
/*
* Imported from ttycommon_ioctl routine
*/
case TCSETSF: {
tty_common_t *tc = &pty->pt_ttycommon;
struct termios *cb;
error = miocpullup(mp, sizeof (struct termios));
if (error != 0)
goto out;
cb = (struct termios *)mp->b_cont->b_rptr;
flushq(RD(q), FLUSHDATA);
mutex_exit(&pty->ptc_lock);
(void) putnextctl1(RD(q), M_FLUSH, FLUSHR);
mutex_enter(&pty->ptc_lock);
mutex_enter(&tc->t_excl);
tc->t_iflag = cb->c_iflag;
tc->t_cflag = cb->c_cflag;
tc->t_stopc = cb->c_cc[VSTOP];
tc->t_startc = cb->c_cc[VSTART];
mutex_exit(&tc->t_excl);
/*
* Turn the ioctl message into an ioctl ACK message.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
goto ioctldone;
}
case TCSETAF: {
tty_common_t *tc = &pty->pt_ttycommon;
struct termios *cb;
error = miocpullup(mp, sizeof (struct termios));
if (error != 0)
goto out;
cb = (struct termios *)mp->b_cont->b_rptr;
flushq(RD(q), FLUSHDATA);
mutex_exit(&pty->ptc_lock);
(void) putnextctl1(RD(q), M_FLUSH, FLUSHR);
mutex_enter(&pty->ptc_lock);
mutex_enter(&tc->t_excl);
tc->t_iflag = (tc->t_iflag & 0xffff0000 | cb->c_iflag);
tc->t_cflag = (tc->t_cflag & 0xffff0000 | cb->c_cflag);
mutex_exit(&tc->t_excl);
/*
* Turn the ioctl message into an ioctl ACK message.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
goto ioctldone;
}
case TIOCSWINSZ: {
tty_common_t *tc = &pty->pt_ttycommon;
struct winsize *ws;
error = miocpullup(mp, sizeof (struct winsize));
if (error != 0)
goto out;
ws = (struct winsize *)mp->b_cont->b_rptr;
/*
* If the window size changed, send a SIGWINCH.
*/
mutex_enter(&tc->t_excl);
if (bcmp(&tc->t_size, ws, sizeof (struct winsize))) {
tc->t_size = *ws;
mutex_exit(&tc->t_excl);
mutex_exit(&pty->ptc_lock);
(void) putnextctl1(RD(q), M_PCSIG, SIGWINCH);
mutex_enter(&pty->ptc_lock);
} else
mutex_exit(&tc->t_excl);
/*
* Turn the ioctl message into an ioctl ACK message.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
goto ioctldone;
}
/*
* If they were just trying to drain output, that's OK.
* If they are actually trying to send a break it's an error.
*/
case TCSBRK:
error = miocpullup(mp, sizeof (int));
if (error != 0)
goto out;
if (*(int *)mp->b_cont->b_rptr != 0) {
/*
* Turn the ioctl message into an ioctl ACK message.
*/
iocp->ioc_count = 0; /* no data returned */
mp->b_datap->db_type = M_IOCACK;
} else {
error = ENOTTY;
}
goto out;
}
/*
* The only way in which "ttycommon_ioctl" can fail is if the "ioctl"
* requires a response containing data to be returned to the user,
* and no mblk could be allocated for the data.
* No such "ioctl" alters our state. Thus, we always go ahead and
* do any state-changes the "ioctl" calls for. If we couldn't allocate
* the data, "ttycommon_ioctl" has stashed the "ioctl" away safely, so
* we just call "bufcall" to request that we be called back when we
* stand a better chance of allocating the data.
*/
if ((datasize =
ttycommon_ioctl(&pty->pt_ttycommon, q, mp, &error)) != 0) {
if (pty->pt_wbufcid) {
if (pty->pt_ttycommon.t_iocpending)
freemsg(pty->pt_ttycommon.t_iocpending);
pty->pt_ttycommon.t_iocpending = mp;
return;
}
pty->pt_wbufcid = bufcall(datasize, BPRI_HI, ptslreioctl, pty);
if (pty->pt_wbufcid == 0) {
error = ENOMEM;
goto out;
}
pty->pt_ttycommon.t_iocpending = mp;
return;
}
ioctldone:
if (error == 0) {
/*
* "ttycommon_ioctl" did most of the work; we just use the
* data it set up.
*/
switch (cmd) {
case TCSETSF:
case TCSETAF:
/*
* Set the "flush read" flag, so that we
* notify the controller if they're in packet
* mode.
*/
if (!(pty->pt_send & TIOCPKT_FLUSHREAD)) {
pty->pt_send |= TIOCPKT_FLUSHREAD;
ptcpollwakeup(pty, 0);
}
/*FALLTHROUGH*/
case TCSETSW:
case TCSETAW:
cmd = TIOCSETP; /* map backwards to old codes */
pt_sendstop(pty);
break;
case TCSETS:
case TCSETA:
cmd = TIOCSETN; /* map backwards to old codes */
pt_sendstop(pty);
break;
}
}
if (pty->pt_flags & PF_43UCNTL) {
if (error < 0) {
if ((cmd & ~0xff) == _IO('u', 0)) {
if (cmd & 0xff) {
pty->pt_ucntl = (uchar_t)cmd & 0xff;
ptcpollwakeup(pty, FREAD);
}
error = 0; /* XXX */
goto out;
}
error = ENOTTY;
}
} else {
if ((pty->pt_flags & PF_UCNTL) &&
(cmd & (IOC_INOUT | 0xff00)) == (IOC_IN|('t'<<8)) &&
(cmd & 0xff)) {
pty->pt_ucntl = (uchar_t)cmd & 0xff;
ptcpollwakeup(pty, FREAD);
goto out;
}
if (error < 0)
error = ENOTTY;
}
out:
if (error != 0) {
((struct iocblk *)mp->b_rptr)->ioc_error = error;
mp->b_datap->db_type = M_IOCNAK;
}
mutex_exit(&pty->ptc_lock);
qreply(q, mp);
mutex_enter(&pty->ptc_lock);
}
/*
* Service routine for read queue.
* Just wakes the controller side up so it can write some more data
* to that queue.
*/
static int
ptslrserv(queue_t *q)
{
struct pty *pty = (struct pty *)q->q_ptr;
mblk_t *mp;
mblk_t *head = NULL, *tail = NULL;
/*
* Build up the link list of messages, then drop
* drop the lock and do putnext()
*/
mutex_enter(&pty->ptc_lock);
while ((mp = getq(q)) != NULL) {
if ((mp->b_datap->db_type < QPCTL) && !canputnext(q)) {
(void) putbq(q, mp);
break;
}
if (!head) {
head = mp;
tail = mp;
} else {
tail->b_next = mp;
tail = mp;
}
}
if (q->q_count <= q->q_lowat)
ptcpollwakeup((struct pty *)q->q_ptr, FWRITE);
mutex_exit(&pty->ptc_lock);
while (head) {
mp = head;
head = mp->b_next;
mp->b_next = NULL;
putnext(q, mp);
}
return (0);
}
static void
pt_sendstop(struct pty *pty)
{
int stop;
ASSERT(MUTEX_HELD(&pty->ptc_lock));
if ((pty->pt_ttycommon.t_cflag&CBAUD) == 0) {
if (pty->pt_flags & PF_CARR_ON) {
/*
* Let the controller know, then wake up
* readers/selectors and writers/selectors.
*/
pty->pt_flags |= PF_SLAVEGONE;
ptcpollwakeup(pty, 0);
ptcpollwakeup(pty, FWRITE);
}
}
stop = (pty->pt_ttycommon.t_iflag & IXON) &&
pty->pt_ttycommon.t_stopc == CTRL('s') &&
pty->pt_ttycommon.t_startc == CTRL('q');
if (pty->pt_flags & PF_NOSTOP) {
if (stop) {
pty->pt_send &= ~TIOCPKT_NOSTOP;
pty->pt_send |= TIOCPKT_DOSTOP;
pty->pt_flags &= ~PF_NOSTOP;
ptcpollwakeup(pty, 0);
}
} else {
if (!stop) {
pty->pt_send &= ~TIOCPKT_DOSTOP;
pty->pt_send |= TIOCPKT_NOSTOP;
pty->pt_flags |= PF_NOSTOP;
ptcpollwakeup(pty, 0);
}
}
}
/*
* Wake up controller side. "flag" is 0 if a special packet or
* user control mode message has been queued up (this data is readable,
* so we also treat it as a regular data event; should we send SIGIO,
* though?), FREAD if regular data has been queued up, or FWRITE if
* the slave's read queue has drained sufficiently to allow writing.
*/
static void
ptcpollwakeup(struct pty *pty, int flag)
{
ASSERT(MUTEX_HELD(&pty->ptc_lock));
if (flag == 0) {
/*
* "Exceptional condition" occurred. This means that
* a "read" is now possible, so do a "read" wakeup.
*/
flag = FREAD;
pollwakeup(&ptcph, POLLIN | POLLRDBAND);
if (pty->pt_flags & PF_ASYNC)
gsignal(pty->pt_pgrp, SIGURG);
}
if (flag & FREAD) {
/*
* Wake up the parent process as there is regular
* data to read from slave's write queue
*/
pollwakeup(&ptcph, POLLIN | POLLRDNORM);
cv_broadcast(&pty->pt_cv_writeq);
if (pty->pt_flags & PF_ASYNC)
gsignal(pty->pt_pgrp, SIGIO);
}
if (flag & FWRITE) {
/*
* Wake up the parent process to write
* data into slave's read queue as the
* read queue has drained enough
*/
pollwakeup(&ptcph, POLLOUT | POLLWRNORM);
cv_broadcast(&pty->pt_cv_readq);
if (pty->pt_flags & PF_ASYNC)
gsignal(pty->pt_pgrp, SIGIO);
}
}