Home | History | Annotate | Line # | Download | only in kern
tty_pty.c revision 1.108
      1  1.108     rmind /*	$NetBSD: tty_pty.c,v 1.108 2008/03/01 14:16:51 rmind Exp $	*/
      2   1.23       cgd 
      3    1.1       cgd /*
      4   1.22       cgd  * Copyright (c) 1982, 1986, 1989, 1993
      5   1.22       cgd  *	The Regents of the University of California.  All rights reserved.
      6    1.1       cgd  *
      7    1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8    1.1       cgd  * modification, are permitted provided that the following conditions
      9    1.1       cgd  * are met:
     10    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15   1.72       agc  * 3. Neither the name of the University nor the names of its contributors
     16    1.1       cgd  *    may be used to endorse or promote products derived from this software
     17    1.1       cgd  *    without specific prior written permission.
     18    1.1       cgd  *
     19    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29    1.1       cgd  * SUCH DAMAGE.
     30    1.1       cgd  *
     31   1.39      fvdl  *	@(#)tty_pty.c	8.4 (Berkeley) 2/20/95
     32    1.1       cgd  */
     33    1.1       cgd 
     34    1.1       cgd /*
     35    1.1       cgd  * Pseudo-teletype Driver
     36    1.1       cgd  * (Actually two drivers, requiring two entries in 'cdevsw')
     37    1.1       cgd  */
     38   1.57     lukem 
     39   1.57     lukem #include <sys/cdefs.h>
     40  1.108     rmind __KERNEL_RCSID(0, "$NetBSD: tty_pty.c,v 1.108 2008/03/01 14:16:51 rmind Exp $");
     41   1.41   thorpej 
     42   1.41   thorpej #include "opt_compat_sunos.h"
     43   1.80  christos #include "opt_ptm.h"
     44   1.41   thorpej 
     45   1.16   mycroft #include <sys/param.h>
     46   1.16   mycroft #include <sys/systm.h>
     47   1.16   mycroft #include <sys/ioctl.h>
     48   1.22       cgd #include <sys/proc.h>
     49   1.16   mycroft #include <sys/tty.h>
     50   1.77  christos #include <sys/stat.h>
     51   1.16   mycroft #include <sys/file.h>
     52   1.16   mycroft #include <sys/kernel.h>
     53   1.16   mycroft #include <sys/vnode.h>
     54   1.77  christos #include <sys/namei.h>
     55   1.31  christos #include <sys/signalvar.h>
     56   1.31  christos #include <sys/uio.h>
     57   1.77  christos #include <sys/filedesc.h>
     58   1.33  christos #include <sys/conf.h>
     59   1.38   mycroft #include <sys/poll.h>
     60   1.47  jdolecek #include <sys/malloc.h>
     61   1.81  christos #include <sys/pty.h>
     62   1.89      elad #include <sys/kauth.h>
     63   1.31  christos 
     64   1.47  jdolecek #define	DEFAULT_NPTYS		16	/* default number of initial ptys */
     65   1.58       tls #define DEFAULT_MAXPTYS		992	/* default maximum number of ptys */
     66    1.1       cgd 
     67    1.1       cgd #define BUFSIZ 100		/* Chunk size iomoved to/from user */
     68    1.1       cgd 
     69   1.27   mycroft struct	pt_softc {
     70   1.27   mycroft 	struct	tty *pt_tty;
     71    1.1       cgd 	int	pt_flags;
     72   1.22       cgd 	struct	selinfo pt_selr, pt_selw;
     73    1.1       cgd 	u_char	pt_send;
     74    1.1       cgd 	u_char	pt_ucntl;
     75   1.47  jdolecek };
     76   1.47  jdolecek 
     77   1.48  jdolecek static struct pt_softc **pt_softc = NULL;	/* pty array */
     78   1.48  jdolecek static int maxptys = DEFAULT_MAXPTYS;	/* maximum number of ptys (sysctable) */
     79  1.100        ad kmutex_t pt_softc_mutex;
     80   1.81  christos int npty = 0;			/* for pstat -t */
     81    1.1       cgd 
     82    1.1       cgd #define	PF_PKT		0x08		/* packet mode */
     83    1.1       cgd #define	PF_STOPPED	0x10		/* user told stopped */
     84    1.1       cgd #define	PF_REMOTE	0x20		/* remote and flow controlled input */
     85    1.1       cgd #define	PF_NOSTOP	0x40
     86    1.1       cgd #define PF_UCNTL	0x80		/* user control mode */
     87    1.1       cgd 
     88   1.76  junyoung void	ptyattach(int);
     89   1.76  junyoung void	ptcwakeup(struct tty *, int);
     90   1.76  junyoung void	ptsstart(struct tty *);
     91   1.76  junyoung int	pty_maxptys(int, int);
     92   1.15   deraadt 
     93   1.76  junyoung static struct pt_softc **ptyarralloc(int);
     94   1.77  christos 
     95   1.63   gehenna dev_type_open(ptcopen);
     96   1.63   gehenna dev_type_close(ptcclose);
     97   1.63   gehenna dev_type_read(ptcread);
     98   1.63   gehenna dev_type_write(ptcwrite);
     99   1.63   gehenna dev_type_poll(ptcpoll);
    100   1.65  jdolecek dev_type_kqfilter(ptckqfilter);
    101   1.63   gehenna 
    102   1.63   gehenna dev_type_open(ptsopen);
    103   1.63   gehenna dev_type_close(ptsclose);
    104   1.63   gehenna dev_type_read(ptsread);
    105   1.63   gehenna dev_type_write(ptswrite);
    106   1.63   gehenna dev_type_stop(ptsstop);
    107   1.63   gehenna dev_type_poll(ptspoll);
    108   1.63   gehenna 
    109   1.63   gehenna dev_type_ioctl(ptyioctl);
    110   1.63   gehenna dev_type_tty(ptytty);
    111   1.63   gehenna 
    112   1.63   gehenna const struct cdevsw ptc_cdevsw = {
    113   1.63   gehenna 	ptcopen, ptcclose, ptcread, ptcwrite, ptyioctl,
    114   1.65  jdolecek 	nullstop, ptytty, ptcpoll, nommap, ptckqfilter, D_TTY
    115   1.63   gehenna };
    116   1.63   gehenna 
    117   1.63   gehenna const struct cdevsw pts_cdevsw = {
    118   1.63   gehenna 	ptsopen, ptsclose, ptsread, ptswrite, ptyioctl,
    119   1.65  jdolecek 	ptsstop, ptytty, ptspoll, nommap, ttykqfilter, D_TTY
    120   1.63   gehenna };
    121   1.63   gehenna 
    122   1.63   gehenna #if defined(pmax)
    123   1.63   gehenna const struct cdevsw ptc_ultrix_cdevsw = {
    124   1.63   gehenna 	ptcopen, ptcclose, ptcread, ptcwrite, ptyioctl,
    125   1.65  jdolecek 	nullstop, ptytty, ptcpoll, nommap, ptckqfilter, D_TTY
    126   1.63   gehenna };
    127   1.63   gehenna 
    128   1.63   gehenna const struct cdevsw pts_ultrix_cdevsw = {
    129   1.63   gehenna 	ptsopen, ptsclose, ptsread, ptswrite, ptyioctl,
    130   1.65  jdolecek 	ptsstop, ptytty, ptspoll, nommap, ttykqfilter, D_TTY
    131   1.63   gehenna };
    132   1.63   gehenna #endif /* defined(pmax) */
    133   1.63   gehenna 
    134   1.47  jdolecek /*
    135   1.81  christos  * Check if a pty is free to use.
    136   1.81  christos  */
    137   1.81  christos int
    138   1.81  christos pty_isfree(int minor, int lock)
    139   1.81  christos {
    140   1.81  christos 	struct pt_softc *pt = pt_softc[minor];
    141   1.81  christos 	if (lock)
    142  1.100        ad 		mutex_enter(&pt_softc_mutex);
    143   1.81  christos 	minor = pt == NULL || pt->pt_tty == NULL ||
    144   1.81  christos 	    pt->pt_tty->t_oproc == NULL;
    145   1.81  christos 	if (lock)
    146  1.100        ad 		mutex_exit(&pt_softc_mutex);
    147   1.81  christos 	return minor;
    148   1.81  christos }
    149   1.81  christos 
    150   1.81  christos /*
    151   1.48  jdolecek  * Allocate and zero array of nelem elements.
    152   1.47  jdolecek  */
    153   1.47  jdolecek static struct pt_softc **
    154   1.47  jdolecek ptyarralloc(nelem)
    155   1.47  jdolecek 	int nelem;
    156   1.47  jdolecek {
    157   1.47  jdolecek 	struct pt_softc **pt;
    158   1.47  jdolecek 	nelem += 10;
    159   1.71       dsl 	pt = malloc(nelem * sizeof *pt, M_DEVBUF, M_WAITOK | M_ZERO);
    160   1.47  jdolecek 	return pt;
    161   1.47  jdolecek }
    162   1.47  jdolecek 
    163   1.47  jdolecek /*
    164   1.47  jdolecek  * Check if the minor is correct and ensure necessary structures
    165   1.47  jdolecek  * are properly allocated.
    166   1.47  jdolecek  */
    167   1.81  christos int
    168   1.81  christos pty_check(int ptn)
    169   1.47  jdolecek {
    170   1.47  jdolecek 	struct pt_softc *pti;
    171   1.47  jdolecek 
    172   1.71       dsl 	if (ptn >= npty) {
    173   1.71       dsl 		struct pt_softc **newpt, **oldpt;
    174   1.48  jdolecek 		int newnpty;
    175   1.47  jdolecek 
    176   1.48  jdolecek 		/* check if the requested pty can be granted */
    177   1.71       dsl 		if (ptn >= maxptys) {
    178   1.48  jdolecek 	    limit_reached:
    179   1.48  jdolecek 			tablefull("pty", "increase kern.maxptys");
    180   1.48  jdolecek 			return (ENXIO);
    181   1.48  jdolecek 		}
    182   1.47  jdolecek 
    183   1.71       dsl 		/* Allocate a larger pty array */
    184   1.71       dsl 		for (newnpty = npty; newnpty <= ptn;)
    185   1.71       dsl 			newnpty *= 2;
    186   1.71       dsl 		if (newnpty > maxptys)
    187   1.71       dsl 			newnpty = maxptys;
    188   1.71       dsl 		newpt = ptyarralloc(newnpty);
    189   1.71       dsl 
    190   1.47  jdolecek 		/*
    191   1.48  jdolecek 		 * Now grab the pty array mutex - we need to ensure
    192   1.47  jdolecek 		 * that the pty array is consistent while copying it's
    193   1.48  jdolecek 		 * content to newly allocated, larger space; we also
    194   1.48  jdolecek 		 * need to be safe against pty_maxptys().
    195   1.47  jdolecek 		 */
    196  1.100        ad 		mutex_enter(&pt_softc_mutex);
    197   1.48  jdolecek 
    198   1.71       dsl 		if (newnpty >= maxptys) {
    199   1.71       dsl 			/* limit cut away beneath us... */
    200   1.71       dsl 			newnpty = maxptys;
    201   1.71       dsl 			if (ptn >= newnpty) {
    202  1.100        ad 				mutex_exit(&pt_softc_mutex);
    203   1.71       dsl 				free(newpt, M_DEVBUF);
    204   1.48  jdolecek 				goto limit_reached;
    205   1.48  jdolecek 			}
    206   1.71       dsl 		}
    207   1.47  jdolecek 
    208   1.47  jdolecek 		/*
    209   1.48  jdolecek 		 * If the pty array was not enlarged while we were waiting
    210   1.48  jdolecek 		 * for mutex, copy current contents of pt_softc[] to newly
    211   1.48  jdolecek 		 * allocated array and start using the new bigger array.
    212   1.47  jdolecek 		 */
    213   1.71       dsl 		if (newnpty > npty) {
    214   1.47  jdolecek 			memcpy(newpt, pt_softc, npty*sizeof(struct pt_softc *));
    215   1.71       dsl 			oldpt = pt_softc;
    216   1.47  jdolecek 			pt_softc = newpt;
    217   1.47  jdolecek 			npty = newnpty;
    218   1.47  jdolecek 		} else {
    219   1.71       dsl 			/* was enlarged when waited for lock, free new space */
    220   1.71       dsl 			oldpt = newpt;
    221   1.47  jdolecek 		}
    222   1.48  jdolecek 
    223  1.100        ad 		mutex_exit(&pt_softc_mutex);
    224   1.71       dsl 		free(oldpt, M_DEVBUF);
    225   1.47  jdolecek 	}
    226   1.71       dsl 
    227   1.47  jdolecek 	/*
    228   1.48  jdolecek 	 * If the entry is not yet allocated, allocate one. The mutex is
    229   1.48  jdolecek 	 * needed so that the state of pt_softc[] array is consistant
    230   1.71       dsl 	 * in case it has been lengthened above.
    231   1.47  jdolecek 	 */
    232   1.71       dsl 	if (!pt_softc[ptn]) {
    233  1.108     rmind 		pti = malloc(sizeof(struct pt_softc),
    234  1.108     rmind 		    M_DEVBUF, M_WAITOK | M_ZERO);
    235   1.48  jdolecek 
    236  1.108     rmind 		selinit(&pti->pt_selr);
    237  1.108     rmind 		selinit(&pti->pt_selw);
    238  1.108     rmind 		pti->pt_tty = ttymalloc();
    239   1.48  jdolecek 
    240  1.100        ad 		mutex_enter(&pt_softc_mutex);
    241   1.47  jdolecek 
    242   1.47  jdolecek 		/*
    243   1.48  jdolecek 		 * Check the entry again - it might have been
    244   1.48  jdolecek 		 * added while we were waiting for mutex.
    245   1.47  jdolecek 		 */
    246  1.108     rmind 		if (pt_softc[ptn]) {
    247  1.108     rmind 			mutex_exit(&pt_softc_mutex);
    248   1.48  jdolecek 			ttyfree(pti->pt_tty);
    249  1.108     rmind 			seldestroy(&pti->pt_selr);
    250  1.108     rmind 			seldestroy(&pti->pt_selw);
    251   1.71       dsl 			free(pti, M_DEVBUF);
    252  1.108     rmind 			return (0);
    253   1.47  jdolecek 		}
    254  1.108     rmind 		tty_attach(pti->pt_tty);
    255  1.108     rmind 		pt_softc[ptn] = pti;
    256   1.48  jdolecek 
    257  1.100        ad 		mutex_exit(&pt_softc_mutex);
    258   1.48  jdolecek 	}
    259   1.48  jdolecek 
    260   1.48  jdolecek 	return (0);
    261   1.48  jdolecek }
    262   1.48  jdolecek 
    263   1.48  jdolecek /*
    264   1.48  jdolecek  * Set maxpty in thread-safe way. Returns 0 in case of error, otherwise
    265   1.48  jdolecek  * new value of maxptys.
    266   1.48  jdolecek  */
    267   1.48  jdolecek int
    268   1.48  jdolecek pty_maxptys(newmax, set)
    269   1.48  jdolecek 	int newmax, set;
    270   1.48  jdolecek {
    271   1.48  jdolecek 	if (!set)
    272   1.48  jdolecek 		return (maxptys);
    273   1.48  jdolecek 
    274   1.48  jdolecek 	/*
    275   1.48  jdolecek 	 * We have to grab the pt_softc lock, so that we would pick correct
    276   1.81  christos 	 * value of npty (might be modified in pty_check()).
    277   1.48  jdolecek 	 */
    278  1.100        ad 	mutex_enter(&pt_softc_mutex);
    279   1.48  jdolecek 
    280   1.71       dsl 	/*
    281   1.71       dsl 	 * The value cannot be set to value lower than the highest pty
    282   1.71       dsl 	 * number ever allocated.
    283   1.71       dsl 	 */
    284   1.71       dsl 	if (newmax >= npty)
    285   1.48  jdolecek 		maxptys = newmax;
    286   1.71       dsl 	else
    287   1.71       dsl 		newmax = 0;
    288   1.47  jdolecek 
    289  1.100        ad 	mutex_exit(&pt_softc_mutex);
    290   1.48  jdolecek 
    291   1.71       dsl 	return newmax;
    292   1.47  jdolecek }
    293   1.47  jdolecek 
    294   1.22       cgd /*
    295   1.22       cgd  * Establish n (or default if n is 1) ptys in the system.
    296   1.22       cgd  */
    297   1.15   deraadt void
    298   1.15   deraadt ptyattach(n)
    299   1.15   deraadt 	int n;
    300   1.15   deraadt {
    301  1.100        ad 
    302  1.100        ad 	mutex_init(&pt_softc_mutex, MUTEX_DEFAULT, IPL_NONE);
    303  1.100        ad 
    304   1.22       cgd 	/* maybe should allow 0 => none? */
    305   1.22       cgd 	if (n <= 1)
    306   1.47  jdolecek 		n = DEFAULT_NPTYS;
    307   1.47  jdolecek 	pt_softc = ptyarralloc(n);
    308   1.22       cgd 	npty = n;
    309   1.80  christos #ifndef NO_DEV_PTM
    310   1.80  christos 	ptmattach(1);
    311   1.80  christos #endif
    312   1.15   deraadt }
    313    1.7    andrew 
    314    1.1       cgd /*ARGSUSED*/
    315   1.31  christos int
    316   1.96      yamt ptsopen(dev_t dev, int flag, int devtype, struct lwp *l)
    317    1.1       cgd {
    318   1.27   mycroft 	struct pt_softc *pti;
    319   1.43  augustss 	struct tty *tp;
    320    1.1       cgd 	int error;
    321   1.71       dsl 	int ptn = minor(dev);
    322    1.1       cgd 
    323   1.81  christos 	if ((error = pty_check(ptn)) != 0)
    324   1.47  jdolecek 		return (error);
    325   1.47  jdolecek 
    326  1.104        ad 	mutex_spin_enter(&tty_lock);
    327   1.71       dsl 	pti = pt_softc[ptn];
    328   1.47  jdolecek 	tp = pti->pt_tty;
    329   1.37   mycroft 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    330    1.1       cgd 		ttychars(tp);		/* Set up default chars */
    331    1.1       cgd 		tp->t_iflag = TTYDEF_IFLAG;
    332    1.1       cgd 		tp->t_oflag = TTYDEF_OFLAG;
    333    1.1       cgd 		tp->t_lflag = TTYDEF_LFLAG;
    334    1.1       cgd 		tp->t_cflag = TTYDEF_CFLAG;
    335    1.1       cgd 		tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
    336    1.1       cgd 		ttsetwater(tp);		/* would be done in xxparam() */
    337   1.97      elad 	} else if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN,
    338  1.104        ad 	    tp) != 0) {
    339  1.104        ad 		mutex_spin_exit(&tty_lock);
    340    1.1       cgd 		return (EBUSY);
    341  1.104        ad 	}
    342    1.1       cgd 	if (tp->t_oproc)			/* Ctrlr still around. */
    343   1.37   mycroft 		SET(tp->t_state, TS_CARR_ON);
    344   1.68        pk 	if (!ISSET(flag, O_NONBLOCK)) {
    345   1.40   mycroft 		while (!ISSET(tp->t_state, TS_CARR_ON)) {
    346   1.40   mycroft 			tp->t_wopen++;
    347  1.102        ad 			error = ttysleep(tp, &tp->t_rawq.c_cv, true, 0);
    348   1.40   mycroft 			tp->t_wopen--;
    349   1.68        pk 			if (error) {
    350  1.102        ad 				mutex_spin_exit(&tty_lock);
    351   1.40   mycroft 				return (error);
    352   1.68        pk 			}
    353   1.40   mycroft 		}
    354   1.68        pk 	}
    355  1.104        ad 	mutex_spin_exit(&tty_lock);
    356   1.50       eeh 	error = (*tp->t_linesw->l_open)(dev, tp);
    357    1.1       cgd 	ptcwakeup(tp, FREAD|FWRITE);
    358   1.22       cgd 	return (error);
    359    1.1       cgd }
    360    1.1       cgd 
    361   1.31  christos int
    362   1.96      yamt ptsclose(dev_t dev, int flag, int mode, struct lwp *l)
    363    1.1       cgd {
    364   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    365   1.43  augustss 	struct tty *tp = pti->pt_tty;
    366   1.31  christos 	int error;
    367    1.1       cgd 
    368   1.50       eeh 	error = (*tp->t_linesw->l_close)(tp, flag);
    369   1.31  christos 	error |= ttyclose(tp);
    370    1.1       cgd 	ptcwakeup(tp, FREAD|FWRITE);
    371   1.31  christos 	return (error);
    372    1.1       cgd }
    373    1.1       cgd 
    374   1.31  christos int
    375    1.1       cgd ptsread(dev, uio, flag)
    376    1.1       cgd 	dev_t dev;
    377    1.1       cgd 	struct uio *uio;
    378    1.7    andrew 	int flag;
    379    1.1       cgd {
    380    1.1       cgd 	struct proc *p = curproc;
    381   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    382   1.43  augustss 	struct tty *tp = pti->pt_tty;
    383    1.1       cgd 	int error = 0;
    384  1.104        ad 	int cc, c;
    385    1.1       cgd 
    386    1.1       cgd again:
    387    1.1       cgd 	if (pti->pt_flags & PF_REMOTE) {
    388  1.104        ad 		mutex_spin_enter(&tty_lock);
    389   1.98        ad 		while (isbackground(p, tp)) {	/* XXXSMP */
    390   1.98        ad 			if (sigismasked(curlwp, SIGTTIN) ||
    391    1.1       cgd 			    p->p_pgrp->pg_jobc == 0 ||
    392  1.104        ad 			    p->p_flag & PS_PPWAIT) {
    393  1.104        ad 				mutex_spin_exit(&tty_lock);
    394    1.1       cgd 				return (EIO);
    395  1.104        ad 			}
    396  1.102        ad 			ttysig(tp, TTYSIG_PG1, SIGTTIN);
    397  1.102        ad 			error = ttysleep(tp, &lbolt, true, 0);
    398  1.104        ad 			if (error) {
    399  1.104        ad 				mutex_spin_exit(&tty_lock);
    400    1.1       cgd 				return (error);
    401  1.104        ad 			}
    402    1.1       cgd 		}
    403    1.8   mycroft 		if (tp->t_canq.c_cc == 0) {
    404   1.68        pk 			if (flag & IO_NDELAY) {
    405  1.102        ad 				mutex_spin_exit(&tty_lock);
    406    1.1       cgd 				return (EWOULDBLOCK);
    407   1.68        pk 			}
    408  1.102        ad 			error = ttysleep(tp, &tp->t_canq.c_cv, true, 0);
    409  1.102        ad 			mutex_spin_exit(&tty_lock);
    410   1.31  christos 			if (error)
    411    1.1       cgd 				return (error);
    412    1.1       cgd 			goto again;
    413    1.1       cgd 		}
    414   1.68        pk 		while(error == 0 && tp->t_canq.c_cc > 1 && uio->uio_resid > 0) {
    415  1.104        ad 			c = getc(&tp->t_canq);
    416  1.102        ad 			mutex_spin_exit(&tty_lock);
    417  1.104        ad 			error = ureadc(c, uio);
    418  1.102        ad 			mutex_spin_enter(&tty_lock);
    419   1.68        pk 			/* Re-check terminal state here? */
    420   1.68        pk 		}
    421    1.8   mycroft 		if (tp->t_canq.c_cc == 1)
    422    1.8   mycroft 			(void) getc(&tp->t_canq);
    423   1.68        pk 		cc = tp->t_canq.c_cc;
    424  1.102        ad 		mutex_spin_exit(&tty_lock);
    425   1.68        pk 		if (cc)
    426    1.1       cgd 			return (error);
    427  1.104        ad 	} else if (tp->t_oproc)
    428  1.104        ad 		error = (*tp->t_linesw->l_read)(tp, uio, flag);
    429    1.1       cgd 	ptcwakeup(tp, FWRITE);
    430    1.1       cgd 	return (error);
    431    1.1       cgd }
    432    1.1       cgd 
    433    1.1       cgd /*
    434    1.1       cgd  * Write to pseudo-tty.
    435    1.1       cgd  * Wakeups of controlling tty will happen
    436    1.1       cgd  * indirectly, when tty driver calls ptsstart.
    437    1.1       cgd  */
    438   1.31  christos int
    439    1.1       cgd ptswrite(dev, uio, flag)
    440    1.1       cgd 	dev_t dev;
    441    1.1       cgd 	struct uio *uio;
    442    1.7    andrew 	int flag;
    443    1.1       cgd {
    444   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    445   1.43  augustss 	struct tty *tp = pti->pt_tty;
    446    1.1       cgd 
    447    1.1       cgd 	if (tp->t_oproc == 0)
    448    1.1       cgd 		return (EIO);
    449   1.50       eeh 	return ((*tp->t_linesw->l_write)(tp, uio, flag));
    450   1.56       scw }
    451   1.56       scw 
    452   1.56       scw /*
    453   1.56       scw  * Poll pseudo-tty.
    454   1.56       scw  */
    455   1.56       scw int
    456   1.86  christos ptspoll(dev, events, l)
    457   1.56       scw 	dev_t dev;
    458   1.56       scw 	int events;
    459   1.86  christos 	struct lwp *l;
    460   1.56       scw {
    461   1.56       scw 	struct pt_softc *pti = pt_softc[minor(dev)];
    462   1.56       scw 	struct tty *tp = pti->pt_tty;
    463   1.56       scw 
    464   1.56       scw 	if (tp->t_oproc == 0)
    465   1.85        ws 		return (POLLHUP);
    466   1.83     perry 
    467   1.86  christos 	return ((*tp->t_linesw->l_poll)(tp, events, l));
    468    1.1       cgd }
    469    1.1       cgd 
    470    1.1       cgd /*
    471    1.1       cgd  * Start output on pseudo-tty.
    472   1.38   mycroft  * Wake up process polling or sleeping for input from controlling tty.
    473    1.1       cgd  */
    474   1.12   deraadt void
    475    1.1       cgd ptsstart(tp)
    476    1.1       cgd 	struct tty *tp;
    477    1.1       cgd {
    478   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
    479    1.1       cgd 
    480  1.104        ad 	KASSERT(mutex_owned(&tty_lock));
    481  1.104        ad 
    482   1.37   mycroft 	if (ISSET(tp->t_state, TS_TTSTOP))
    483   1.12   deraadt 		return;
    484    1.1       cgd 	if (pti->pt_flags & PF_STOPPED) {
    485    1.1       cgd 		pti->pt_flags &= ~PF_STOPPED;
    486    1.1       cgd 		pti->pt_send = TIOCPKT_START;
    487    1.1       cgd 	}
    488   1.68        pk 
    489  1.108     rmind 	selnotify(&pti->pt_selr, 0, NOTE_SUBMIT);
    490  1.106        ad 	cv_broadcast(&tp->t_outq.c_cvf);
    491    1.1       cgd }
    492    1.1       cgd 
    493   1.68        pk /*
    494   1.68        pk  * Stop output.
    495   1.68        pk  */
    496   1.36   mycroft void
    497   1.31  christos ptsstop(tp, flush)
    498   1.43  augustss 	struct tty *tp;
    499   1.31  christos 	int flush;
    500   1.31  christos {
    501   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
    502   1.31  christos 
    503  1.104        ad 	KASSERT(mutex_owned(&tty_lock));
    504  1.104        ad 
    505   1.31  christos 	/* note: FLUSHREAD and FLUSHWRITE already ok */
    506   1.31  christos 	if (flush == 0) {
    507   1.31  christos 		flush = TIOCPKT_STOP;
    508   1.31  christos 		pti->pt_flags |= PF_STOPPED;
    509   1.31  christos 	} else
    510   1.31  christos 		pti->pt_flags &= ~PF_STOPPED;
    511   1.31  christos 	pti->pt_send |= flush;
    512   1.68        pk 
    513   1.31  christos 	/* change of perspective */
    514   1.68        pk 	if (flush & FREAD) {
    515  1.108     rmind 		selnotify(&pti->pt_selw, 0, NOTE_SUBMIT);
    516  1.106        ad 		cv_broadcast(&tp->t_rawq.c_cvf);
    517   1.68        pk 	}
    518   1.68        pk 	if (flush & FWRITE) {
    519  1.108     rmind 		selnotify(&pti->pt_selr, 0, NOTE_SUBMIT);
    520  1.106        ad 		cv_broadcast(&tp->t_outq.c_cvf);
    521   1.68        pk 	}
    522   1.31  christos }
    523   1.31  christos 
    524   1.31  christos void
    525    1.1       cgd ptcwakeup(tp, flag)
    526    1.1       cgd 	struct tty *tp;
    527    1.7    andrew 	int flag;
    528    1.1       cgd {
    529   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
    530    1.1       cgd 
    531  1.102        ad 	mutex_spin_enter(&tty_lock);
    532    1.1       cgd 	if (flag & FREAD) {
    533  1.108     rmind 		selnotify(&pti->pt_selr, 0, NOTE_SUBMIT);
    534  1.106        ad 		cv_broadcast(&tp->t_outq.c_cvf);
    535    1.1       cgd 	}
    536    1.1       cgd 	if (flag & FWRITE) {
    537  1.108     rmind 		selnotify(&pti->pt_selw, 0, NOTE_SUBMIT);
    538  1.106        ad 		cv_broadcast(&tp->t_rawq.c_cvf);
    539    1.1       cgd 	}
    540  1.102        ad 	mutex_spin_exit(&tty_lock);
    541    1.1       cgd }
    542    1.1       cgd 
    543    1.1       cgd /*ARGSUSED*/
    544   1.25   mycroft int
    545   1.96      yamt ptcopen(dev_t dev, int flag, int devtype, struct lwp *l)
    546    1.1       cgd {
    547   1.27   mycroft 	struct pt_softc *pti;
    548   1.43  augustss 	struct tty *tp;
    549   1.47  jdolecek 	int error;
    550   1.71       dsl 	int ptn = minor(dev);
    551   1.47  jdolecek 
    552   1.81  christos 	if ((error = pty_check(ptn)) != 0)
    553   1.47  jdolecek 		return (error);
    554   1.47  jdolecek 
    555   1.71       dsl 	pti = pt_softc[ptn];
    556   1.47  jdolecek 	tp = pti->pt_tty;
    557    1.1       cgd 
    558  1.102        ad 	mutex_spin_enter(&tty_lock);
    559   1.71       dsl 	if (tp->t_oproc) {
    560  1.102        ad 		mutex_spin_exit(&tty_lock);
    561    1.1       cgd 		return (EIO);
    562   1.71       dsl 	}
    563    1.1       cgd 	tp->t_oproc = ptsstart;
    564  1.102        ad 	mutex_spin_exit(&tty_lock);
    565   1.50       eeh 	(void)(*tp->t_linesw->l_modem)(tp, 1);
    566   1.37   mycroft 	CLR(tp->t_lflag, EXTPROC);
    567   1.22       cgd 	pti->pt_flags = 0;
    568    1.1       cgd 	pti->pt_send = 0;
    569    1.1       cgd 	pti->pt_ucntl = 0;
    570    1.1       cgd 	return (0);
    571    1.1       cgd }
    572    1.1       cgd 
    573   1.31  christos /*ARGSUSED*/
    574   1.25   mycroft int
    575   1.96      yamt ptcclose(dev_t dev, int flag, int devtype, struct lwp *l)
    576    1.1       cgd {
    577   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    578   1.43  augustss 	struct tty *tp = pti->pt_tty;
    579    1.1       cgd 
    580   1.50       eeh 	(void)(*tp->t_linesw->l_modem)(tp, 0);
    581  1.104        ad 	mutex_spin_enter(&tty_lock);
    582   1.37   mycroft 	CLR(tp->t_state, TS_CARR_ON);
    583    1.1       cgd 	tp->t_oproc = 0;		/* mark closed */
    584  1.102        ad 	mutex_spin_exit(&tty_lock);
    585    1.2       cgd 	return (0);
    586    1.1       cgd }
    587    1.1       cgd 
    588   1.31  christos int
    589    1.1       cgd ptcread(dev, uio, flag)
    590    1.1       cgd 	dev_t dev;
    591    1.1       cgd 	struct uio *uio;
    592    1.7    andrew 	int flag;
    593    1.1       cgd {
    594   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    595   1.43  augustss 	struct tty *tp = pti->pt_tty;
    596   1.84  christos 	u_char bf[BUFSIZ];
    597    1.1       cgd 	int error = 0, cc;
    598    1.1       cgd 
    599    1.1       cgd 	/*
    600    1.1       cgd 	 * We want to block until the slave
    601    1.1       cgd 	 * is open, and there's something to read;
    602    1.1       cgd 	 * but if we lost the slave or we're NBIO,
    603    1.1       cgd 	 * then return the appropriate error instead.
    604    1.1       cgd 	 */
    605  1.102        ad 	mutex_spin_enter(&tty_lock);
    606    1.1       cgd 	for (;;) {
    607   1.37   mycroft 		if (ISSET(tp->t_state, TS_ISOPEN)) {
    608   1.71       dsl 			if (pti->pt_flags & PF_PKT && pti->pt_send) {
    609  1.102        ad 				mutex_spin_exit(&tty_lock);
    610    1.1       cgd 				error = ureadc((int)pti->pt_send, uio);
    611    1.1       cgd 				if (error)
    612    1.1       cgd 					return (error);
    613   1.68        pk 				/*
    614   1.68        pk 				 * Since we don't have the tty locked, there's
    615   1.68        pk 				 * a risk of messing up `t_termios'. This is
    616   1.68        pk 				 * relevant only if the tty got closed and then
    617   1.68        pk 				 * opened again while we were out uiomoving.
    618   1.68        pk 				 */
    619    1.1       cgd 				if (pti->pt_send & TIOCPKT_IOCTL) {
    620   1.22       cgd 					cc = min(uio->uio_resid,
    621    1.1       cgd 						sizeof(tp->t_termios));
    622   1.99  christos 					uiomove((void *) &tp->t_termios,
    623   1.31  christos 						cc, uio);
    624    1.1       cgd 				}
    625    1.1       cgd 				pti->pt_send = 0;
    626    1.1       cgd 				return (0);
    627    1.1       cgd 			}
    628   1.71       dsl 			if (pti->pt_flags & PF_UCNTL && pti->pt_ucntl) {
    629  1.102        ad 				mutex_spin_exit(&tty_lock);
    630    1.1       cgd 				error = ureadc((int)pti->pt_ucntl, uio);
    631    1.1       cgd 				if (error)
    632    1.1       cgd 					return (error);
    633    1.1       cgd 				pti->pt_ucntl = 0;
    634    1.1       cgd 				return (0);
    635    1.1       cgd 			}
    636   1.37   mycroft 			if (tp->t_outq.c_cc && !ISSET(tp->t_state, TS_TTSTOP))
    637    1.1       cgd 				break;
    638    1.1       cgd 		}
    639   1.68        pk 		if (!ISSET(tp->t_state, TS_CARR_ON)) {
    640   1.68        pk 			error = 0;	/* EOF */
    641   1.68        pk 			goto out;
    642   1.68        pk 		}
    643   1.68        pk 		if (flag & IO_NDELAY) {
    644   1.68        pk 			error = EWOULDBLOCK;
    645   1.68        pk 			goto out;
    646   1.68        pk 		}
    647  1.106        ad 		error = cv_wait_sig(&tp->t_outq.c_cvf, &tty_lock);
    648   1.31  christos 		if (error)
    649   1.68        pk 			goto out;
    650    1.1       cgd 	}
    651   1.68        pk 
    652   1.68        pk 	if (pti->pt_flags & (PF_PKT|PF_UCNTL)) {
    653  1.102        ad 		mutex_spin_exit(&tty_lock);
    654    1.1       cgd 		error = ureadc(0, uio);
    655  1.102        ad 		mutex_spin_enter(&tty_lock);
    656   1.68        pk 		if (error == 0 && !ISSET(tp->t_state, TS_ISOPEN))
    657   1.68        pk 			error = EIO;
    658   1.68        pk 	}
    659    1.1       cgd 	while (uio->uio_resid > 0 && error == 0) {
    660   1.84  christos 		cc = q_to_b(&tp->t_outq, bf, min(uio->uio_resid, BUFSIZ));
    661    1.1       cgd 		if (cc <= 0)
    662    1.1       cgd 			break;
    663  1.102        ad 		mutex_spin_exit(&tty_lock);
    664   1.84  christos 		error = uiomove(bf, cc, uio);
    665  1.102        ad 		mutex_spin_enter(&tty_lock);
    666   1.68        pk 		if (error == 0 && !ISSET(tp->t_state, TS_ISOPEN))
    667   1.68        pk 			error = EIO;
    668    1.1       cgd 	}
    669  1.103        ad 	ttypull(tp);
    670   1.68        pk out:
    671  1.102        ad 	mutex_spin_exit(&tty_lock);
    672    1.1       cgd 	return (error);
    673    1.1       cgd }
    674    1.1       cgd 
    675    1.1       cgd 
    676   1.31  christos int
    677    1.1       cgd ptcwrite(dev, uio, flag)
    678    1.1       cgd 	dev_t dev;
    679   1.43  augustss 	struct uio *uio;
    680    1.7    andrew 	int flag;
    681    1.1       cgd {
    682   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    683   1.43  augustss 	struct tty *tp = pti->pt_tty;
    684   1.43  augustss 	u_char *cp = NULL;
    685   1.43  augustss 	int cc = 0;
    686    1.1       cgd 	u_char locbuf[BUFSIZ];
    687    1.1       cgd 	int cnt = 0;
    688    1.1       cgd 	int error = 0;
    689    1.1       cgd 
    690    1.1       cgd again:
    691  1.102        ad 	mutex_spin_enter(&tty_lock);
    692   1.37   mycroft 	if (!ISSET(tp->t_state, TS_ISOPEN))
    693    1.1       cgd 		goto block;
    694    1.1       cgd 	if (pti->pt_flags & PF_REMOTE) {
    695    1.8   mycroft 		if (tp->t_canq.c_cc)
    696    1.1       cgd 			goto block;
    697    1.8   mycroft 		while (uio->uio_resid > 0 && tp->t_canq.c_cc < TTYHOG - 1) {
    698    1.1       cgd 			if (cc == 0) {
    699    1.1       cgd 				cc = min(uio->uio_resid, BUFSIZ);
    700    1.8   mycroft 				cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc);
    701    1.1       cgd 				cp = locbuf;
    702  1.102        ad 				mutex_spin_exit(&tty_lock);
    703   1.99  christos 				error = uiomove((void *)cp, cc, uio);
    704    1.1       cgd 				if (error)
    705    1.1       cgd 					return (error);
    706  1.102        ad 				mutex_spin_enter(&tty_lock);
    707    1.1       cgd 				/* check again for safety */
    708   1.68        pk 				if (!ISSET(tp->t_state, TS_ISOPEN)) {
    709   1.93  christos 					/*
    710   1.93  christos 					 * adjust for data copied in but not
    711   1.93  christos 					 * written
    712   1.93  christos 					 */
    713   1.93  christos 					uio->uio_resid += cc;
    714   1.68        pk 					error = EIO;
    715   1.68        pk 					goto out;
    716   1.68        pk 				}
    717    1.1       cgd 			}
    718    1.1       cgd 			if (cc)
    719   1.67    simonb 				(void) b_to_q(cp, cc, &tp->t_canq);
    720    1.1       cgd 			cc = 0;
    721    1.1       cgd 		}
    722    1.8   mycroft 		(void) putc(0, &tp->t_canq);
    723    1.1       cgd 		ttwakeup(tp);
    724  1.103        ad 		clwakeup(&tp->t_canq);
    725   1.68        pk 		error = 0;
    726   1.68        pk 		goto out;
    727    1.1       cgd 	}
    728    1.1       cgd 	while (uio->uio_resid > 0) {
    729    1.1       cgd 		if (cc == 0) {
    730    1.1       cgd 			cc = min(uio->uio_resid, BUFSIZ);
    731    1.1       cgd 			cp = locbuf;
    732  1.102        ad 			mutex_spin_exit(&tty_lock);
    733   1.99  christos 			error = uiomove((void *)cp, cc, uio);
    734    1.1       cgd 			if (error)
    735    1.1       cgd 				return (error);
    736  1.102        ad 			mutex_spin_enter(&tty_lock);
    737    1.1       cgd 			/* check again for safety */
    738   1.68        pk 			if (!ISSET(tp->t_state, TS_ISOPEN)) {
    739   1.92  christos 				/* adjust for data copied in but not written */
    740   1.92  christos 				uio->uio_resid += cc;
    741   1.68        pk 				error = EIO;
    742   1.68        pk 				goto out;
    743   1.68        pk 			}
    744    1.1       cgd 		}
    745    1.1       cgd 		while (cc > 0) {
    746    1.8   mycroft 			if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 &&
    747   1.59  christos 			   (tp->t_canq.c_cc > 0 || !ISSET(tp->t_lflag, ICANON))) {
    748  1.103        ad 				clwakeup(&tp->t_rawq);
    749    1.1       cgd 				goto block;
    750    1.1       cgd 			}
    751   1.68        pk 			/* XXX - should change l_rint to be called with lock
    752   1.68        pk 			 *	 see also tty.c:ttyinput_wlock()
    753   1.68        pk 			 */
    754  1.102        ad 			mutex_spin_exit(&tty_lock);
    755   1.50       eeh 			(*tp->t_linesw->l_rint)(*cp++, tp);
    756  1.102        ad 			mutex_spin_enter(&tty_lock);
    757    1.1       cgd 			cnt++;
    758    1.1       cgd 			cc--;
    759    1.1       cgd 		}
    760    1.1       cgd 		cc = 0;
    761    1.1       cgd 	}
    762   1.68        pk 	error = 0;
    763   1.68        pk 	goto out;
    764   1.68        pk 
    765    1.1       cgd block:
    766    1.1       cgd 	/*
    767    1.1       cgd 	 * Come here to wait for slave to open, for space
    768    1.1       cgd 	 * in outq, or space in rawq.
    769    1.1       cgd 	 */
    770   1.68        pk 	if (!ISSET(tp->t_state, TS_CARR_ON)) {
    771   1.92  christos 		/* adjust for data copied in but not written */
    772   1.92  christos 		uio->uio_resid += cc;
    773   1.68        pk 		error = EIO;
    774   1.68        pk 		goto out;
    775   1.68        pk 	}
    776    1.1       cgd 	if (flag & IO_NDELAY) {
    777    1.1       cgd 		/* adjust for data copied in but not written */
    778    1.1       cgd 		uio->uio_resid += cc;
    779   1.68        pk 		error = cnt == 0 ? EWOULDBLOCK : 0;
    780   1.68        pk 		goto out;
    781    1.1       cgd 	}
    782  1.102        ad 	error = cv_wait_sig(&tp->t_rawq.c_cv, &tty_lock);
    783  1.102        ad 	mutex_spin_exit(&tty_lock);
    784   1.31  christos 	if (error) {
    785    1.1       cgd 		/* adjust for data copied in but not written */
    786    1.1       cgd 		uio->uio_resid += cc;
    787    1.1       cgd 		return (error);
    788    1.1       cgd 	}
    789    1.1       cgd 	goto again;
    790   1.68        pk 
    791   1.68        pk out:
    792  1.102        ad 	mutex_spin_exit(&tty_lock);
    793   1.68        pk 	return (error);
    794   1.29   mycroft }
    795   1.29   mycroft 
    796   1.31  christos int
    797   1.86  christos ptcpoll(dev, events, l)
    798   1.31  christos 	dev_t dev;
    799   1.38   mycroft 	int events;
    800   1.86  christos 	struct lwp *l;
    801   1.31  christos {
    802   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    803   1.43  augustss 	struct tty *tp = pti->pt_tty;
    804   1.38   mycroft 	int revents = 0;
    805  1.102        ad 
    806  1.102        ad 	mutex_spin_enter(&tty_lock);
    807   1.31  christos 
    808   1.38   mycroft 	if (events & (POLLIN | POLLRDNORM))
    809   1.37   mycroft 		if (ISSET(tp->t_state, TS_ISOPEN) &&
    810   1.38   mycroft 		    ((tp->t_outq.c_cc > 0 && !ISSET(tp->t_state, TS_TTSTOP)) ||
    811   1.38   mycroft 		     ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
    812   1.38   mycroft 		     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)))
    813   1.38   mycroft 			revents |= events & (POLLIN | POLLRDNORM);
    814   1.31  christos 
    815   1.38   mycroft 	if (events & (POLLOUT | POLLWRNORM))
    816   1.37   mycroft 		if (ISSET(tp->t_state, TS_ISOPEN) &&
    817   1.38   mycroft 		    ((pti->pt_flags & PF_REMOTE) ?
    818   1.38   mycroft 		     (tp->t_canq.c_cc == 0) :
    819   1.38   mycroft 		     ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2) ||
    820   1.59  christos 		      (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON)))))
    821   1.38   mycroft 			revents |= events & (POLLOUT | POLLWRNORM);
    822   1.31  christos 
    823   1.38   mycroft 	if (events & POLLHUP)
    824   1.38   mycroft 		if (!ISSET(tp->t_state, TS_CARR_ON))
    825   1.38   mycroft 			revents |= POLLHUP;
    826   1.31  christos 
    827   1.38   mycroft 	if (revents == 0) {
    828   1.38   mycroft 		if (events & (POLLIN | POLLHUP | POLLRDNORM))
    829   1.86  christos 			selrecord(l, &pti->pt_selr);
    830   1.31  christos 
    831   1.38   mycroft 		if (events & (POLLOUT | POLLWRNORM))
    832   1.86  christos 			selrecord(l, &pti->pt_selw);
    833   1.31  christos 	}
    834   1.38   mycroft 
    835  1.102        ad 	mutex_spin_exit(&tty_lock);
    836  1.102        ad 
    837   1.38   mycroft 	return (revents);
    838   1.31  christos }
    839   1.31  christos 
    840   1.65  jdolecek static void
    841   1.65  jdolecek filt_ptcrdetach(struct knote *kn)
    842   1.65  jdolecek {
    843   1.65  jdolecek 	struct pt_softc *pti;
    844  1.102        ad 	struct tty	*tp;
    845   1.65  jdolecek 
    846   1.65  jdolecek 	pti = kn->kn_hook;
    847  1.102        ad 	tp = pti->pt_tty;
    848  1.102        ad 
    849  1.102        ad 	mutex_spin_enter(&tty_lock);
    850   1.66  christos 	SLIST_REMOVE(&pti->pt_selr.sel_klist, kn, knote, kn_selnext);
    851  1.102        ad 	mutex_spin_exit(&tty_lock);
    852   1.65  jdolecek }
    853   1.65  jdolecek 
    854   1.65  jdolecek static int
    855   1.96      yamt filt_ptcread(struct knote *kn, long hint)
    856   1.65  jdolecek {
    857   1.65  jdolecek 	struct pt_softc *pti;
    858   1.65  jdolecek 	struct tty	*tp;
    859   1.65  jdolecek 	int canread;
    860   1.65  jdolecek 
    861   1.65  jdolecek 	pti = kn->kn_hook;
    862   1.65  jdolecek 	tp = pti->pt_tty;
    863   1.65  jdolecek 
    864  1.107        ad 	if ((hint & NOTE_SUBMIT) == 0) {
    865  1.107        ad 		mutex_spin_enter(&tty_lock);
    866  1.107        ad 	}
    867  1.102        ad 
    868   1.65  jdolecek 	canread = (ISSET(tp->t_state, TS_ISOPEN) &&
    869   1.65  jdolecek 		    ((tp->t_outq.c_cc > 0 && !ISSET(tp->t_state, TS_TTSTOP)) ||
    870   1.65  jdolecek 		     ((pti->pt_flags & PF_PKT) && pti->pt_send) ||
    871   1.65  jdolecek 		     ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)));
    872   1.65  jdolecek 
    873   1.65  jdolecek 	if (canread) {
    874   1.65  jdolecek 		/*
    875   1.65  jdolecek 		 * c_cc is number of characters after output post-processing;
    876   1.83     perry 		 * the amount of data actually read(2) depends on
    877   1.65  jdolecek 		 * setting of input flags for the terminal.
    878   1.65  jdolecek 		 */
    879   1.65  jdolecek 		kn->kn_data = tp->t_outq.c_cc;
    880   1.65  jdolecek 		if (((pti->pt_flags & PF_PKT) && pti->pt_send) ||
    881   1.65  jdolecek 		    ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl))
    882   1.65  jdolecek 			kn->kn_data++;
    883   1.65  jdolecek 	}
    884   1.65  jdolecek 
    885  1.107        ad 	if ((hint & NOTE_SUBMIT) == 0) {
    886  1.107        ad 		mutex_spin_exit(&tty_lock);
    887  1.107        ad 	}
    888  1.102        ad 
    889   1.65  jdolecek 	return (canread);
    890   1.65  jdolecek }
    891   1.65  jdolecek 
    892   1.65  jdolecek static void
    893   1.65  jdolecek filt_ptcwdetach(struct knote *kn)
    894   1.65  jdolecek {
    895   1.65  jdolecek 	struct pt_softc *pti;
    896  1.102        ad 	struct tty	*tp;
    897   1.65  jdolecek 
    898   1.65  jdolecek 	pti = kn->kn_hook;
    899  1.102        ad 	tp = pti->pt_tty;
    900  1.102        ad 
    901  1.102        ad 	mutex_spin_enter(&tty_lock);
    902   1.66  christos 	SLIST_REMOVE(&pti->pt_selw.sel_klist, kn, knote, kn_selnext);
    903  1.102        ad 	mutex_spin_exit(&tty_lock);
    904   1.65  jdolecek }
    905   1.65  jdolecek 
    906   1.65  jdolecek static int
    907   1.96      yamt filt_ptcwrite(struct knote *kn, long hint)
    908   1.65  jdolecek {
    909   1.65  jdolecek 	struct pt_softc *pti;
    910   1.65  jdolecek 	struct tty	*tp;
    911   1.65  jdolecek 	int canwrite;
    912   1.65  jdolecek 	int nwrite;
    913   1.65  jdolecek 
    914   1.65  jdolecek 	pti = kn->kn_hook;
    915   1.65  jdolecek 	tp = pti->pt_tty;
    916   1.65  jdolecek 
    917  1.107        ad 	if ((hint & NOTE_SUBMIT) == 0) {
    918  1.107        ad 		mutex_spin_enter(&tty_lock);
    919  1.107        ad 	}
    920  1.102        ad 
    921   1.65  jdolecek 	canwrite = (ISSET(tp->t_state, TS_ISOPEN) &&
    922   1.65  jdolecek 		    ((pti->pt_flags & PF_REMOTE) ?
    923   1.65  jdolecek 		     (tp->t_canq.c_cc == 0) :
    924   1.65  jdolecek 		     ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG-2) ||
    925   1.65  jdolecek 		      (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON)))));
    926   1.65  jdolecek 
    927   1.65  jdolecek 	if (canwrite) {
    928   1.65  jdolecek 		if (pti->pt_flags & PF_REMOTE)
    929   1.65  jdolecek 			nwrite = tp->t_canq.c_cn;
    930   1.65  jdolecek 		else {
    931   1.65  jdolecek 			/* this is guaranteed to be > 0 due to above check */
    932   1.65  jdolecek 			nwrite = tp->t_canq.c_cn
    933   1.65  jdolecek 				- (tp->t_rawq.c_cc + tp->t_canq.c_cc);
    934   1.65  jdolecek 		}
    935   1.65  jdolecek 		kn->kn_data = nwrite;
    936   1.65  jdolecek 	}
    937   1.65  jdolecek 
    938  1.107        ad 	if ((hint & NOTE_SUBMIT) == 0) {
    939  1.107        ad 		mutex_spin_exit(&tty_lock);
    940  1.107        ad 	}
    941  1.102        ad 
    942   1.65  jdolecek 	return (canwrite);
    943   1.65  jdolecek }
    944   1.65  jdolecek 
    945   1.65  jdolecek static const struct filterops ptcread_filtops =
    946   1.65  jdolecek 	{ 1, NULL, filt_ptcrdetach, filt_ptcread };
    947   1.65  jdolecek static const struct filterops ptcwrite_filtops =
    948   1.65  jdolecek 	{ 1, NULL, filt_ptcwdetach, filt_ptcwrite };
    949   1.65  jdolecek 
    950   1.65  jdolecek int
    951   1.65  jdolecek ptckqfilter(dev_t dev, struct knote *kn)
    952   1.65  jdolecek {
    953   1.65  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    954   1.65  jdolecek 	struct klist	*klist;
    955   1.65  jdolecek 
    956   1.65  jdolecek 	switch (kn->kn_filter) {
    957   1.65  jdolecek 	case EVFILT_READ:
    958   1.66  christos 		klist = &pti->pt_selr.sel_klist;
    959   1.65  jdolecek 		kn->kn_fop = &ptcread_filtops;
    960   1.65  jdolecek 		break;
    961   1.65  jdolecek 	case EVFILT_WRITE:
    962   1.66  christos 		klist = &pti->pt_selw.sel_klist;
    963   1.65  jdolecek 		kn->kn_fop = &ptcwrite_filtops;
    964   1.65  jdolecek 		break;
    965   1.65  jdolecek 	default:
    966  1.105     pooka 		return (EINVAL);
    967   1.65  jdolecek 	}
    968   1.65  jdolecek 
    969   1.65  jdolecek 	kn->kn_hook = pti;
    970   1.65  jdolecek 
    971  1.102        ad 	mutex_spin_enter(&tty_lock);
    972   1.65  jdolecek 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
    973  1.102        ad 	mutex_spin_exit(&tty_lock);
    974   1.65  jdolecek 
    975   1.65  jdolecek 	return (0);
    976   1.65  jdolecek }
    977   1.31  christos 
    978   1.29   mycroft struct tty *
    979   1.29   mycroft ptytty(dev)
    980   1.29   mycroft 	dev_t dev;
    981   1.29   mycroft {
    982   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    983   1.43  augustss 	struct tty *tp = pti->pt_tty;
    984   1.29   mycroft 
    985   1.29   mycroft 	return (tp);
    986    1.1       cgd }
    987    1.1       cgd 
    988    1.1       cgd /*ARGSUSED*/
    989   1.31  christos int
    990   1.86  christos ptyioctl(dev, cmd, data, flag, l)
    991   1.18   mycroft 	dev_t dev;
    992   1.24       cgd 	u_long cmd;
    993   1.99  christos 	void *data;
    994   1.18   mycroft 	int flag;
    995   1.86  christos 	struct lwp *l;
    996    1.1       cgd {
    997   1.47  jdolecek 	struct pt_softc *pti = pt_softc[minor(dev)];
    998   1.43  augustss 	struct tty *tp = pti->pt_tty;
    999   1.63   gehenna 	const struct cdevsw *cdev;
   1000   1.43  augustss 	u_char *cc = tp->t_cc;
   1001   1.44      fvdl 	int stop, error, sig;
   1002    1.1       cgd 
   1003    1.1       cgd 	/*
   1004    1.1       cgd 	 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG.
   1005    1.1       cgd 	 * ttywflush(tp) will hang if there are characters in the outq.
   1006    1.1       cgd 	 */
   1007    1.1       cgd 	if (cmd == TIOCEXT) {
   1008    1.1       cgd 		/*
   1009    1.1       cgd 		 * When the EXTPROC bit is being toggled, we need
   1010    1.1       cgd 		 * to send an TIOCPKT_IOCTL if the packet driver
   1011    1.1       cgd 		 * is turned on.
   1012    1.1       cgd 		 */
   1013    1.1       cgd 		if (*(int *)data) {
   1014    1.1       cgd 			if (pti->pt_flags & PF_PKT) {
   1015    1.1       cgd 				pti->pt_send |= TIOCPKT_IOCTL;
   1016    1.1       cgd 				ptcwakeup(tp, FREAD);
   1017    1.1       cgd 			}
   1018   1.37   mycroft 			SET(tp->t_lflag, EXTPROC);
   1019    1.1       cgd 		} else {
   1020   1.39      fvdl 			if (ISSET(tp->t_lflag, EXTPROC) &&
   1021    1.1       cgd 			    (pti->pt_flags & PF_PKT)) {
   1022    1.1       cgd 				pti->pt_send |= TIOCPKT_IOCTL;
   1023    1.1       cgd 				ptcwakeup(tp, FREAD);
   1024    1.1       cgd 			}
   1025   1.37   mycroft 			CLR(tp->t_lflag, EXTPROC);
   1026    1.1       cgd 		}
   1027    1.1       cgd 		return(0);
   1028   1.71       dsl 	}
   1029   1.71       dsl 
   1030   1.81  christos #ifndef NO_DEV_PTM
   1031   1.81  christos 	/* Allow getting the name from either the master or the slave */
   1032   1.81  christos 	if (cmd == TIOCPTSNAME)
   1033   1.88  christos 		return pty_fill_ptmget(l, dev, -1, -1, data);
   1034   1.81  christos #endif
   1035   1.81  christos 
   1036   1.81  christos 	cdev = cdevsw_lookup(dev);
   1037   1.63   gehenna 	if (cdev != NULL && cdev->d_open == ptcopen)
   1038    1.1       cgd 		switch (cmd) {
   1039   1.80  christos #ifndef NO_DEV_PTM
   1040   1.77  christos 		case TIOCGRANTPT:
   1041   1.86  christos 			return pty_grant_slave(l, dev);
   1042   1.77  christos #endif
   1043    1.1       cgd 
   1044    1.1       cgd 		case TIOCGPGRP:
   1045   1.35        pk 			/*
   1046   1.35        pk 			 * We avoid calling ttioctl on the controller since,
   1047    1.1       cgd 			 * in that case, tp must be the controlling terminal.
   1048    1.1       cgd 			 */
   1049    1.1       cgd 			*(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
   1050    1.1       cgd 			return (0);
   1051    1.1       cgd 
   1052    1.1       cgd 		case TIOCPKT:
   1053    1.1       cgd 			if (*(int *)data) {
   1054    1.1       cgd 				if (pti->pt_flags & PF_UCNTL)
   1055    1.1       cgd 					return (EINVAL);
   1056    1.1       cgd 				pti->pt_flags |= PF_PKT;
   1057    1.1       cgd 			} else
   1058    1.1       cgd 				pti->pt_flags &= ~PF_PKT;
   1059    1.1       cgd 			return (0);
   1060    1.1       cgd 
   1061    1.1       cgd 		case TIOCUCNTL:
   1062    1.1       cgd 			if (*(int *)data) {
   1063    1.1       cgd 				if (pti->pt_flags & PF_PKT)
   1064    1.1       cgd 					return (EINVAL);
   1065    1.1       cgd 				pti->pt_flags |= PF_UCNTL;
   1066    1.1       cgd 			} else
   1067    1.1       cgd 				pti->pt_flags &= ~PF_UCNTL;
   1068    1.1       cgd 			return (0);
   1069    1.1       cgd 
   1070    1.1       cgd 		case TIOCREMOTE:
   1071    1.1       cgd 			if (*(int *)data)
   1072    1.1       cgd 				pti->pt_flags |= PF_REMOTE;
   1073    1.1       cgd 			else
   1074    1.1       cgd 				pti->pt_flags &= ~PF_REMOTE;
   1075  1.102        ad 			mutex_spin_enter(&tty_lock);
   1076    1.1       cgd 			ttyflush(tp, FREAD|FWRITE);
   1077  1.102        ad 			mutex_spin_exit(&tty_lock);
   1078    1.1       cgd 			return (0);
   1079    1.1       cgd 
   1080   1.32  christos #ifdef COMPAT_OLDTTY
   1081   1.35        pk 		case TIOCSETP:
   1082    1.1       cgd 		case TIOCSETN:
   1083    1.2       cgd #endif
   1084    1.1       cgd 		case TIOCSETD:
   1085    1.1       cgd 		case TIOCSETA:
   1086    1.1       cgd 		case TIOCSETAW:
   1087    1.1       cgd 		case TIOCSETAF:
   1088  1.102        ad 			mutex_spin_enter(&tty_lock);
   1089   1.21       cgd 			ndflush(&tp->t_outq, tp->t_outq.c_cc);
   1090  1.102        ad 			mutex_spin_exit(&tty_lock);
   1091    1.1       cgd 			break;
   1092    1.1       cgd 
   1093    1.1       cgd 		case TIOCSIG:
   1094   1.99  christos 			sig = (int)(long)*(void **)data;
   1095   1.44      fvdl 			if (sig <= 0 || sig >= NSIG)
   1096   1.44      fvdl 				return (EINVAL);
   1097  1.102        ad 			mutex_spin_enter(&tty_lock);
   1098   1.37   mycroft 			if (!ISSET(tp->t_lflag, NOFLSH))
   1099    1.1       cgd 				ttyflush(tp, FREAD|FWRITE);
   1100   1.44      fvdl 			if ((sig == SIGINFO) &&
   1101   1.37   mycroft 			    (!ISSET(tp->t_lflag, NOKERNINFO)))
   1102   1.90  christos 				ttyinfo(tp, 1);
   1103  1.102        ad 			ttysig(tp, TTYSIG_PG1, sig);
   1104  1.102        ad 			mutex_spin_exit(&tty_lock);
   1105    1.1       cgd 			return(0);
   1106    1.1       cgd 		}
   1107   1.71       dsl 
   1108   1.86  christos 	error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
   1109   1.61    atatat 	if (error == EPASSTHROUGH)
   1110   1.86  christos 		 error = ttioctl(tp, cmd, data, flag, l);
   1111   1.61    atatat 	if (error == EPASSTHROUGH) {
   1112    1.1       cgd 		if (pti->pt_flags & PF_UCNTL &&
   1113    1.1       cgd 		    (cmd & ~0xff) == UIOCCMD(0)) {
   1114    1.1       cgd 			if (cmd & 0xff) {
   1115    1.1       cgd 				pti->pt_ucntl = (u_char)cmd;
   1116    1.1       cgd 				ptcwakeup(tp, FREAD);
   1117    1.1       cgd 			}
   1118    1.1       cgd 			return (0);
   1119    1.1       cgd 		}
   1120    1.1       cgd 	}
   1121    1.1       cgd 	/*
   1122    1.1       cgd 	 * If external processing and packet mode send ioctl packet.
   1123    1.1       cgd 	 */
   1124   1.37   mycroft 	if (ISSET(tp->t_lflag, EXTPROC) && (pti->pt_flags & PF_PKT)) {
   1125    1.1       cgd 		switch(cmd) {
   1126    1.1       cgd 		case TIOCSETA:
   1127    1.1       cgd 		case TIOCSETAW:
   1128    1.1       cgd 		case TIOCSETAF:
   1129   1.32  christos #ifdef COMPAT_OLDTTY
   1130    1.1       cgd 		case TIOCSETP:
   1131    1.1       cgd 		case TIOCSETN:
   1132    1.1       cgd 		case TIOCSETC:
   1133    1.1       cgd 		case TIOCSLTC:
   1134    1.1       cgd 		case TIOCLBIS:
   1135    1.1       cgd 		case TIOCLBIC:
   1136    1.1       cgd 		case TIOCLSET:
   1137    1.1       cgd #endif
   1138    1.1       cgd 			pti->pt_send |= TIOCPKT_IOCTL;
   1139   1.22       cgd 			ptcwakeup(tp, FREAD);
   1140    1.1       cgd 		default:
   1141    1.1       cgd 			break;
   1142    1.1       cgd 		}
   1143    1.1       cgd 	}
   1144   1.37   mycroft 	stop = ISSET(tp->t_iflag, IXON) && CCEQ(cc[VSTOP], CTRL('s'))
   1145    1.1       cgd 		&& CCEQ(cc[VSTART], CTRL('q'));
   1146    1.1       cgd 	if (pti->pt_flags & PF_NOSTOP) {
   1147    1.1       cgd 		if (stop) {
   1148    1.1       cgd 			pti->pt_send &= ~TIOCPKT_NOSTOP;
   1149    1.1       cgd 			pti->pt_send |= TIOCPKT_DOSTOP;
   1150    1.1       cgd 			pti->pt_flags &= ~PF_NOSTOP;
   1151    1.1       cgd 			ptcwakeup(tp, FREAD);
   1152    1.1       cgd 		}
   1153    1.1       cgd 	} else {
   1154    1.1       cgd 		if (!stop) {
   1155    1.1       cgd 			pti->pt_send &= ~TIOCPKT_DOSTOP;
   1156    1.1       cgd 			pti->pt_send |= TIOCPKT_NOSTOP;
   1157    1.1       cgd 			pti->pt_flags |= PF_NOSTOP;
   1158    1.1       cgd 			ptcwakeup(tp, FREAD);
   1159    1.1       cgd 		}
   1160    1.1       cgd 	}
   1161    1.1       cgd 	return (error);
   1162    1.1       cgd }
   1163