int
ptsread(dev_t dev, struct uio *uio, int flag)
{
struct proc *p = curproc;
struct process *pr = p->p_p;
struct pt_softc *pti = pt_softc[minor(dev)];
struct tty *tp = pti->pt_tty;
int error = 0;
again:
if (pti->pt_flags & PF_REMOTE) {
while (isbackground(pr, tp)) {
if ((p->p_sigacts->ps_sigignore & sigmask(SIGTTIN)) ||
(p->p_sigmask & sigmask(SIGTTIN)) ||
pr->ps_pgrp->pg_jobc == 0 ||
pr->ps_flags & PS_PPWAIT)
return (EIO);
pgsignal(pr->ps_pgrp, SIGTTIN, 1);
error = ttysleep(tp, &lbolt,
TTIPRI | PCATCH, ttybg, 0);
if (error)
return (error);
}
if (tp->t_canq.c_cc == 0) {
if (flag & IO_NDELAY)
return (EWOULDBLOCK);
error = ttysleep(tp, &tp->t_canq,
TTIPRI | PCATCH, ttyin, 0);
if (error)
return (error);
goto again;
}
while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0)
if (ureadc(getc(&tp->t_canq), uio) < 0) {
error = EFAULT;
break;
}
if (tp->t_canq.c_cc == 1)
(void) getc(&tp->t_canq);
if (tp->t_canq.c_cc)
return (error);
} else
if (tp->t_oproc)
error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
ptcwakeup(tp, FWRITE);
return (error);
}
static int
ptsdev_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
int flags, struct thread *td)
{
struct tty *tp = fp->f_data;
struct pts_softc *psc = tty_softc(tp);
int error = 0;
char pkt;
if (uio->uio_resid == 0)
return (0);
tty_lock(tp);
for (;;) {
/*
* Implement packet mode. When packet mode is turned on,
* the first byte contains a bitmask of events that
* occured (start, stop, flush, window size, etc).
*/
if (psc->pts_flags & PTS_PKT && psc->pts_pkt) {
pkt = psc->pts_pkt;
psc->pts_pkt = 0;
tty_unlock(tp);
error = ureadc(pkt, uio);
return (error);
}
/*
* Transmit regular data.
*
* XXX: We shouldn't use ttydisc_getc_poll()! Even
* though in this implementation, there is likely going
* to be data, we should just call ttydisc_getc_uio()
* and use its return value to sleep.
*/
if (ttydisc_getc_poll(tp)) {
if (psc->pts_flags & PTS_PKT) {
/*
* XXX: Small race. Fortunately PTY
* consumers aren't multithreaded.
*/
tty_unlock(tp);
error = ureadc(TIOCPKT_DATA, uio);
if (error)
return (error);
tty_lock(tp);
}
error = ttydisc_getc_uio(tp, uio);
break;
}
/* Maybe the device isn't used anyway. */
if (psc->pts_flags & PTS_FINISHED)
break;
/* Wait for more data. */
if (fp->f_flag & O_NONBLOCK) {
error = EWOULDBLOCK;
break;
}
error = cv_wait_sig(&psc->pts_outwait, tp->t_mtx);
if (error != 0)
break;
}
tty_unlock(tp);
return (error);
}
int
ptcread(dev_t dev, struct uio *uio, int flag)
{
struct pt_softc *pti = pt_softc[minor(dev)];
struct tty *tp = pti->pt_tty;
char buf[BUFSIZ];
int error = 0, cc, bufcc = 0;
/*
* 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.
*/
for (;;) {
if (tp->t_state&TS_ISOPEN) {
if (pti->pt_flags&PF_PKT && pti->pt_send) {
error = ureadc((int)pti->pt_send, uio);
if (error)
return (error);
if (pti->pt_send & TIOCPKT_IOCTL) {
cc = MIN(uio->uio_resid,
sizeof(tp->t_termios));
uiomove(&tp->t_termios, cc, uio);
}
pti->pt_send = 0;
return (0);
}
if (pti->pt_flags&PF_UCNTL && pti->pt_ucntl) {
error = ureadc((int)pti->pt_ucntl, uio);
if (error)
return (error);
pti->pt_ucntl = 0;
return (0);
}
if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
break;
}
if ((tp->t_state&TS_CARR_ON) == 0)
return (0); /* EOF */
if (flag & IO_NDELAY)
return (EWOULDBLOCK);
error = tsleep(&tp->t_outq.c_cf, TTIPRI | PCATCH,
ttyin, 0);
if (error)
return (error);
}
if (pti->pt_flags & (PF_PKT|PF_UCNTL))
error = ureadc(0, uio);
while (uio->uio_resid > 0 && error == 0) {
cc = MIN(uio->uio_resid, BUFSIZ);
cc = q_to_b(&tp->t_outq, buf, cc);
if (cc > bufcc)
bufcc = cc;
if (cc <= 0)
break;
error = uiomove(buf, cc, uio);
}
if (tp->t_outq.c_cc <= tp->t_lowat) {
if (tp->t_state&TS_ASLEEP) {
tp->t_state &= ~TS_ASLEEP;
wakeup(&tp->t_outq);
}
selwakeup(&tp->t_wsel);
}
if (bufcc)
bzero(buf, bufcc);
return (error);
}
static int
ptcread(struct dev_read_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
struct tty *tp = dev->si_tty;
struct pt_ioctl *pti = dev->si_drv1;
char buf[BUFSIZ];
int error = 0, cc;
lwkt_gettoken(&tty_token);
/*
* 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.
*/
for (;;) {
if (tp->t_state&TS_ISOPEN) {
if ((pti->pt_flags & PF_PKT) && pti->pt_send) {
error = ureadc((int)pti->pt_send, ap->a_uio);
if (error) {
lwkt_reltoken(&tty_token);
return (error);
}
if (pti->pt_send & TIOCPKT_IOCTL) {
cc = (int)szmin(ap->a_uio->uio_resid,
sizeof(tp->t_termios));
uiomove((caddr_t)&tp->t_termios, cc,
ap->a_uio);
}
pti->pt_send = 0;
lwkt_reltoken(&tty_token);
return (0);
}
if ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl) {
error = ureadc((int)pti->pt_ucntl, ap->a_uio);
if (error) {
lwkt_reltoken(&tty_token);
return (error);
}
pti->pt_ucntl = 0;
lwkt_reltoken(&tty_token);
return (0);
}
if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0)
break;
}
if ((tp->t_state & TS_CONNECTED) == 0) {
lwkt_reltoken(&tty_token);
return (0); /* EOF */
}
if (ap->a_ioflag & IO_NDELAY) {
lwkt_reltoken(&tty_token);
return (EWOULDBLOCK);
}
error = tsleep(TSA_PTC_READ(tp), PCATCH, "ptcin", 0);
if (error) {
lwkt_reltoken(&tty_token);
return (error);
}
}
if (pti->pt_flags & (PF_PKT|PF_UCNTL))
error = ureadc(0, ap->a_uio);
while (ap->a_uio->uio_resid > 0 && error == 0) {
cc = q_to_b(&tp->t_outq, buf,
(int)szmin(ap->a_uio->uio_resid, BUFSIZ));
if (cc <= 0)
break;
error = uiomove(buf, (size_t)cc, ap->a_uio);
}
ttwwakeup(tp);
lwkt_reltoken(&tty_token);
return (error);
}
static int
ptsread(struct dev_read_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
struct proc *p = curproc;
struct tty *tp = dev->si_tty;
struct pt_ioctl *pti = dev->si_drv1;
struct lwp *lp;
int error = 0;
lp = curthread->td_lwp;
lwkt_gettoken(&tty_token);
again:
if (pti->pt_flags & PF_REMOTE) {
while (isbackground(p, tp)) {
if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
p->p_pgrp->pg_jobc == 0 ||
(p->p_flags & P_PPWAIT)) {
lwkt_reltoken(&tty_token);
return (EIO);
}
pgsignal(p->p_pgrp, SIGTTIN, 1);
error = ttysleep(tp, &lbolt, PCATCH, "ptsbg", 0);
if (error) {
lwkt_reltoken(&tty_token);
return (error);
}
}
if (tp->t_canq.c_cc == 0) {
if (ap->a_ioflag & IO_NDELAY) {
lwkt_reltoken(&tty_token);
return (EWOULDBLOCK);
}
error = ttysleep(tp, TSA_PTS_READ(tp), PCATCH,
"ptsin", 0);
if (error) {
lwkt_reltoken(&tty_token);
return (error);
}
goto again;
}
while (tp->t_canq.c_cc > 1 && ap->a_uio->uio_resid > 0)
if (ureadc(clist_getc(&tp->t_canq), ap->a_uio) < 0) {
error = EFAULT;
break;
}
if (tp->t_canq.c_cc == 1)
clist_getc(&tp->t_canq);
if (tp->t_canq.c_cc) {
lwkt_reltoken(&tty_token);
return (error);
}
} else
if (tp->t_oproc)
error = (*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag);
ptcwakeup(tp, FWRITE);
lwkt_reltoken(&tty_token);
return (error);
}