Home | History | Annotate | Line # | Download | only in kern
tty.c revision 1.204
      1  1.204        ad /*	$NetBSD: tty.c,v 1.204 2007/11/19 19:53:48 ad Exp $	*/
      2   1.49       cgd 
      3   1.49       cgd /*-
      4   1.49       cgd  * Copyright (c) 1982, 1986, 1990, 1991, 1993
      5   1.49       cgd  *	The Regents of the University of California.  All rights reserved.
      6   1.49       cgd  * (c) UNIX System Laboratories, Inc.
      7   1.49       cgd  * All or some portions of this file are derived from material licensed
      8   1.49       cgd  * to the University of California by American Telephone and Telegraph
      9   1.49       cgd  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     10   1.49       cgd  * the permission of UNIX System Laboratories, Inc.
     11   1.49       cgd  *
     12   1.49       cgd  * Redistribution and use in source and binary forms, with or without
     13   1.49       cgd  * modification, are permitted provided that the following conditions
     14   1.49       cgd  * are met:
     15   1.49       cgd  * 1. Redistributions of source code must retain the above copyright
     16   1.49       cgd  *    notice, this list of conditions and the following disclaimer.
     17   1.49       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18   1.49       cgd  *    notice, this list of conditions and the following disclaimer in the
     19   1.49       cgd  *    documentation and/or other materials provided with the distribution.
     20  1.155       agc  * 3. Neither the name of the University nor the names of its contributors
     21   1.49       cgd  *    may be used to endorse or promote products derived from this software
     22   1.49       cgd  *    without specific prior written permission.
     23   1.49       cgd  *
     24   1.49       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     25   1.49       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     26   1.49       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     27   1.49       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     28   1.49       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     29   1.49       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     30   1.49       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     31   1.49       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     32   1.49       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     33   1.49       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     34   1.49       cgd  * SUCH DAMAGE.
     35   1.49       cgd  *
     36  1.105      fvdl  *	@(#)tty.c	8.13 (Berkeley) 1/9/95
     37   1.49       cgd  */
     38  1.129     lukem 
     39  1.129     lukem #include <sys/cdefs.h>
     40  1.204        ad __KERNEL_RCSID(0, "$NetBSD: tty.c,v 1.204 2007/11/19 19:53:48 ad Exp $");
     41   1.49       cgd 
     42   1.49       cgd #include <sys/param.h>
     43   1.49       cgd #include <sys/systm.h>
     44   1.49       cgd #include <sys/ioctl.h>
     45   1.49       cgd #include <sys/proc.h>
     46   1.49       cgd #define	TTYDEFCHARS
     47   1.49       cgd #include <sys/tty.h>
     48   1.49       cgd #undef	TTYDEFCHARS
     49   1.49       cgd #include <sys/file.h>
     50   1.49       cgd #include <sys/conf.h>
     51   1.49       cgd #include <sys/dkstat.h>
     52   1.49       cgd #include <sys/uio.h>
     53   1.49       cgd #include <sys/kernel.h>
     54   1.49       cgd #include <sys/vnode.h>
     55   1.49       cgd #include <sys/syslog.h>
     56   1.49       cgd #include <sys/malloc.h>
     57  1.111   thorpej #include <sys/pool.h>
     58   1.65  christos #include <sys/signalvar.h>
     59   1.65  christos #include <sys/resourcevar.h>
     60   1.74   mycroft #include <sys/poll.h>
     61  1.149  christos #include <sys/kprintf.h>
     62  1.151  christos #include <sys/namei.h>
     63  1.159    atatat #include <sys/sysctl.h>
     64  1.182      elad #include <sys/kauth.h>
     65  1.201        ad #include <sys/intr.h>
     66  1.149  christos 
     67  1.149  christos #include <machine/stdarg.h>
     68   1.49       cgd 
     69  1.126     lukem static int	ttnread(struct tty *);
     70  1.126     lukem static void	ttyblock(struct tty *);
     71  1.126     lukem static void	ttyecho(int, struct tty *);
     72  1.126     lukem static void	ttyrubo(struct tty *, int);
     73  1.149  christos static void	ttyprintf_nolock(struct tty *, const char *fmt, ...)
     74  1.149  christos     __attribute__((__format__(__printf__,2,3)));
     75  1.126     lukem static int	proc_compare(struct proc *, struct proc *);
     76  1.201        ad static void	ttysigintr(void *);
     77   1.49       cgd 
     78   1.49       cgd /* Symbolic sleep message strings. */
     79   1.98   mycroft const char	ttclos[] = "ttycls";
     80   1.98   mycroft const char	ttopen[] = "ttyopn";
     81   1.98   mycroft const char	ttybg[] = "ttybg";
     82   1.98   mycroft const char	ttyin[] = "ttyin";
     83   1.98   mycroft const char	ttyout[] = "ttyout";
     84   1.49       cgd 
     85   1.49       cgd /*
     86   1.83   mycroft  * Used to determine whether we still have a connection.  This is true in
     87   1.83   mycroft  * one of 3 cases:
     88   1.83   mycroft  * 1) We have carrier.
     89   1.83   mycroft  * 2) It's a locally attached terminal, and we are therefore ignoring carrier.
     90   1.83   mycroft  * 3) We're using a flow control mechanism that overloads the carrier signal.
     91   1.83   mycroft  */
     92   1.83   mycroft #define	CONNECTED(tp)	(ISSET(tp->t_state, TS_CARR_ON) ||	\
     93   1.83   mycroft 			 ISSET(tp->t_cflag, CLOCAL | MDMBUF))
     94   1.83   mycroft 
     95   1.83   mycroft /*
     96   1.49       cgd  * Table with character classes and parity. The 8th bit indicates parity,
     97   1.49       cgd  * the 7th bit indicates the character is an alphameric or underscore (for
     98   1.49       cgd  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
     99   1.49       cgd  * are 0 then the character needs no special processing on output; classes
    100   1.49       cgd  * other than 0 might be translated or (not currently) require delays.
    101   1.49       cgd  */
    102   1.49       cgd #define	E	0x00	/* Even parity. */
    103   1.49       cgd #define	O	0x80	/* Odd parity. */
    104   1.49       cgd #define	PARITY(c)	(char_type[c] & O)
    105   1.49       cgd 
    106   1.49       cgd #define	ALPHA	0x40	/* Alpha or underscore. */
    107   1.49       cgd #define	ISALPHA(c)	(char_type[(c) & TTY_CHARMASK] & ALPHA)
    108   1.49       cgd 
    109   1.49       cgd #define	CCLASSMASK	0x3f
    110   1.49       cgd #define	CCLASS(c)	(char_type[c] & CCLASSMASK)
    111   1.49       cgd 
    112   1.49       cgd #define	BS	BACKSPACE
    113   1.49       cgd #define	CC	CONTROL
    114   1.49       cgd #define	CR	RETURN
    115   1.49       cgd #define	NA	ORDINARY | ALPHA
    116   1.49       cgd #define	NL	NEWLINE
    117   1.49       cgd #define	NO	ORDINARY
    118   1.49       cgd #define	TB	TAB
    119   1.49       cgd #define	VT	VTAB
    120   1.49       cgd 
    121  1.146    simonb unsigned char const char_type[] = {
    122   1.49       cgd 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC,	/* nul - bel */
    123  1.137    simonb 	O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC,	/* bs - si */
    124  1.138     enami 	O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC,	/* dle - etb */
    125  1.138     enami 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC,	/* can - us */
    126  1.138     enami 	O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO,	/* sp - ' */
    127  1.138     enami 	E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO,	/* ( - / */
    128  1.138     enami 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA,	/* 0 - 7 */
    129  1.138     enami 	O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO,	/* 8 - ? */
    130  1.138     enami 	O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA,	/* @ - G */
    131  1.138     enami 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA,	/* H - O */
    132  1.138     enami 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA,	/* P - W */
    133  1.138     enami 	O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA,	/* X - _ */
    134  1.138     enami 	E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA,	/* ` - g */
    135  1.138     enami 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA,	/* h - o */
    136  1.138     enami 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA,	/* p - w */
    137  1.138     enami 	E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC,	/* x - del */
    138   1.49       cgd 	/*
    139   1.49       cgd 	 * Meta chars; should be settable per character set;
    140   1.49       cgd 	 * for now, treat them all as normal characters.
    141   1.49       cgd 	 */
    142   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    143   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    144   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    145   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    146   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    147   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    148   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    149   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    150   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    151   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    152   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    153   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    154   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    155   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    156   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    157   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    158   1.49       cgd };
    159   1.49       cgd #undef	BS
    160   1.49       cgd #undef	CC
    161   1.49       cgd #undef	CR
    162   1.49       cgd #undef	NA
    163   1.49       cgd #undef	NL
    164   1.49       cgd #undef	NO
    165   1.49       cgd #undef	TB
    166   1.49       cgd #undef	VT
    167   1.49       cgd 
    168  1.201        ad static struct ttylist_head tty_sigqueue = TAILQ_HEAD_INITIALIZER(tty_sigqueue);
    169  1.201        ad static void *tty_sigsih;
    170  1.201        ad 
    171  1.169   thorpej struct ttylist_head ttylist = TAILQ_HEAD_INITIALIZER(ttylist);
    172   1.69       mrg int tty_count;
    173  1.201        ad kmutex_t tty_lock;
    174   1.69       mrg 
    175  1.167    simonb POOL_INIT(tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl",
    176  1.194        ad     &pool_allocator_nointr, IPL_NONE);
    177  1.130    simonb 
    178  1.179     perry uint64_t tk_cancc;
    179  1.179     perry uint64_t tk_nin;
    180  1.179     perry uint64_t tk_nout;
    181  1.179     perry uint64_t tk_rawcc;
    182  1.159    atatat 
    183  1.159    atatat SYSCTL_SETUP(sysctl_kern_tkstat_setup, "sysctl kern.tkstat subtree setup")
    184  1.159    atatat {
    185  1.159    atatat 
    186  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    187  1.165    atatat 		       CTLFLAG_PERMANENT,
    188  1.159    atatat 		       CTLTYPE_NODE, "kern", NULL,
    189  1.159    atatat 		       NULL, 0, NULL, 0,
    190  1.159    atatat 		       CTL_KERN, CTL_EOL);
    191  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    192  1.165    atatat 		       CTLFLAG_PERMANENT,
    193  1.168    atatat 		       CTLTYPE_NODE, "tkstat",
    194  1.168    atatat 		       SYSCTL_DESCR("Number of characters sent and and "
    195  1.168    atatat 				    "received on ttys"),
    196  1.159    atatat 		       NULL, 0, NULL, 0,
    197  1.159    atatat 		       CTL_KERN, KERN_TKSTAT, CTL_EOL);
    198  1.159    atatat 
    199  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    200  1.165    atatat 		       CTLFLAG_PERMANENT,
    201  1.168    atatat 		       CTLTYPE_QUAD, "nin",
    202  1.168    atatat 		       SYSCTL_DESCR("Total number of tty input characters"),
    203  1.159    atatat 		       NULL, 0, &tk_nin, 0,
    204  1.159    atatat 		       CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NIN, CTL_EOL);
    205  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    206  1.165    atatat 		       CTLFLAG_PERMANENT,
    207  1.168    atatat 		       CTLTYPE_QUAD, "nout",
    208  1.168    atatat 		       SYSCTL_DESCR("Total number of tty output characters"),
    209  1.159    atatat 		       NULL, 0, &tk_nout, 0,
    210  1.159    atatat 		       CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NOUT, CTL_EOL);
    211  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    212  1.165    atatat 		       CTLFLAG_PERMANENT,
    213  1.168    atatat 		       CTLTYPE_QUAD, "cancc",
    214  1.168    atatat 		       SYSCTL_DESCR("Number of canonical tty input characters"),
    215  1.159    atatat 		       NULL, 0, &tk_cancc, 0,
    216  1.159    atatat 		       CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_CANCC, CTL_EOL);
    217  1.165    atatat 	sysctl_createv(clog, 0, NULL, NULL,
    218  1.165    atatat 		       CTLFLAG_PERMANENT,
    219  1.168    atatat 		       CTLTYPE_QUAD, "rawcc",
    220  1.168    atatat 		       SYSCTL_DESCR("Number of raw tty input characters"),
    221  1.159    atatat 		       NULL, 0, &tk_rawcc, 0,
    222  1.159    atatat 		       CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_RAWCC, CTL_EOL);
    223  1.159    atatat }
    224  1.111   thorpej 
    225  1.107   mycroft int
    226  1.126     lukem ttyopen(struct tty *tp, int dialout, int nonblock)
    227  1.107   mycroft {
    228  1.201        ad 	int	error;
    229  1.107   mycroft 
    230  1.147        pk 	error = 0;
    231  1.147        pk 
    232  1.201        ad 	mutex_spin_enter(&tty_lock);
    233  1.107   mycroft 
    234  1.107   mycroft 	if (dialout) {
    235  1.107   mycroft 		/*
    236  1.107   mycroft 		 * If the device is already open for non-dialout, fail.
    237  1.107   mycroft 		 * Otherwise, set TS_DIALOUT to block any pending non-dialout
    238  1.107   mycroft 		 * opens.
    239  1.107   mycroft 		 */
    240  1.107   mycroft 		if (ISSET(tp->t_state, TS_ISOPEN) &&
    241  1.107   mycroft 		    !ISSET(tp->t_state, TS_DIALOUT)) {
    242  1.147        pk 			error = EBUSY;
    243  1.147        pk 			goto out;
    244  1.107   mycroft 		}
    245  1.107   mycroft 		SET(tp->t_state, TS_DIALOUT);
    246  1.107   mycroft 	} else {
    247  1.107   mycroft 		if (!nonblock) {
    248  1.107   mycroft 			/*
    249  1.107   mycroft 			 * Wait for carrier.  Also wait for any dialout
    250  1.107   mycroft 			 * processes to close the tty first.
    251  1.107   mycroft 			 */
    252  1.107   mycroft 			while (ISSET(tp->t_state, TS_DIALOUT) ||
    253  1.147        pk 			       !CONNECTED(tp)) {
    254  1.107   mycroft 				tp->t_wopen++;
    255  1.201        ad 				error = ttysleep(tp, &tp->t_rawq.c_cv, true, 0);
    256  1.107   mycroft 				tp->t_wopen--;
    257  1.147        pk 				if (error)
    258  1.147        pk 					goto out;
    259  1.107   mycroft 			}
    260  1.107   mycroft 		} else {
    261  1.107   mycroft 			/*
    262  1.107   mycroft 			 * Don't allow a non-blocking non-dialout open if the
    263  1.107   mycroft 			 * device is already open for dialout.
    264  1.107   mycroft 			 */
    265  1.138     enami 			if (ISSET(tp->t_state, TS_DIALOUT)) {
    266  1.147        pk 				error = EBUSY;
    267  1.147        pk 				goto out;
    268  1.107   mycroft 			}
    269  1.107   mycroft 		}
    270  1.107   mycroft 	}
    271  1.107   mycroft 
    272  1.147        pk out:
    273  1.201        ad 	mutex_spin_exit(&tty_lock);
    274  1.147        pk 	return (error);
    275  1.107   mycroft }
    276  1.107   mycroft 
    277   1.49       cgd /*
    278   1.49       cgd  * Initial open of tty, or (re)entry to standard tty line discipline.
    279   1.49       cgd  */
    280   1.49       cgd int
    281  1.126     lukem ttylopen(dev_t device, struct tty *tp)
    282   1.49       cgd {
    283   1.49       cgd 
    284  1.201        ad 	mutex_spin_enter(&tty_lock);
    285   1.49       cgd 	tp->t_dev = device;
    286   1.49       cgd 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    287   1.49       cgd 		SET(tp->t_state, TS_ISOPEN);
    288  1.109     perry 		memset(&tp->t_winsize, 0, sizeof(tp->t_winsize));
    289   1.66  christos #ifdef COMPAT_OLDTTY
    290   1.50   mycroft 		tp->t_flags = 0;
    291   1.50   mycroft #endif
    292   1.49       cgd 	}
    293  1.201        ad 	mutex_spin_exit(&tty_lock);
    294   1.49       cgd 	return (0);
    295   1.49       cgd }
    296   1.49       cgd 
    297   1.49       cgd /*
    298   1.49       cgd  * Handle close() on a tty line: flush and set to initial state,
    299   1.49       cgd  * bumping generation number so that pending read/write calls
    300   1.49       cgd  * can detect recycling of the tty.
    301   1.49       cgd  */
    302   1.49       cgd int
    303  1.126     lukem ttyclose(struct tty *tp)
    304   1.49       cgd {
    305   1.49       cgd 	extern struct tty *constty;	/* Temporary virtual console. */
    306  1.201        ad 	struct session *sess;
    307  1.147        pk 
    308  1.201        ad 	mutex_spin_enter(&tty_lock);
    309   1.49       cgd 
    310   1.49       cgd 	if (constty == tp)
    311   1.49       cgd 		constty = NULL;
    312   1.49       cgd 
    313   1.49       cgd 	ttyflush(tp, FREAD | FWRITE);
    314   1.49       cgd 
    315   1.49       cgd 	tp->t_gen++;
    316   1.49       cgd 	tp->t_pgrp = NULL;
    317  1.190        ad 	tp->t_state = 0;
    318  1.190        ad 
    319  1.201        ad 	mutex_spin_exit(&tty_lock);
    320  1.190        ad 
    321  1.193        ad 	mutex_enter(&proclist_lock);
    322  1.201        ad 	if ((sess = tp->t_session) != NULL) {
    323  1.136  christos 		SESSRELE(tp->t_session);
    324  1.136  christos 		tp->t_session = NULL;
    325  1.136  christos 	}
    326  1.193        ad 	mutex_exit(&proclist_lock);
    327  1.190        ad 
    328   1.49       cgd 	return (0);
    329   1.49       cgd }
    330   1.49       cgd 
    331   1.49       cgd #define	FLUSHQ(q) {							\
    332   1.49       cgd 	if ((q)->c_cc)							\
    333   1.49       cgd 		ndflush(q, (q)->c_cc);					\
    334   1.49       cgd }
    335   1.49       cgd 
    336   1.88    kleink /*
    337   1.88    kleink  * This macro is used in canonical mode input processing, where a read
    338   1.88    kleink  * request shall not return unless a 'line delimiter' ('\n') or 'break'
    339   1.88    kleink  * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2
    340   1.88    kleink  * is an extension to the POSIX.1 defined set of special characters,
    341   1.88    kleink  * recognize it only if IEXTEN is set in the set of local flags.
    342   1.88    kleink  */
    343   1.85    kleink #define	TTBREAKC(c, lflg)						\
    344   1.87       cgd 	((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] ||		\
    345   1.85    kleink 	((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE))
    346   1.49       cgd 
    347   1.49       cgd 
    348  1.147        pk 
    349   1.49       cgd /*
    350  1.147        pk  * ttyinput() helper.
    351  1.201        ad  * Call with the tty lock held.
    352   1.49       cgd  */
    353  1.147        pk static int
    354  1.147        pk ttyinput_wlock(int c, struct tty *tp)
    355   1.49       cgd {
    356  1.126     lukem 	int	iflag, lflag, i, error;
    357  1.126     lukem 	u_char	*cc;
    358   1.78  christos 
    359  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
    360  1.201        ad 
    361   1.78  christos 	/*
    362   1.49       cgd 	 * If input is pending take it first.
    363   1.49       cgd 	 */
    364   1.49       cgd 	lflag = tp->t_lflag;
    365   1.49       cgd 	if (ISSET(lflag, PENDIN))
    366   1.49       cgd 		ttypend(tp);
    367   1.49       cgd 	/*
    368   1.49       cgd 	 * Gather stats.
    369   1.49       cgd 	 */
    370   1.49       cgd 	if (ISSET(lflag, ICANON)) {
    371   1.49       cgd 		++tk_cancc;
    372   1.49       cgd 		++tp->t_cancc;
    373   1.49       cgd 	} else {
    374   1.49       cgd 		++tk_rawcc;
    375   1.49       cgd 		++tp->t_rawcc;
    376   1.49       cgd 	}
    377   1.49       cgd 	++tk_nin;
    378   1.49       cgd 
    379   1.49       cgd 	cc = tp->t_cc;
    380   1.94    kleink 
    381   1.94    kleink 	/*
    382   1.94    kleink 	 * Handle exceptional conditions (break, parity, framing).
    383   1.94    kleink 	 */
    384   1.49       cgd 	iflag = tp->t_iflag;
    385   1.65  christos 	if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
    386   1.49       cgd 		CLR(c, TTY_ERRORMASK);
    387   1.94    kleink 		if (ISSET(error, TTY_FE) && c == 0) {		/* Break. */
    388   1.49       cgd 			if (ISSET(iflag, IGNBRK))
    389   1.94    kleink 				return (0);
    390   1.94    kleink 			else if (ISSET(iflag, BRKINT)) {
    391   1.94    kleink 				ttyflush(tp, FREAD | FWRITE);
    392  1.201        ad 				ttysig(tp, TTYSIG_PG1, SIGINT);
    393   1.94    kleink 				return (0);
    394  1.138     enami 			} else if (ISSET(iflag, PARMRK))
    395   1.49       cgd 				goto parmrk;
    396  1.138     enami 		} else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
    397   1.94    kleink 		    ISSET(error, TTY_FE)) {
    398   1.49       cgd 			if (ISSET(iflag, IGNPAR))
    399   1.94    kleink 				return (0);
    400   1.49       cgd 			else if (ISSET(iflag, PARMRK)) {
    401  1.126     lukem  parmrk:			(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    402   1.94    kleink 				(void)putc(0    | TTY_QUOTE, &tp->t_rawq);
    403   1.94    kleink 				(void)putc(c    | TTY_QUOTE, &tp->t_rawq);
    404   1.94    kleink 				return (0);
    405  1.138     enami 			} else
    406   1.49       cgd 				c = 0;
    407   1.49       cgd 		}
    408  1.138     enami 	} else if (c == 0377 &&
    409   1.94    kleink 	    ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) {
    410   1.94    kleink 		/* "Escape" a valid character of '\377'. */
    411   1.94    kleink 		(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    412   1.94    kleink 		(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    413   1.94    kleink 		goto endcase;
    414   1.94    kleink 	}
    415   1.94    kleink 
    416   1.49       cgd 	/*
    417   1.49       cgd 	 * In tandem mode, check high water mark.
    418   1.49       cgd 	 */
    419   1.49       cgd 	if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
    420   1.49       cgd 		ttyblock(tp);
    421   1.49       cgd 	if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
    422   1.49       cgd 		CLR(c, 0x80);
    423   1.49       cgd 	if (!ISSET(lflag, EXTPROC)) {
    424   1.49       cgd 		/*
    425   1.49       cgd 		 * Check for literal nexting very first
    426   1.49       cgd 		 */
    427   1.49       cgd 		if (ISSET(tp->t_state, TS_LNCH)) {
    428   1.49       cgd 			SET(c, TTY_QUOTE);
    429   1.49       cgd 			CLR(tp->t_state, TS_LNCH);
    430   1.49       cgd 		}
    431   1.49       cgd 		/*
    432   1.49       cgd 		 * Scan for special characters.  This code
    433   1.49       cgd 		 * is really just a big case statement with
    434   1.49       cgd 		 * non-constant cases.  The bottom of the
    435   1.49       cgd 		 * case statement is labeled ``endcase'', so goto
    436   1.49       cgd 		 * it after a case match, or similar.
    437   1.49       cgd 		 */
    438   1.49       cgd 
    439   1.49       cgd 		/*
    440   1.49       cgd 		 * Control chars which aren't controlled
    441   1.49       cgd 		 * by ICANON, ISIG, or IXON.
    442   1.49       cgd 		 */
    443   1.49       cgd 		if (ISSET(lflag, IEXTEN)) {
    444   1.49       cgd 			if (CCEQ(cc[VLNEXT], c)) {
    445   1.49       cgd 				if (ISSET(lflag, ECHO)) {
    446   1.49       cgd 					if (ISSET(lflag, ECHOE)) {
    447   1.49       cgd 						(void)ttyoutput('^', tp);
    448   1.49       cgd 						(void)ttyoutput('\b', tp);
    449   1.49       cgd 					} else
    450   1.49       cgd 						ttyecho(c, tp);
    451   1.49       cgd 				}
    452   1.49       cgd 				SET(tp->t_state, TS_LNCH);
    453   1.49       cgd 				goto endcase;
    454   1.49       cgd 			}
    455   1.49       cgd 			if (CCEQ(cc[VDISCARD], c)) {
    456   1.49       cgd 				if (ISSET(lflag, FLUSHO))
    457   1.49       cgd 					CLR(tp->t_lflag, FLUSHO);
    458   1.49       cgd 				else {
    459   1.49       cgd 					ttyflush(tp, FWRITE);
    460   1.49       cgd 					ttyecho(c, tp);
    461   1.49       cgd 					if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
    462   1.49       cgd 						ttyretype(tp);
    463   1.49       cgd 					SET(tp->t_lflag, FLUSHO);
    464   1.49       cgd 				}
    465   1.49       cgd 				goto startoutput;
    466   1.49       cgd 			}
    467   1.49       cgd 		}
    468   1.49       cgd 		/*
    469   1.49       cgd 		 * Signals.
    470   1.49       cgd 		 */
    471   1.49       cgd 		if (ISSET(lflag, ISIG)) {
    472   1.49       cgd 			if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
    473   1.49       cgd 				if (!ISSET(lflag, NOFLSH))
    474   1.49       cgd 					ttyflush(tp, FREAD | FWRITE);
    475   1.49       cgd 				ttyecho(c, tp);
    476  1.201        ad 				ttysig(tp, TTYSIG_PG1, CCEQ(cc[VINTR], c) ?
    477  1.201        ad 				    SIGINT : SIGQUIT);
    478   1.49       cgd 				goto endcase;
    479   1.49       cgd 			}
    480   1.49       cgd 			if (CCEQ(cc[VSUSP], c)) {
    481   1.49       cgd 				if (!ISSET(lflag, NOFLSH))
    482   1.49       cgd 					ttyflush(tp, FREAD);
    483   1.49       cgd 				ttyecho(c, tp);
    484  1.201        ad 				ttysig(tp, TTYSIG_PG1, SIGTSTP);
    485   1.49       cgd 				goto endcase;
    486   1.49       cgd 			}
    487   1.49       cgd 		}
    488   1.49       cgd 		/*
    489   1.49       cgd 		 * Handle start/stop characters.
    490   1.49       cgd 		 */
    491   1.49       cgd 		if (ISSET(iflag, IXON)) {
    492   1.49       cgd 			if (CCEQ(cc[VSTOP], c)) {
    493   1.49       cgd 				if (!ISSET(tp->t_state, TS_TTSTOP)) {
    494   1.49       cgd 					SET(tp->t_state, TS_TTSTOP);
    495  1.201        ad 					cdev_stop(tp, 0);
    496   1.49       cgd 					return (0);
    497   1.49       cgd 				}
    498   1.49       cgd 				if (!CCEQ(cc[VSTART], c))
    499   1.49       cgd 					return (0);
    500   1.49       cgd 				/*
    501   1.49       cgd 				 * if VSTART == VSTOP then toggle
    502   1.49       cgd 				 */
    503   1.49       cgd 				goto endcase;
    504   1.49       cgd 			}
    505   1.49       cgd 			if (CCEQ(cc[VSTART], c))
    506   1.49       cgd 				goto restartoutput;
    507   1.49       cgd 		}
    508   1.49       cgd 		/*
    509   1.49       cgd 		 * IGNCR, ICRNL, & INLCR
    510   1.49       cgd 		 */
    511   1.49       cgd 		if (c == '\r') {
    512   1.49       cgd 			if (ISSET(iflag, IGNCR))
    513   1.49       cgd 				goto endcase;
    514   1.49       cgd 			else if (ISSET(iflag, ICRNL))
    515   1.49       cgd 				c = '\n';
    516   1.49       cgd 		} else if (c == '\n' && ISSET(iflag, INLCR))
    517   1.49       cgd 			c = '\r';
    518   1.49       cgd 	}
    519  1.147        pk 	if (!ISSET(lflag, EXTPROC) && ISSET(lflag, ICANON)) {
    520   1.49       cgd 		/*
    521   1.49       cgd 		 * From here on down canonical mode character
    522   1.49       cgd 		 * processing takes place.
    523   1.49       cgd 		 */
    524   1.49       cgd 		/*
    525   1.49       cgd 		 * erase (^H / ^?)
    526   1.49       cgd 		 */
    527   1.49       cgd 		if (CCEQ(cc[VERASE], c)) {
    528   1.49       cgd 			if (tp->t_rawq.c_cc)
    529   1.49       cgd 				ttyrub(unputc(&tp->t_rawq), tp);
    530   1.49       cgd 			goto endcase;
    531   1.49       cgd 		}
    532   1.49       cgd 		/*
    533   1.49       cgd 		 * kill (^U)
    534   1.49       cgd 		 */
    535   1.49       cgd 		if (CCEQ(cc[VKILL], c)) {
    536   1.49       cgd 			if (ISSET(lflag, ECHOKE) &&
    537   1.49       cgd 			    tp->t_rawq.c_cc == tp->t_rocount &&
    538   1.49       cgd 			    !ISSET(lflag, ECHOPRT))
    539   1.49       cgd 				while (tp->t_rawq.c_cc)
    540   1.49       cgd 					ttyrub(unputc(&tp->t_rawq), tp);
    541   1.49       cgd 			else {
    542   1.49       cgd 				ttyecho(c, tp);
    543   1.49       cgd 				if (ISSET(lflag, ECHOK) ||
    544   1.49       cgd 				    ISSET(lflag, ECHOKE))
    545   1.49       cgd 					ttyecho('\n', tp);
    546   1.49       cgd 				FLUSHQ(&tp->t_rawq);
    547   1.49       cgd 				tp->t_rocount = 0;
    548   1.49       cgd 			}
    549   1.49       cgd 			CLR(tp->t_state, TS_LOCAL);
    550   1.49       cgd 			goto endcase;
    551   1.49       cgd 		}
    552   1.49       cgd 		/*
    553   1.81    kleink 		 * Extensions to the POSIX.1 GTI set of functions.
    554   1.49       cgd 		 */
    555   1.81    kleink 		if (ISSET(lflag, IEXTEN)) {
    556   1.49       cgd 			/*
    557   1.81    kleink 			 * word erase (^W)
    558   1.49       cgd 			 */
    559   1.81    kleink 			if (CCEQ(cc[VWERASE], c)) {
    560   1.81    kleink 				int alt = ISSET(lflag, ALTWERASE);
    561   1.81    kleink 				int ctype;
    562   1.81    kleink 
    563   1.81    kleink 				/*
    564   1.81    kleink 				 * erase whitespace
    565   1.81    kleink 				 */
    566   1.81    kleink 				while ((c = unputc(&tp->t_rawq)) == ' ' ||
    567  1.138     enami 				    c == '\t')
    568   1.81    kleink 					ttyrub(c, tp);
    569   1.81    kleink 				if (c == -1)
    570   1.81    kleink 					goto endcase;
    571   1.81    kleink 				/*
    572   1.81    kleink 				 * erase last char of word and remember the
    573   1.81    kleink 				 * next chars type (for ALTWERASE)
    574   1.81    kleink 				 */
    575   1.49       cgd 				ttyrub(c, tp);
    576   1.81    kleink 				c = unputc(&tp->t_rawq);
    577   1.81    kleink 				if (c == -1)
    578   1.81    kleink 					goto endcase;
    579   1.81    kleink 				if (c == ' ' || c == '\t') {
    580   1.81    kleink 					(void)putc(c, &tp->t_rawq);
    581   1.81    kleink 					goto endcase;
    582   1.81    kleink 				}
    583   1.81    kleink 				ctype = ISALPHA(c);
    584   1.81    kleink 				/*
    585   1.81    kleink 				 * erase rest of word
    586   1.81    kleink 				 */
    587   1.81    kleink 				do {
    588   1.81    kleink 					ttyrub(c, tp);
    589   1.81    kleink 					c = unputc(&tp->t_rawq);
    590   1.81    kleink 					if (c == -1)
    591   1.81    kleink 						goto endcase;
    592   1.81    kleink 				} while (c != ' ' && c != '\t' &&
    593  1.138     enami 				    (alt == 0 || ISALPHA(c) == ctype));
    594   1.81    kleink 				(void)putc(c, &tp->t_rawq);
    595   1.49       cgd 				goto endcase;
    596   1.81    kleink 			}
    597   1.49       cgd 			/*
    598   1.81    kleink 			 * reprint line (^R)
    599   1.49       cgd 			 */
    600   1.81    kleink 			if (CCEQ(cc[VREPRINT], c)) {
    601   1.81    kleink 				ttyretype(tp);
    602   1.49       cgd 				goto endcase;
    603   1.49       cgd 			}
    604   1.49       cgd 			/*
    605   1.81    kleink 			 * ^T - kernel info and generate SIGINFO
    606   1.49       cgd 			 */
    607   1.81    kleink 			if (CCEQ(cc[VSTATUS], c)) {
    608  1.135     itohy 				if (!ISSET(lflag, NOKERNINFO))
    609  1.183  christos 					ttyinfo(tp, 1);
    610  1.201        ad 				if (ISSET(lflag, ISIG))
    611  1.201        ad 					ttysig(tp, TTYSIG_PG1, SIGINFO);
    612   1.81    kleink 				goto endcase;
    613   1.81    kleink 			}
    614   1.49       cgd 		}
    615   1.49       cgd 	}
    616   1.49       cgd 	/*
    617   1.49       cgd 	 * Check for input buffer overflow
    618   1.49       cgd 	 */
    619   1.49       cgd 	if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
    620   1.49       cgd 		if (ISSET(iflag, IMAXBEL)) {
    621   1.49       cgd 			if (tp->t_outq.c_cc < tp->t_hiwat)
    622   1.49       cgd 				(void)ttyoutput(CTRL('g'), tp);
    623   1.49       cgd 		} else
    624   1.49       cgd 			ttyflush(tp, FREAD | FWRITE);
    625   1.49       cgd 		goto endcase;
    626   1.49       cgd 	}
    627   1.49       cgd 	/*
    628   1.49       cgd 	 * Put data char in q for user and
    629   1.49       cgd 	 * wakeup on seeing a line delimiter.
    630   1.49       cgd 	 */
    631   1.49       cgd 	if (putc(c, &tp->t_rawq) >= 0) {
    632   1.49       cgd 		if (!ISSET(lflag, ICANON)) {
    633   1.49       cgd 			ttwakeup(tp);
    634   1.49       cgd 			ttyecho(c, tp);
    635   1.49       cgd 			goto endcase;
    636   1.49       cgd 		}
    637   1.85    kleink 		if (TTBREAKC(c, lflag)) {
    638   1.49       cgd 			tp->t_rocount = 0;
    639   1.49       cgd 			catq(&tp->t_rawq, &tp->t_canq);
    640   1.49       cgd 			ttwakeup(tp);
    641   1.49       cgd 		} else if (tp->t_rocount++ == 0)
    642   1.49       cgd 			tp->t_rocol = tp->t_column;
    643   1.49       cgd 		if (ISSET(tp->t_state, TS_ERASE)) {
    644   1.49       cgd 			/*
    645   1.49       cgd 			 * end of prterase \.../
    646   1.49       cgd 			 */
    647   1.49       cgd 			CLR(tp->t_state, TS_ERASE);
    648   1.49       cgd 			(void)ttyoutput('/', tp);
    649   1.49       cgd 		}
    650   1.49       cgd 		i = tp->t_column;
    651   1.49       cgd 		ttyecho(c, tp);
    652   1.49       cgd 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
    653   1.49       cgd 			/*
    654   1.49       cgd 			 * Place the cursor over the '^' of the ^D.
    655   1.49       cgd 			 */
    656   1.49       cgd 			i = min(2, tp->t_column - i);
    657   1.49       cgd 			while (i > 0) {
    658   1.49       cgd 				(void)ttyoutput('\b', tp);
    659   1.49       cgd 				i--;
    660   1.49       cgd 			}
    661   1.49       cgd 		}
    662   1.49       cgd 	}
    663  1.126     lukem  endcase:
    664   1.49       cgd 	/*
    665   1.49       cgd 	 * IXANY means allow any character to restart output.
    666   1.49       cgd 	 */
    667   1.49       cgd 	if (ISSET(tp->t_state, TS_TTSTOP) &&
    668  1.147        pk 	    !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
    669   1.49       cgd 		return (0);
    670  1.147        pk 	}
    671  1.126     lukem  restartoutput:
    672   1.49       cgd 	CLR(tp->t_lflag, FLUSHO);
    673   1.49       cgd 	CLR(tp->t_state, TS_TTSTOP);
    674  1.126     lukem  startoutput:
    675   1.49       cgd 	return (ttstart(tp));
    676   1.49       cgd }
    677   1.49       cgd 
    678   1.49       cgd /*
    679  1.147        pk  * Process input of a single character received on a tty.
    680  1.147        pk  *
    681  1.147        pk  * XXX - this is a hack, all drivers must changed to acquire the
    682  1.147        pk  *	 lock before calling linesw->l_rint()
    683  1.147        pk  */
    684  1.147        pk int
    685  1.147        pk ttyinput(int c, struct tty *tp)
    686  1.147        pk {
    687  1.147        pk 	int error;
    688  1.147        pk 
    689  1.147        pk 	/*
    690  1.147        pk 	 * Unless the receiver is enabled, drop incoming data.
    691  1.147        pk 	 */
    692  1.147        pk 	if (!ISSET(tp->t_cflag, CREAD))
    693  1.147        pk 		return (0);
    694  1.147        pk 
    695  1.201        ad 	mutex_spin_enter(&tty_lock);
    696  1.147        pk 	error = ttyinput_wlock(c, tp);
    697  1.201        ad 	mutex_spin_exit(&tty_lock);
    698  1.201        ad 
    699  1.147        pk 	return (error);
    700  1.147        pk }
    701  1.147        pk 
    702  1.147        pk /*
    703   1.49       cgd  * Output a single character on a tty, doing output processing
    704   1.49       cgd  * as needed (expanding tabs, newline processing, etc.).
    705   1.49       cgd  * Returns < 0 if succeeds, otherwise returns char to resend.
    706   1.49       cgd  * Must be recursive.
    707  1.201        ad  *
    708  1.201        ad  * Call with tty lock held.
    709   1.49       cgd  */
    710   1.49       cgd int
    711  1.126     lukem ttyoutput(int c, struct tty *tp)
    712   1.49       cgd {
    713  1.126     lukem 	long	oflag;
    714  1.201        ad 	int	col, notout;
    715  1.201        ad 
    716  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
    717   1.49       cgd 
    718   1.49       cgd 	oflag = tp->t_oflag;
    719   1.49       cgd 	if (!ISSET(oflag, OPOST)) {
    720   1.49       cgd 		tk_nout++;
    721   1.49       cgd 		tp->t_outcc++;
    722   1.99   mycroft 		if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
    723   1.99   mycroft 			return (c);
    724   1.49       cgd 		return (-1);
    725   1.49       cgd 	}
    726   1.49       cgd 	/*
    727  1.103    kleink 	 * Do tab expansion if OXTABS is set.  Special case if we do external
    728   1.49       cgd 	 * processing, we don't do the tab expansion because we'll probably
    729   1.49       cgd 	 * get it wrong.  If tab expansion needs to be done, let it happen
    730   1.49       cgd 	 * externally.
    731   1.49       cgd 	 */
    732   1.49       cgd 	CLR(c, ~TTY_CHARMASK);
    733   1.49       cgd 	if (c == '\t' &&
    734   1.49       cgd 	    ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
    735   1.49       cgd 		c = 8 - (tp->t_column & 7);
    736   1.49       cgd 		if (ISSET(tp->t_lflag, FLUSHO)) {
    737   1.49       cgd 			notout = 0;
    738   1.49       cgd 		} else {
    739   1.49       cgd 			notout = b_to_q("        ", c, &tp->t_outq);
    740   1.49       cgd 			c -= notout;
    741   1.49       cgd 			tk_nout += c;
    742   1.49       cgd 			tp->t_outcc += c;
    743   1.49       cgd 		}
    744   1.49       cgd 		tp->t_column += c;
    745   1.49       cgd 		return (notout ? '\t' : -1);
    746   1.49       cgd 	}
    747   1.49       cgd 	if (c == CEOT && ISSET(oflag, ONOEOT))
    748   1.49       cgd 		return (-1);
    749   1.49       cgd 
    750   1.49       cgd 	/*
    751   1.49       cgd 	 * Newline translation: if ONLCR is set,
    752   1.49       cgd 	 * translate newline into "\r\n".
    753   1.49       cgd 	 */
    754   1.49       cgd 	if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
    755   1.49       cgd 		tk_nout++;
    756   1.49       cgd 		tp->t_outcc++;
    757   1.99   mycroft 		if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
    758   1.49       cgd 			return (c);
    759   1.49       cgd 	}
    760  1.103    kleink 	/* If OCRNL is set, translate "\r" into "\n". */
    761   1.79    kleink 	else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
    762   1.79    kleink 		c = '\n';
    763  1.103    kleink 	/* If ONOCR is set, don't transmit CRs when on column 0. */
    764  1.103    kleink 	else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
    765  1.103    kleink 		return (-1);
    766   1.79    kleink 
    767   1.49       cgd 	tk_nout++;
    768   1.49       cgd 	tp->t_outcc++;
    769   1.49       cgd 	if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
    770   1.49       cgd 		return (c);
    771   1.49       cgd 
    772   1.49       cgd 	col = tp->t_column;
    773   1.49       cgd 	switch (CCLASS(c)) {
    774   1.49       cgd 	case BACKSPACE:
    775   1.49       cgd 		if (col > 0)
    776   1.49       cgd 			--col;
    777   1.49       cgd 		break;
    778   1.49       cgd 	case CONTROL:
    779   1.49       cgd 		break;
    780   1.49       cgd 	case NEWLINE:
    781  1.103    kleink 		if (ISSET(tp->t_oflag, ONLCR | ONLRET))
    782   1.79    kleink 			col = 0;
    783   1.79    kleink 		break;
    784   1.49       cgd 	case RETURN:
    785   1.49       cgd 		col = 0;
    786   1.49       cgd 		break;
    787   1.49       cgd 	case ORDINARY:
    788   1.49       cgd 		++col;
    789   1.49       cgd 		break;
    790   1.49       cgd 	case TAB:
    791   1.49       cgd 		col = (col + 8) & ~7;
    792   1.49       cgd 		break;
    793   1.49       cgd 	}
    794   1.49       cgd 	tp->t_column = col;
    795   1.49       cgd 	return (-1);
    796   1.49       cgd }
    797   1.49       cgd 
    798   1.49       cgd /*
    799   1.49       cgd  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
    800   1.49       cgd  * has been called to do discipline-specific functions and/or reject any
    801   1.49       cgd  * of these ioctl commands.
    802   1.49       cgd  */
    803   1.49       cgd /* ARGSUSED */
    804   1.49       cgd int
    805  1.192  christos ttioctl(struct tty *tp, u_long cmd, void *data, int flag, struct lwp *l)
    806   1.49       cgd {
    807   1.49       cgd 	extern struct tty *constty;	/* Temporary virtual console. */
    808  1.188    martin 	struct proc *p = l ? l->l_proc : NULL;
    809  1.126     lukem 	struct linesw	*lp;
    810  1.126     lukem 	int		s, error;
    811  1.151  christos 	struct nameidata nd;
    812   1.49       cgd 
    813   1.49       cgd 	/* If the ioctl involves modification, hang if in the background. */
    814   1.49       cgd 	switch (cmd) {
    815   1.49       cgd 	case  TIOCFLUSH:
    816   1.92    kleink 	case  TIOCDRAIN:
    817   1.95    kleink 	case  TIOCSBRK:
    818   1.95    kleink 	case  TIOCCBRK:
    819   1.95    kleink 	case  TIOCSTART:
    820   1.49       cgd 	case  TIOCSETA:
    821   1.49       cgd 	case  TIOCSETD:
    822  1.121       eeh 	case  TIOCSLINED:
    823   1.49       cgd 	case  TIOCSETAF:
    824   1.49       cgd 	case  TIOCSETAW:
    825   1.49       cgd #ifdef notdef
    826   1.49       cgd 	case  TIOCSPGRP:
    827  1.158  jdolecek 	case  FIOSETOWN:
    828   1.49       cgd #endif
    829   1.49       cgd 	case  TIOCSTAT:
    830   1.49       cgd 	case  TIOCSTI:
    831   1.49       cgd 	case  TIOCSWINSZ:
    832   1.66  christos #ifdef COMPAT_OLDTTY
    833   1.49       cgd 	case  TIOCLBIC:
    834   1.49       cgd 	case  TIOCLBIS:
    835   1.49       cgd 	case  TIOCLSET:
    836   1.49       cgd 	case  TIOCSETC:
    837   1.49       cgd 	case OTIOCSETD:
    838   1.49       cgd 	case  TIOCSETN:
    839   1.49       cgd 	case  TIOCSETP:
    840   1.49       cgd 	case  TIOCSLTC:
    841   1.49       cgd #endif
    842  1.190        ad 		/* XXXSMP */
    843   1.49       cgd 		while (isbackground(curproc, tp) &&
    844  1.190        ad 		    p->p_pgrp->pg_jobc && (p->p_sflag & PS_PPWAIT) == 0 &&
    845  1.190        ad 		    !sigismasked(l, SIGTTOU)) {
    846  1.201        ad 			mutex_spin_enter(&tty_lock);
    847  1.201        ad 			ttysig(tp, TTYSIG_PG1, SIGTTOU);
    848  1.201        ad 			error = ttysleep(tp, &lbolt, true, 0);
    849  1.201        ad 			mutex_spin_exit(&tty_lock);
    850  1.147        pk 			if (error) {
    851   1.49       cgd 				return (error);
    852  1.147        pk 			}
    853   1.49       cgd 		}
    854   1.49       cgd 		break;
    855   1.49       cgd 	}
    856   1.49       cgd 
    857   1.49       cgd 	switch (cmd) {			/* Process the ioctl. */
    858   1.49       cgd 	case FIOASYNC:			/* set/clear async i/o */
    859  1.201        ad 		mutex_spin_enter(&tty_lock);
    860   1.49       cgd 		if (*(int *)data)
    861   1.49       cgd 			SET(tp->t_state, TS_ASYNC);
    862   1.49       cgd 		else
    863   1.49       cgd 			CLR(tp->t_state, TS_ASYNC);
    864  1.201        ad 		mutex_spin_exit(&tty_lock);
    865   1.49       cgd 		break;
    866   1.49       cgd 	case FIONBIO:			/* set/clear non-blocking i/o */
    867   1.49       cgd 		break;			/* XXX: delete. */
    868   1.49       cgd 	case FIONREAD:			/* get # bytes to read */
    869  1.201        ad 		mutex_spin_enter(&tty_lock);
    870   1.49       cgd 		*(int *)data = ttnread(tp);
    871  1.201        ad 		mutex_spin_exit(&tty_lock);
    872   1.49       cgd 		break;
    873  1.170  wrstuden 	case FIONWRITE:			/* get # bytes to written & unsent */
    874  1.201        ad 		mutex_spin_enter(&tty_lock);
    875  1.170  wrstuden 		*(int *)data = tp->t_outq.c_cc;
    876  1.201        ad 		mutex_spin_exit(&tty_lock);
    877  1.170  wrstuden 		break;
    878  1.170  wrstuden 	case FIONSPACE:			/* get # bytes to written & unsent */
    879  1.201        ad 		mutex_spin_enter(&tty_lock);
    880  1.170  wrstuden 		*(int *)data = tp->t_outq.c_cn - tp->t_outq.c_cc;
    881  1.201        ad 		mutex_spin_exit(&tty_lock);
    882  1.170  wrstuden 		break;
    883   1.49       cgd 	case TIOCEXCL:			/* set exclusive use of tty */
    884  1.201        ad 		mutex_spin_enter(&tty_lock);
    885   1.49       cgd 		SET(tp->t_state, TS_XCLUDE);
    886  1.201        ad 		mutex_spin_exit(&tty_lock);
    887   1.49       cgd 		break;
    888   1.49       cgd 	case TIOCFLUSH: {		/* flush buffers */
    889  1.118  augustss 		int flags = *(int *)data;
    890   1.49       cgd 
    891   1.49       cgd 		if (flags == 0)
    892   1.49       cgd 			flags = FREAD | FWRITE;
    893   1.49       cgd 		else
    894   1.49       cgd 			flags &= FREAD | FWRITE;
    895  1.201        ad 		mutex_spin_enter(&tty_lock);
    896   1.49       cgd 		ttyflush(tp, flags);
    897  1.201        ad 		mutex_spin_exit(&tty_lock);
    898   1.49       cgd 		break;
    899   1.49       cgd 	}
    900   1.49       cgd 	case TIOCCONS:			/* become virtual console */
    901   1.49       cgd 		if (*(int *)data) {
    902   1.49       cgd 			if (constty && constty != tp &&
    903   1.49       cgd 			    ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
    904   1.49       cgd 			    (TS_CARR_ON | TS_ISOPEN))
    905  1.151  christos 				return EBUSY;
    906  1.151  christos 
    907  1.151  christos 			NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
    908  1.178  christos 			    "/dev/console", l);
    909  1.151  christos 			if ((error = namei(&nd)) != 0)
    910  1.151  christos 				return error;
    911  1.186        ad 			error = VOP_ACCESS(nd.ni_vp, VREAD, l->l_cred, l);
    912  1.151  christos 			vput(nd.ni_vp);
    913  1.151  christos 			if (error)
    914  1.151  christos 				return error;
    915  1.151  christos 
    916   1.49       cgd 			constty = tp;
    917   1.49       cgd 		} else if (tp == constty)
    918   1.49       cgd 			constty = NULL;
    919   1.49       cgd 		break;
    920   1.49       cgd 	case TIOCDRAIN:			/* wait till output drained */
    921   1.65  christos 		if ((error = ttywait(tp)) != 0)
    922   1.49       cgd 			return (error);
    923   1.49       cgd 		break;
    924   1.49       cgd 	case TIOCGETA: {		/* get termios struct */
    925   1.49       cgd 		struct termios *t = (struct termios *)data;
    926   1.49       cgd 
    927  1.109     perry 		memcpy(t, &tp->t_termios, sizeof(struct termios));
    928   1.49       cgd 		break;
    929   1.49       cgd 	}
    930  1.177   thorpej 	case TIOCGETD:			/* get line discipline (old) */
    931  1.127     enami 		*(int *)data = tp->t_linesw->l_no;
    932  1.121       eeh 		break;
    933  1.177   thorpej 	case TIOCGLINED:		/* get line discipline (new) */
    934  1.138     enami 		(void)strncpy((char *)data, tp->t_linesw->l_name,
    935  1.131  christos 		    TTLINEDNAMELEN - 1);
    936   1.49       cgd 		break;
    937   1.49       cgd 	case TIOCGWINSZ:		/* get window size */
    938   1.49       cgd 		*(struct winsize *)data = tp->t_winsize;
    939   1.49       cgd 		break;
    940  1.158  jdolecek 	case FIOGETOWN:
    941  1.174  christos 		if (tp->t_session != NULL && !isctty(p, tp))
    942  1.158  jdolecek 			return (ENOTTY);
    943  1.158  jdolecek 		*(int *)data = tp->t_pgrp ? -tp->t_pgrp->pg_id : 0;
    944  1.158  jdolecek 		break;
    945   1.49       cgd 	case TIOCGPGRP:			/* get pgrp of tty */
    946   1.49       cgd 		if (!isctty(p, tp))
    947   1.49       cgd 			return (ENOTTY);
    948  1.150       dsl 		*(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
    949  1.104   thorpej 		break;
    950  1.104   thorpej 	case TIOCGSID:			/* get sid of tty */
    951  1.104   thorpej 		if (!isctty(p, tp))
    952  1.104   thorpej 			return (ENOTTY);
    953  1.104   thorpej 		*(int *)data = tp->t_session->s_sid;
    954   1.49       cgd 		break;
    955   1.49       cgd #ifdef TIOCHPCL
    956   1.49       cgd 	case TIOCHPCL:			/* hang up on last close */
    957  1.201        ad 		mutex_spin_enter(&tty_lock);
    958   1.49       cgd 		SET(tp->t_cflag, HUPCL);
    959  1.201        ad 		mutex_spin_exit(&tty_lock);
    960   1.49       cgd 		break;
    961   1.49       cgd #endif
    962   1.49       cgd 	case TIOCNXCL:			/* reset exclusive use of tty */
    963  1.201        ad 		mutex_spin_enter(&tty_lock);
    964   1.49       cgd 		CLR(tp->t_state, TS_XCLUDE);
    965  1.201        ad 		mutex_spin_exit(&tty_lock);
    966   1.49       cgd 		break;
    967   1.49       cgd 	case TIOCOUTQ:			/* output queue size */
    968   1.49       cgd 		*(int *)data = tp->t_outq.c_cc;
    969   1.49       cgd 		break;
    970   1.49       cgd 	case TIOCSETA:			/* set termios struct */
    971   1.49       cgd 	case TIOCSETAW:			/* drain output, set */
    972   1.49       cgd 	case TIOCSETAF: {		/* drn out, fls in, set */
    973  1.118  augustss 		struct termios *t = (struct termios *)data;
    974   1.49       cgd 
    975   1.49       cgd 		if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
    976  1.147        pk 			if ((error = ttywait(tp)) != 0)
    977  1.147        pk 				return (error);
    978  1.147        pk 
    979  1.147        pk 			if (cmd == TIOCSETAF) {
    980  1.201        ad 				mutex_spin_enter(&tty_lock);
    981  1.147        pk 				ttyflush(tp, FREAD);
    982  1.201        ad 				mutex_spin_exit(&tty_lock);
    983   1.49       cgd 			}
    984   1.49       cgd 		}
    985  1.147        pk 
    986  1.147        pk 		s = spltty();
    987  1.148        pk 		/*
    988  1.148        pk 		 * XXXSMP - some drivers call back on us from t_param(), so
    989  1.148        pk 		 *	    don't take the tty spin lock here.
    990  1.148        pk 		 *	    require t_param() to unlock upon callback?
    991  1.148        pk 		 */
    992  1.201        ad 		/* wanted here: mutex_spin_enter(&tty_lock); */
    993   1.49       cgd 		if (!ISSET(t->c_cflag, CIGNORE)) {
    994   1.49       cgd 			/*
    995   1.49       cgd 			 * Set device hardware.
    996   1.49       cgd 			 */
    997   1.49       cgd 			if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
    998  1.201        ad 				/* wanted here: mutex_spin_exit(&tty_lock); */
    999   1.49       cgd 				splx(s);
   1000   1.49       cgd 				return (error);
   1001   1.49       cgd 			} else {
   1002   1.49       cgd 				tp->t_cflag = t->c_cflag;
   1003   1.49       cgd 				tp->t_ispeed = t->c_ispeed;
   1004   1.49       cgd 				tp->t_ospeed = t->c_ospeed;
   1005  1.201        ad 				if (t->c_ospeed == 0)
   1006  1.201        ad 					ttysig(tp, TTYSIG_LEADER, SIGHUP);
   1007   1.49       cgd 			}
   1008   1.49       cgd 			ttsetwater(tp);
   1009   1.49       cgd 		}
   1010  1.148        pk 
   1011  1.201        ad 		/* delayed lock acquiring */
   1012  1.201        ad 		mutex_spin_enter(&tty_lock);
   1013   1.49       cgd 		if (cmd != TIOCSETAF) {
   1014   1.49       cgd 			if (ISSET(t->c_lflag, ICANON) !=
   1015  1.110   thorpej 			    ISSET(tp->t_lflag, ICANON)) {
   1016   1.49       cgd 				if (ISSET(t->c_lflag, ICANON)) {
   1017   1.49       cgd 					SET(tp->t_lflag, PENDIN);
   1018   1.49       cgd 					ttwakeup(tp);
   1019   1.49       cgd 				} else {
   1020   1.49       cgd 					struct clist tq;
   1021   1.49       cgd 
   1022   1.49       cgd 					catq(&tp->t_rawq, &tp->t_canq);
   1023   1.49       cgd 					tq = tp->t_rawq;
   1024   1.49       cgd 					tp->t_rawq = tp->t_canq;
   1025   1.49       cgd 					tp->t_canq = tq;
   1026   1.49       cgd 					CLR(tp->t_lflag, PENDIN);
   1027   1.49       cgd 				}
   1028  1.110   thorpej 			}
   1029   1.49       cgd 		}
   1030   1.49       cgd 		tp->t_iflag = t->c_iflag;
   1031   1.49       cgd 		tp->t_oflag = t->c_oflag;
   1032   1.49       cgd 		/*
   1033   1.49       cgd 		 * Make the EXTPROC bit read only.
   1034   1.49       cgd 		 */
   1035   1.49       cgd 		if (ISSET(tp->t_lflag, EXTPROC))
   1036   1.49       cgd 			SET(t->c_lflag, EXTPROC);
   1037   1.49       cgd 		else
   1038   1.49       cgd 			CLR(t->c_lflag, EXTPROC);
   1039   1.49       cgd 		tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
   1040  1.109     perry 		memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc));
   1041  1.201        ad 		mutex_spin_exit(&tty_lock);
   1042   1.49       cgd 		splx(s);
   1043   1.49       cgd 		break;
   1044   1.49       cgd 	}
   1045  1.177   thorpej 	case TIOCSETD:			/* set line discipline (old) */
   1046  1.177   thorpej 		lp = ttyldisc_lookup_bynum(*(int *)data);
   1047  1.177   thorpej 		goto setldisc;
   1048   1.49       cgd 
   1049  1.177   thorpej 	case TIOCSLINED: {		/* set line discipline (new) */
   1050  1.121       eeh 		char *name = (char *)data;
   1051  1.124     enami 		dev_t device;
   1052  1.121       eeh 
   1053  1.121       eeh 		/* Null terminate to prevent buffer overflow */
   1054  1.138     enami 		name[TTLINEDNAMELEN - 1] = '\0';
   1055  1.121       eeh 		lp = ttyldisc_lookup(name);
   1056  1.126     lukem  setldisc:
   1057  1.124     enami 		if (lp == NULL)
   1058  1.121       eeh 			return (ENXIO);
   1059  1.121       eeh 
   1060  1.121       eeh 		if (lp != tp->t_linesw) {
   1061  1.124     enami 			device = tp->t_dev;
   1062   1.49       cgd 			s = spltty();
   1063  1.124     enami 			(*tp->t_linesw->l_close)(tp, flag);
   1064  1.121       eeh 			error = (*lp->l_open)(device, tp);
   1065   1.49       cgd 			if (error) {
   1066  1.121       eeh 				(void)(*tp->t_linesw->l_open)(device, tp);
   1067   1.49       cgd 				splx(s);
   1068  1.177   thorpej 				ttyldisc_release(lp);
   1069   1.49       cgd 				return (error);
   1070   1.49       cgd 			}
   1071  1.177   thorpej 			ttyldisc_release(tp->t_linesw);
   1072  1.121       eeh 			tp->t_linesw = lp;
   1073   1.49       cgd 			splx(s);
   1074  1.177   thorpej 		} else {
   1075  1.177   thorpej 			/* Drop extra reference. */
   1076  1.177   thorpej 			ttyldisc_release(lp);
   1077   1.49       cgd 		}
   1078   1.49       cgd 		break;
   1079   1.49       cgd 	}
   1080   1.49       cgd 	case TIOCSTART:			/* start output, like ^Q */
   1081  1.201        ad 		mutex_spin_enter(&tty_lock);
   1082   1.49       cgd 		if (ISSET(tp->t_state, TS_TTSTOP) ||
   1083   1.49       cgd 		    ISSET(tp->t_lflag, FLUSHO)) {
   1084   1.49       cgd 			CLR(tp->t_lflag, FLUSHO);
   1085   1.49       cgd 			CLR(tp->t_state, TS_TTSTOP);
   1086   1.49       cgd 			ttstart(tp);
   1087   1.49       cgd 		}
   1088  1.201        ad 		mutex_spin_exit(&tty_lock);
   1089   1.49       cgd 		break;
   1090   1.49       cgd 	case TIOCSTI:			/* simulate terminal input */
   1091  1.189      elad 		if (kauth_authorize_generic(l->l_cred, KAUTH_GENERIC_ISSUSER,
   1092  1.189      elad 		    NULL) != 0) {
   1093  1.189      elad 			if (!ISSET(flag, FREAD))
   1094  1.189      elad 				return (EPERM);
   1095  1.189      elad 			if (!isctty(p, tp))
   1096  1.189      elad 				return (EACCES);
   1097  1.189      elad 		}
   1098  1.121       eeh 		(*tp->t_linesw->l_rint)(*(u_char *)data, tp);
   1099   1.49       cgd 		break;
   1100   1.49       cgd 	case TIOCSTOP:			/* stop output, like ^S */
   1101  1.142   gehenna 	{
   1102  1.201        ad 		mutex_spin_enter(&tty_lock);
   1103   1.49       cgd 		if (!ISSET(tp->t_state, TS_TTSTOP)) {
   1104   1.49       cgd 			SET(tp->t_state, TS_TTSTOP);
   1105  1.201        ad 			cdev_stop(tp, 0);
   1106   1.49       cgd 		}
   1107  1.201        ad 		mutex_spin_exit(&tty_lock);
   1108   1.49       cgd 		break;
   1109  1.142   gehenna 	}
   1110   1.49       cgd 	case TIOCSCTTY:			/* become controlling tty */
   1111  1.193        ad 		mutex_enter(&proclist_lock);
   1112  1.190        ad 
   1113   1.49       cgd 		/* Session ctty vnode pointer set in vnode layer. */
   1114   1.49       cgd 		if (!SESS_LEADER(p) ||
   1115   1.65  christos 		    ((p->p_session->s_ttyvp || tp->t_session) &&
   1116  1.190        ad 		    (tp->t_session != p->p_session))) {
   1117  1.193        ad 			mutex_exit(&proclist_lock);
   1118   1.49       cgd 			return (EPERM);
   1119  1.190        ad 		}
   1120  1.139  jdolecek 
   1121  1.160        pk 		/*
   1122  1.160        pk 		 * `p_session' acquires a reference.
   1123  1.160        pk 		 * But note that if `t_session' is set at this point,
   1124  1.160        pk 		 * it must equal `p_session', in which case the session
   1125  1.160        pk 		 * already has the correct reference count.
   1126  1.160        pk 		 */
   1127  1.160        pk 		if (tp->t_session == NULL)
   1128  1.160        pk 			SESSHOLD(p->p_session);
   1129  1.139  jdolecek 
   1130   1.49       cgd 		tp->t_session = p->p_session;
   1131   1.49       cgd 		tp->t_pgrp = p->p_pgrp;
   1132   1.49       cgd 		p->p_session->s_ttyp = tp;
   1133  1.190        ad 		p->p_lflag |= PL_CONTROLT;
   1134  1.193        ad 		mutex_exit(&proclist_lock);
   1135   1.49       cgd 		break;
   1136  1.158  jdolecek 	case FIOSETOWN: {		/* set pgrp of tty */
   1137  1.158  jdolecek 		pid_t pgid = *(int *)data;
   1138  1.158  jdolecek 		struct pgrp *pgrp;
   1139  1.158  jdolecek 
   1140  1.174  christos 		if (tp->t_session != NULL && !isctty(p, tp))
   1141  1.158  jdolecek 			return (ENOTTY);
   1142  1.158  jdolecek 
   1143  1.193        ad 		mutex_enter(&proclist_lock);
   1144  1.191       dsl 
   1145  1.191       dsl 		if (pgid < 0) {
   1146  1.191       dsl 			pgrp = pg_find(-pgid, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
   1147  1.191       dsl 			if (pgrp == NULL)
   1148  1.191       dsl 				return (EINVAL);
   1149  1.191       dsl 		} else {
   1150  1.191       dsl 			struct proc *p1;
   1151  1.191       dsl 			p1 = p_find(pgid, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
   1152  1.158  jdolecek 			if (!p1)
   1153  1.158  jdolecek 				return (ESRCH);
   1154  1.158  jdolecek 			pgrp = p1->p_pgrp;
   1155  1.158  jdolecek 		}
   1156  1.158  jdolecek 
   1157  1.191       dsl 		if (pgrp->pg_session != p->p_session) {
   1158  1.193        ad 			mutex_exit(&proclist_lock);
   1159  1.158  jdolecek 			return (EPERM);
   1160  1.191       dsl 		}
   1161  1.158  jdolecek 		tp->t_pgrp = pgrp;
   1162  1.193        ad 		mutex_exit(&proclist_lock);
   1163  1.158  jdolecek 		break;
   1164  1.158  jdolecek 	}
   1165   1.49       cgd 	case TIOCSPGRP: {		/* set pgrp of tty */
   1166  1.191       dsl 		struct pgrp *pgrp;
   1167   1.49       cgd 
   1168   1.49       cgd 		if (!isctty(p, tp))
   1169   1.49       cgd 			return (ENOTTY);
   1170  1.193        ad 		mutex_enter(&proclist_lock);
   1171  1.191       dsl 		pgrp = pg_find(*(int *)data, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
   1172  1.191       dsl 		if (pgrp == NULL)
   1173   1.93    kleink 			return (EINVAL);
   1174  1.191       dsl 		if (pgrp->pg_session != p->p_session) {
   1175  1.193        ad 			mutex_exit(&proclist_lock);
   1176   1.49       cgd 			return (EPERM);
   1177  1.191       dsl 		}
   1178   1.49       cgd 		tp->t_pgrp = pgrp;
   1179  1.193        ad 		mutex_exit(&proclist_lock);
   1180   1.49       cgd 		break;
   1181   1.49       cgd 	}
   1182   1.49       cgd 	case TIOCSTAT:			/* get load avg stats */
   1183  1.201        ad 		mutex_spin_enter(&tty_lock);
   1184  1.183  christos 		ttyinfo(tp, 0);
   1185  1.201        ad 		mutex_spin_exit(&tty_lock);
   1186   1.49       cgd 		break;
   1187   1.49       cgd 	case TIOCSWINSZ:		/* set window size */
   1188  1.201        ad 		mutex_spin_enter(&tty_lock);
   1189  1.192  christos 		if (memcmp((void *)&tp->t_winsize, data,
   1190  1.108     perry 		    sizeof(struct winsize))) {
   1191   1.49       cgd 			tp->t_winsize = *(struct winsize *)data;
   1192  1.201        ad 			ttysig(tp, TTYSIG_PG1, SIGWINCH);
   1193   1.49       cgd 		}
   1194  1.201        ad 		mutex_spin_exit(&tty_lock);
   1195   1.49       cgd 		break;
   1196   1.49       cgd 	default:
   1197   1.66  christos #ifdef COMPAT_OLDTTY
   1198  1.178  christos 		return (ttcompat(tp, cmd, data, flag, l));
   1199   1.49       cgd #else
   1200  1.134    atatat 		return (EPASSTHROUGH);
   1201   1.49       cgd #endif
   1202   1.49       cgd 	}
   1203   1.49       cgd 	return (0);
   1204   1.49       cgd }
   1205   1.49       cgd 
   1206   1.49       cgd int
   1207  1.178  christos ttpoll(struct tty *tp, int events, struct lwp *l)
   1208  1.126     lukem {
   1209  1.201        ad 	int	revents;
   1210   1.74   mycroft 
   1211  1.126     lukem 	revents = 0;
   1212  1.201        ad 	mutex_spin_enter(&tty_lock);
   1213   1.74   mycroft 	if (events & (POLLIN | POLLRDNORM))
   1214   1.74   mycroft 		if (ttnread(tp) > 0)
   1215   1.74   mycroft 			revents |= events & (POLLIN | POLLRDNORM);
   1216   1.74   mycroft 
   1217   1.74   mycroft 	if (events & (POLLOUT | POLLWRNORM))
   1218   1.74   mycroft 		if (tp->t_outq.c_cc <= tp->t_lowat)
   1219   1.74   mycroft 			revents |= events & (POLLOUT | POLLWRNORM);
   1220   1.74   mycroft 
   1221   1.74   mycroft 	if (events & POLLHUP)
   1222   1.83   mycroft 		if (!CONNECTED(tp))
   1223   1.74   mycroft 			revents |= POLLHUP;
   1224   1.74   mycroft 
   1225   1.74   mycroft 	if (revents == 0) {
   1226   1.74   mycroft 		if (events & (POLLIN | POLLHUP | POLLRDNORM))
   1227  1.178  christos 			selrecord(l, &tp->t_rsel);
   1228   1.49       cgd 
   1229   1.74   mycroft 		if (events & (POLLOUT | POLLWRNORM))
   1230  1.178  christos 			selrecord(l, &tp->t_wsel);
   1231   1.74   mycroft 	}
   1232   1.49       cgd 
   1233  1.201        ad 	mutex_spin_exit(&tty_lock);
   1234  1.201        ad 
   1235   1.74   mycroft 	return (revents);
   1236   1.49       cgd }
   1237   1.49       cgd 
   1238  1.143  jdolecek static void
   1239  1.143  jdolecek filt_ttyrdetach(struct knote *kn)
   1240  1.143  jdolecek {
   1241  1.143  jdolecek 	struct tty	*tp;
   1242  1.143  jdolecek 
   1243  1.143  jdolecek 	tp = kn->kn_hook;
   1244  1.201        ad 	mutex_spin_enter(&tty_lock);
   1245  1.144  christos 	SLIST_REMOVE(&tp->t_rsel.sel_klist, kn, knote, kn_selnext);
   1246  1.201        ad 	mutex_spin_exit(&tty_lock);
   1247  1.143  jdolecek }
   1248  1.143  jdolecek 
   1249  1.143  jdolecek static int
   1250  1.143  jdolecek filt_ttyread(struct knote *kn, long hint)
   1251  1.143  jdolecek {
   1252  1.143  jdolecek 	struct tty	*tp;
   1253  1.143  jdolecek 
   1254  1.143  jdolecek 	tp = kn->kn_hook;
   1255  1.162  jdolecek 	if ((hint & NOTE_SUBMIT) == 0)
   1256  1.201        ad 		mutex_spin_enter(&tty_lock);
   1257  1.143  jdolecek 	kn->kn_data = ttnread(tp);
   1258  1.162  jdolecek 	if ((hint & NOTE_SUBMIT) == 0)
   1259  1.201        ad 		mutex_spin_exit(&tty_lock);
   1260  1.143  jdolecek 	return (kn->kn_data > 0);
   1261  1.143  jdolecek }
   1262  1.143  jdolecek 
   1263  1.143  jdolecek static void
   1264  1.143  jdolecek filt_ttywdetach(struct knote *kn)
   1265  1.143  jdolecek {
   1266  1.143  jdolecek 	struct tty	*tp;
   1267  1.143  jdolecek 
   1268  1.143  jdolecek 	tp = kn->kn_hook;
   1269  1.201        ad 	mutex_spin_enter(&tty_lock);
   1270  1.144  christos 	SLIST_REMOVE(&tp->t_wsel.sel_klist, kn, knote, kn_selnext);
   1271  1.201        ad 	mutex_spin_exit(&tty_lock);
   1272  1.143  jdolecek }
   1273  1.143  jdolecek 
   1274  1.143  jdolecek static int
   1275  1.143  jdolecek filt_ttywrite(struct knote *kn, long hint)
   1276  1.143  jdolecek {
   1277  1.143  jdolecek 	struct tty	*tp;
   1278  1.201        ad 	int		canwrite;
   1279  1.143  jdolecek 
   1280  1.143  jdolecek 	tp = kn->kn_hook;
   1281  1.162  jdolecek 	if ((hint & NOTE_SUBMIT) == 0)
   1282  1.201        ad 		mutex_spin_enter(&tty_lock);
   1283  1.143  jdolecek 	kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc;
   1284  1.147        pk 	canwrite = (tp->t_outq.c_cc <= tp->t_lowat) && CONNECTED(tp);
   1285  1.162  jdolecek 	if ((hint & NOTE_SUBMIT) == 0)
   1286  1.201        ad 		mutex_spin_exit(&tty_lock);
   1287  1.147        pk 	return (canwrite);
   1288  1.143  jdolecek }
   1289  1.143  jdolecek 
   1290  1.143  jdolecek static const struct filterops ttyread_filtops =
   1291  1.143  jdolecek 	{ 1, NULL, filt_ttyrdetach, filt_ttyread };
   1292  1.143  jdolecek static const struct filterops ttywrite_filtops =
   1293  1.143  jdolecek 	{ 1, NULL, filt_ttywdetach, filt_ttywrite };
   1294  1.143  jdolecek 
   1295  1.143  jdolecek int
   1296  1.143  jdolecek ttykqfilter(dev_t dev, struct knote *kn)
   1297  1.143  jdolecek {
   1298  1.143  jdolecek 	struct tty	*tp;
   1299  1.143  jdolecek 	struct klist	*klist;
   1300  1.143  jdolecek 
   1301  1.201        ad 	if ((tp = cdev_tty(dev)) == NULL)
   1302  1.143  jdolecek 		return (ENXIO);
   1303  1.157      manu 
   1304  1.143  jdolecek 	switch (kn->kn_filter) {
   1305  1.143  jdolecek 	case EVFILT_READ:
   1306  1.144  christos 		klist = &tp->t_rsel.sel_klist;
   1307  1.143  jdolecek 		kn->kn_fop = &ttyread_filtops;
   1308  1.143  jdolecek 		break;
   1309  1.143  jdolecek 	case EVFILT_WRITE:
   1310  1.144  christos 		klist = &tp->t_wsel.sel_klist;
   1311  1.143  jdolecek 		kn->kn_fop = &ttywrite_filtops;
   1312  1.143  jdolecek 		break;
   1313  1.143  jdolecek 	default:
   1314  1.176  christos 		return EINVAL;
   1315  1.143  jdolecek 	}
   1316  1.143  jdolecek 
   1317  1.143  jdolecek 	kn->kn_hook = tp;
   1318  1.143  jdolecek 
   1319  1.201        ad 	mutex_spin_enter(&tty_lock);
   1320  1.143  jdolecek 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
   1321  1.201        ad 	mutex_spin_exit(&tty_lock);
   1322  1.143  jdolecek 
   1323  1.143  jdolecek 	return (0);
   1324  1.143  jdolecek }
   1325  1.143  jdolecek 
   1326  1.147        pk /*
   1327  1.147        pk  * Find the number of chars ready to be read from this tty.
   1328  1.201        ad  * Call with the tty lock held.
   1329  1.147        pk  */
   1330   1.49       cgd static int
   1331  1.126     lukem ttnread(struct tty *tp)
   1332   1.49       cgd {
   1333  1.126     lukem 	int	nread;
   1334   1.49       cgd 
   1335  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   1336  1.201        ad 
   1337   1.49       cgd 	if (ISSET(tp->t_lflag, PENDIN))
   1338   1.49       cgd 		ttypend(tp);
   1339   1.49       cgd 	nread = tp->t_canq.c_cc;
   1340   1.49       cgd 	if (!ISSET(tp->t_lflag, ICANON)) {
   1341   1.49       cgd 		nread += tp->t_rawq.c_cc;
   1342   1.49       cgd 		if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
   1343   1.49       cgd 			nread = 0;
   1344   1.49       cgd 	}
   1345   1.49       cgd 	return (nread);
   1346   1.49       cgd }
   1347   1.49       cgd 
   1348   1.49       cgd /*
   1349   1.49       cgd  * Wait for output to drain.
   1350   1.49       cgd  */
   1351   1.49       cgd int
   1352  1.138     enami ttywait(struct tty *tp)
   1353   1.49       cgd {
   1354  1.201        ad 	int	error;
   1355   1.49       cgd 
   1356   1.49       cgd 	error = 0;
   1357  1.201        ad 
   1358  1.201        ad 	mutex_spin_enter(&tty_lock);
   1359   1.49       cgd 	while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
   1360   1.83   mycroft 	    CONNECTED(tp) && tp->t_oproc) {
   1361   1.49       cgd 		(*tp->t_oproc)(tp);
   1362  1.201        ad 		error = ttysleep(tp, &tp->t_outq.c_cv, true, 0);
   1363   1.65  christos 		if (error)
   1364   1.49       cgd 			break;
   1365   1.49       cgd 	}
   1366  1.201        ad 	mutex_spin_exit(&tty_lock);
   1367  1.201        ad 
   1368   1.49       cgd 	return (error);
   1369   1.49       cgd }
   1370   1.49       cgd 
   1371   1.49       cgd /*
   1372   1.49       cgd  * Flush if successfully wait.
   1373   1.49       cgd  */
   1374   1.49       cgd int
   1375  1.126     lukem ttywflush(struct tty *tp)
   1376   1.49       cgd {
   1377  1.126     lukem 	int	error;
   1378   1.49       cgd 
   1379  1.147        pk 	if ((error = ttywait(tp)) == 0) {
   1380  1.201        ad 		mutex_spin_enter(&tty_lock);
   1381   1.49       cgd 		ttyflush(tp, FREAD);
   1382  1.201        ad 		mutex_spin_exit(&tty_lock);
   1383  1.147        pk 	}
   1384   1.49       cgd 	return (error);
   1385   1.49       cgd }
   1386   1.49       cgd 
   1387   1.49       cgd /*
   1388   1.49       cgd  * Flush tty read and/or write queues, notifying anyone waiting.
   1389  1.201        ad  * Call with the tty lock held.
   1390   1.49       cgd  */
   1391   1.49       cgd void
   1392  1.126     lukem ttyflush(struct tty *tp, int rw)
   1393   1.49       cgd {
   1394  1.201        ad 
   1395  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   1396   1.49       cgd 
   1397   1.49       cgd 	if (rw & FREAD) {
   1398   1.49       cgd 		FLUSHQ(&tp->t_canq);
   1399   1.49       cgd 		FLUSHQ(&tp->t_rawq);
   1400   1.49       cgd 		tp->t_rocount = 0;
   1401   1.49       cgd 		tp->t_rocol = 0;
   1402   1.49       cgd 		CLR(tp->t_state, TS_LOCAL);
   1403   1.49       cgd 		ttwakeup(tp);
   1404   1.49       cgd 	}
   1405   1.49       cgd 	if (rw & FWRITE) {
   1406   1.49       cgd 		CLR(tp->t_state, TS_TTSTOP);
   1407  1.201        ad 		cdev_stop(tp, rw);
   1408   1.49       cgd 		FLUSHQ(&tp->t_outq);
   1409  1.203        ad 		clwakeup(&tp->t_outq);
   1410  1.162  jdolecek 		selnotify(&tp->t_wsel, NOTE_SUBMIT);
   1411   1.49       cgd 	}
   1412   1.49       cgd }
   1413   1.49       cgd 
   1414   1.49       cgd /*
   1415   1.49       cgd  * Copy in the default termios characters.
   1416   1.49       cgd  */
   1417   1.49       cgd void
   1418  1.126     lukem ttychars(struct tty *tp)
   1419   1.49       cgd {
   1420   1.49       cgd 
   1421  1.109     perry 	memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars));
   1422   1.49       cgd }
   1423   1.49       cgd 
   1424   1.49       cgd /*
   1425   1.49       cgd  * Send stop character on input overflow.
   1426  1.203        ad  * Call with the tty lock held.
   1427   1.49       cgd  */
   1428   1.49       cgd static void
   1429  1.126     lukem ttyblock(struct tty *tp)
   1430   1.49       cgd {
   1431  1.126     lukem 	int	total;
   1432   1.49       cgd 
   1433  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   1434  1.201        ad 
   1435   1.49       cgd 	total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
   1436   1.49       cgd 	if (tp->t_rawq.c_cc > TTYHOG) {
   1437   1.49       cgd 		ttyflush(tp, FREAD | FWRITE);
   1438   1.49       cgd 		CLR(tp->t_state, TS_TBLOCK);
   1439   1.49       cgd 	}
   1440   1.49       cgd 	/*
   1441   1.49       cgd 	 * Block further input iff: current input > threshold
   1442   1.49       cgd 	 * AND input is available to user program.
   1443   1.49       cgd 	 */
   1444  1.101  drochner 	if (total >= TTYHOG / 2 &&
   1445  1.101  drochner 	    !ISSET(tp->t_state, TS_TBLOCK) &&
   1446  1.101  drochner 	    (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) {
   1447   1.60   mycroft 		if (ISSET(tp->t_iflag, IXOFF) &&
   1448   1.60   mycroft 		    tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
   1449   1.60   mycroft 		    putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
   1450   1.49       cgd 			SET(tp->t_state, TS_TBLOCK);
   1451   1.49       cgd 			ttstart(tp);
   1452   1.49       cgd 		}
   1453   1.59   mycroft 		/* Try to block remote output via hardware flow control. */
   1454   1.49       cgd 		if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
   1455   1.49       cgd 		    (*tp->t_hwiflow)(tp, 1) != 0)
   1456   1.49       cgd 			SET(tp->t_state, TS_TBLOCK);
   1457   1.49       cgd 	}
   1458   1.49       cgd }
   1459   1.49       cgd 
   1460  1.147        pk /*
   1461  1.147        pk  * Delayed line discipline output
   1462  1.147        pk  */
   1463   1.49       cgd void
   1464  1.126     lukem ttrstrt(void *tp_arg)
   1465   1.49       cgd {
   1466  1.126     lukem 	struct tty	*tp;
   1467   1.49       cgd 
   1468   1.49       cgd #ifdef DIAGNOSTIC
   1469   1.49       cgd 	if (tp_arg == NULL)
   1470   1.49       cgd 		panic("ttrstrt");
   1471   1.49       cgd #endif
   1472   1.49       cgd 	tp = tp_arg;
   1473  1.201        ad 	mutex_spin_enter(&tty_lock);
   1474   1.49       cgd 
   1475   1.49       cgd 	CLR(tp->t_state, TS_TIMEOUT);
   1476  1.147        pk 	ttstart(tp); /* XXX - Shouldn't this be tp->l_start(tp)? */
   1477   1.49       cgd 
   1478  1.201        ad 	mutex_spin_exit(&tty_lock);
   1479   1.49       cgd }
   1480   1.49       cgd 
   1481  1.147        pk /*
   1482  1.147        pk  * start a line discipline
   1483  1.201        ad  * Always call with tty lock held?
   1484  1.147        pk  */
   1485   1.49       cgd int
   1486  1.126     lukem ttstart(struct tty *tp)
   1487   1.49       cgd {
   1488   1.49       cgd 
   1489   1.49       cgd 	if (tp->t_oproc != NULL)	/* XXX: Kludge for pty. */
   1490   1.49       cgd 		(*tp->t_oproc)(tp);
   1491   1.49       cgd 	return (0);
   1492   1.49       cgd }
   1493   1.49       cgd 
   1494   1.49       cgd /*
   1495   1.49       cgd  * "close" a line discipline
   1496   1.49       cgd  */
   1497   1.49       cgd int
   1498  1.126     lukem ttylclose(struct tty *tp, int flag)
   1499   1.49       cgd {
   1500   1.49       cgd 
   1501  1.147        pk 	if (flag & FNONBLOCK) {
   1502  1.201        ad 		mutex_spin_enter(&tty_lock);
   1503   1.49       cgd 		ttyflush(tp, FREAD | FWRITE);
   1504  1.201        ad 		mutex_spin_exit(&tty_lock);
   1505  1.147        pk 	} else
   1506   1.49       cgd 		ttywflush(tp);
   1507   1.49       cgd 	return (0);
   1508   1.49       cgd }
   1509   1.49       cgd 
   1510   1.49       cgd /*
   1511   1.49       cgd  * Handle modem control transition on a tty.
   1512   1.49       cgd  * Flag indicates new state of carrier.
   1513   1.49       cgd  * Returns 0 if the line should be turned off, otherwise 1.
   1514   1.49       cgd  */
   1515   1.49       cgd int
   1516  1.126     lukem ttymodem(struct tty *tp, int flag)
   1517   1.49       cgd {
   1518   1.49       cgd 
   1519  1.201        ad 	mutex_spin_enter(&tty_lock);
   1520   1.83   mycroft 	if (flag == 0) {
   1521   1.96    kleink 		if (ISSET(tp->t_state, TS_CARR_ON)) {
   1522   1.96    kleink 			/*
   1523   1.96    kleink 			 * Lost carrier.
   1524   1.96    kleink 			 */
   1525   1.96    kleink 			CLR(tp->t_state, TS_CARR_ON);
   1526   1.96    kleink 			if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) {
   1527  1.201        ad 				ttysig(tp, TTYSIG_LEADER, SIGHUP);
   1528   1.96    kleink 				ttyflush(tp, FREAD | FWRITE);
   1529  1.201        ad 				mutex_spin_exit(&tty_lock);
   1530   1.96    kleink 				return (0);
   1531   1.96    kleink 			}
   1532   1.49       cgd 		}
   1533   1.49       cgd 	} else {
   1534   1.96    kleink 		if (!ISSET(tp->t_state, TS_CARR_ON)) {
   1535   1.96    kleink 			/*
   1536   1.96    kleink 			 * Carrier now on.
   1537   1.96    kleink 			 */
   1538   1.96    kleink 			SET(tp->t_state, TS_CARR_ON);
   1539   1.96    kleink 			ttwakeup(tp);
   1540   1.96    kleink 		}
   1541   1.49       cgd 	}
   1542  1.201        ad 	mutex_spin_exit(&tty_lock);
   1543  1.201        ad 
   1544   1.49       cgd 	return (1);
   1545   1.49       cgd }
   1546   1.49       cgd 
   1547   1.49       cgd /*
   1548   1.49       cgd  * Default modem control routine (for other line disciplines).
   1549   1.49       cgd  * Return argument flag, to turn off device on carrier drop.
   1550   1.49       cgd  */
   1551   1.49       cgd int
   1552  1.126     lukem nullmodem(struct tty *tp, int flag)
   1553   1.49       cgd {
   1554   1.49       cgd 
   1555  1.201        ad 	mutex_spin_enter(&tty_lock);
   1556   1.49       cgd 	if (flag)
   1557   1.49       cgd 		SET(tp->t_state, TS_CARR_ON);
   1558   1.49       cgd 	else {
   1559   1.49       cgd 		CLR(tp->t_state, TS_CARR_ON);
   1560   1.83   mycroft 		if (!CONNECTED(tp)) {
   1561  1.201        ad 			ttysig(tp, TTYSIG_LEADER, SIGHUP);
   1562  1.201        ad 			mutex_spin_exit(&tty_lock);
   1563   1.49       cgd 			return (0);
   1564   1.49       cgd 		}
   1565   1.49       cgd 	}
   1566  1.201        ad 	mutex_spin_exit(&tty_lock);
   1567  1.201        ad 
   1568   1.49       cgd 	return (1);
   1569   1.49       cgd }
   1570   1.49       cgd 
   1571   1.49       cgd /*
   1572  1.147        pk  * Reinput pending characters after state switch.
   1573   1.49       cgd  */
   1574   1.49       cgd void
   1575  1.126     lukem ttypend(struct tty *tp)
   1576   1.49       cgd {
   1577  1.126     lukem 	struct clist	tq;
   1578  1.126     lukem 	int		c;
   1579   1.49       cgd 
   1580  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   1581  1.201        ad 
   1582   1.49       cgd 	CLR(tp->t_lflag, PENDIN);
   1583   1.49       cgd 	SET(tp->t_state, TS_TYPEN);
   1584   1.49       cgd 	tq = tp->t_rawq;
   1585   1.49       cgd 	tp->t_rawq.c_cc = 0;
   1586   1.49       cgd 	tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
   1587   1.49       cgd 	while ((c = getc(&tq)) >= 0)
   1588  1.147        pk 		ttyinput_wlock(c, tp);
   1589   1.49       cgd 	CLR(tp->t_state, TS_TYPEN);
   1590   1.49       cgd }
   1591   1.49       cgd 
   1592   1.49       cgd /*
   1593   1.49       cgd  * Process a read call on a tty device.
   1594   1.49       cgd  */
   1595   1.49       cgd int
   1596  1.126     lukem ttread(struct tty *tp, struct uio *uio, int flag)
   1597   1.49       cgd {
   1598  1.126     lukem 	struct clist	*qp;
   1599  1.126     lukem 	u_char		*cc;
   1600  1.126     lukem 	struct proc	*p;
   1601  1.201        ad 	int		c, first, error, has_stime, last_cc;
   1602  1.126     lukem 	long		lflag, slp;
   1603  1.185    kardel 	struct timeval	now, stime;
   1604   1.49       cgd 
   1605  1.181       mrg 	stime.tv_usec = 0;	/* XXX gcc */
   1606  1.181       mrg 	stime.tv_sec = 0;	/* XXX gcc */
   1607  1.181       mrg 
   1608  1.126     lukem 	cc = tp->t_cc;
   1609  1.126     lukem 	p = curproc;
   1610  1.126     lukem 	error = 0;
   1611  1.126     lukem 	has_stime = 0;
   1612  1.126     lukem 	last_cc = 0;
   1613  1.126     lukem 	slp = 0;
   1614  1.126     lukem 
   1615  1.126     lukem  loop:
   1616  1.201        ad 	mutex_spin_enter(&tty_lock);
   1617  1.126     lukem 	lflag = tp->t_lflag;
   1618   1.49       cgd 	/*
   1619   1.49       cgd 	 * take pending input first
   1620   1.49       cgd 	 */
   1621   1.49       cgd 	if (ISSET(lflag, PENDIN))
   1622   1.49       cgd 		ttypend(tp);
   1623   1.49       cgd 
   1624   1.49       cgd 	/*
   1625  1.190        ad 	 * Hang process if it's in the background. XXXSMP
   1626   1.49       cgd 	 */
   1627   1.49       cgd 	if (isbackground(p, tp)) {
   1628  1.125  jdolecek 		if (sigismember(&p->p_sigctx.ps_sigignore, SIGTTIN) ||
   1629  1.190        ad 		    sigismember(&curlwp->l_sigmask, SIGTTIN) ||
   1630  1.190        ad 		    p->p_sflag & PS_PPWAIT || p->p_pgrp->pg_jobc == 0) {
   1631  1.201        ad 			mutex_spin_exit(&tty_lock);
   1632   1.49       cgd 			return (EIO);
   1633  1.147        pk 		}
   1634  1.201        ad 		ttysig(tp, TTYSIG_PG1, SIGTTIN);
   1635  1.201        ad 		error = ttysleep(tp, &lbolt, true, 0);
   1636  1.201        ad 		mutex_spin_exit(&tty_lock);
   1637   1.65  christos 		if (error)
   1638   1.49       cgd 			return (error);
   1639   1.49       cgd 		goto loop;
   1640   1.49       cgd 	}
   1641   1.49       cgd 
   1642   1.49       cgd 	if (!ISSET(lflag, ICANON)) {
   1643   1.49       cgd 		int m = cc[VMIN];
   1644   1.49       cgd 		long t = cc[VTIME];
   1645   1.49       cgd 
   1646   1.49       cgd 		qp = &tp->t_rawq;
   1647   1.49       cgd 		/*
   1648   1.49       cgd 		 * Check each of the four combinations.
   1649   1.49       cgd 		 * (m > 0 && t == 0) is the normal read case.
   1650   1.49       cgd 		 * It should be fairly efficient, so we check that and its
   1651   1.49       cgd 		 * companion case (m == 0 && t == 0) first.
   1652   1.49       cgd 		 * For the other two cases, we compute the target sleep time
   1653   1.49       cgd 		 * into slp.
   1654   1.49       cgd 		 */
   1655   1.49       cgd 		if (t == 0) {
   1656   1.49       cgd 			if (qp->c_cc < m)
   1657   1.49       cgd 				goto sleep;
   1658   1.49       cgd 			goto read;
   1659   1.49       cgd 		}
   1660  1.156       dsl 		t *= hz;		/* time in deca-ticks */
   1661  1.156       dsl /*
   1662  1.156       dsl  * Time difference in deca-ticks, split division to avoid numeric overflow.
   1663  1.156       dsl  * Ok for hz < ~200kHz
   1664  1.156       dsl  */
   1665  1.156       dsl #define	diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 10 * hz + \
   1666  1.156       dsl 			 ((t1).tv_usec - (t2).tv_usec) / 100 * hz / 1000)
   1667   1.49       cgd 		if (m > 0) {
   1668   1.49       cgd 			if (qp->c_cc <= 0)
   1669   1.49       cgd 				goto sleep;
   1670   1.49       cgd 			if (qp->c_cc >= m)
   1671   1.49       cgd 				goto read;
   1672   1.49       cgd 			if (!has_stime) {
   1673   1.49       cgd 				/* first character, start timer */
   1674   1.49       cgd 				has_stime = 1;
   1675  1.185    kardel 				getmicrotime(&stime);
   1676   1.49       cgd 				slp = t;
   1677   1.49       cgd 			} else if (qp->c_cc > last_cc) {
   1678   1.49       cgd 				/* got a character, restart timer */
   1679  1.185    kardel 				getmicrotime(&stime);
   1680   1.49       cgd 				slp = t;
   1681   1.49       cgd 			} else {
   1682   1.49       cgd 				/* nothing, check expiration */
   1683  1.185    kardel 				getmicrotime(&now);
   1684  1.185    kardel 				slp = t - diff(now, stime);
   1685   1.49       cgd 			}
   1686   1.49       cgd 		} else {	/* m == 0 */
   1687   1.49       cgd 			if (qp->c_cc > 0)
   1688   1.49       cgd 				goto read;
   1689   1.49       cgd 			if (!has_stime) {
   1690   1.49       cgd 				has_stime = 1;
   1691  1.185    kardel 				getmicrotime(&stime);
   1692   1.49       cgd 				slp = t;
   1693  1.185    kardel 			} else {
   1694  1.185    kardel 				getmicrotime(&now);
   1695  1.185    kardel 				slp = t - diff(now, stime);
   1696  1.185    kardel 			}
   1697   1.49       cgd 		}
   1698   1.54   mycroft 		last_cc = qp->c_cc;
   1699   1.49       cgd #undef diff
   1700   1.49       cgd 		if (slp > 0) {
   1701   1.49       cgd 			/*
   1702  1.156       dsl 			 * Convert deca-ticks back to ticks.
   1703   1.49       cgd 			 * Rounding down may make us wake up just short
   1704   1.49       cgd 			 * of the target, so we round up.
   1705  1.156       dsl 			 * Maybe we should do 'slp/10 + 1' because the
   1706  1.156       dsl 			 * first tick maybe almost immediate.
   1707  1.156       dsl 			 * However it is more useful for a program that sets
   1708  1.156       dsl 			 * VTIME=10 to wakeup every second not every 1.01
   1709  1.156       dsl 			 * seconds (if hz=100).
   1710   1.49       cgd 			 */
   1711  1.156       dsl 			slp = (slp + 9)/ 10;
   1712   1.49       cgd 			goto sleep;
   1713   1.49       cgd 		}
   1714   1.49       cgd 	} else if ((qp = &tp->t_canq)->c_cc <= 0) {
   1715  1.126     lukem 		int	carrier;
   1716   1.49       cgd 
   1717  1.126     lukem  sleep:
   1718   1.49       cgd 		/*
   1719   1.49       cgd 		 * If there is no input, sleep on rawq
   1720   1.49       cgd 		 * awaiting hardware receipt and notification.
   1721   1.49       cgd 		 * If we have data, we don't need to check for carrier.
   1722   1.49       cgd 		 */
   1723   1.83   mycroft 		carrier = CONNECTED(tp);
   1724   1.49       cgd 		if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
   1725  1.201        ad 			mutex_spin_exit(&tty_lock);
   1726   1.49       cgd 			return (0);	/* EOF */
   1727   1.49       cgd 		}
   1728   1.49       cgd 		if (flag & IO_NDELAY) {
   1729  1.201        ad 			mutex_spin_exit(&tty_lock);
   1730   1.49       cgd 			return (EWOULDBLOCK);
   1731   1.49       cgd 		}
   1732  1.201        ad 		error = ttysleep(tp, &tp->t_rawq.c_cv, true, slp);
   1733  1.201        ad 		mutex_spin_exit(&tty_lock);
   1734   1.82    kleink 		/* VMIN == 0: any quantity read satisfies */
   1735   1.82    kleink 		if (cc[VMIN] == 0 && error == EWOULDBLOCK)
   1736   1.82    kleink 			return (0);
   1737   1.54   mycroft 		if (error && error != EWOULDBLOCK)
   1738   1.49       cgd 			return (error);
   1739   1.49       cgd 		goto loop;
   1740   1.49       cgd 	}
   1741  1.126     lukem  read:
   1742  1.201        ad 	mutex_spin_exit(&tty_lock);
   1743   1.49       cgd 
   1744   1.49       cgd 	/*
   1745   1.49       cgd 	 * Input present, check for input mapping and processing.
   1746   1.49       cgd 	 */
   1747   1.49       cgd 	first = 1;
   1748   1.49       cgd 	while ((c = getc(qp)) >= 0) {
   1749   1.49       cgd 		/*
   1750   1.49       cgd 		 * delayed suspend (^Y)
   1751   1.49       cgd 		 */
   1752   1.81    kleink 		if (CCEQ(cc[VDSUSP], c) &&
   1753   1.81    kleink 		    ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) {
   1754  1.201        ad 			mutex_spin_enter(&tty_lock);
   1755  1.201        ad 			ttysig(tp, TTYSIG_PG1, SIGTSTP);
   1756   1.49       cgd 			if (first) {
   1757  1.201        ad 				error = ttysleep(tp, &lbolt, true, 0);
   1758  1.201        ad 				mutex_spin_exit(&tty_lock);
   1759   1.65  christos 				if (error)
   1760   1.49       cgd 					break;
   1761   1.49       cgd 				goto loop;
   1762  1.201        ad 			} else
   1763  1.201        ad 				mutex_spin_exit(&tty_lock);
   1764   1.49       cgd 			break;
   1765   1.49       cgd 		}
   1766   1.49       cgd 		/*
   1767   1.49       cgd 		 * Interpret EOF only in canonical mode.
   1768   1.49       cgd 		 */
   1769   1.49       cgd 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
   1770   1.49       cgd 			break;
   1771   1.49       cgd 		/*
   1772   1.49       cgd 		 * Give user character.
   1773   1.49       cgd 		 */
   1774   1.49       cgd  		error = ureadc(c, uio);
   1775   1.49       cgd 		if (error)
   1776   1.49       cgd 			break;
   1777   1.49       cgd  		if (uio->uio_resid == 0)
   1778   1.49       cgd 			break;
   1779   1.49       cgd 		/*
   1780   1.49       cgd 		 * In canonical mode check for a "break character"
   1781   1.49       cgd 		 * marking the end of a "line of input".
   1782   1.49       cgd 		 */
   1783   1.85    kleink 		if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
   1784   1.49       cgd 			break;
   1785   1.49       cgd 		first = 0;
   1786   1.49       cgd 	}
   1787   1.49       cgd 	/*
   1788   1.49       cgd 	 * Look to unblock output now that (presumably)
   1789   1.49       cgd 	 * the input queue has gone down.
   1790   1.49       cgd 	 */
   1791  1.201        ad 	mutex_spin_enter(&tty_lock);
   1792  1.138     enami 	if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) {
   1793   1.60   mycroft 		if (ISSET(tp->t_iflag, IXOFF) &&
   1794   1.60   mycroft 		    cc[VSTART] != _POSIX_VDISABLE &&
   1795   1.49       cgd 		    putc(cc[VSTART], &tp->t_outq) == 0) {
   1796   1.49       cgd 			CLR(tp->t_state, TS_TBLOCK);
   1797   1.49       cgd 			ttstart(tp);
   1798   1.49       cgd 		}
   1799   1.59   mycroft 		/* Try to unblock remote output via hardware flow control. */
   1800   1.59   mycroft 		if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
   1801   1.49       cgd 		    (*tp->t_hwiflow)(tp, 0) != 0)
   1802   1.59   mycroft 			CLR(tp->t_state, TS_TBLOCK);
   1803   1.49       cgd 	}
   1804  1.201        ad 	mutex_spin_exit(&tty_lock);
   1805  1.201        ad 
   1806   1.49       cgd 	return (error);
   1807   1.49       cgd }
   1808   1.49       cgd 
   1809   1.49       cgd /*
   1810   1.49       cgd  * Check the output queue on tp for space for a kernel message (from uprintf
   1811   1.49       cgd  * or tprintf).  Allow some space over the normal hiwater mark so we don't
   1812   1.49       cgd  * lose messages due to normal flow control, but don't let the tty run amok.
   1813   1.49       cgd  * Sleeps here are not interruptible, but we return prematurely if new signals
   1814   1.49       cgd  * arrive.
   1815  1.201        ad  * Call with tty lock held.
   1816   1.49       cgd  */
   1817  1.147        pk static int
   1818  1.147        pk ttycheckoutq_wlock(struct tty *tp, int wait)
   1819   1.49       cgd {
   1820  1.201        ad 	int	hiwat, error;
   1821  1.201        ad 
   1822  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   1823   1.49       cgd 
   1824   1.49       cgd 	hiwat = tp->t_hiwat;
   1825   1.49       cgd 	if (tp->t_outq.c_cc > hiwat + 200)
   1826   1.49       cgd 		while (tp->t_outq.c_cc > hiwat) {
   1827   1.49       cgd 			ttstart(tp);
   1828  1.201        ad 			if (wait == 0)
   1829   1.49       cgd 				return (0);
   1830  1.201        ad 			error = ttysleep(tp, &tp->t_outq.c_cv, true, hz);
   1831  1.112   mycroft 			if (error == EINTR)
   1832  1.112   mycroft 				wait = 0;
   1833   1.49       cgd 		}
   1834  1.147        pk 
   1835   1.49       cgd 	return (1);
   1836   1.49       cgd }
   1837   1.49       cgd 
   1838  1.147        pk int
   1839  1.147        pk ttycheckoutq(struct tty *tp, int wait)
   1840  1.147        pk {
   1841  1.201        ad 	int	r;
   1842  1.147        pk 
   1843  1.201        ad 	mutex_spin_enter(&tty_lock);
   1844  1.147        pk 	r = ttycheckoutq_wlock(tp, wait);
   1845  1.201        ad 	mutex_spin_exit(&tty_lock);
   1846  1.201        ad 
   1847  1.147        pk 	return (r);
   1848  1.147        pk }
   1849  1.147        pk 
   1850   1.49       cgd /*
   1851   1.49       cgd  * Process a write call on a tty device.
   1852   1.49       cgd  */
   1853   1.49       cgd int
   1854  1.126     lukem ttwrite(struct tty *tp, struct uio *uio, int flag)
   1855   1.49       cgd {
   1856  1.126     lukem 	u_char		*cp;
   1857  1.126     lukem 	struct proc	*p;
   1858  1.201        ad 	int		cc, ce, i, hiwat, error;
   1859  1.140   thorpej 	size_t		cnt;
   1860  1.126     lukem 	u_char		obuf[OBUFSIZ];
   1861   1.49       cgd 
   1862  1.126     lukem 	cp = NULL;
   1863   1.49       cgd 	hiwat = tp->t_hiwat;
   1864   1.49       cgd 	cnt = uio->uio_resid;
   1865   1.49       cgd 	error = 0;
   1866   1.49       cgd 	cc = 0;
   1867  1.126     lukem  loop:
   1868  1.201        ad 	mutex_spin_enter(&tty_lock);
   1869   1.83   mycroft 	if (!CONNECTED(tp)) {
   1870   1.49       cgd 		if (ISSET(tp->t_state, TS_ISOPEN)) {
   1871  1.201        ad 			mutex_spin_exit(&tty_lock);
   1872   1.49       cgd 			return (EIO);
   1873   1.49       cgd 		} else if (flag & IO_NDELAY) {
   1874  1.201        ad 			mutex_spin_exit(&tty_lock);
   1875   1.49       cgd 			error = EWOULDBLOCK;
   1876   1.49       cgd 			goto out;
   1877   1.49       cgd 		} else {
   1878   1.49       cgd 			/* Sleep awaiting carrier. */
   1879  1.201        ad 			error = ttysleep(tp, &tp->t_rawq.c_cv, true, 0);
   1880  1.201        ad 			mutex_spin_exit(&tty_lock);
   1881   1.49       cgd 			if (error)
   1882   1.49       cgd 				goto out;
   1883   1.49       cgd 			goto loop;
   1884   1.49       cgd 		}
   1885   1.49       cgd 	}
   1886  1.201        ad 	mutex_spin_exit(&tty_lock);
   1887   1.49       cgd 	/*
   1888  1.190        ad 	 * Hang the process if it's in the background. XXXSMP
   1889   1.49       cgd 	 */
   1890   1.49       cgd 	p = curproc;
   1891   1.49       cgd 	if (isbackground(p, tp) &&
   1892  1.190        ad 	    ISSET(tp->t_lflag, TOSTOP) && (p->p_sflag & PS_PPWAIT) == 0 &&
   1893  1.125  jdolecek 	    !sigismember(&p->p_sigctx.ps_sigignore, SIGTTOU) &&
   1894  1.190        ad 	    !sigismember(&curlwp->l_sigmask, SIGTTOU)) {
   1895   1.86    kleink 		if (p->p_pgrp->pg_jobc == 0) {
   1896   1.86    kleink 			error = EIO;
   1897   1.86    kleink 			goto out;
   1898   1.86    kleink 		}
   1899  1.201        ad 		mutex_spin_enter(&tty_lock);
   1900  1.201        ad 		ttysig(tp, TTYSIG_PG1, SIGTTOU);
   1901  1.201        ad 		error = ttysleep(tp, &lbolt, true, 0);
   1902  1.201        ad 		mutex_spin_exit(&tty_lock);
   1903   1.65  christos 		if (error)
   1904   1.49       cgd 			goto out;
   1905   1.49       cgd 		goto loop;
   1906   1.49       cgd 	}
   1907   1.49       cgd 	/*
   1908   1.49       cgd 	 * Process the user's data in at most OBUFSIZ chunks.  Perform any
   1909   1.49       cgd 	 * output translation.  Keep track of high water mark, sleep on
   1910   1.49       cgd 	 * overflow awaiting device aid in acquiring new space.
   1911   1.49       cgd 	 */
   1912   1.49       cgd 	while (uio->uio_resid > 0 || cc > 0) {
   1913   1.49       cgd 		if (ISSET(tp->t_lflag, FLUSHO)) {
   1914   1.49       cgd 			uio->uio_resid = 0;
   1915   1.49       cgd 			return (0);
   1916   1.49       cgd 		}
   1917   1.49       cgd 		if (tp->t_outq.c_cc > hiwat)
   1918   1.49       cgd 			goto ovhiwat;
   1919   1.49       cgd 		/*
   1920   1.49       cgd 		 * Grab a hunk of data from the user, unless we have some
   1921   1.49       cgd 		 * leftover from last time.
   1922   1.49       cgd 		 */
   1923   1.49       cgd 		if (cc == 0) {
   1924   1.49       cgd 			cc = min(uio->uio_resid, OBUFSIZ);
   1925   1.49       cgd 			cp = obuf;
   1926   1.49       cgd 			error = uiomove(cp, cc, uio);
   1927   1.49       cgd 			if (error) {
   1928   1.49       cgd 				cc = 0;
   1929  1.147        pk 				goto out;
   1930   1.49       cgd 			}
   1931   1.49       cgd 		}
   1932   1.49       cgd 		/*
   1933   1.49       cgd 		 * If nothing fancy need be done, grab those characters we
   1934   1.49       cgd 		 * can handle without any of ttyoutput's processing and
   1935   1.49       cgd 		 * just transfer them to the output q.  For those chars
   1936   1.49       cgd 		 * which require special processing (as indicated by the
   1937   1.49       cgd 		 * bits in char_type), call ttyoutput.  After processing
   1938   1.49       cgd 		 * a hunk of data, look for FLUSHO so ^O's will take effect
   1939   1.49       cgd 		 * immediately.
   1940   1.49       cgd 		 */
   1941  1.201        ad 		mutex_spin_enter(&tty_lock);
   1942   1.49       cgd 		while (cc > 0) {
   1943   1.49       cgd 			if (!ISSET(tp->t_oflag, OPOST))
   1944   1.49       cgd 				ce = cc;
   1945   1.49       cgd 			else {
   1946   1.77       cgd 				ce = cc - scanc((u_int)cc, cp, char_type,
   1947   1.77       cgd 				    CCLASSMASK);
   1948   1.49       cgd 				/*
   1949   1.49       cgd 				 * If ce is zero, then we're processing
   1950   1.49       cgd 				 * a special character through ttyoutput.
   1951   1.49       cgd 				 */
   1952   1.49       cgd 				if (ce == 0) {
   1953   1.49       cgd 					tp->t_rocount = 0;
   1954   1.49       cgd 					if (ttyoutput(*cp, tp) >= 0) {
   1955   1.49       cgd 						/* out of space */
   1956  1.201        ad 						mutex_spin_exit(&tty_lock);
   1957   1.49       cgd 						goto overfull;
   1958   1.49       cgd 					}
   1959   1.49       cgd 					cp++;
   1960   1.49       cgd 					cc--;
   1961   1.49       cgd 					if (ISSET(tp->t_lflag, FLUSHO) ||
   1962  1.147        pk 					    tp->t_outq.c_cc > hiwat) {
   1963  1.201        ad 						mutex_spin_exit(&tty_lock);
   1964   1.49       cgd 						goto ovhiwat;
   1965  1.147        pk 					}
   1966   1.49       cgd 					continue;
   1967   1.49       cgd 				}
   1968   1.49       cgd 			}
   1969   1.49       cgd 			/*
   1970   1.49       cgd 			 * A bunch of normal characters have been found.
   1971   1.49       cgd 			 * Transfer them en masse to the output queue and
   1972   1.49       cgd 			 * continue processing at the top of the loop.
   1973   1.49       cgd 			 * If there are any further characters in this
   1974   1.49       cgd 			 * <= OBUFSIZ chunk, the first should be a character
   1975   1.49       cgd 			 * requiring special handling by ttyoutput.
   1976   1.49       cgd 			 */
   1977   1.49       cgd 			tp->t_rocount = 0;
   1978   1.49       cgd 			i = b_to_q(cp, ce, &tp->t_outq);
   1979   1.49       cgd 			ce -= i;
   1980   1.49       cgd 			tp->t_column += ce;
   1981   1.49       cgd 			cp += ce, cc -= ce, tk_nout += ce;
   1982   1.49       cgd 			tp->t_outcc += ce;
   1983   1.49       cgd 			if (i > 0) {
   1984   1.49       cgd 				/* out of space */
   1985  1.201        ad 				mutex_spin_exit(&tty_lock);
   1986   1.49       cgd 				goto overfull;
   1987   1.49       cgd 			}
   1988   1.49       cgd 			if (ISSET(tp->t_lflag, FLUSHO) ||
   1989   1.49       cgd 			    tp->t_outq.c_cc > hiwat)
   1990   1.49       cgd 				break;
   1991   1.49       cgd 		}
   1992  1.201        ad 		mutex_spin_exit(&tty_lock);
   1993   1.49       cgd 		ttstart(tp);
   1994   1.49       cgd 	}
   1995  1.147        pk 
   1996  1.126     lukem  out:
   1997   1.49       cgd 	/*
   1998   1.49       cgd 	 * If cc is nonzero, we leave the uio structure inconsistent, as the
   1999   1.49       cgd 	 * offset and iov pointers have moved forward, but it doesn't matter
   2000   1.49       cgd 	 * (the call will either return short or restart with a new uio).
   2001   1.49       cgd 	 */
   2002   1.49       cgd 	uio->uio_resid += cc;
   2003   1.49       cgd 	return (error);
   2004   1.49       cgd 
   2005  1.126     lukem  overfull:
   2006   1.49       cgd 	/*
   2007   1.49       cgd 	 * Since we are using ring buffers, if we can't insert any more into
   2008   1.49       cgd 	 * the output queue, we can assume the ring is full and that someone
   2009   1.49       cgd 	 * forgot to set the high water mark correctly.  We set it and then
   2010   1.49       cgd 	 * proceed as normal.
   2011   1.49       cgd 	 */
   2012   1.49       cgd 	hiwat = tp->t_outq.c_cc - 1;
   2013   1.49       cgd 
   2014  1.126     lukem  ovhiwat:
   2015   1.49       cgd 	ttstart(tp);
   2016  1.201        ad 	mutex_spin_enter(&tty_lock);
   2017   1.49       cgd 	/*
   2018   1.49       cgd 	 * This can only occur if FLUSHO is set in t_lflag,
   2019   1.49       cgd 	 * or if ttstart/oproc is synchronous (or very fast).
   2020   1.49       cgd 	 */
   2021   1.49       cgd 	if (tp->t_outq.c_cc <= hiwat) {
   2022  1.201        ad 		mutex_spin_exit(&tty_lock);
   2023   1.49       cgd 		goto loop;
   2024   1.49       cgd 	}
   2025   1.49       cgd 	if (flag & IO_NDELAY) {
   2026  1.201        ad 		mutex_spin_exit(&tty_lock);
   2027  1.187  christos 		error = EWOULDBLOCK;
   2028  1.147        pk 		goto out;
   2029   1.49       cgd 	}
   2030  1.201        ad 	error = ttysleep(tp, &tp->t_outq.c_cv, true, 0);
   2031  1.201        ad 	mutex_spin_exit(&tty_lock);
   2032   1.49       cgd 	if (error)
   2033   1.49       cgd 		goto out;
   2034   1.49       cgd 	goto loop;
   2035   1.49       cgd }
   2036   1.49       cgd 
   2037   1.49       cgd /*
   2038  1.203        ad  * Try to pull more output from the producer.  Return non-zero if
   2039  1.203        ad  * there is output ready to be sent.
   2040  1.203        ad  */
   2041  1.203        ad bool
   2042  1.203        ad ttypull(struct tty *tp)
   2043  1.203        ad {
   2044  1.203        ad 
   2045  1.203        ad 	/* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */
   2046  1.203        ad 
   2047  1.203        ad 	if (tp->t_outq.c_cc <= tp->t_lowat) {
   2048  1.203        ad 		clwakeup(&tp->t_outq);
   2049  1.203        ad 		selnotify(&tp->t_wsel, NOTE_SUBMIT);
   2050  1.203        ad 	}
   2051  1.203        ad 	return tp->t_outq.c_cc != 0;
   2052  1.203        ad }
   2053  1.203        ad 
   2054  1.203        ad /*
   2055   1.49       cgd  * Rubout one character from the rawq of tp
   2056   1.49       cgd  * as cleanly as possible.
   2057  1.201        ad  * Called with tty lock held.
   2058   1.49       cgd  */
   2059   1.49       cgd void
   2060  1.126     lukem ttyrub(int c, struct tty *tp)
   2061   1.49       cgd {
   2062  1.126     lukem 	u_char	*cp;
   2063  1.201        ad 	int	savecol, tabc;
   2064  1.201        ad 
   2065  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2066   1.49       cgd 
   2067   1.49       cgd 	if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
   2068   1.49       cgd 		return;
   2069   1.49       cgd 	CLR(tp->t_lflag, FLUSHO);
   2070   1.49       cgd 	if (ISSET(tp->t_lflag, ECHOE)) {
   2071   1.49       cgd 		if (tp->t_rocount == 0) {
   2072   1.49       cgd 			/*
   2073   1.49       cgd 			 * Screwed by ttwrite; retype
   2074   1.49       cgd 			 */
   2075   1.49       cgd 			ttyretype(tp);
   2076   1.49       cgd 			return;
   2077   1.49       cgd 		}
   2078   1.49       cgd 		if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
   2079   1.49       cgd 			ttyrubo(tp, 2);
   2080   1.49       cgd 		else {
   2081   1.49       cgd 			CLR(c, ~TTY_CHARMASK);
   2082   1.49       cgd 			switch (CCLASS(c)) {
   2083   1.49       cgd 			case ORDINARY:
   2084   1.49       cgd 				ttyrubo(tp, 1);
   2085   1.49       cgd 				break;
   2086   1.49       cgd 			case BACKSPACE:
   2087   1.49       cgd 			case CONTROL:
   2088   1.49       cgd 			case NEWLINE:
   2089   1.49       cgd 			case RETURN:
   2090   1.49       cgd 			case VTAB:
   2091   1.49       cgd 				if (ISSET(tp->t_lflag, ECHOCTL))
   2092   1.49       cgd 					ttyrubo(tp, 2);
   2093   1.49       cgd 				break;
   2094   1.49       cgd 			case TAB:
   2095   1.49       cgd 				if (tp->t_rocount < tp->t_rawq.c_cc) {
   2096   1.49       cgd 					ttyretype(tp);
   2097   1.49       cgd 					return;
   2098   1.49       cgd 				}
   2099   1.49       cgd 				savecol = tp->t_column;
   2100   1.49       cgd 				SET(tp->t_state, TS_CNTTB);
   2101   1.49       cgd 				SET(tp->t_lflag, FLUSHO);
   2102   1.49       cgd 				tp->t_column = tp->t_rocol;
   2103   1.52   deraadt 				for (cp = firstc(&tp->t_rawq, &tabc); cp;
   2104   1.49       cgd 				    cp = nextc(&tp->t_rawq, cp, &tabc))
   2105   1.49       cgd 					ttyecho(tabc, tp);
   2106   1.49       cgd 				CLR(tp->t_lflag, FLUSHO);
   2107   1.49       cgd 				CLR(tp->t_state, TS_CNTTB);
   2108   1.49       cgd 
   2109   1.49       cgd 				/* savecol will now be length of the tab. */
   2110   1.49       cgd 				savecol -= tp->t_column;
   2111   1.49       cgd 				tp->t_column += savecol;
   2112   1.49       cgd 				if (savecol > 8)
   2113   1.49       cgd 					savecol = 8;	/* overflow screw */
   2114   1.49       cgd 				while (--savecol >= 0)
   2115   1.49       cgd 					(void)ttyoutput('\b', tp);
   2116   1.49       cgd 				break;
   2117   1.49       cgd 			default:			/* XXX */
   2118  1.172  christos 				(void)printf("ttyrub: would panic c = %d, "
   2119  1.172  christos 				    "val = %d\n", c, CCLASS(c));
   2120   1.49       cgd 			}
   2121   1.49       cgd 		}
   2122   1.49       cgd 	} else if (ISSET(tp->t_lflag, ECHOPRT)) {
   2123   1.49       cgd 		if (!ISSET(tp->t_state, TS_ERASE)) {
   2124   1.49       cgd 			SET(tp->t_state, TS_ERASE);
   2125   1.49       cgd 			(void)ttyoutput('\\', tp);
   2126   1.49       cgd 		}
   2127   1.49       cgd 		ttyecho(c, tp);
   2128   1.49       cgd 	} else
   2129   1.49       cgd 		ttyecho(tp->t_cc[VERASE], tp);
   2130   1.49       cgd 	--tp->t_rocount;
   2131   1.49       cgd }
   2132   1.49       cgd 
   2133   1.49       cgd /*
   2134   1.49       cgd  * Back over cnt characters, erasing them.
   2135  1.201        ad  * Called with tty lock held.
   2136   1.49       cgd  */
   2137   1.49       cgd static void
   2138  1.126     lukem ttyrubo(struct tty *tp, int cnt)
   2139   1.49       cgd {
   2140   1.49       cgd 
   2141  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2142  1.201        ad 
   2143   1.49       cgd 	while (cnt-- > 0) {
   2144   1.49       cgd 		(void)ttyoutput('\b', tp);
   2145   1.49       cgd 		(void)ttyoutput(' ', tp);
   2146   1.49       cgd 		(void)ttyoutput('\b', tp);
   2147   1.49       cgd 	}
   2148   1.49       cgd }
   2149   1.49       cgd 
   2150   1.49       cgd /*
   2151   1.49       cgd  * ttyretype --
   2152   1.49       cgd  *	Reprint the rawq line.  Note, it is assumed that c_cc has already
   2153   1.49       cgd  *	been checked.
   2154  1.147        pk  *
   2155  1.201        ad  * Called with tty lock held.
   2156   1.49       cgd  */
   2157   1.49       cgd void
   2158  1.126     lukem ttyretype(struct tty *tp)
   2159   1.49       cgd {
   2160  1.126     lukem 	u_char	*cp;
   2161  1.201        ad 	int	c;
   2162  1.201        ad 
   2163  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2164   1.49       cgd 
   2165   1.49       cgd 	/* Echo the reprint character. */
   2166   1.49       cgd 	if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
   2167   1.49       cgd 		ttyecho(tp->t_cc[VREPRINT], tp);
   2168   1.49       cgd 
   2169   1.49       cgd 	(void)ttyoutput('\n', tp);
   2170   1.49       cgd 
   2171   1.49       cgd 	for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
   2172   1.49       cgd 		ttyecho(c, tp);
   2173   1.49       cgd 	for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
   2174   1.49       cgd 		ttyecho(c, tp);
   2175   1.49       cgd 	CLR(tp->t_state, TS_ERASE);
   2176   1.49       cgd 
   2177   1.49       cgd 	tp->t_rocount = tp->t_rawq.c_cc;
   2178   1.49       cgd 	tp->t_rocol = 0;
   2179   1.49       cgd }
   2180   1.49       cgd 
   2181   1.49       cgd /*
   2182   1.49       cgd  * Echo a typed character to the terminal.
   2183  1.201        ad  * Called with tty lock held.
   2184   1.49       cgd  */
   2185   1.49       cgd static void
   2186  1.126     lukem ttyecho(int c, struct tty *tp)
   2187   1.49       cgd {
   2188   1.49       cgd 
   2189  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2190  1.201        ad 
   2191   1.49       cgd 	if (!ISSET(tp->t_state, TS_CNTTB))
   2192   1.49       cgd 		CLR(tp->t_lflag, FLUSHO);
   2193   1.49       cgd 	if ((!ISSET(tp->t_lflag, ECHO) &&
   2194   1.64        pk 	    (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
   2195   1.49       cgd 	    ISSET(tp->t_lflag, EXTPROC))
   2196   1.49       cgd 		return;
   2197   1.65  christos 	if (((ISSET(tp->t_lflag, ECHOCTL) &&
   2198  1.138     enami 	    (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
   2199   1.49       cgd 	    ISSET(c, TTY_CHARMASK) == 0177)) {
   2200   1.49       cgd 		(void)ttyoutput('^', tp);
   2201   1.49       cgd 		CLR(c, ~TTY_CHARMASK);
   2202   1.49       cgd 		if (c == 0177)
   2203   1.49       cgd 			c = '?';
   2204   1.49       cgd 		else
   2205   1.49       cgd 			c += 'A' - 1;
   2206   1.49       cgd 	}
   2207   1.49       cgd 	(void)ttyoutput(c, tp);
   2208   1.49       cgd }
   2209   1.49       cgd 
   2210   1.49       cgd /*
   2211   1.49       cgd  * Wake up any readers on a tty.
   2212  1.201        ad  * Called with tty lock held.
   2213   1.49       cgd  */
   2214   1.49       cgd void
   2215  1.126     lukem ttwakeup(struct tty *tp)
   2216   1.49       cgd {
   2217   1.49       cgd 
   2218  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2219  1.201        ad 
   2220  1.162  jdolecek 	selnotify(&tp->t_rsel, NOTE_SUBMIT);
   2221  1.201        ad 	if (ISSET(tp->t_state, TS_ASYNC))
   2222  1.201        ad 		ttysig(tp, TTYSIG_PG2, SIGIO);
   2223  1.204        ad #if 0
   2224  1.204        ad 	/* XXX tp->t_rawq.c_cv.cv_waiters dropping to zero early!? */
   2225  1.203        ad 	clwakeup(&tp->t_rawq);
   2226  1.204        ad #else
   2227  1.204        ad 	cv_wakeup(&tp->t_rawq.c_cv);
   2228  1.204        ad #endif
   2229   1.49       cgd }
   2230   1.49       cgd 
   2231   1.49       cgd /*
   2232   1.49       cgd  * Look up a code for a specified speed in a conversion table;
   2233   1.49       cgd  * used by drivers to map software speed values to hardware parameters.
   2234   1.49       cgd  */
   2235   1.49       cgd int
   2236  1.166      matt ttspeedtab(int speed, const struct speedtab *table)
   2237   1.49       cgd {
   2238   1.49       cgd 
   2239  1.138     enami 	for (; table->sp_speed != -1; table++)
   2240   1.49       cgd 		if (table->sp_speed == speed)
   2241   1.49       cgd 			return (table->sp_code);
   2242   1.49       cgd 	return (-1);
   2243   1.49       cgd }
   2244   1.49       cgd 
   2245   1.49       cgd /*
   2246   1.49       cgd  * Set tty hi and low water marks.
   2247   1.49       cgd  *
   2248   1.49       cgd  * Try to arrange the dynamics so there's about one second
   2249   1.49       cgd  * from hi to low water.
   2250   1.49       cgd  */
   2251   1.49       cgd void
   2252  1.126     lukem ttsetwater(struct tty *tp)
   2253   1.49       cgd {
   2254  1.126     lukem 	int	cps, x;
   2255   1.49       cgd 
   2256  1.201        ad 	/* XXX not yet KASSERT(mutex_owned(&tty_lock)); */
   2257  1.201        ad 
   2258  1.126     lukem #define	CLAMP(x, h, l)	((x) > h ? h : ((x) < l) ? l : (x))
   2259   1.49       cgd 
   2260   1.49       cgd 	cps = tp->t_ospeed / 10;
   2261   1.49       cgd 	tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
   2262   1.49       cgd 	x += cps;
   2263   1.49       cgd 	x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
   2264   1.49       cgd 	tp->t_hiwat = roundup(x, CBSIZE);
   2265   1.49       cgd #undef	CLAMP
   2266   1.49       cgd }
   2267   1.49       cgd 
   2268   1.49       cgd /*
   2269   1.49       cgd  * Report on state of foreground process group.
   2270  1.201        ad  * Call with tty lock held.
   2271  1.190        ad  * XXXSMP locking.
   2272   1.49       cgd  */
   2273   1.49       cgd void
   2274  1.183  christos ttyinfo(struct tty *tp, int fromsig)
   2275   1.49       cgd {
   2276  1.145   thorpej 	struct lwp	*l;
   2277  1.184  christos 	struct proc	*p, *pick = NULL;
   2278  1.126     lukem 	struct timeval	utime, stime;
   2279  1.126     lukem 	int		tmp;
   2280  1.196      yamt 	fixpt_t		pctcpu = 0;
   2281  1.183  christos 	const char	*msg;
   2282   1.49       cgd 
   2283  1.147        pk 	if (ttycheckoutq_wlock(tp, 0) == 0)
   2284   1.49       cgd 		return;
   2285   1.49       cgd 
   2286   1.49       cgd 	if (tp->t_session == NULL)
   2287  1.183  christos 		msg = "not a controlling terminal\n";
   2288   1.49       cgd 	else if (tp->t_pgrp == NULL)
   2289  1.183  christos 		msg = "no foreground process group\n";
   2290  1.183  christos 	else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL)
   2291  1.183  christos 		msg = "empty foreground process group\n";
   2292   1.49       cgd 	else {
   2293   1.49       cgd 		/* Pick interesting process. */
   2294  1.184  christos 		for (; p != NULL; p = LIST_NEXT(p, p_pglist))
   2295   1.49       cgd 			if (proc_compare(pick, p))
   2296   1.49       cgd 				pick = p;
   2297  1.183  christos 		if (fromsig &&
   2298  1.183  christos 		    (SIGACTION_PS(pick->p_sigacts, SIGINFO).sa_flags &
   2299  1.183  christos 		    SA_NOKERNINFO))
   2300  1.183  christos 			return;
   2301  1.183  christos 		msg = NULL;
   2302  1.183  christos 	}
   2303  1.183  christos 
   2304  1.183  christos 	/* Print load average. */
   2305  1.183  christos 	tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
   2306  1.183  christos 	ttyprintf_nolock(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
   2307   1.49       cgd 
   2308  1.184  christos 	if (pick == NULL) {
   2309  1.183  christos 		ttyprintf_nolock(tp, msg);
   2310  1.183  christos 		tp->t_rocount = 0; /* so pending input will be retyped if BS */
   2311  1.183  christos 		return;
   2312  1.183  christos 	}
   2313  1.183  christos 
   2314  1.183  christos 	ttyprintf_nolock(tp, " cmd: %s %d [", pick->p_comm, pick->p_pid);
   2315  1.196      yamt 	LIST_FOREACH(l, &pick->p_lwps, l_sibling) {
   2316  1.183  christos 	    ttyprintf_nolock(tp, "%s%s",
   2317  1.183  christos 	    l->l_stat == LSONPROC ? "running" :
   2318  1.183  christos 	    l->l_stat == LSRUN ? "runnable" :
   2319  1.183  christos 	    l->l_wmesg ? l->l_wmesg : "iowait",
   2320  1.183  christos 		(LIST_NEXT(l, l_sibling) != NULL) ? " " : "] ");
   2321  1.196      yamt 	    pctcpu += l->l_pctcpu;
   2322  1.196      yamt 	}
   2323  1.196      yamt 	pctcpu += pick->p_pctcpu;
   2324  1.183  christos 
   2325  1.190        ad 	mutex_enter(&pick->p_smutex);
   2326  1.190        ad 	calcru(pick, &utime, &stime, NULL, NULL);
   2327  1.190        ad 	mutex_exit(&pick->p_smutex);
   2328  1.183  christos 
   2329  1.183  christos 	/* Round up and print user time. */
   2330  1.183  christos 	utime.tv_usec += 5000;
   2331  1.183  christos 	if (utime.tv_usec >= 1000000) {
   2332  1.183  christos 		utime.tv_sec += 1;
   2333  1.183  christos 		utime.tv_usec -= 1000000;
   2334  1.183  christos 	}
   2335  1.183  christos 	ttyprintf_nolock(tp, "%ld.%02ldu ", (long int)utime.tv_sec,
   2336  1.183  christos 	    (long int)utime.tv_usec / 10000);
   2337  1.183  christos 
   2338  1.183  christos 	/* Round up and print system time. */
   2339  1.183  christos 	stime.tv_usec += 5000;
   2340  1.183  christos 	if (stime.tv_usec >= 1000000) {
   2341  1.183  christos 		stime.tv_sec += 1;
   2342  1.183  christos 		stime.tv_usec -= 1000000;
   2343  1.183  christos 	}
   2344  1.183  christos 	ttyprintf_nolock(tp, "%ld.%02lds ", (long int)stime.tv_sec,
   2345  1.183  christos 	    (long int)stime.tv_usec / 10000);
   2346   1.49       cgd 
   2347  1.123   thorpej #define	pgtok(a)	(((u_long) ((a) * PAGE_SIZE) / 1024))
   2348  1.183  christos 	/* Print percentage CPU. */
   2349  1.196      yamt 	tmp = (pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
   2350  1.183  christos 	ttyprintf_nolock(tp, "%d%% ", tmp / 100);
   2351  1.183  christos 
   2352  1.183  christos 	/* Print resident set size. */
   2353  1.183  christos 	if (pick->p_stat == SIDL || P_ZOMBIE(pick))
   2354  1.183  christos 		tmp = 0;
   2355  1.183  christos 	else {
   2356  1.183  christos 		struct vmspace *vm = pick->p_vmspace;
   2357  1.183  christos 		tmp = pgtok(vm_resident_count(vm));
   2358   1.49       cgd 	}
   2359  1.183  christos 	ttyprintf_nolock(tp, "%dk\n", tmp);
   2360   1.49       cgd 	tp->t_rocount = 0;	/* so pending input will be retyped if BS */
   2361   1.49       cgd }
   2362   1.49       cgd 
   2363   1.49       cgd /*
   2364   1.49       cgd  * Returns 1 if p2 is "better" than p1
   2365   1.49       cgd  *
   2366   1.49       cgd  * The algorithm for picking the "interesting" process is thus:
   2367   1.49       cgd  *
   2368   1.49       cgd  *	1) Only foreground processes are eligible - implied.
   2369   1.49       cgd  *	2) Runnable processes are favored over anything else.  The runner
   2370  1.200        ad  *	   with the highest CPU utilization is picked (l_pctcpu).  Ties are
   2371   1.49       cgd  *	   broken by picking the highest pid.
   2372   1.49       cgd  *	3) The sleeper with the shortest sleep time is next.  With ties,
   2373   1.49       cgd  *	   we pick out just "short-term" sleepers (P_SINTR == 0).
   2374   1.49       cgd  *	4) Further ties are broken by picking the highest pid.
   2375  1.190        ad  *
   2376  1.190        ad  * XXXSMP
   2377   1.49       cgd  */
   2378  1.145   thorpej #define	ISRUN(p)	((p)->p_nrlwps > 0)
   2379  1.138     enami #define	TESTAB(a, b)	((a)<<1 | (b))
   2380  1.138     enami #define	ONLYA	2
   2381  1.138     enami #define	ONLYB	1
   2382  1.138     enami #define	BOTH	3
   2383   1.49       cgd 
   2384   1.49       cgd static int
   2385  1.126     lukem proc_compare(struct proc *p1, struct proc *p2)
   2386   1.49       cgd {
   2387  1.200        ad 	lwp_t *l1, *l2;
   2388   1.49       cgd 
   2389   1.49       cgd 	if (p1 == NULL)
   2390   1.49       cgd 		return (1);
   2391   1.49       cgd 	/*
   2392   1.49       cgd 	 * see if at least one of them is runnable
   2393   1.49       cgd 	 */
   2394   1.49       cgd 	switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
   2395   1.49       cgd 	case ONLYA:
   2396   1.49       cgd 		return (0);
   2397   1.49       cgd 	case ONLYB:
   2398   1.49       cgd 		return (1);
   2399   1.49       cgd 	case BOTH:
   2400   1.49       cgd 		/*
   2401  1.161       wiz 		 * tie - favor one with highest recent CPU utilization
   2402   1.49       cgd 		 */
   2403  1.200        ad 		l1 = LIST_FIRST(&p1->p_lwps);
   2404  1.200        ad 		l2 = LIST_FIRST(&p2->p_lwps);
   2405  1.200        ad 		if (l2->l_pctcpu > l1->l_pctcpu)
   2406   1.49       cgd 			return (1);
   2407   1.49       cgd 		return (p2->p_pid > p1->p_pid);	/* tie - return highest pid */
   2408   1.49       cgd 	}
   2409   1.49       cgd 	/*
   2410   1.49       cgd  	 * weed out zombies
   2411   1.49       cgd 	 */
   2412  1.114   thorpej 	switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
   2413   1.49       cgd 	case ONLYA:
   2414   1.49       cgd 		return (1);
   2415   1.49       cgd 	case ONLYB:
   2416   1.49       cgd 		return (0);
   2417   1.49       cgd 	case BOTH:
   2418  1.138     enami 		return (p2->p_pid > p1->p_pid);	/* tie - return highest pid */
   2419   1.49       cgd 	}
   2420  1.145   thorpej #if 0 /* XXX NJWLWP */
   2421   1.49       cgd 	/*
   2422   1.49       cgd 	 * pick the one with the smallest sleep time
   2423   1.49       cgd 	 */
   2424   1.49       cgd 	if (p2->p_slptime > p1->p_slptime)
   2425   1.49       cgd 		return (0);
   2426   1.49       cgd 	if (p1->p_slptime > p2->p_slptime)
   2427   1.49       cgd 		return (1);
   2428   1.49       cgd 	/*
   2429   1.49       cgd 	 * favor one sleeping in a non-interruptible sleep
   2430   1.49       cgd 	 */
   2431   1.49       cgd 	if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
   2432   1.49       cgd 		return (1);
   2433   1.49       cgd 	if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
   2434   1.49       cgd 		return (0);
   2435  1.145   thorpej #endif
   2436   1.49       cgd 	return (p2->p_pid > p1->p_pid);		/* tie - return highest pid */
   2437   1.49       cgd }
   2438   1.49       cgd 
   2439   1.49       cgd /*
   2440   1.49       cgd  * Output char to tty; console putchar style.
   2441  1.147        pk  * Can be called with tty lock held through kprintf() machinery..
   2442   1.49       cgd  */
   2443   1.49       cgd int
   2444  1.149  christos tputchar(int c, int flags, struct tty *tp)
   2445   1.49       cgd {
   2446  1.201        ad 	int r = 0;
   2447   1.49       cgd 
   2448  1.149  christos 	if ((flags & NOLOCK) == 0)
   2449  1.201        ad 		mutex_spin_enter(&tty_lock);
   2450  1.147        pk 	if (!CONNECTED(tp)) {
   2451  1.147        pk 		r = -1;
   2452  1.147        pk 		goto out;
   2453   1.49       cgd 	}
   2454   1.49       cgd 	if (c == '\n')
   2455   1.49       cgd 		(void)ttyoutput('\r', tp);
   2456   1.49       cgd 	(void)ttyoutput(c, tp);
   2457   1.49       cgd 	ttstart(tp);
   2458  1.147        pk out:
   2459  1.149  christos 	if ((flags & NOLOCK) == 0)
   2460  1.201        ad 		mutex_spin_exit(&tty_lock);
   2461  1.147        pk 	return (r);
   2462   1.49       cgd }
   2463   1.49       cgd 
   2464   1.49       cgd /*
   2465   1.49       cgd  * Sleep on chan, returning ERESTART if tty changed while we napped and
   2466   1.49       cgd  * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep.  If
   2467   1.49       cgd  * the tty is revoked, restarting a pending call will redo validation done
   2468   1.49       cgd  * at the start of the call.
   2469  1.147        pk  *
   2470  1.201        ad  * Must be called with the tty lock held.
   2471   1.49       cgd  */
   2472   1.49       cgd int
   2473  1.201        ad ttysleep(struct tty *tp, kcondvar_t *cv, bool catch, int timo)
   2474   1.49       cgd {
   2475  1.126     lukem 	int	error;
   2476  1.126     lukem 	short	gen;
   2477   1.49       cgd 
   2478  1.201        ad 	KASSERT(mutex_owned(&tty_lock));
   2479  1.201        ad 
   2480   1.49       cgd 	gen = tp->t_gen;
   2481  1.201        ad 	if (catch)
   2482  1.201        ad 		error = cv_timedwait_sig(cv, &tty_lock, timo);
   2483  1.201        ad 	else
   2484  1.201        ad 		error = cv_timedwait(cv, &tty_lock, timo);
   2485  1.201        ad 	if (error != 0)
   2486   1.49       cgd 		return (error);
   2487   1.49       cgd 	return (tp->t_gen == gen ? 0 : ERESTART);
   2488   1.49       cgd }
   2489   1.49       cgd 
   2490   1.49       cgd /*
   2491   1.69       mrg  * Attach a tty to the tty list.
   2492   1.72       mrg  *
   2493   1.72       mrg  * This should be called ONLY once per real tty (including pty's).
   2494   1.72       mrg  * eg, on the sparc, the keyboard and mouse have struct tty's that are
   2495   1.72       mrg  * distinctly NOT usable as tty's, and thus should not be attached to
   2496   1.72       mrg  * the ttylist.  This is why this call is not done from ttymalloc().
   2497   1.72       mrg  *
   2498   1.72       mrg  * Device drivers should attach tty's at a similar time that they are
   2499   1.72       mrg  * ttymalloc()'ed, or, for the case of statically allocated struct tty's
   2500   1.72       mrg  * either in the attach or (first) open routine.
   2501   1.69       mrg  */
   2502   1.69       mrg void
   2503  1.126     lukem tty_attach(struct tty *tp)
   2504   1.69       mrg {
   2505   1.71       cgd 
   2506  1.201        ad 	mutex_spin_enter(&tty_lock);
   2507   1.69       mrg 	TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
   2508   1.69       mrg 	++tty_count;
   2509  1.201        ad 	mutex_spin_exit(&tty_lock);
   2510   1.69       mrg }
   2511   1.69       mrg 
   2512   1.69       mrg /*
   2513   1.69       mrg  * Remove a tty from the tty list.
   2514   1.69       mrg  */
   2515   1.69       mrg void
   2516  1.126     lukem tty_detach(struct tty *tp)
   2517   1.69       mrg {
   2518   1.71       cgd 
   2519  1.201        ad 	mutex_spin_enter(&tty_lock);
   2520   1.69       mrg 	--tty_count;
   2521   1.69       mrg #ifdef DIAGNOSTIC
   2522   1.69       mrg 	if (tty_count < 0)
   2523   1.69       mrg 		panic("tty_detach: tty_count < 0");
   2524   1.69       mrg #endif
   2525   1.70       mrg 	TAILQ_REMOVE(&ttylist, tp, tty_link);
   2526  1.201        ad 	mutex_spin_exit(&tty_lock);
   2527   1.69       mrg }
   2528   1.69       mrg 
   2529   1.69       mrg /*
   2530   1.49       cgd  * Allocate a tty structure and its associated buffers.
   2531   1.49       cgd  */
   2532   1.49       cgd struct tty *
   2533  1.126     lukem ttymalloc(void)
   2534   1.49       cgd {
   2535  1.126     lukem 	struct tty	*tp;
   2536  1.202        ad 	int i;
   2537   1.49       cgd 
   2538  1.111   thorpej 	tp = pool_get(&tty_pool, PR_WAITOK);
   2539  1.109     perry 	memset(tp, 0, sizeof(*tp));
   2540  1.197        ad 	callout_init(&tp->t_rstrt_ch, 0);
   2541  1.199     joerg 	callout_setfunc(&tp->t_rstrt_ch, ttrstrt, tp);
   2542   1.84   mycroft 	/* XXX: default to 1024 chars for now */
   2543   1.84   mycroft 	clalloc(&tp->t_rawq, 1024, 1);
   2544   1.84   mycroft 	clalloc(&tp->t_canq, 1024, 1);
   2545   1.49       cgd 	/* output queue doesn't need quoting */
   2546   1.84   mycroft 	clalloc(&tp->t_outq, 1024, 0);
   2547  1.121       eeh 	/* Set default line discipline. */
   2548  1.177   thorpej 	tp->t_linesw = ttyldisc_default();
   2549  1.198        ad 	selinit(&tp->t_rsel);
   2550  1.198        ad 	selinit(&tp->t_wsel);
   2551  1.202        ad 	for (i = 0; i < TTYSIG_COUNT; i++)
   2552  1.202        ad 		sigemptyset(&tp->t_sigs[i]);
   2553  1.138     enami 	return (tp);
   2554   1.49       cgd }
   2555   1.49       cgd 
   2556   1.49       cgd /*
   2557   1.49       cgd  * Free a tty structure and its buffers.
   2558   1.73       mrg  *
   2559   1.73       mrg  * Be sure to call tty_detach() for any tty that has been
   2560   1.73       mrg  * tty_attach()ed.
   2561   1.49       cgd  */
   2562   1.49       cgd void
   2563  1.126     lukem ttyfree(struct tty *tp)
   2564   1.49       cgd {
   2565  1.202        ad 	int i;
   2566   1.71       cgd 
   2567  1.201        ad 	mutex_enter(&tty_lock);
   2568  1.202        ad 	for (i = 0; i < TTYSIG_COUNT; i++)
   2569  1.202        ad 		sigemptyset(&tp->t_sigs[i]);
   2570  1.201        ad 	if (tp->t_sigcount != 0)
   2571  1.201        ad 		TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue);
   2572  1.201        ad 	mutex_exit(&tty_lock);
   2573  1.201        ad 
   2574  1.116   thorpej 	callout_stop(&tp->t_rstrt_ch);
   2575  1.177   thorpej 	ttyldisc_release(tp->t_linesw);
   2576   1.49       cgd 	clfree(&tp->t_rawq);
   2577   1.49       cgd 	clfree(&tp->t_canq);
   2578   1.49       cgd 	clfree(&tp->t_outq);
   2579  1.201        ad 	callout_destroy(&tp->t_rstrt_ch);
   2580  1.198        ad 	seldestroy(&tp->t_rsel);
   2581  1.198        ad 	seldestroy(&tp->t_wsel);
   2582  1.111   thorpej 	pool_put(&tty_pool, tp);
   2583  1.149  christos }
   2584  1.149  christos 
   2585  1.149  christos /*
   2586  1.149  christos  * ttyprintf_nolock: send a message to a specific tty, without locking.
   2587  1.149  christos  *
   2588  1.149  christos  * => should be used only by tty driver or anything that knows the
   2589  1.149  christos  *    underlying tty will not be revoked(2)'d away.  [otherwise,
   2590  1.149  christos  *    use tprintf]
   2591  1.149  christos  */
   2592  1.149  christos static void
   2593  1.149  christos ttyprintf_nolock(struct tty *tp, const char *fmt, ...)
   2594  1.149  christos {
   2595  1.149  christos 	va_list ap;
   2596  1.149  christos 
   2597  1.149  christos 	/* No mutex needed; going to process TTY. */
   2598  1.149  christos 	va_start(ap, fmt);
   2599  1.149  christos 	kprintf(fmt, TOTTY|NOLOCK, tp, NULL, ap);
   2600  1.149  christos 	va_end(ap);
   2601   1.49       cgd }
   2602  1.201        ad 
   2603  1.201        ad /*
   2604  1.201        ad  * Initialize the tty subsystem.
   2605  1.201        ad  */
   2606  1.201        ad void
   2607  1.201        ad tty_init(void)
   2608  1.201        ad {
   2609  1.201        ad 
   2610  1.201        ad 	mutex_init(&tty_lock, MUTEX_DEFAULT, IPL_VM);
   2611  1.201        ad 	tty_sigsih = softint_establish(SOFTINT_CLOCK, ttysigintr, NULL);
   2612  1.201        ad 	KASSERT(tty_sigsih != NULL);
   2613  1.201        ad }
   2614  1.201        ad 
   2615  1.201        ad /*
   2616  1.201        ad  * Send a signal from a tty to its process group or session leader.
   2617  1.201        ad  * Handoff to the target is deferred to a soft interrupt.
   2618  1.201        ad  */
   2619  1.201        ad void
   2620  1.201        ad ttysig(struct tty *tp, enum ttysigtype st, int sig)
   2621  1.201        ad {
   2622  1.202        ad 	sigset_t *sp;
   2623  1.201        ad 
   2624  1.201        ad 	/* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */
   2625  1.201        ad 
   2626  1.202        ad 	sp = &tp->t_sigs[st];
   2627  1.202        ad 	if (sigismember(sp, sig))
   2628  1.202        ad 		return;
   2629  1.202        ad 	sigaddset(sp, sig);
   2630  1.202        ad 	if (tp->t_sigcount++ == 0)
   2631  1.202        ad 		TAILQ_INSERT_TAIL(&tty_sigqueue, tp, t_sigqueue);
   2632  1.201        ad 	softint_schedule(tty_sigsih);
   2633  1.201        ad }
   2634  1.201        ad 
   2635  1.201        ad /*
   2636  1.201        ad  * Deliver deferred signals from ttys.  Note that the process groups
   2637  1.201        ad  * and sessions associated with the ttys may have changed from when
   2638  1.201        ad  * the signal was originally sent, but in practice it should not matter.
   2639  1.201        ad  * For signals produced as a result of a syscall, the soft interrupt
   2640  1.201        ad  * will fire before the syscall returns to the user.
   2641  1.201        ad  */
   2642  1.201        ad static void
   2643  1.201        ad ttysigintr(void *cookie)
   2644  1.201        ad {
   2645  1.201        ad 	struct tty *tp;
   2646  1.201        ad 	enum ttysigtype st;
   2647  1.201        ad 	struct pgrp *pgrp;
   2648  1.201        ad 	struct session *sess;
   2649  1.201        ad 	int sig;
   2650  1.201        ad 
   2651  1.202        ad 	/* XXXSMP notyet mutex_enter(&proclist_lock); */
   2652  1.201        ad 	for (;;) {
   2653  1.201        ad 		mutex_spin_enter(&tty_lock);
   2654  1.201        ad 		if ((tp = TAILQ_FIRST(&tty_sigqueue)) == NULL) {
   2655  1.201        ad 			mutex_spin_exit(&tty_lock);
   2656  1.201        ad 			break;
   2657  1.201        ad 		}
   2658  1.201        ad 		KASSERT(tp->t_sigcount > 0);
   2659  1.202        ad 		for (st = 0; st < TTYSIG_COUNT; st++) {
   2660  1.202        ad 			if ((sig = firstsig(&tp->t_sigs[st])) != 0)
   2661  1.202        ad 				break;
   2662  1.201        ad 		}
   2663  1.202        ad 		KASSERT(st < TTYSIG_COUNT);
   2664  1.202        ad 		sigdelset(&tp->t_sigs[st], sig);
   2665  1.201        ad 		if (--tp->t_sigcount == 0)
   2666  1.201        ad 			TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue);
   2667  1.201        ad 		pgrp = tp->t_pgrp;
   2668  1.201        ad 		sess = tp->t_session;
   2669  1.201        ad 		mutex_spin_exit(&tty_lock);
   2670  1.201        ad 		if (sig == 0)
   2671  1.201        ad 			panic("ttysigintr");
   2672  1.201        ad 		mutex_enter(&proclist_mutex);
   2673  1.201        ad 		switch (st) {
   2674  1.201        ad 		case TTYSIG_PG1:
   2675  1.201        ad 			if (pgrp != NULL)
   2676  1.201        ad 				pgsignal(pgrp, sig, 1);
   2677  1.201        ad 			break;
   2678  1.201        ad 		case TTYSIG_PG2:
   2679  1.203        ad 			if (pgrp != NULL)
   2680  1.203        ad 				pgsignal(pgrp, sig, sess != NULL);
   2681  1.201        ad 			break;
   2682  1.201        ad 		case TTYSIG_LEADER:
   2683  1.201        ad 			if (sess != NULL && sess->s_leader != NULL)
   2684  1.201        ad 				psignal(sess->s_leader, sig);
   2685  1.201        ad 			break;
   2686  1.202        ad 		default:
   2687  1.202        ad 			/* NOTREACHED */
   2688  1.202        ad 			break;
   2689  1.201        ad 		}
   2690  1.201        ad 		mutex_exit(&proclist_mutex);
   2691  1.201        ad 	}
   2692  1.203        ad 
   2693  1.203        ad 
   2694  1.202        ad 	/* XXXSMP notyet mutex_exit(&proclist_lock); */
   2695  1.201        ad }
   2696