Home | History | Annotate | Line # | Download | only in kern
tty.c revision 1.116
      1  1.116   thorpej /*	$NetBSD: tty.c,v 1.116 2000/03/23 06:30:12 thorpej 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.49       cgd  * 3. All advertising materials mentioning features or use of this software
     21   1.49       cgd  *    must display the following acknowledgement:
     22   1.49       cgd  *	This product includes software developed by the University of
     23   1.49       cgd  *	California, Berkeley and its contributors.
     24   1.49       cgd  * 4. Neither the name of the University nor the names of its contributors
     25   1.49       cgd  *    may be used to endorse or promote products derived from this software
     26   1.49       cgd  *    without specific prior written permission.
     27   1.49       cgd  *
     28   1.49       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29   1.49       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30   1.49       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31   1.49       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32   1.49       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33   1.49       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34   1.49       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35   1.49       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36   1.49       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37   1.49       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38   1.49       cgd  * SUCH DAMAGE.
     39   1.49       cgd  *
     40  1.105      fvdl  *	@(#)tty.c	8.13 (Berkeley) 1/9/95
     41   1.49       cgd  */
     42  1.100   thorpej 
     43  1.100   thorpej #include "opt_uconsole.h"
     44   1.49       cgd 
     45   1.49       cgd #include <sys/param.h>
     46   1.49       cgd #include <sys/systm.h>
     47   1.49       cgd #include <sys/ioctl.h>
     48   1.49       cgd #include <sys/proc.h>
     49   1.49       cgd #define	TTYDEFCHARS
     50   1.49       cgd #include <sys/tty.h>
     51   1.49       cgd #undef	TTYDEFCHARS
     52   1.49       cgd #include <sys/file.h>
     53   1.49       cgd #include <sys/conf.h>
     54   1.49       cgd #include <sys/dkstat.h>
     55   1.49       cgd #include <sys/uio.h>
     56   1.49       cgd #include <sys/kernel.h>
     57   1.49       cgd #include <sys/vnode.h>
     58   1.49       cgd #include <sys/syslog.h>
     59   1.49       cgd #include <sys/malloc.h>
     60  1.111   thorpej #include <sys/pool.h>
     61   1.65  christos #include <sys/signalvar.h>
     62   1.65  christos #include <sys/resourcevar.h>
     63   1.74   mycroft #include <sys/poll.h>
     64   1.49       cgd 
     65   1.49       cgd #include <vm/vm.h>
     66   1.49       cgd 
     67   1.65  christos static int ttnread __P((struct tty *));
     68   1.65  christos static void ttyblock __P((struct tty *));
     69   1.65  christos static void ttyecho __P((int, struct tty *));
     70   1.65  christos static void ttyrubo __P((struct tty *, int));
     71   1.65  christos static int proc_compare __P((struct proc *, struct proc *));
     72   1.49       cgd 
     73   1.49       cgd /* Symbolic sleep message strings. */
     74   1.98   mycroft const char	ttclos[] = "ttycls";
     75   1.98   mycroft const char	ttopen[] = "ttyopn";
     76   1.98   mycroft const char	ttybg[] = "ttybg";
     77   1.98   mycroft const char	ttyin[] = "ttyin";
     78   1.98   mycroft const char	ttyout[] = "ttyout";
     79   1.49       cgd 
     80   1.49       cgd /*
     81   1.83   mycroft  * Used to determine whether we still have a connection.  This is true in
     82   1.83   mycroft  * one of 3 cases:
     83   1.83   mycroft  * 1) We have carrier.
     84   1.83   mycroft  * 2) It's a locally attached terminal, and we are therefore ignoring carrier.
     85   1.83   mycroft  * 3) We're using a flow control mechanism that overloads the carrier signal.
     86   1.83   mycroft  */
     87   1.83   mycroft #define	CONNECTED(tp)	(ISSET(tp->t_state, TS_CARR_ON) ||	\
     88   1.83   mycroft 			 ISSET(tp->t_cflag, CLOCAL | MDMBUF))
     89   1.83   mycroft 
     90   1.83   mycroft /*
     91   1.49       cgd  * Table with character classes and parity. The 8th bit indicates parity,
     92   1.49       cgd  * the 7th bit indicates the character is an alphameric or underscore (for
     93   1.49       cgd  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
     94   1.49       cgd  * are 0 then the character needs no special processing on output; classes
     95   1.49       cgd  * other than 0 might be translated or (not currently) require delays.
     96   1.49       cgd  */
     97   1.49       cgd #define	E	0x00	/* Even parity. */
     98   1.49       cgd #define	O	0x80	/* Odd parity. */
     99   1.49       cgd #define	PARITY(c)	(char_type[c] & O)
    100   1.49       cgd 
    101   1.49       cgd #define	ALPHA	0x40	/* Alpha or underscore. */
    102   1.49       cgd #define	ISALPHA(c)	(char_type[(c) & TTY_CHARMASK] & ALPHA)
    103   1.49       cgd 
    104   1.49       cgd #define	CCLASSMASK	0x3f
    105   1.49       cgd #define	CCLASS(c)	(char_type[c] & CCLASSMASK)
    106   1.49       cgd 
    107   1.49       cgd #define	BS	BACKSPACE
    108   1.49       cgd #define	CC	CONTROL
    109   1.49       cgd #define	CR	RETURN
    110   1.49       cgd #define	NA	ORDINARY | ALPHA
    111   1.49       cgd #define	NL	NEWLINE
    112   1.49       cgd #define	NO	ORDINARY
    113   1.49       cgd #define	TB	TAB
    114   1.49       cgd #define	VT	VTAB
    115   1.49       cgd 
    116   1.49       cgd char const char_type[] = {
    117   1.49       cgd 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC,	/* nul - bel */
    118   1.49       cgd 	O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
    119   1.49       cgd 	O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
    120   1.49       cgd 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
    121   1.49       cgd 	O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
    122   1.49       cgd 	E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
    123   1.49       cgd 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
    124   1.49       cgd 	O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
    125   1.49       cgd 	O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
    126   1.49       cgd 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
    127   1.49       cgd 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
    128   1.49       cgd 	O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
    129   1.49       cgd 	E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
    130   1.49       cgd 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
    131   1.49       cgd 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
    132   1.49       cgd 	E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
    133   1.49       cgd 	/*
    134   1.49       cgd 	 * Meta chars; should be settable per character set;
    135   1.49       cgd 	 * for now, treat them all as normal characters.
    136   1.49       cgd 	 */
    137   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    138   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    139   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    140   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    141   1.49       cgd 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
    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 };
    154   1.49       cgd #undef	BS
    155   1.49       cgd #undef	CC
    156   1.49       cgd #undef	CR
    157   1.49       cgd #undef	NA
    158   1.49       cgd #undef	NL
    159   1.49       cgd #undef	NO
    160   1.49       cgd #undef	TB
    161   1.49       cgd #undef	VT
    162   1.49       cgd 
    163   1.49       cgd /* Macros to clear/set/test flags. */
    164   1.49       cgd #define	SET(t, f)	(t) |= (f)
    165   1.65  christos #define	CLR(t, f)	(t) &= ~((unsigned)(f))
    166   1.49       cgd #define	ISSET(t, f)	((t) & (f))
    167   1.49       cgd 
    168   1.69       mrg struct ttylist_head ttylist;	/* TAILQ_HEAD */
    169   1.69       mrg int tty_count;
    170   1.69       mrg 
    171  1.111   thorpej struct pool tty_pool;
    172  1.111   thorpej 
    173  1.107   mycroft int
    174  1.107   mycroft ttyopen(tp, dialout, nonblock)
    175  1.107   mycroft 	struct tty *tp;
    176  1.107   mycroft 	int dialout, nonblock;
    177  1.107   mycroft {
    178  1.107   mycroft 	int s;
    179  1.107   mycroft 	int error;
    180  1.107   mycroft 
    181  1.107   mycroft 	s = spltty();
    182  1.107   mycroft 
    183  1.107   mycroft 	if (dialout) {
    184  1.107   mycroft 		/*
    185  1.107   mycroft 		 * If the device is already open for non-dialout, fail.
    186  1.107   mycroft 		 * Otherwise, set TS_DIALOUT to block any pending non-dialout
    187  1.107   mycroft 		 * opens.
    188  1.107   mycroft 		 */
    189  1.107   mycroft 		if (ISSET(tp->t_state, TS_ISOPEN) &&
    190  1.107   mycroft 		    !ISSET(tp->t_state, TS_DIALOUT)) {
    191  1.107   mycroft 			splx(s);
    192  1.107   mycroft 			return (EBUSY);
    193  1.107   mycroft 		}
    194  1.107   mycroft 		SET(tp->t_state, TS_DIALOUT);
    195  1.107   mycroft 	} else {
    196  1.107   mycroft 		if (!nonblock) {
    197  1.107   mycroft 			/*
    198  1.107   mycroft 			 * Wait for carrier.  Also wait for any dialout
    199  1.107   mycroft 			 * processes to close the tty first.
    200  1.107   mycroft 			 */
    201  1.107   mycroft 			while (ISSET(tp->t_state, TS_DIALOUT) ||
    202  1.107   mycroft 			       (!ISSET(tp->t_state, TS_CARR_ON) &&
    203  1.107   mycroft 				!ISSET(tp->t_cflag, CLOCAL | MDMBUF))) {
    204  1.107   mycroft 				tp->t_wopen++;
    205  1.107   mycroft 				error = ttysleep(tp, &tp->t_rawq,
    206  1.107   mycroft 				    TTIPRI | PCATCH, ttopen, 0);
    207  1.107   mycroft 				tp->t_wopen--;
    208  1.107   mycroft 				if (error) {
    209  1.107   mycroft 					splx(s);
    210  1.107   mycroft 					return (error);
    211  1.107   mycroft 				}
    212  1.107   mycroft 			}
    213  1.107   mycroft 		} else {
    214  1.107   mycroft 			/*
    215  1.107   mycroft 			 * Don't allow a non-blocking non-dialout open if the
    216  1.107   mycroft 			 * device is already open for dialout.
    217  1.107   mycroft 			 */
    218  1.107   mycroft 		        if (ISSET(tp->t_state, TS_DIALOUT)) {
    219  1.107   mycroft 				splx(s);
    220  1.107   mycroft 				return (EBUSY);
    221  1.107   mycroft 			}
    222  1.107   mycroft 		}
    223  1.107   mycroft 	}
    224  1.107   mycroft 
    225  1.107   mycroft 	splx(s);
    226  1.107   mycroft 	return (0);
    227  1.107   mycroft }
    228  1.107   mycroft 
    229   1.49       cgd /*
    230   1.49       cgd  * Initial open of tty, or (re)entry to standard tty line discipline.
    231   1.49       cgd  */
    232   1.49       cgd int
    233  1.107   mycroft ttylopen(device, tp)
    234   1.49       cgd 	dev_t device;
    235   1.49       cgd 	register struct tty *tp;
    236   1.49       cgd {
    237   1.49       cgd 	int s;
    238   1.49       cgd 
    239   1.49       cgd 	s = spltty();
    240   1.49       cgd 	tp->t_dev = device;
    241   1.49       cgd 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    242   1.49       cgd 		SET(tp->t_state, TS_ISOPEN);
    243  1.109     perry 		memset(&tp->t_winsize, 0, sizeof(tp->t_winsize));
    244   1.66  christos #ifdef COMPAT_OLDTTY
    245   1.50   mycroft 		tp->t_flags = 0;
    246   1.50   mycroft #endif
    247   1.49       cgd 	}
    248   1.49       cgd 	splx(s);
    249   1.49       cgd 	return (0);
    250   1.49       cgd }
    251   1.49       cgd 
    252   1.49       cgd /*
    253   1.49       cgd  * Handle close() on a tty line: flush and set to initial state,
    254   1.49       cgd  * bumping generation number so that pending read/write calls
    255   1.49       cgd  * can detect recycling of the tty.
    256   1.49       cgd  */
    257   1.49       cgd int
    258   1.49       cgd ttyclose(tp)
    259   1.49       cgd 	register struct tty *tp;
    260   1.49       cgd {
    261   1.49       cgd 	extern struct tty *constty;	/* Temporary virtual console. */
    262   1.49       cgd 
    263   1.49       cgd 	if (constty == tp)
    264   1.49       cgd 		constty = NULL;
    265   1.49       cgd 
    266   1.49       cgd 	ttyflush(tp, FREAD | FWRITE);
    267   1.49       cgd 
    268   1.49       cgd 	tp->t_gen++;
    269   1.49       cgd 	tp->t_pgrp = NULL;
    270   1.49       cgd 	tp->t_session = NULL;
    271   1.49       cgd 	tp->t_state = 0;
    272   1.49       cgd 	return (0);
    273   1.49       cgd }
    274   1.49       cgd 
    275   1.49       cgd #define	FLUSHQ(q) {							\
    276   1.49       cgd 	if ((q)->c_cc)							\
    277   1.49       cgd 		ndflush(q, (q)->c_cc);					\
    278   1.49       cgd }
    279   1.49       cgd 
    280   1.88    kleink /*
    281   1.88    kleink  * This macro is used in canonical mode input processing, where a read
    282   1.88    kleink  * request shall not return unless a 'line delimiter' ('\n') or 'break'
    283   1.88    kleink  * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2
    284   1.88    kleink  * is an extension to the POSIX.1 defined set of special characters,
    285   1.88    kleink  * recognize it only if IEXTEN is set in the set of local flags.
    286   1.88    kleink  */
    287   1.85    kleink #define	TTBREAKC(c, lflg)						\
    288   1.87       cgd 	((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] ||		\
    289   1.85    kleink 	((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE))
    290   1.49       cgd 
    291   1.49       cgd 
    292   1.49       cgd /*
    293   1.49       cgd  * Process input of a single character received on a tty.
    294   1.49       cgd  */
    295   1.49       cgd int
    296   1.49       cgd ttyinput(c, tp)
    297   1.49       cgd 	register int c;
    298   1.49       cgd 	register struct tty *tp;
    299   1.49       cgd {
    300   1.49       cgd 	register int iflag, lflag;
    301   1.49       cgd 	register u_char *cc;
    302   1.65  christos 	int i, error;
    303   1.78  christos 
    304   1.78  christos 	/*
    305   1.78  christos 	 * Unless the receiver is enabled, drop incoming data.
    306   1.78  christos 	 */
    307   1.78  christos 	if (!ISSET(tp->t_cflag, CREAD))
    308   1.78  christos 		return (0);
    309   1.49       cgd 
    310   1.49       cgd 	/*
    311   1.49       cgd 	 * If input is pending take it first.
    312   1.49       cgd 	 */
    313   1.49       cgd 	lflag = tp->t_lflag;
    314   1.49       cgd 	if (ISSET(lflag, PENDIN))
    315   1.49       cgd 		ttypend(tp);
    316   1.49       cgd 	/*
    317   1.49       cgd 	 * Gather stats.
    318   1.49       cgd 	 */
    319   1.49       cgd 	if (ISSET(lflag, ICANON)) {
    320   1.49       cgd 		++tk_cancc;
    321   1.49       cgd 		++tp->t_cancc;
    322   1.49       cgd 	} else {
    323   1.49       cgd 		++tk_rawcc;
    324   1.49       cgd 		++tp->t_rawcc;
    325   1.49       cgd 	}
    326   1.49       cgd 	++tk_nin;
    327   1.49       cgd 
    328   1.49       cgd 	cc = tp->t_cc;
    329   1.94    kleink 
    330   1.94    kleink 	/*
    331   1.94    kleink 	 * Handle exceptional conditions (break, parity, framing).
    332   1.94    kleink 	 */
    333   1.49       cgd 	iflag = tp->t_iflag;
    334   1.65  christos 	if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
    335   1.49       cgd 		CLR(c, TTY_ERRORMASK);
    336   1.94    kleink 		if (ISSET(error, TTY_FE) && c == 0) {		/* Break. */
    337   1.49       cgd 			if (ISSET(iflag, IGNBRK))
    338   1.94    kleink 				return (0);
    339   1.94    kleink 			else if (ISSET(iflag, BRKINT)) {
    340   1.94    kleink 				ttyflush(tp, FREAD | FWRITE);
    341   1.94    kleink 				pgsignal(tp->t_pgrp, SIGINT, 1);
    342   1.94    kleink 				return (0);
    343   1.94    kleink 			}
    344   1.49       cgd 			else if (ISSET(iflag, PARMRK))
    345   1.49       cgd 				goto parmrk;
    346   1.94    kleink 		}
    347   1.94    kleink 		else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
    348   1.94    kleink 		    ISSET(error, TTY_FE)) {
    349   1.49       cgd 			if (ISSET(iflag, IGNPAR))
    350   1.94    kleink 				return (0);
    351   1.49       cgd 			else if (ISSET(iflag, PARMRK)) {
    352   1.49       cgd parmrk:				(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    353   1.94    kleink 				(void)putc(0    | TTY_QUOTE, &tp->t_rawq);
    354   1.94    kleink 				(void)putc(c    | TTY_QUOTE, &tp->t_rawq);
    355   1.94    kleink 				return (0);
    356   1.94    kleink 			}
    357   1.94    kleink 			else
    358   1.49       cgd 				c = 0;
    359   1.49       cgd 		}
    360   1.49       cgd 	}
    361   1.94    kleink 	else if (c == 0377 &&
    362   1.94    kleink 	    ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) {
    363   1.94    kleink 		/* "Escape" a valid character of '\377'. */
    364   1.94    kleink 		(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    365   1.94    kleink 		(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
    366   1.94    kleink 		goto endcase;
    367   1.94    kleink 	}
    368   1.94    kleink 
    369   1.49       cgd 	/*
    370   1.49       cgd 	 * In tandem mode, check high water mark.
    371   1.49       cgd 	 */
    372   1.49       cgd 	if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
    373   1.49       cgd 		ttyblock(tp);
    374   1.49       cgd 	if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
    375   1.49       cgd 		CLR(c, 0x80);
    376   1.49       cgd 	if (!ISSET(lflag, EXTPROC)) {
    377   1.49       cgd 		/*
    378   1.49       cgd 		 * Check for literal nexting very first
    379   1.49       cgd 		 */
    380   1.49       cgd 		if (ISSET(tp->t_state, TS_LNCH)) {
    381   1.49       cgd 			SET(c, TTY_QUOTE);
    382   1.49       cgd 			CLR(tp->t_state, TS_LNCH);
    383   1.49       cgd 		}
    384   1.49       cgd 		/*
    385   1.49       cgd 		 * Scan for special characters.  This code
    386   1.49       cgd 		 * is really just a big case statement with
    387   1.49       cgd 		 * non-constant cases.  The bottom of the
    388   1.49       cgd 		 * case statement is labeled ``endcase'', so goto
    389   1.49       cgd 		 * it after a case match, or similar.
    390   1.49       cgd 		 */
    391   1.49       cgd 
    392   1.49       cgd 		/*
    393   1.49       cgd 		 * Control chars which aren't controlled
    394   1.49       cgd 		 * by ICANON, ISIG, or IXON.
    395   1.49       cgd 		 */
    396   1.49       cgd 		if (ISSET(lflag, IEXTEN)) {
    397   1.49       cgd 			if (CCEQ(cc[VLNEXT], c)) {
    398   1.49       cgd 				if (ISSET(lflag, ECHO)) {
    399   1.49       cgd 					if (ISSET(lflag, ECHOE)) {
    400   1.49       cgd 						(void)ttyoutput('^', tp);
    401   1.49       cgd 						(void)ttyoutput('\b', tp);
    402   1.49       cgd 					} else
    403   1.49       cgd 						ttyecho(c, tp);
    404   1.49       cgd 				}
    405   1.49       cgd 				SET(tp->t_state, TS_LNCH);
    406   1.49       cgd 				goto endcase;
    407   1.49       cgd 			}
    408   1.49       cgd 			if (CCEQ(cc[VDISCARD], c)) {
    409   1.49       cgd 				if (ISSET(lflag, FLUSHO))
    410   1.49       cgd 					CLR(tp->t_lflag, FLUSHO);
    411   1.49       cgd 				else {
    412   1.49       cgd 					ttyflush(tp, FWRITE);
    413   1.49       cgd 					ttyecho(c, tp);
    414   1.49       cgd 					if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
    415   1.49       cgd 						ttyretype(tp);
    416   1.49       cgd 					SET(tp->t_lflag, FLUSHO);
    417   1.49       cgd 				}
    418   1.49       cgd 				goto startoutput;
    419   1.49       cgd 			}
    420   1.49       cgd 		}
    421   1.49       cgd 		/*
    422   1.49       cgd 		 * Signals.
    423   1.49       cgd 		 */
    424   1.49       cgd 		if (ISSET(lflag, ISIG)) {
    425   1.49       cgd 			if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
    426   1.49       cgd 				if (!ISSET(lflag, NOFLSH))
    427   1.49       cgd 					ttyflush(tp, FREAD | FWRITE);
    428   1.49       cgd 				ttyecho(c, tp);
    429   1.49       cgd 				pgsignal(tp->t_pgrp,
    430   1.49       cgd 				    CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
    431   1.49       cgd 				goto endcase;
    432   1.49       cgd 			}
    433   1.49       cgd 			if (CCEQ(cc[VSUSP], c)) {
    434   1.49       cgd 				if (!ISSET(lflag, NOFLSH))
    435   1.49       cgd 					ttyflush(tp, FREAD);
    436   1.49       cgd 				ttyecho(c, tp);
    437   1.49       cgd 				pgsignal(tp->t_pgrp, SIGTSTP, 1);
    438   1.49       cgd 				goto endcase;
    439   1.49       cgd 			}
    440   1.49       cgd 		}
    441   1.49       cgd 		/*
    442   1.49       cgd 		 * Handle start/stop characters.
    443   1.49       cgd 		 */
    444   1.49       cgd 		if (ISSET(iflag, IXON)) {
    445   1.49       cgd 			if (CCEQ(cc[VSTOP], c)) {
    446   1.49       cgd 				if (!ISSET(tp->t_state, TS_TTSTOP)) {
    447   1.49       cgd 					SET(tp->t_state, TS_TTSTOP);
    448   1.49       cgd 					(*cdevsw[major(tp->t_dev)].d_stop)(tp,
    449   1.49       cgd 					   0);
    450   1.49       cgd 					return (0);
    451   1.49       cgd 				}
    452   1.49       cgd 				if (!CCEQ(cc[VSTART], c))
    453   1.49       cgd 					return (0);
    454   1.49       cgd 				/*
    455   1.49       cgd 				 * if VSTART == VSTOP then toggle
    456   1.49       cgd 				 */
    457   1.49       cgd 				goto endcase;
    458   1.49       cgd 			}
    459   1.49       cgd 			if (CCEQ(cc[VSTART], c))
    460   1.49       cgd 				goto restartoutput;
    461   1.49       cgd 		}
    462   1.49       cgd 		/*
    463   1.49       cgd 		 * IGNCR, ICRNL, & INLCR
    464   1.49       cgd 		 */
    465   1.49       cgd 		if (c == '\r') {
    466   1.49       cgd 			if (ISSET(iflag, IGNCR))
    467   1.49       cgd 				goto endcase;
    468   1.49       cgd 			else if (ISSET(iflag, ICRNL))
    469   1.49       cgd 				c = '\n';
    470   1.49       cgd 		} else if (c == '\n' && ISSET(iflag, INLCR))
    471   1.49       cgd 			c = '\r';
    472   1.49       cgd 	}
    473   1.49       cgd 	if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
    474   1.49       cgd 		/*
    475   1.49       cgd 		 * From here on down canonical mode character
    476   1.49       cgd 		 * processing takes place.
    477   1.49       cgd 		 */
    478   1.49       cgd 		/*
    479   1.49       cgd 		 * erase (^H / ^?)
    480   1.49       cgd 		 */
    481   1.49       cgd 		if (CCEQ(cc[VERASE], c)) {
    482   1.49       cgd 			if (tp->t_rawq.c_cc)
    483   1.49       cgd 				ttyrub(unputc(&tp->t_rawq), tp);
    484   1.49       cgd 			goto endcase;
    485   1.49       cgd 		}
    486   1.49       cgd 		/*
    487   1.49       cgd 		 * kill (^U)
    488   1.49       cgd 		 */
    489   1.49       cgd 		if (CCEQ(cc[VKILL], c)) {
    490   1.49       cgd 			if (ISSET(lflag, ECHOKE) &&
    491   1.49       cgd 			    tp->t_rawq.c_cc == tp->t_rocount &&
    492   1.49       cgd 			    !ISSET(lflag, ECHOPRT))
    493   1.49       cgd 				while (tp->t_rawq.c_cc)
    494   1.49       cgd 					ttyrub(unputc(&tp->t_rawq), tp);
    495   1.49       cgd 			else {
    496   1.49       cgd 				ttyecho(c, tp);
    497   1.49       cgd 				if (ISSET(lflag, ECHOK) ||
    498   1.49       cgd 				    ISSET(lflag, ECHOKE))
    499   1.49       cgd 					ttyecho('\n', tp);
    500   1.49       cgd 				FLUSHQ(&tp->t_rawq);
    501   1.49       cgd 				tp->t_rocount = 0;
    502   1.49       cgd 			}
    503   1.49       cgd 			CLR(tp->t_state, TS_LOCAL);
    504   1.49       cgd 			goto endcase;
    505   1.49       cgd 		}
    506   1.49       cgd 		/*
    507   1.81    kleink 		 * Extensions to the POSIX.1 GTI set of functions.
    508   1.49       cgd 		 */
    509   1.81    kleink 		if (ISSET(lflag, IEXTEN)) {
    510   1.49       cgd 			/*
    511   1.81    kleink 			 * word erase (^W)
    512   1.49       cgd 			 */
    513   1.81    kleink 			if (CCEQ(cc[VWERASE], c)) {
    514   1.81    kleink 				int alt = ISSET(lflag, ALTWERASE);
    515   1.81    kleink 				int ctype;
    516   1.81    kleink 
    517   1.81    kleink 				/*
    518   1.81    kleink 				 * erase whitespace
    519   1.81    kleink 				 */
    520   1.81    kleink 				while ((c = unputc(&tp->t_rawq)) == ' ' ||
    521   1.81    kleink 				       c == '\t')
    522   1.81    kleink 					ttyrub(c, tp);
    523   1.81    kleink 				if (c == -1)
    524   1.81    kleink 					goto endcase;
    525   1.81    kleink 				/*
    526   1.81    kleink 				 * erase last char of word and remember the
    527   1.81    kleink 				 * next chars type (for ALTWERASE)
    528   1.81    kleink 				 */
    529   1.49       cgd 				ttyrub(c, tp);
    530   1.81    kleink 				c = unputc(&tp->t_rawq);
    531   1.81    kleink 				if (c == -1)
    532   1.81    kleink 					goto endcase;
    533   1.81    kleink 				if (c == ' ' || c == '\t') {
    534   1.81    kleink 					(void)putc(c, &tp->t_rawq);
    535   1.81    kleink 					goto endcase;
    536   1.81    kleink 				}
    537   1.81    kleink 				ctype = ISALPHA(c);
    538   1.81    kleink 				/*
    539   1.81    kleink 				 * erase rest of word
    540   1.81    kleink 				 */
    541   1.81    kleink 				do {
    542   1.81    kleink 					ttyrub(c, tp);
    543   1.81    kleink 					c = unputc(&tp->t_rawq);
    544   1.81    kleink 					if (c == -1)
    545   1.81    kleink 						goto endcase;
    546   1.81    kleink 				} while (c != ' ' && c != '\t' &&
    547   1.81    kleink 				         (alt == 0 || ISALPHA(c) == ctype));
    548   1.81    kleink 				(void)putc(c, &tp->t_rawq);
    549   1.49       cgd 				goto endcase;
    550   1.81    kleink 			}
    551   1.49       cgd 			/*
    552   1.81    kleink 			 * reprint line (^R)
    553   1.49       cgd 			 */
    554   1.81    kleink 			if (CCEQ(cc[VREPRINT], c)) {
    555   1.81    kleink 				ttyretype(tp);
    556   1.49       cgd 				goto endcase;
    557   1.49       cgd 			}
    558   1.49       cgd 			/*
    559   1.81    kleink 			 * ^T - kernel info and generate SIGINFO
    560   1.49       cgd 			 */
    561   1.81    kleink 			if (CCEQ(cc[VSTATUS], c)) {
    562   1.81    kleink 				if (ISSET(lflag, ISIG))
    563   1.81    kleink 					pgsignal(tp->t_pgrp, SIGINFO, 1);
    564   1.81    kleink 				if (!ISSET(lflag, NOKERNINFO))
    565   1.81    kleink 					ttyinfo(tp);
    566   1.81    kleink 				goto endcase;
    567   1.81    kleink 			}
    568   1.49       cgd 		}
    569   1.49       cgd 	}
    570   1.49       cgd 	/*
    571   1.49       cgd 	 * Check for input buffer overflow
    572   1.49       cgd 	 */
    573   1.49       cgd 	if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
    574   1.49       cgd 		if (ISSET(iflag, IMAXBEL)) {
    575   1.49       cgd 			if (tp->t_outq.c_cc < tp->t_hiwat)
    576   1.49       cgd 				(void)ttyoutput(CTRL('g'), tp);
    577   1.49       cgd 		} else
    578   1.49       cgd 			ttyflush(tp, FREAD | FWRITE);
    579   1.49       cgd 		goto endcase;
    580   1.49       cgd 	}
    581   1.49       cgd 	/*
    582   1.49       cgd 	 * Put data char in q for user and
    583   1.49       cgd 	 * wakeup on seeing a line delimiter.
    584   1.49       cgd 	 */
    585   1.49       cgd 	if (putc(c, &tp->t_rawq) >= 0) {
    586   1.49       cgd 		if (!ISSET(lflag, ICANON)) {
    587   1.49       cgd 			ttwakeup(tp);
    588   1.49       cgd 			ttyecho(c, tp);
    589   1.49       cgd 			goto endcase;
    590   1.49       cgd 		}
    591   1.85    kleink 		if (TTBREAKC(c, lflag)) {
    592   1.49       cgd 			tp->t_rocount = 0;
    593   1.49       cgd 			catq(&tp->t_rawq, &tp->t_canq);
    594   1.49       cgd 			ttwakeup(tp);
    595   1.49       cgd 		} else if (tp->t_rocount++ == 0)
    596   1.49       cgd 			tp->t_rocol = tp->t_column;
    597   1.49       cgd 		if (ISSET(tp->t_state, TS_ERASE)) {
    598   1.49       cgd 			/*
    599   1.49       cgd 			 * end of prterase \.../
    600   1.49       cgd 			 */
    601   1.49       cgd 			CLR(tp->t_state, TS_ERASE);
    602   1.49       cgd 			(void)ttyoutput('/', tp);
    603   1.49       cgd 		}
    604   1.49       cgd 		i = tp->t_column;
    605   1.49       cgd 		ttyecho(c, tp);
    606   1.49       cgd 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
    607   1.49       cgd 			/*
    608   1.49       cgd 			 * Place the cursor over the '^' of the ^D.
    609   1.49       cgd 			 */
    610   1.49       cgd 			i = min(2, tp->t_column - i);
    611   1.49       cgd 			while (i > 0) {
    612   1.49       cgd 				(void)ttyoutput('\b', tp);
    613   1.49       cgd 				i--;
    614   1.49       cgd 			}
    615   1.49       cgd 		}
    616   1.49       cgd 	}
    617   1.49       cgd endcase:
    618   1.49       cgd 	/*
    619   1.49       cgd 	 * IXANY means allow any character to restart output.
    620   1.49       cgd 	 */
    621   1.49       cgd 	if (ISSET(tp->t_state, TS_TTSTOP) &&
    622   1.49       cgd 	    !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
    623   1.49       cgd 		return (0);
    624   1.49       cgd restartoutput:
    625   1.49       cgd 	CLR(tp->t_lflag, FLUSHO);
    626   1.49       cgd 	CLR(tp->t_state, TS_TTSTOP);
    627   1.49       cgd startoutput:
    628   1.49       cgd 	return (ttstart(tp));
    629   1.49       cgd }
    630   1.49       cgd 
    631   1.49       cgd /*
    632   1.49       cgd  * Output a single character on a tty, doing output processing
    633   1.49       cgd  * as needed (expanding tabs, newline processing, etc.).
    634   1.49       cgd  * Returns < 0 if succeeds, otherwise returns char to resend.
    635   1.49       cgd  * Must be recursive.
    636   1.49       cgd  */
    637   1.49       cgd int
    638   1.49       cgd ttyoutput(c, tp)
    639   1.49       cgd 	register int c;
    640   1.49       cgd 	register struct tty *tp;
    641   1.49       cgd {
    642   1.49       cgd 	register long oflag;
    643   1.49       cgd 	register int col, notout, s;
    644   1.49       cgd 
    645   1.49       cgd 	oflag = tp->t_oflag;
    646   1.49       cgd 	if (!ISSET(oflag, OPOST)) {
    647   1.49       cgd 		tk_nout++;
    648   1.49       cgd 		tp->t_outcc++;
    649   1.99   mycroft 		if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
    650   1.99   mycroft 			return (c);
    651   1.49       cgd 		return (-1);
    652   1.49       cgd 	}
    653   1.49       cgd 	/*
    654  1.103    kleink 	 * Do tab expansion if OXTABS is set.  Special case if we do external
    655   1.49       cgd 	 * processing, we don't do the tab expansion because we'll probably
    656   1.49       cgd 	 * get it wrong.  If tab expansion needs to be done, let it happen
    657   1.49       cgd 	 * externally.
    658   1.49       cgd 	 */
    659   1.49       cgd 	CLR(c, ~TTY_CHARMASK);
    660   1.49       cgd 	if (c == '\t' &&
    661   1.49       cgd 	    ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
    662   1.49       cgd 		c = 8 - (tp->t_column & 7);
    663   1.49       cgd 		if (ISSET(tp->t_lflag, FLUSHO)) {
    664   1.49       cgd 			notout = 0;
    665   1.49       cgd 		} else {
    666   1.49       cgd 			s = spltty();		/* Don't interrupt tabs. */
    667   1.49       cgd 			notout = b_to_q("        ", c, &tp->t_outq);
    668   1.49       cgd 			c -= notout;
    669   1.49       cgd 			tk_nout += c;
    670   1.49       cgd 			tp->t_outcc += c;
    671   1.49       cgd 			splx(s);
    672   1.49       cgd 		}
    673   1.49       cgd 		tp->t_column += c;
    674   1.49       cgd 		return (notout ? '\t' : -1);
    675   1.49       cgd 	}
    676   1.49       cgd 	if (c == CEOT && ISSET(oflag, ONOEOT))
    677   1.49       cgd 		return (-1);
    678   1.49       cgd 
    679   1.49       cgd 	/*
    680   1.49       cgd 	 * Newline translation: if ONLCR is set,
    681   1.49       cgd 	 * translate newline into "\r\n".
    682   1.49       cgd 	 */
    683   1.49       cgd 	if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
    684   1.49       cgd 		tk_nout++;
    685   1.49       cgd 		tp->t_outcc++;
    686   1.99   mycroft 		if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
    687   1.49       cgd 			return (c);
    688   1.49       cgd 	}
    689  1.103    kleink 	/* If OCRNL is set, translate "\r" into "\n". */
    690   1.79    kleink 	else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
    691   1.79    kleink 		c = '\n';
    692  1.103    kleink 	/* If ONOCR is set, don't transmit CRs when on column 0. */
    693  1.103    kleink 	else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
    694  1.103    kleink 		return (-1);
    695   1.79    kleink 
    696   1.49       cgd 	tk_nout++;
    697   1.49       cgd 	tp->t_outcc++;
    698   1.49       cgd 	if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
    699   1.49       cgd 		return (c);
    700   1.49       cgd 
    701   1.49       cgd 	col = tp->t_column;
    702   1.49       cgd 	switch (CCLASS(c)) {
    703   1.49       cgd 	case BACKSPACE:
    704   1.49       cgd 		if (col > 0)
    705   1.49       cgd 			--col;
    706   1.49       cgd 		break;
    707   1.49       cgd 	case CONTROL:
    708   1.49       cgd 		break;
    709   1.49       cgd 	case NEWLINE:
    710  1.103    kleink 		if (ISSET(tp->t_oflag, ONLCR | ONLRET))
    711   1.79    kleink 			col = 0;
    712   1.79    kleink 		break;
    713   1.49       cgd 	case RETURN:
    714   1.49       cgd 		col = 0;
    715   1.49       cgd 		break;
    716   1.49       cgd 	case ORDINARY:
    717   1.49       cgd 		++col;
    718   1.49       cgd 		break;
    719   1.49       cgd 	case TAB:
    720   1.49       cgd 		col = (col + 8) & ~7;
    721   1.49       cgd 		break;
    722   1.49       cgd 	}
    723   1.49       cgd 	tp->t_column = col;
    724   1.49       cgd 	return (-1);
    725   1.49       cgd }
    726   1.49       cgd 
    727   1.49       cgd /*
    728   1.49       cgd  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
    729   1.49       cgd  * has been called to do discipline-specific functions and/or reject any
    730   1.49       cgd  * of these ioctl commands.
    731   1.49       cgd  */
    732   1.49       cgd /* ARGSUSED */
    733   1.49       cgd int
    734   1.49       cgd ttioctl(tp, cmd, data, flag, p)
    735   1.49       cgd 	register struct tty *tp;
    736   1.55       cgd 	u_long cmd;
    737   1.56   mycroft 	caddr_t data;
    738   1.55       cgd 	int flag;
    739   1.49       cgd 	struct proc *p;
    740   1.49       cgd {
    741   1.49       cgd 	extern struct tty *constty;	/* Temporary virtual console. */
    742   1.49       cgd 	extern int nlinesw;
    743   1.49       cgd 	int s, error;
    744   1.49       cgd 
    745   1.49       cgd 	/* If the ioctl involves modification, hang if in the background. */
    746   1.49       cgd 	switch (cmd) {
    747   1.49       cgd 	case  TIOCFLUSH:
    748   1.92    kleink 	case  TIOCDRAIN:
    749   1.95    kleink 	case  TIOCSBRK:
    750   1.95    kleink 	case  TIOCCBRK:
    751   1.95    kleink 	case  TIOCSTART:
    752   1.49       cgd 	case  TIOCSETA:
    753   1.49       cgd 	case  TIOCSETD:
    754   1.49       cgd 	case  TIOCSETAF:
    755   1.49       cgd 	case  TIOCSETAW:
    756   1.49       cgd #ifdef notdef
    757   1.49       cgd 	case  TIOCSPGRP:
    758   1.49       cgd #endif
    759   1.49       cgd 	case  TIOCSTAT:
    760   1.49       cgd 	case  TIOCSTI:
    761   1.49       cgd 	case  TIOCSWINSZ:
    762   1.66  christos #ifdef COMPAT_OLDTTY
    763   1.49       cgd 	case  TIOCLBIC:
    764   1.49       cgd 	case  TIOCLBIS:
    765   1.49       cgd 	case  TIOCLSET:
    766   1.49       cgd 	case  TIOCSETC:
    767   1.49       cgd 	case OTIOCSETD:
    768   1.49       cgd 	case  TIOCSETN:
    769   1.49       cgd 	case  TIOCSETP:
    770   1.49       cgd 	case  TIOCSLTC:
    771   1.49       cgd #endif
    772   1.49       cgd 		while (isbackground(curproc, tp) &&
    773   1.49       cgd 		    p->p_pgrp->pg_jobc && (p->p_flag & P_PPWAIT) == 0 &&
    774  1.112   mycroft 		    !sigismember(&p->p_sigignore, SIGTTOU) &&
    775  1.112   mycroft 		    !sigismember(&p->p_sigmask, SIGTTOU)) {
    776   1.49       cgd 			pgsignal(p->p_pgrp, SIGTTOU, 1);
    777  1.112   mycroft 			error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, ttybg, 0);
    778   1.65  christos 			if (error)
    779   1.49       cgd 				return (error);
    780   1.49       cgd 		}
    781   1.49       cgd 		break;
    782   1.49       cgd 	}
    783   1.49       cgd 
    784   1.49       cgd 	switch (cmd) {			/* Process the ioctl. */
    785   1.49       cgd 	case FIOASYNC:			/* set/clear async i/o */
    786   1.49       cgd 		s = spltty();
    787   1.49       cgd 		if (*(int *)data)
    788   1.49       cgd 			SET(tp->t_state, TS_ASYNC);
    789   1.49       cgd 		else
    790   1.49       cgd 			CLR(tp->t_state, TS_ASYNC);
    791   1.49       cgd 		splx(s);
    792   1.49       cgd 		break;
    793   1.49       cgd 	case FIONBIO:			/* set/clear non-blocking i/o */
    794   1.49       cgd 		break;			/* XXX: delete. */
    795   1.49       cgd 	case FIONREAD:			/* get # bytes to read */
    796   1.49       cgd 		*(int *)data = ttnread(tp);
    797   1.49       cgd 		break;
    798   1.49       cgd 	case TIOCEXCL:			/* set exclusive use of tty */
    799   1.49       cgd 		s = spltty();
    800   1.49       cgd 		SET(tp->t_state, TS_XCLUDE);
    801   1.49       cgd 		splx(s);
    802   1.49       cgd 		break;
    803   1.49       cgd 	case TIOCFLUSH: {		/* flush buffers */
    804   1.49       cgd 		register int flags = *(int *)data;
    805   1.49       cgd 
    806   1.49       cgd 		if (flags == 0)
    807   1.49       cgd 			flags = FREAD | FWRITE;
    808   1.49       cgd 		else
    809   1.49       cgd 			flags &= FREAD | FWRITE;
    810   1.49       cgd 		ttyflush(tp, flags);
    811   1.49       cgd 		break;
    812   1.49       cgd 	}
    813   1.49       cgd 	case TIOCCONS:			/* become virtual console */
    814   1.49       cgd 		if (*(int *)data) {
    815   1.49       cgd 			if (constty && constty != tp &&
    816   1.49       cgd 			    ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
    817   1.49       cgd 			    (TS_CARR_ON | TS_ISOPEN))
    818   1.49       cgd 				return (EBUSY);
    819   1.49       cgd #ifndef	UCONSOLE
    820   1.65  christos 			if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
    821   1.49       cgd 				return (error);
    822   1.49       cgd #endif
    823   1.49       cgd 			constty = tp;
    824   1.49       cgd 		} else if (tp == constty)
    825   1.49       cgd 			constty = NULL;
    826   1.49       cgd 		break;
    827   1.49       cgd 	case TIOCDRAIN:			/* wait till output drained */
    828   1.65  christos 		if ((error = ttywait(tp)) != 0)
    829   1.49       cgd 			return (error);
    830   1.49       cgd 		break;
    831   1.49       cgd 	case TIOCGETA: {		/* get termios struct */
    832   1.49       cgd 		struct termios *t = (struct termios *)data;
    833   1.49       cgd 
    834  1.109     perry 		memcpy(t, &tp->t_termios, sizeof(struct termios));
    835   1.49       cgd 		break;
    836   1.49       cgd 	}
    837   1.49       cgd 	case TIOCGETD:			/* get line discipline */
    838   1.49       cgd 		*(int *)data = tp->t_line;
    839   1.49       cgd 		break;
    840   1.49       cgd 	case TIOCGWINSZ:		/* get window size */
    841   1.49       cgd 		*(struct winsize *)data = tp->t_winsize;
    842   1.49       cgd 		break;
    843   1.49       cgd 	case TIOCGPGRP:			/* get pgrp of tty */
    844   1.49       cgd 		if (!isctty(p, tp))
    845   1.49       cgd 			return (ENOTTY);
    846   1.49       cgd 		*(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
    847  1.104   thorpej 		break;
    848  1.104   thorpej 	case TIOCGSID:			/* get sid of tty */
    849  1.104   thorpej 		if (!isctty(p, tp))
    850  1.104   thorpej 			return (ENOTTY);
    851  1.104   thorpej 		*(int *)data = tp->t_session->s_sid;
    852   1.49       cgd 		break;
    853   1.49       cgd #ifdef TIOCHPCL
    854   1.49       cgd 	case TIOCHPCL:			/* hang up on last close */
    855   1.49       cgd 		s = spltty();
    856   1.49       cgd 		SET(tp->t_cflag, HUPCL);
    857   1.49       cgd 		splx(s);
    858   1.49       cgd 		break;
    859   1.49       cgd #endif
    860   1.49       cgd 	case TIOCNXCL:			/* reset exclusive use of tty */
    861   1.49       cgd 		s = spltty();
    862   1.49       cgd 		CLR(tp->t_state, TS_XCLUDE);
    863   1.49       cgd 		splx(s);
    864   1.49       cgd 		break;
    865   1.49       cgd 	case TIOCOUTQ:			/* output queue size */
    866   1.49       cgd 		*(int *)data = tp->t_outq.c_cc;
    867   1.49       cgd 		break;
    868   1.49       cgd 	case TIOCSETA:			/* set termios struct */
    869   1.49       cgd 	case TIOCSETAW:			/* drain output, set */
    870   1.49       cgd 	case TIOCSETAF: {		/* drn out, fls in, set */
    871   1.49       cgd 		register struct termios *t = (struct termios *)data;
    872   1.49       cgd 
    873   1.49       cgd 		s = spltty();
    874   1.49       cgd 		if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
    875   1.65  christos 			if ((error = ttywait(tp)) != 0) {
    876   1.49       cgd 				splx(s);
    877   1.49       cgd 				return (error);
    878   1.49       cgd 			}
    879   1.49       cgd 			if (cmd == TIOCSETAF)
    880   1.49       cgd 				ttyflush(tp, FREAD);
    881   1.49       cgd 		}
    882   1.49       cgd 		if (!ISSET(t->c_cflag, CIGNORE)) {
    883   1.49       cgd 			/*
    884   1.49       cgd 			 * Set device hardware.
    885   1.49       cgd 			 */
    886   1.49       cgd 			if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
    887   1.49       cgd 				splx(s);
    888   1.49       cgd 				return (error);
    889   1.49       cgd 			} else {
    890   1.49       cgd 				tp->t_cflag = t->c_cflag;
    891   1.49       cgd 				tp->t_ispeed = t->c_ispeed;
    892   1.49       cgd 				tp->t_ospeed = t->c_ospeed;
    893   1.49       cgd 				if (t->c_ospeed == 0 && tp->t_session &&
    894   1.49       cgd 				    tp->t_session->s_leader)
    895   1.49       cgd 					psignal(tp->t_session->s_leader,
    896   1.49       cgd 					    SIGHUP);
    897   1.49       cgd 			}
    898   1.49       cgd 			ttsetwater(tp);
    899   1.49       cgd 		}
    900   1.49       cgd 		if (cmd != TIOCSETAF) {
    901   1.49       cgd 			if (ISSET(t->c_lflag, ICANON) !=
    902  1.110   thorpej 			    ISSET(tp->t_lflag, ICANON)) {
    903   1.49       cgd 				if (ISSET(t->c_lflag, ICANON)) {
    904   1.49       cgd 					SET(tp->t_lflag, PENDIN);
    905   1.49       cgd 					ttwakeup(tp);
    906   1.49       cgd 				} else {
    907   1.49       cgd 					struct clist tq;
    908   1.49       cgd 
    909   1.49       cgd 					catq(&tp->t_rawq, &tp->t_canq);
    910   1.49       cgd 					tq = tp->t_rawq;
    911   1.49       cgd 					tp->t_rawq = tp->t_canq;
    912   1.49       cgd 					tp->t_canq = tq;
    913   1.49       cgd 					CLR(tp->t_lflag, PENDIN);
    914   1.49       cgd 				}
    915  1.110   thorpej 			}
    916   1.49       cgd 		}
    917   1.49       cgd 		tp->t_iflag = t->c_iflag;
    918   1.49       cgd 		tp->t_oflag = t->c_oflag;
    919   1.49       cgd 		/*
    920   1.49       cgd 		 * Make the EXTPROC bit read only.
    921   1.49       cgd 		 */
    922   1.49       cgd 		if (ISSET(tp->t_lflag, EXTPROC))
    923   1.49       cgd 			SET(t->c_lflag, EXTPROC);
    924   1.49       cgd 		else
    925   1.49       cgd 			CLR(t->c_lflag, EXTPROC);
    926   1.49       cgd 		tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
    927  1.109     perry 		memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc));
    928   1.49       cgd 		splx(s);
    929   1.49       cgd 		break;
    930   1.49       cgd 	}
    931   1.49       cgd 	case TIOCSETD: {		/* set line discipline */
    932   1.49       cgd 		register int t = *(int *)data;
    933   1.49       cgd 		dev_t device = tp->t_dev;
    934   1.49       cgd 
    935   1.49       cgd 		if ((u_int)t >= nlinesw)
    936   1.49       cgd 			return (ENXIO);
    937   1.49       cgd 		if (t != tp->t_line) {
    938   1.49       cgd 			s = spltty();
    939   1.49       cgd 			(*linesw[tp->t_line].l_close)(tp, flag);
    940   1.49       cgd 			error = (*linesw[t].l_open)(device, tp);
    941   1.49       cgd 			if (error) {
    942   1.49       cgd 				(void)(*linesw[tp->t_line].l_open)(device, tp);
    943   1.49       cgd 				splx(s);
    944   1.49       cgd 				return (error);
    945   1.49       cgd 			}
    946   1.49       cgd 			tp->t_line = t;
    947   1.49       cgd 			splx(s);
    948   1.49       cgd 		}
    949   1.49       cgd 		break;
    950   1.49       cgd 	}
    951   1.49       cgd 	case TIOCSTART:			/* start output, like ^Q */
    952   1.49       cgd 		s = spltty();
    953   1.49       cgd 		if (ISSET(tp->t_state, TS_TTSTOP) ||
    954   1.49       cgd 		    ISSET(tp->t_lflag, FLUSHO)) {
    955   1.49       cgd 			CLR(tp->t_lflag, FLUSHO);
    956   1.49       cgd 			CLR(tp->t_state, TS_TTSTOP);
    957   1.49       cgd 			ttstart(tp);
    958   1.49       cgd 		}
    959   1.49       cgd 		splx(s);
    960   1.49       cgd 		break;
    961   1.49       cgd 	case TIOCSTI:			/* simulate terminal input */
    962   1.49       cgd 		if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
    963   1.49       cgd 			return (EPERM);
    964   1.49       cgd 		if (p->p_ucred->cr_uid && !isctty(p, tp))
    965   1.49       cgd 			return (EACCES);
    966   1.49       cgd 		(*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
    967   1.49       cgd 		break;
    968   1.49       cgd 	case TIOCSTOP:			/* stop output, like ^S */
    969   1.49       cgd 		s = spltty();
    970   1.49       cgd 		if (!ISSET(tp->t_state, TS_TTSTOP)) {
    971   1.49       cgd 			SET(tp->t_state, TS_TTSTOP);
    972   1.49       cgd 			(*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
    973   1.49       cgd 		}
    974   1.49       cgd 		splx(s);
    975   1.49       cgd 		break;
    976   1.49       cgd 	case TIOCSCTTY:			/* become controlling tty */
    977   1.49       cgd 		/* Session ctty vnode pointer set in vnode layer. */
    978   1.49       cgd 		if (!SESS_LEADER(p) ||
    979   1.65  christos 		    ((p->p_session->s_ttyvp || tp->t_session) &&
    980   1.65  christos 		     (tp->t_session != p->p_session)))
    981   1.49       cgd 			return (EPERM);
    982   1.49       cgd 		tp->t_session = p->p_session;
    983   1.49       cgd 		tp->t_pgrp = p->p_pgrp;
    984   1.49       cgd 		p->p_session->s_ttyp = tp;
    985   1.49       cgd 		p->p_flag |= P_CONTROLT;
    986   1.49       cgd 		break;
    987   1.49       cgd 	case TIOCSPGRP: {		/* set pgrp of tty */
    988   1.49       cgd 		register struct pgrp *pgrp = pgfind(*(int *)data);
    989   1.49       cgd 
    990   1.49       cgd 		if (!isctty(p, tp))
    991   1.49       cgd 			return (ENOTTY);
    992   1.93    kleink 		else if (pgrp == NULL)
    993   1.93    kleink 			return (EINVAL);
    994   1.93    kleink 		else if (pgrp->pg_session != p->p_session)
    995   1.49       cgd 			return (EPERM);
    996   1.49       cgd 		tp->t_pgrp = pgrp;
    997   1.49       cgd 		break;
    998   1.49       cgd 	}
    999   1.49       cgd 	case TIOCSTAT:			/* get load avg stats */
   1000   1.49       cgd 		ttyinfo(tp);
   1001   1.49       cgd 		break;
   1002   1.49       cgd 	case TIOCSWINSZ:		/* set window size */
   1003  1.109     perry 		if (memcmp((caddr_t)&tp->t_winsize, data,
   1004  1.108     perry 		    sizeof(struct winsize))) {
   1005   1.49       cgd 			tp->t_winsize = *(struct winsize *)data;
   1006   1.49       cgd 			pgsignal(tp->t_pgrp, SIGWINCH, 1);
   1007   1.49       cgd 		}
   1008   1.49       cgd 		break;
   1009   1.49       cgd 	default:
   1010   1.66  christos #ifdef COMPAT_OLDTTY
   1011   1.49       cgd 		return (ttcompat(tp, cmd, data, flag, p));
   1012   1.49       cgd #else
   1013   1.49       cgd 		return (-1);
   1014   1.49       cgd #endif
   1015   1.49       cgd 	}
   1016   1.49       cgd 	return (0);
   1017   1.49       cgd }
   1018   1.49       cgd 
   1019   1.49       cgd int
   1020   1.74   mycroft ttpoll(dev, events, p)
   1021   1.74   mycroft 	dev_t dev;
   1022   1.74   mycroft 	int events;
   1023   1.49       cgd 	struct proc *p;
   1024   1.49       cgd {
   1025   1.74   mycroft 	register struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
   1026   1.74   mycroft 	int revents = 0;
   1027   1.74   mycroft 	int s = spltty();
   1028   1.74   mycroft 
   1029   1.74   mycroft 	if (events & (POLLIN | POLLRDNORM))
   1030   1.74   mycroft 		if (ttnread(tp) > 0)
   1031   1.74   mycroft 			revents |= events & (POLLIN | POLLRDNORM);
   1032   1.74   mycroft 
   1033   1.74   mycroft 	if (events & (POLLOUT | POLLWRNORM))
   1034   1.74   mycroft 		if (tp->t_outq.c_cc <= tp->t_lowat)
   1035   1.74   mycroft 			revents |= events & (POLLOUT | POLLWRNORM);
   1036   1.74   mycroft 
   1037   1.74   mycroft 	if (events & POLLHUP)
   1038   1.83   mycroft 		if (!CONNECTED(tp))
   1039   1.74   mycroft 			revents |= POLLHUP;
   1040   1.74   mycroft 
   1041   1.74   mycroft 	if (revents == 0) {
   1042   1.74   mycroft 		if (events & (POLLIN | POLLHUP | POLLRDNORM))
   1043   1.74   mycroft 			selrecord(p, &tp->t_rsel);
   1044   1.49       cgd 
   1045   1.74   mycroft 		if (events & (POLLOUT | POLLWRNORM))
   1046   1.74   mycroft 			selrecord(p, &tp->t_wsel);
   1047   1.74   mycroft 	}
   1048   1.49       cgd 
   1049   1.49       cgd 	splx(s);
   1050   1.74   mycroft 	return (revents);
   1051   1.49       cgd }
   1052   1.49       cgd 
   1053   1.49       cgd static int
   1054   1.49       cgd ttnread(tp)
   1055   1.49       cgd 	struct tty *tp;
   1056   1.49       cgd {
   1057   1.49       cgd 	int nread;
   1058   1.49       cgd 
   1059   1.49       cgd 	if (ISSET(tp->t_lflag, PENDIN))
   1060   1.49       cgd 		ttypend(tp);
   1061   1.49       cgd 	nread = tp->t_canq.c_cc;
   1062   1.49       cgd 	if (!ISSET(tp->t_lflag, ICANON)) {
   1063   1.49       cgd 		nread += tp->t_rawq.c_cc;
   1064   1.49       cgd 		if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
   1065   1.49       cgd 			nread = 0;
   1066   1.49       cgd 	}
   1067   1.49       cgd 	return (nread);
   1068   1.49       cgd }
   1069   1.49       cgd 
   1070   1.49       cgd /*
   1071   1.49       cgd  * Wait for output to drain.
   1072   1.49       cgd  */
   1073   1.49       cgd int
   1074   1.49       cgd ttywait(tp)
   1075   1.49       cgd 	register struct tty *tp;
   1076   1.49       cgd {
   1077   1.49       cgd 	int error, s;
   1078   1.49       cgd 
   1079   1.49       cgd 	error = 0;
   1080   1.49       cgd 	s = spltty();
   1081   1.49       cgd 	while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
   1082   1.83   mycroft 	    CONNECTED(tp) && tp->t_oproc) {
   1083   1.49       cgd 		(*tp->t_oproc)(tp);
   1084   1.49       cgd 		SET(tp->t_state, TS_ASLEEP);
   1085   1.65  christos 		error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
   1086   1.65  christos 		if (error)
   1087   1.49       cgd 			break;
   1088   1.49       cgd 	}
   1089   1.49       cgd 	splx(s);
   1090   1.49       cgd 	return (error);
   1091   1.49       cgd }
   1092   1.49       cgd 
   1093   1.49       cgd /*
   1094   1.49       cgd  * Flush if successfully wait.
   1095   1.49       cgd  */
   1096   1.49       cgd int
   1097   1.49       cgd ttywflush(tp)
   1098   1.49       cgd 	struct tty *tp;
   1099   1.49       cgd {
   1100   1.49       cgd 	int error;
   1101   1.49       cgd 
   1102   1.49       cgd 	if ((error = ttywait(tp)) == 0)
   1103   1.49       cgd 		ttyflush(tp, FREAD);
   1104   1.49       cgd 	return (error);
   1105   1.49       cgd }
   1106   1.49       cgd 
   1107   1.49       cgd /*
   1108   1.49       cgd  * Flush tty read and/or write queues, notifying anyone waiting.
   1109   1.49       cgd  */
   1110   1.49       cgd void
   1111   1.49       cgd ttyflush(tp, rw)
   1112   1.49       cgd 	register struct tty *tp;
   1113   1.49       cgd 	int rw;
   1114   1.49       cgd {
   1115   1.49       cgd 	register int s;
   1116   1.49       cgd 
   1117   1.49       cgd 	s = spltty();
   1118   1.49       cgd 	if (rw & FREAD) {
   1119   1.49       cgd 		FLUSHQ(&tp->t_canq);
   1120   1.49       cgd 		FLUSHQ(&tp->t_rawq);
   1121   1.49       cgd 		tp->t_rocount = 0;
   1122   1.49       cgd 		tp->t_rocol = 0;
   1123   1.49       cgd 		CLR(tp->t_state, TS_LOCAL);
   1124   1.49       cgd 		ttwakeup(tp);
   1125   1.49       cgd 	}
   1126   1.49       cgd 	if (rw & FWRITE) {
   1127   1.49       cgd 		CLR(tp->t_state, TS_TTSTOP);
   1128   1.49       cgd 		(*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
   1129   1.49       cgd 		FLUSHQ(&tp->t_outq);
   1130   1.49       cgd 		wakeup((caddr_t)&tp->t_outq);
   1131   1.49       cgd 		selwakeup(&tp->t_wsel);
   1132   1.49       cgd 	}
   1133   1.49       cgd 	splx(s);
   1134   1.49       cgd }
   1135   1.49       cgd 
   1136   1.49       cgd /*
   1137   1.49       cgd  * Copy in the default termios characters.
   1138   1.49       cgd  */
   1139   1.49       cgd void
   1140   1.49       cgd ttychars(tp)
   1141   1.49       cgd 	struct tty *tp;
   1142   1.49       cgd {
   1143   1.49       cgd 
   1144  1.109     perry 	memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars));
   1145   1.49       cgd }
   1146   1.49       cgd 
   1147   1.49       cgd /*
   1148   1.49       cgd  * Send stop character on input overflow.
   1149   1.49       cgd  */
   1150   1.49       cgd static void
   1151   1.49       cgd ttyblock(tp)
   1152   1.49       cgd 	register struct tty *tp;
   1153   1.49       cgd {
   1154   1.49       cgd 	register int total;
   1155   1.49       cgd 
   1156   1.49       cgd 	total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
   1157   1.49       cgd 	if (tp->t_rawq.c_cc > TTYHOG) {
   1158   1.49       cgd 		ttyflush(tp, FREAD | FWRITE);
   1159   1.49       cgd 		CLR(tp->t_state, TS_TBLOCK);
   1160   1.49       cgd 	}
   1161   1.49       cgd 	/*
   1162   1.49       cgd 	 * Block further input iff: current input > threshold
   1163   1.49       cgd 	 * AND input is available to user program.
   1164   1.49       cgd 	 */
   1165  1.101  drochner 	if (total >= TTYHOG / 2 &&
   1166  1.101  drochner 	    !ISSET(tp->t_state, TS_TBLOCK) &&
   1167  1.101  drochner 	    (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) {
   1168   1.60   mycroft 		if (ISSET(tp->t_iflag, IXOFF) &&
   1169   1.60   mycroft 		    tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
   1170   1.60   mycroft 		    putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
   1171   1.49       cgd 			SET(tp->t_state, TS_TBLOCK);
   1172   1.49       cgd 			ttstart(tp);
   1173   1.49       cgd 		}
   1174   1.59   mycroft 		/* Try to block remote output via hardware flow control. */
   1175   1.49       cgd 		if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
   1176   1.49       cgd 		    (*tp->t_hwiflow)(tp, 1) != 0)
   1177   1.49       cgd 			SET(tp->t_state, TS_TBLOCK);
   1178   1.49       cgd 	}
   1179   1.49       cgd }
   1180   1.49       cgd 
   1181   1.49       cgd void
   1182   1.49       cgd ttrstrt(tp_arg)
   1183   1.49       cgd 	void *tp_arg;
   1184   1.49       cgd {
   1185   1.49       cgd 	struct tty *tp;
   1186   1.49       cgd 	int s;
   1187   1.49       cgd 
   1188   1.49       cgd #ifdef DIAGNOSTIC
   1189   1.49       cgd 	if (tp_arg == NULL)
   1190   1.49       cgd 		panic("ttrstrt");
   1191   1.49       cgd #endif
   1192   1.49       cgd 	tp = tp_arg;
   1193   1.49       cgd 	s = spltty();
   1194   1.49       cgd 
   1195   1.49       cgd 	CLR(tp->t_state, TS_TIMEOUT);
   1196   1.49       cgd 	ttstart(tp);
   1197   1.49       cgd 
   1198   1.49       cgd 	splx(s);
   1199   1.49       cgd }
   1200   1.49       cgd 
   1201   1.49       cgd int
   1202   1.49       cgd ttstart(tp)
   1203   1.49       cgd 	struct tty *tp;
   1204   1.49       cgd {
   1205   1.49       cgd 
   1206   1.49       cgd 	if (tp->t_oproc != NULL)	/* XXX: Kludge for pty. */
   1207   1.49       cgd 		(*tp->t_oproc)(tp);
   1208   1.49       cgd 	return (0);
   1209   1.49       cgd }
   1210   1.49       cgd 
   1211   1.49       cgd /*
   1212   1.49       cgd  * "close" a line discipline
   1213   1.49       cgd  */
   1214   1.49       cgd int
   1215   1.49       cgd ttylclose(tp, flag)
   1216   1.49       cgd 	struct tty *tp;
   1217   1.49       cgd 	int flag;
   1218   1.49       cgd {
   1219   1.49       cgd 
   1220   1.61   mycroft 	if (flag & FNONBLOCK)
   1221   1.49       cgd 		ttyflush(tp, FREAD | FWRITE);
   1222   1.49       cgd 	else
   1223   1.49       cgd 		ttywflush(tp);
   1224   1.49       cgd 	return (0);
   1225   1.49       cgd }
   1226   1.49       cgd 
   1227   1.49       cgd /*
   1228   1.49       cgd  * Handle modem control transition on a tty.
   1229   1.49       cgd  * Flag indicates new state of carrier.
   1230   1.49       cgd  * Returns 0 if the line should be turned off, otherwise 1.
   1231   1.49       cgd  */
   1232   1.49       cgd int
   1233   1.49       cgd ttymodem(tp, flag)
   1234   1.49       cgd 	register struct tty *tp;
   1235   1.49       cgd 	int flag;
   1236   1.49       cgd {
   1237   1.49       cgd 
   1238   1.83   mycroft 	if (flag == 0) {
   1239   1.96    kleink 		if (ISSET(tp->t_state, TS_CARR_ON)) {
   1240   1.96    kleink 			/*
   1241   1.96    kleink 			 * Lost carrier.
   1242   1.96    kleink 			 */
   1243   1.96    kleink 			CLR(tp->t_state, TS_CARR_ON);
   1244   1.96    kleink 			if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) {
   1245   1.96    kleink 				if (tp->t_session && tp->t_session->s_leader)
   1246   1.96    kleink 					psignal(tp->t_session->s_leader, SIGHUP);
   1247   1.96    kleink 				ttyflush(tp, FREAD | FWRITE);
   1248   1.96    kleink 				return (0);
   1249   1.96    kleink 			}
   1250   1.49       cgd 		}
   1251   1.49       cgd 	} else {
   1252   1.96    kleink 		if (!ISSET(tp->t_state, TS_CARR_ON)) {
   1253   1.96    kleink 			/*
   1254   1.96    kleink 			 * Carrier now on.
   1255   1.96    kleink 			 */
   1256   1.96    kleink 			SET(tp->t_state, TS_CARR_ON);
   1257   1.96    kleink 			ttwakeup(tp);
   1258   1.96    kleink 		}
   1259   1.49       cgd 	}
   1260   1.49       cgd 	return (1);
   1261   1.49       cgd }
   1262   1.49       cgd 
   1263   1.49       cgd /*
   1264   1.49       cgd  * Default modem control routine (for other line disciplines).
   1265   1.49       cgd  * Return argument flag, to turn off device on carrier drop.
   1266   1.49       cgd  */
   1267   1.49       cgd int
   1268   1.49       cgd nullmodem(tp, flag)
   1269   1.49       cgd 	register struct tty *tp;
   1270   1.49       cgd 	int flag;
   1271   1.49       cgd {
   1272   1.49       cgd 
   1273   1.49       cgd 	if (flag)
   1274   1.49       cgd 		SET(tp->t_state, TS_CARR_ON);
   1275   1.49       cgd 	else {
   1276   1.49       cgd 		CLR(tp->t_state, TS_CARR_ON);
   1277   1.83   mycroft 		if (!CONNECTED(tp)) {
   1278   1.49       cgd 			if (tp->t_session && tp->t_session->s_leader)
   1279   1.49       cgd 				psignal(tp->t_session->s_leader, SIGHUP);
   1280   1.49       cgd 			return (0);
   1281   1.49       cgd 		}
   1282   1.49       cgd 	}
   1283   1.49       cgd 	return (1);
   1284   1.49       cgd }
   1285   1.49       cgd 
   1286   1.49       cgd /*
   1287   1.49       cgd  * Reinput pending characters after state switch
   1288   1.49       cgd  * call at spltty().
   1289   1.49       cgd  */
   1290   1.49       cgd void
   1291   1.49       cgd ttypend(tp)
   1292   1.49       cgd 	register struct tty *tp;
   1293   1.49       cgd {
   1294   1.49       cgd 	struct clist tq;
   1295  1.102    kleink 	register int c;
   1296   1.49       cgd 
   1297   1.49       cgd 	CLR(tp->t_lflag, PENDIN);
   1298   1.49       cgd 	SET(tp->t_state, TS_TYPEN);
   1299   1.49       cgd 	tq = tp->t_rawq;
   1300   1.49       cgd 	tp->t_rawq.c_cc = 0;
   1301   1.49       cgd 	tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
   1302   1.49       cgd 	while ((c = getc(&tq)) >= 0)
   1303   1.49       cgd 		ttyinput(c, tp);
   1304   1.49       cgd 	CLR(tp->t_state, TS_TYPEN);
   1305   1.49       cgd }
   1306   1.49       cgd 
   1307   1.49       cgd /*
   1308   1.49       cgd  * Process a read call on a tty device.
   1309   1.49       cgd  */
   1310   1.49       cgd int
   1311   1.49       cgd ttread(tp, uio, flag)
   1312   1.49       cgd 	register struct tty *tp;
   1313   1.49       cgd 	struct uio *uio;
   1314   1.49       cgd 	int flag;
   1315   1.49       cgd {
   1316   1.49       cgd 	register struct clist *qp;
   1317   1.49       cgd 	register int c;
   1318   1.49       cgd 	register long lflag;
   1319   1.49       cgd 	register u_char *cc = tp->t_cc;
   1320   1.49       cgd 	register struct proc *p = curproc;
   1321   1.49       cgd 	int s, first, error = 0;
   1322   1.49       cgd 	struct timeval stime;
   1323   1.65  christos 	int has_stime = 0, last_cc = 0;
   1324   1.49       cgd 	long slp = 0;
   1325   1.49       cgd 
   1326   1.49       cgd loop:	lflag = tp->t_lflag;
   1327   1.49       cgd 	s = spltty();
   1328   1.49       cgd 	/*
   1329   1.49       cgd 	 * take pending input first
   1330   1.49       cgd 	 */
   1331   1.49       cgd 	if (ISSET(lflag, PENDIN))
   1332   1.49       cgd 		ttypend(tp);
   1333   1.49       cgd 	splx(s);
   1334   1.49       cgd 
   1335   1.49       cgd 	/*
   1336   1.49       cgd 	 * Hang process if it's in the background.
   1337   1.49       cgd 	 */
   1338   1.49       cgd 	if (isbackground(p, tp)) {
   1339  1.112   mycroft 		if (sigismember(&p->p_sigignore, SIGTTIN) ||
   1340  1.112   mycroft 		    sigismember(&p->p_sigmask, SIGTTIN) ||
   1341   1.49       cgd 		    p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0)
   1342   1.49       cgd 			return (EIO);
   1343   1.49       cgd 		pgsignal(p->p_pgrp, SIGTTIN, 1);
   1344   1.65  christos 		error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
   1345   1.65  christos 		if (error)
   1346   1.49       cgd 			return (error);
   1347   1.49       cgd 		goto loop;
   1348   1.49       cgd 	}
   1349   1.49       cgd 
   1350   1.49       cgd 	s = spltty();
   1351   1.49       cgd 	if (!ISSET(lflag, ICANON)) {
   1352   1.49       cgd 		int m = cc[VMIN];
   1353   1.49       cgd 		long t = cc[VTIME];
   1354   1.49       cgd 
   1355   1.49       cgd 		qp = &tp->t_rawq;
   1356   1.49       cgd 		/*
   1357   1.49       cgd 		 * Check each of the four combinations.
   1358   1.49       cgd 		 * (m > 0 && t == 0) is the normal read case.
   1359   1.49       cgd 		 * It should be fairly efficient, so we check that and its
   1360   1.49       cgd 		 * companion case (m == 0 && t == 0) first.
   1361   1.49       cgd 		 * For the other two cases, we compute the target sleep time
   1362   1.49       cgd 		 * into slp.
   1363   1.49       cgd 		 */
   1364   1.49       cgd 		if (t == 0) {
   1365   1.49       cgd 			if (qp->c_cc < m)
   1366   1.49       cgd 				goto sleep;
   1367   1.49       cgd 			goto read;
   1368   1.49       cgd 		}
   1369   1.49       cgd 		t *= 100000;		/* time in us */
   1370   1.49       cgd #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
   1371   1.49       cgd 			 ((t1).tv_usec - (t2).tv_usec))
   1372   1.49       cgd 		if (m > 0) {
   1373   1.49       cgd 			if (qp->c_cc <= 0)
   1374   1.49       cgd 				goto sleep;
   1375   1.49       cgd 			if (qp->c_cc >= m)
   1376   1.49       cgd 				goto read;
   1377   1.49       cgd 			if (!has_stime) {
   1378   1.49       cgd 				/* first character, start timer */
   1379   1.49       cgd 				has_stime = 1;
   1380   1.49       cgd 				stime = time;
   1381   1.49       cgd 				slp = t;
   1382   1.49       cgd 			} else if (qp->c_cc > last_cc) {
   1383   1.49       cgd 				/* got a character, restart timer */
   1384   1.49       cgd 				stime = time;
   1385   1.49       cgd 				slp = t;
   1386   1.49       cgd 			} else {
   1387   1.49       cgd 				/* nothing, check expiration */
   1388   1.49       cgd 				slp = t - diff(time, stime);
   1389   1.49       cgd 			}
   1390   1.49       cgd 		} else {	/* m == 0 */
   1391   1.49       cgd 			if (qp->c_cc > 0)
   1392   1.49       cgd 				goto read;
   1393   1.49       cgd 			if (!has_stime) {
   1394   1.49       cgd 				has_stime = 1;
   1395   1.49       cgd 				stime = time;
   1396   1.49       cgd 				slp = t;
   1397   1.49       cgd 			} else
   1398   1.49       cgd 				slp = t - diff(time, stime);
   1399   1.49       cgd 		}
   1400   1.54   mycroft 		last_cc = qp->c_cc;
   1401   1.49       cgd #undef diff
   1402   1.49       cgd 		if (slp > 0) {
   1403   1.49       cgd 			/*
   1404   1.49       cgd 			 * Rounding down may make us wake up just short
   1405   1.49       cgd 			 * of the target, so we round up.
   1406   1.49       cgd 			 * The formula is ceiling(slp * hz/1000000).
   1407   1.49       cgd 			 * 32-bit arithmetic is enough for hz < 169.
   1408   1.49       cgd 			 *
   1409   1.49       cgd 			 * Also, use plain wakeup() not ttwakeup().
   1410   1.49       cgd 			 */
   1411   1.49       cgd 			slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
   1412   1.49       cgd 			goto sleep;
   1413   1.49       cgd 		}
   1414   1.49       cgd 	} else if ((qp = &tp->t_canq)->c_cc <= 0) {
   1415   1.49       cgd 		int carrier;
   1416   1.49       cgd 
   1417   1.49       cgd sleep:
   1418   1.49       cgd 		/*
   1419   1.49       cgd 		 * If there is no input, sleep on rawq
   1420   1.49       cgd 		 * awaiting hardware receipt and notification.
   1421   1.49       cgd 		 * If we have data, we don't need to check for carrier.
   1422   1.49       cgd 		 */
   1423   1.83   mycroft 		carrier = CONNECTED(tp);
   1424   1.49       cgd 		if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
   1425   1.49       cgd 			splx(s);
   1426   1.49       cgd 			return (0);	/* EOF */
   1427   1.49       cgd 		}
   1428   1.49       cgd 		if (flag & IO_NDELAY) {
   1429   1.49       cgd 			splx(s);
   1430   1.49       cgd 			return (EWOULDBLOCK);
   1431   1.49       cgd 		}
   1432   1.49       cgd 		error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
   1433   1.53   mycroft 		    carrier ? ttyin : ttopen, slp);
   1434   1.49       cgd 		splx(s);
   1435   1.82    kleink 		/* VMIN == 0: any quantity read satisfies */
   1436   1.82    kleink 		if (cc[VMIN] == 0 && error == EWOULDBLOCK)
   1437   1.82    kleink 			return (0);
   1438   1.54   mycroft 		if (error && error != EWOULDBLOCK)
   1439   1.49       cgd 			return (error);
   1440   1.49       cgd 		goto loop;
   1441   1.49       cgd 	}
   1442   1.49       cgd read:
   1443   1.49       cgd 	splx(s);
   1444   1.49       cgd 
   1445   1.49       cgd 	/*
   1446   1.49       cgd 	 * Input present, check for input mapping and processing.
   1447   1.49       cgd 	 */
   1448   1.49       cgd 	first = 1;
   1449   1.49       cgd 	while ((c = getc(qp)) >= 0) {
   1450   1.49       cgd 		/*
   1451   1.49       cgd 		 * delayed suspend (^Y)
   1452   1.49       cgd 		 */
   1453   1.81    kleink 		if (CCEQ(cc[VDSUSP], c) &&
   1454   1.81    kleink 		    ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) {
   1455   1.49       cgd 			pgsignal(tp->t_pgrp, SIGTSTP, 1);
   1456   1.49       cgd 			if (first) {
   1457   1.65  christos 				error = ttysleep(tp, &lbolt,
   1458   1.65  christos 						 TTIPRI | PCATCH, ttybg, 0);
   1459   1.65  christos 				if (error)
   1460   1.49       cgd 					break;
   1461   1.49       cgd 				goto loop;
   1462   1.49       cgd 			}
   1463   1.49       cgd 			break;
   1464   1.49       cgd 		}
   1465   1.49       cgd 		/*
   1466   1.49       cgd 		 * Interpret EOF only in canonical mode.
   1467   1.49       cgd 		 */
   1468   1.49       cgd 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
   1469   1.49       cgd 			break;
   1470   1.49       cgd 		/*
   1471   1.49       cgd 		 * Give user character.
   1472   1.49       cgd 		 */
   1473   1.49       cgd  		error = ureadc(c, uio);
   1474   1.49       cgd 		if (error)
   1475   1.49       cgd 			break;
   1476   1.49       cgd  		if (uio->uio_resid == 0)
   1477   1.49       cgd 			break;
   1478   1.49       cgd 		/*
   1479   1.49       cgd 		 * In canonical mode check for a "break character"
   1480   1.49       cgd 		 * marking the end of a "line of input".
   1481   1.49       cgd 		 */
   1482   1.85    kleink 		if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
   1483   1.49       cgd 			break;
   1484   1.49       cgd 		first = 0;
   1485   1.49       cgd 	}
   1486   1.49       cgd 	/*
   1487   1.49       cgd 	 * Look to unblock output now that (presumably)
   1488   1.49       cgd 	 * the input queue has gone down.
   1489   1.49       cgd 	 */
   1490   1.49       cgd 	s = spltty();
   1491   1.49       cgd 	if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG/5) {
   1492   1.60   mycroft 		if (ISSET(tp->t_iflag, IXOFF) &&
   1493   1.60   mycroft 		    cc[VSTART] != _POSIX_VDISABLE &&
   1494   1.49       cgd 		    putc(cc[VSTART], &tp->t_outq) == 0) {
   1495   1.49       cgd 			CLR(tp->t_state, TS_TBLOCK);
   1496   1.49       cgd 			ttstart(tp);
   1497   1.49       cgd 		}
   1498   1.59   mycroft 		/* Try to unblock remote output via hardware flow control. */
   1499   1.59   mycroft 		if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
   1500   1.49       cgd 		    (*tp->t_hwiflow)(tp, 0) != 0)
   1501   1.59   mycroft 			CLR(tp->t_state, TS_TBLOCK);
   1502   1.49       cgd 	}
   1503   1.49       cgd 	splx(s);
   1504   1.49       cgd 	return (error);
   1505   1.49       cgd }
   1506   1.49       cgd 
   1507   1.49       cgd /*
   1508   1.49       cgd  * Check the output queue on tp for space for a kernel message (from uprintf
   1509   1.49       cgd  * or tprintf).  Allow some space over the normal hiwater mark so we don't
   1510   1.49       cgd  * lose messages due to normal flow control, but don't let the tty run amok.
   1511   1.49       cgd  * Sleeps here are not interruptible, but we return prematurely if new signals
   1512   1.49       cgd  * arrive.
   1513   1.49       cgd  */
   1514   1.49       cgd int
   1515   1.49       cgd ttycheckoutq(tp, wait)
   1516   1.49       cgd 	register struct tty *tp;
   1517   1.49       cgd 	int wait;
   1518   1.49       cgd {
   1519  1.112   mycroft 	int hiwat, s;
   1520  1.112   mycroft 	int error;
   1521   1.49       cgd 
   1522   1.49       cgd 	hiwat = tp->t_hiwat;
   1523   1.49       cgd 	s = spltty();
   1524   1.49       cgd 	if (tp->t_outq.c_cc > hiwat + 200)
   1525   1.49       cgd 		while (tp->t_outq.c_cc > hiwat) {
   1526   1.49       cgd 			ttstart(tp);
   1527  1.112   mycroft 			if (wait == 0) {
   1528   1.49       cgd 				splx(s);
   1529   1.49       cgd 				return (0);
   1530   1.49       cgd 			}
   1531  1.116   thorpej 			callout_reset(&tp->t_outq_ch, hz,
   1532  1.116   thorpej 			    (void (*)__P((void *)))wakeup, &tp->t_outq);
   1533   1.49       cgd 			SET(tp->t_state, TS_ASLEEP);
   1534  1.112   mycroft 			error = tsleep(&tp->t_outq, (PZERO - 1) | PCATCH,
   1535  1.112   mycroft 			    "ttckoutq", 0);
   1536  1.112   mycroft 			if (error == EINTR)
   1537  1.112   mycroft 				wait = 0;
   1538   1.49       cgd 		}
   1539   1.49       cgd 	splx(s);
   1540   1.49       cgd 	return (1);
   1541   1.49       cgd }
   1542   1.49       cgd 
   1543   1.49       cgd /*
   1544   1.49       cgd  * Process a write call on a tty device.
   1545   1.49       cgd  */
   1546   1.49       cgd int
   1547   1.49       cgd ttwrite(tp, uio, flag)
   1548   1.49       cgd 	register struct tty *tp;
   1549   1.49       cgd 	register struct uio *uio;
   1550   1.49       cgd 	int flag;
   1551   1.49       cgd {
   1552   1.65  christos 	register u_char *cp = NULL;
   1553   1.49       cgd 	register int cc, ce;
   1554   1.49       cgd 	register struct proc *p;
   1555   1.49       cgd 	int i, hiwat, cnt, error, s;
   1556   1.49       cgd 	u_char obuf[OBUFSIZ];
   1557   1.49       cgd 
   1558   1.49       cgd 	hiwat = tp->t_hiwat;
   1559   1.49       cgd 	cnt = uio->uio_resid;
   1560   1.49       cgd 	error = 0;
   1561   1.49       cgd 	cc = 0;
   1562   1.49       cgd loop:
   1563   1.49       cgd 	s = spltty();
   1564   1.83   mycroft 	if (!CONNECTED(tp)) {
   1565   1.49       cgd 		if (ISSET(tp->t_state, TS_ISOPEN)) {
   1566   1.49       cgd 			splx(s);
   1567   1.49       cgd 			return (EIO);
   1568   1.49       cgd 		} else if (flag & IO_NDELAY) {
   1569   1.49       cgd 			splx(s);
   1570   1.49       cgd 			error = EWOULDBLOCK;
   1571   1.49       cgd 			goto out;
   1572   1.49       cgd 		} else {
   1573   1.49       cgd 			/* Sleep awaiting carrier. */
   1574   1.49       cgd 			error = ttysleep(tp,
   1575   1.49       cgd 			    &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0);
   1576   1.49       cgd 			splx(s);
   1577   1.49       cgd 			if (error)
   1578   1.49       cgd 				goto out;
   1579   1.49       cgd 			goto loop;
   1580   1.49       cgd 		}
   1581   1.49       cgd 	}
   1582   1.49       cgd 	splx(s);
   1583   1.49       cgd 	/*
   1584   1.49       cgd 	 * Hang the process if it's in the background.
   1585   1.49       cgd 	 */
   1586   1.49       cgd 	p = curproc;
   1587   1.49       cgd 	if (isbackground(p, tp) &&
   1588   1.49       cgd 	    ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
   1589  1.112   mycroft 	    !sigismember(&p->p_sigignore, SIGTTOU) &&
   1590  1.112   mycroft 	    !sigismember(&p->p_sigmask, SIGTTOU)) {
   1591   1.86    kleink 		if (p->p_pgrp->pg_jobc == 0) {
   1592   1.86    kleink 			error = EIO;
   1593   1.86    kleink 			goto out;
   1594   1.86    kleink 		}
   1595   1.49       cgd 		pgsignal(p->p_pgrp, SIGTTOU, 1);
   1596   1.65  christos 		error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
   1597   1.65  christos 		if (error)
   1598   1.49       cgd 			goto out;
   1599   1.49       cgd 		goto loop;
   1600   1.49       cgd 	}
   1601   1.49       cgd 	/*
   1602   1.49       cgd 	 * Process the user's data in at most OBUFSIZ chunks.  Perform any
   1603   1.49       cgd 	 * output translation.  Keep track of high water mark, sleep on
   1604   1.49       cgd 	 * overflow awaiting device aid in acquiring new space.
   1605   1.49       cgd 	 */
   1606   1.49       cgd 	while (uio->uio_resid > 0 || cc > 0) {
   1607   1.49       cgd 		if (ISSET(tp->t_lflag, FLUSHO)) {
   1608   1.49       cgd 			uio->uio_resid = 0;
   1609   1.49       cgd 			return (0);
   1610   1.49       cgd 		}
   1611   1.49       cgd 		if (tp->t_outq.c_cc > hiwat)
   1612   1.49       cgd 			goto ovhiwat;
   1613   1.49       cgd 		/*
   1614   1.49       cgd 		 * Grab a hunk of data from the user, unless we have some
   1615   1.49       cgd 		 * leftover from last time.
   1616   1.49       cgd 		 */
   1617   1.49       cgd 		if (cc == 0) {
   1618   1.49       cgd 			cc = min(uio->uio_resid, OBUFSIZ);
   1619   1.49       cgd 			cp = obuf;
   1620   1.49       cgd 			error = uiomove(cp, cc, uio);
   1621   1.49       cgd 			if (error) {
   1622   1.49       cgd 				cc = 0;
   1623   1.49       cgd 				break;
   1624   1.49       cgd 			}
   1625   1.49       cgd 		}
   1626   1.49       cgd 		/*
   1627   1.49       cgd 		 * If nothing fancy need be done, grab those characters we
   1628   1.49       cgd 		 * can handle without any of ttyoutput's processing and
   1629   1.49       cgd 		 * just transfer them to the output q.  For those chars
   1630   1.49       cgd 		 * which require special processing (as indicated by the
   1631   1.49       cgd 		 * bits in char_type), call ttyoutput.  After processing
   1632   1.49       cgd 		 * a hunk of data, look for FLUSHO so ^O's will take effect
   1633   1.49       cgd 		 * immediately.
   1634   1.49       cgd 		 */
   1635   1.49       cgd 		while (cc > 0) {
   1636   1.49       cgd 			if (!ISSET(tp->t_oflag, OPOST))
   1637   1.49       cgd 				ce = cc;
   1638   1.49       cgd 			else {
   1639   1.77       cgd 				ce = cc - scanc((u_int)cc, cp, char_type,
   1640   1.77       cgd 				    CCLASSMASK);
   1641   1.49       cgd 				/*
   1642   1.49       cgd 				 * If ce is zero, then we're processing
   1643   1.49       cgd 				 * a special character through ttyoutput.
   1644   1.49       cgd 				 */
   1645   1.49       cgd 				if (ce == 0) {
   1646   1.49       cgd 					tp->t_rocount = 0;
   1647   1.49       cgd 					if (ttyoutput(*cp, tp) >= 0) {
   1648   1.49       cgd 						/* out of space */
   1649   1.49       cgd 						goto overfull;
   1650   1.49       cgd 					}
   1651   1.49       cgd 					cp++;
   1652   1.49       cgd 					cc--;
   1653   1.49       cgd 					if (ISSET(tp->t_lflag, FLUSHO) ||
   1654   1.49       cgd 					    tp->t_outq.c_cc > hiwat)
   1655   1.49       cgd 						goto ovhiwat;
   1656   1.49       cgd 					continue;
   1657   1.49       cgd 				}
   1658   1.49       cgd 			}
   1659   1.49       cgd 			/*
   1660   1.49       cgd 			 * A bunch of normal characters have been found.
   1661   1.49       cgd 			 * Transfer them en masse to the output queue and
   1662   1.49       cgd 			 * continue processing at the top of the loop.
   1663   1.49       cgd 			 * If there are any further characters in this
   1664   1.49       cgd 			 * <= OBUFSIZ chunk, the first should be a character
   1665   1.49       cgd 			 * requiring special handling by ttyoutput.
   1666   1.49       cgd 			 */
   1667   1.49       cgd 			tp->t_rocount = 0;
   1668   1.49       cgd 			i = b_to_q(cp, ce, &tp->t_outq);
   1669   1.49       cgd 			ce -= i;
   1670   1.49       cgd 			tp->t_column += ce;
   1671   1.49       cgd 			cp += ce, cc -= ce, tk_nout += ce;
   1672   1.49       cgd 			tp->t_outcc += ce;
   1673   1.49       cgd 			if (i > 0) {
   1674   1.49       cgd 				/* out of space */
   1675   1.49       cgd 				goto overfull;
   1676   1.49       cgd 			}
   1677   1.49       cgd 			if (ISSET(tp->t_lflag, FLUSHO) ||
   1678   1.49       cgd 			    tp->t_outq.c_cc > hiwat)
   1679   1.49       cgd 				break;
   1680   1.49       cgd 		}
   1681   1.49       cgd 		ttstart(tp);
   1682   1.49       cgd 	}
   1683   1.49       cgd out:
   1684   1.49       cgd 	/*
   1685   1.49       cgd 	 * If cc is nonzero, we leave the uio structure inconsistent, as the
   1686   1.49       cgd 	 * offset and iov pointers have moved forward, but it doesn't matter
   1687   1.49       cgd 	 * (the call will either return short or restart with a new uio).
   1688   1.49       cgd 	 */
   1689   1.49       cgd 	uio->uio_resid += cc;
   1690   1.49       cgd 	return (error);
   1691   1.49       cgd 
   1692   1.49       cgd overfull:
   1693   1.49       cgd 	/*
   1694   1.49       cgd 	 * Since we are using ring buffers, if we can't insert any more into
   1695   1.49       cgd 	 * the output queue, we can assume the ring is full and that someone
   1696   1.49       cgd 	 * forgot to set the high water mark correctly.  We set it and then
   1697   1.49       cgd 	 * proceed as normal.
   1698   1.49       cgd 	 */
   1699   1.49       cgd 	hiwat = tp->t_outq.c_cc - 1;
   1700   1.49       cgd 
   1701   1.49       cgd ovhiwat:
   1702   1.49       cgd 	ttstart(tp);
   1703   1.49       cgd 	s = spltty();
   1704   1.49       cgd 	/*
   1705   1.49       cgd 	 * This can only occur if FLUSHO is set in t_lflag,
   1706   1.49       cgd 	 * or if ttstart/oproc is synchronous (or very fast).
   1707   1.49       cgd 	 */
   1708   1.49       cgd 	if (tp->t_outq.c_cc <= hiwat) {
   1709   1.49       cgd 		splx(s);
   1710   1.49       cgd 		goto loop;
   1711   1.49       cgd 	}
   1712   1.49       cgd 	if (flag & IO_NDELAY) {
   1713   1.49       cgd 		splx(s);
   1714   1.49       cgd 		uio->uio_resid += cc;
   1715   1.49       cgd 		return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
   1716   1.49       cgd 	}
   1717   1.49       cgd 	SET(tp->t_state, TS_ASLEEP);
   1718   1.49       cgd 	error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
   1719   1.49       cgd 	splx(s);
   1720   1.49       cgd 	if (error)
   1721   1.49       cgd 		goto out;
   1722   1.49       cgd 	goto loop;
   1723   1.49       cgd }
   1724   1.49       cgd 
   1725   1.49       cgd /*
   1726   1.49       cgd  * Rubout one character from the rawq of tp
   1727   1.49       cgd  * as cleanly as possible.
   1728   1.49       cgd  */
   1729   1.49       cgd void
   1730   1.49       cgd ttyrub(c, tp)
   1731   1.49       cgd 	int c;
   1732   1.49       cgd 	register struct tty *tp;
   1733   1.49       cgd {
   1734   1.49       cgd 	register u_char *cp;
   1735   1.49       cgd 	register int savecol;
   1736   1.49       cgd 	int tabc, s;
   1737   1.49       cgd 
   1738   1.49       cgd 	if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
   1739   1.49       cgd 		return;
   1740   1.49       cgd 	CLR(tp->t_lflag, FLUSHO);
   1741   1.49       cgd 	if (ISSET(tp->t_lflag, ECHOE)) {
   1742   1.49       cgd 		if (tp->t_rocount == 0) {
   1743   1.49       cgd 			/*
   1744   1.49       cgd 			 * Screwed by ttwrite; retype
   1745   1.49       cgd 			 */
   1746   1.49       cgd 			ttyretype(tp);
   1747   1.49       cgd 			return;
   1748   1.49       cgd 		}
   1749   1.49       cgd 		if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
   1750   1.49       cgd 			ttyrubo(tp, 2);
   1751   1.49       cgd 		else {
   1752   1.49       cgd 			CLR(c, ~TTY_CHARMASK);
   1753   1.49       cgd 			switch (CCLASS(c)) {
   1754   1.49       cgd 			case ORDINARY:
   1755   1.49       cgd 				ttyrubo(tp, 1);
   1756   1.49       cgd 				break;
   1757   1.49       cgd 			case BACKSPACE:
   1758   1.49       cgd 			case CONTROL:
   1759   1.49       cgd 			case NEWLINE:
   1760   1.49       cgd 			case RETURN:
   1761   1.49       cgd 			case VTAB:
   1762   1.49       cgd 				if (ISSET(tp->t_lflag, ECHOCTL))
   1763   1.49       cgd 					ttyrubo(tp, 2);
   1764   1.49       cgd 				break;
   1765   1.49       cgd 			case TAB:
   1766   1.49       cgd 				if (tp->t_rocount < tp->t_rawq.c_cc) {
   1767   1.49       cgd 					ttyretype(tp);
   1768   1.49       cgd 					return;
   1769   1.49       cgd 				}
   1770   1.49       cgd 				s = spltty();
   1771   1.49       cgd 				savecol = tp->t_column;
   1772   1.49       cgd 				SET(tp->t_state, TS_CNTTB);
   1773   1.49       cgd 				SET(tp->t_lflag, FLUSHO);
   1774   1.49       cgd 				tp->t_column = tp->t_rocol;
   1775   1.52   deraadt 				for (cp = firstc(&tp->t_rawq, &tabc); cp;
   1776   1.49       cgd 				    cp = nextc(&tp->t_rawq, cp, &tabc))
   1777   1.49       cgd 					ttyecho(tabc, tp);
   1778   1.49       cgd 				CLR(tp->t_lflag, FLUSHO);
   1779   1.49       cgd 				CLR(tp->t_state, TS_CNTTB);
   1780   1.49       cgd 				splx(s);
   1781   1.49       cgd 
   1782   1.49       cgd 				/* savecol will now be length of the tab. */
   1783   1.49       cgd 				savecol -= tp->t_column;
   1784   1.49       cgd 				tp->t_column += savecol;
   1785   1.49       cgd 				if (savecol > 8)
   1786   1.49       cgd 					savecol = 8;	/* overflow screw */
   1787   1.49       cgd 				while (--savecol >= 0)
   1788   1.49       cgd 					(void)ttyoutput('\b', tp);
   1789   1.49       cgd 				break;
   1790   1.49       cgd 			default:			/* XXX */
   1791   1.49       cgd #define	PANICSTR	"ttyrub: would panic c = %d, val = %d\n"
   1792   1.76  christos 				(void)printf(PANICSTR, c, CCLASS(c));
   1793   1.49       cgd #ifdef notdef
   1794   1.49       cgd 				panic(PANICSTR, c, CCLASS(c));
   1795   1.49       cgd #endif
   1796   1.49       cgd 			}
   1797   1.49       cgd 		}
   1798   1.49       cgd 	} else if (ISSET(tp->t_lflag, ECHOPRT)) {
   1799   1.49       cgd 		if (!ISSET(tp->t_state, TS_ERASE)) {
   1800   1.49       cgd 			SET(tp->t_state, TS_ERASE);
   1801   1.49       cgd 			(void)ttyoutput('\\', tp);
   1802   1.49       cgd 		}
   1803   1.49       cgd 		ttyecho(c, tp);
   1804   1.49       cgd 	} else
   1805   1.49       cgd 		ttyecho(tp->t_cc[VERASE], tp);
   1806   1.49       cgd 	--tp->t_rocount;
   1807   1.49       cgd }
   1808   1.49       cgd 
   1809   1.49       cgd /*
   1810   1.49       cgd  * Back over cnt characters, erasing them.
   1811   1.49       cgd  */
   1812   1.49       cgd static void
   1813   1.49       cgd ttyrubo(tp, cnt)
   1814   1.49       cgd 	register struct tty *tp;
   1815   1.49       cgd 	int cnt;
   1816   1.49       cgd {
   1817   1.49       cgd 
   1818   1.49       cgd 	while (cnt-- > 0) {
   1819   1.49       cgd 		(void)ttyoutput('\b', tp);
   1820   1.49       cgd 		(void)ttyoutput(' ', tp);
   1821   1.49       cgd 		(void)ttyoutput('\b', tp);
   1822   1.49       cgd 	}
   1823   1.49       cgd }
   1824   1.49       cgd 
   1825   1.49       cgd /*
   1826   1.49       cgd  * ttyretype --
   1827   1.49       cgd  *	Reprint the rawq line.  Note, it is assumed that c_cc has already
   1828   1.49       cgd  *	been checked.
   1829   1.49       cgd  */
   1830   1.49       cgd void
   1831   1.49       cgd ttyretype(tp)
   1832   1.49       cgd 	register struct tty *tp;
   1833   1.49       cgd {
   1834   1.49       cgd 	register u_char *cp;
   1835   1.49       cgd 	int s, c;
   1836   1.49       cgd 
   1837   1.49       cgd 	/* Echo the reprint character. */
   1838   1.49       cgd 	if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
   1839   1.49       cgd 		ttyecho(tp->t_cc[VREPRINT], tp);
   1840   1.49       cgd 
   1841   1.49       cgd 	(void)ttyoutput('\n', tp);
   1842   1.49       cgd 
   1843   1.49       cgd 	s = spltty();
   1844   1.49       cgd 	for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
   1845   1.49       cgd 		ttyecho(c, tp);
   1846   1.49       cgd 	for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
   1847   1.49       cgd 		ttyecho(c, tp);
   1848   1.49       cgd 	CLR(tp->t_state, TS_ERASE);
   1849   1.49       cgd 	splx(s);
   1850   1.49       cgd 
   1851   1.49       cgd 	tp->t_rocount = tp->t_rawq.c_cc;
   1852   1.49       cgd 	tp->t_rocol = 0;
   1853   1.49       cgd }
   1854   1.49       cgd 
   1855   1.49       cgd /*
   1856   1.49       cgd  * Echo a typed character to the terminal.
   1857   1.49       cgd  */
   1858   1.49       cgd static void
   1859   1.49       cgd ttyecho(c, tp)
   1860   1.49       cgd 	register int c;
   1861   1.49       cgd 	register struct tty *tp;
   1862   1.49       cgd {
   1863   1.49       cgd 
   1864   1.49       cgd 	if (!ISSET(tp->t_state, TS_CNTTB))
   1865   1.49       cgd 		CLR(tp->t_lflag, FLUSHO);
   1866   1.49       cgd 	if ((!ISSET(tp->t_lflag, ECHO) &&
   1867   1.64        pk 	    (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
   1868   1.49       cgd 	    ISSET(tp->t_lflag, EXTPROC))
   1869   1.49       cgd 		return;
   1870   1.65  christos 	if (((ISSET(tp->t_lflag, ECHOCTL) &&
   1871   1.65  christos 	     (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
   1872   1.49       cgd 	    ISSET(c, TTY_CHARMASK) == 0177)) {
   1873   1.49       cgd 		(void)ttyoutput('^', tp);
   1874   1.49       cgd 		CLR(c, ~TTY_CHARMASK);
   1875   1.49       cgd 		if (c == 0177)
   1876   1.49       cgd 			c = '?';
   1877   1.49       cgd 		else
   1878   1.49       cgd 			c += 'A' - 1;
   1879   1.49       cgd 	}
   1880   1.49       cgd 	(void)ttyoutput(c, tp);
   1881   1.49       cgd }
   1882   1.49       cgd 
   1883   1.49       cgd /*
   1884   1.49       cgd  * Wake up any readers on a tty.
   1885   1.49       cgd  */
   1886   1.49       cgd void
   1887   1.49       cgd ttwakeup(tp)
   1888   1.49       cgd 	register struct tty *tp;
   1889   1.49       cgd {
   1890   1.49       cgd 
   1891   1.49       cgd 	selwakeup(&tp->t_rsel);
   1892   1.49       cgd 	if (ISSET(tp->t_state, TS_ASYNC))
   1893   1.49       cgd 		pgsignal(tp->t_pgrp, SIGIO, 1);
   1894   1.49       cgd 	wakeup((caddr_t)&tp->t_rawq);
   1895   1.49       cgd }
   1896   1.49       cgd 
   1897   1.49       cgd /*
   1898   1.49       cgd  * Look up a code for a specified speed in a conversion table;
   1899   1.49       cgd  * used by drivers to map software speed values to hardware parameters.
   1900   1.49       cgd  */
   1901   1.49       cgd int
   1902   1.49       cgd ttspeedtab(speed, table)
   1903   1.49       cgd 	int speed;
   1904   1.49       cgd 	register struct speedtab *table;
   1905   1.49       cgd {
   1906   1.49       cgd 
   1907   1.49       cgd 	for ( ; table->sp_speed != -1; table++)
   1908   1.49       cgd 		if (table->sp_speed == speed)
   1909   1.49       cgd 			return (table->sp_code);
   1910   1.49       cgd 	return (-1);
   1911   1.49       cgd }
   1912   1.49       cgd 
   1913   1.49       cgd /*
   1914   1.49       cgd  * Set tty hi and low water marks.
   1915   1.49       cgd  *
   1916   1.49       cgd  * Try to arrange the dynamics so there's about one second
   1917   1.49       cgd  * from hi to low water.
   1918   1.49       cgd  */
   1919   1.49       cgd void
   1920   1.49       cgd ttsetwater(tp)
   1921   1.49       cgd 	struct tty *tp;
   1922   1.49       cgd {
   1923   1.49       cgd 	register int cps, x;
   1924   1.49       cgd 
   1925   1.49       cgd #define CLAMP(x, h, l)	((x) > h ? h : ((x) < l) ? l : (x))
   1926   1.49       cgd 
   1927   1.49       cgd 	cps = tp->t_ospeed / 10;
   1928   1.49       cgd 	tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
   1929   1.49       cgd 	x += cps;
   1930   1.49       cgd 	x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
   1931   1.49       cgd 	tp->t_hiwat = roundup(x, CBSIZE);
   1932   1.49       cgd #undef	CLAMP
   1933   1.49       cgd }
   1934   1.49       cgd 
   1935   1.49       cgd /*
   1936   1.49       cgd  * Report on state of foreground process group.
   1937   1.49       cgd  */
   1938   1.49       cgd void
   1939   1.49       cgd ttyinfo(tp)
   1940   1.49       cgd 	register struct tty *tp;
   1941   1.49       cgd {
   1942   1.49       cgd 	register struct proc *p, *pick;
   1943   1.49       cgd 	struct timeval utime, stime;
   1944   1.49       cgd 	int tmp;
   1945   1.49       cgd 
   1946   1.49       cgd 	if (ttycheckoutq(tp,0) == 0)
   1947   1.49       cgd 		return;
   1948   1.49       cgd 
   1949   1.49       cgd 	/* Print load average. */
   1950   1.49       cgd 	tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
   1951   1.49       cgd 	ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
   1952   1.49       cgd 
   1953   1.49       cgd 	if (tp->t_session == NULL)
   1954   1.49       cgd 		ttyprintf(tp, "not a controlling terminal\n");
   1955   1.49       cgd 	else if (tp->t_pgrp == NULL)
   1956   1.49       cgd 		ttyprintf(tp, "no foreground process group\n");
   1957   1.51   mycroft 	else if ((p = tp->t_pgrp->pg_members.lh_first) == 0)
   1958   1.49       cgd 		ttyprintf(tp, "empty foreground process group\n");
   1959   1.49       cgd 	else {
   1960   1.49       cgd 		/* Pick interesting process. */
   1961  1.115      tron 		for (pick = NULL; p != NULL; p = p->p_pglist.le_next)
   1962   1.49       cgd 			if (proc_compare(pick, p))
   1963   1.49       cgd 				pick = p;
   1964   1.49       cgd 
   1965   1.49       cgd 		ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
   1966   1.49       cgd 		    pick->p_stat == SRUN ? "running" :
   1967   1.49       cgd 		    pick->p_wmesg ? pick->p_wmesg : "iowait");
   1968   1.49       cgd 
   1969   1.49       cgd 		calcru(pick, &utime, &stime, NULL);
   1970   1.49       cgd 
   1971   1.62       cgd 		/* Round up and print user time. */
   1972   1.62       cgd 		utime.tv_usec += 5000;
   1973   1.62       cgd 		if (utime.tv_usec >= 1000000) {
   1974   1.62       cgd 			utime.tv_sec += 1;
   1975   1.62       cgd 			utime.tv_usec -= 1000000;
   1976   1.62       cgd 		}
   1977   1.67  christos 		ttyprintf(tp, "%ld.%02ldu ", utime.tv_sec,
   1978   1.62       cgd 		    utime.tv_usec / 10000);
   1979   1.62       cgd 
   1980   1.62       cgd 		/* Round up and print system time. */
   1981   1.62       cgd 		stime.tv_usec += 5000;
   1982   1.62       cgd 		if (stime.tv_usec >= 1000000) {
   1983   1.62       cgd 			stime.tv_sec += 1;
   1984   1.62       cgd 			stime.tv_usec -= 1000000;
   1985   1.62       cgd 		}
   1986   1.67  christos 		ttyprintf(tp, "%ld.%02lds ", stime.tv_sec,
   1987   1.62       cgd 		    stime.tv_usec / 10000);
   1988   1.49       cgd 
   1989   1.68  christos #define	pgtok(a)	(((u_long) ((a) * NBPG) / 1024))
   1990   1.90       gwr 		/* Print percentage cpu. */
   1991   1.66  christos 		tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
   1992   1.90       gwr 		ttyprintf(tp, "%d%% ", tmp / 100);
   1993   1.90       gwr 
   1994   1.90       gwr 		/* Print resident set size. */
   1995  1.115      tron 		if (pick->p_stat == SIDL || P_ZOMBIE(pick))
   1996   1.90       gwr 			tmp = 0;
   1997   1.90       gwr 		else {
   1998   1.90       gwr 			register struct vmspace *vm = pick->p_vmspace;
   1999   1.90       gwr 			tmp = pgtok(vm_resident_count(vm));
   2000   1.90       gwr 		}
   2001   1.91   thorpej 		ttyprintf(tp, "%dk\n", tmp);
   2002   1.49       cgd 	}
   2003   1.49       cgd 	tp->t_rocount = 0;	/* so pending input will be retyped if BS */
   2004   1.49       cgd }
   2005   1.49       cgd 
   2006   1.49       cgd /*
   2007   1.49       cgd  * Returns 1 if p2 is "better" than p1
   2008   1.49       cgd  *
   2009   1.49       cgd  * The algorithm for picking the "interesting" process is thus:
   2010   1.49       cgd  *
   2011   1.49       cgd  *	1) Only foreground processes are eligible - implied.
   2012   1.49       cgd  *	2) Runnable processes are favored over anything else.  The runner
   2013   1.49       cgd  *	   with the highest cpu utilization is picked (p_estcpu).  Ties are
   2014   1.49       cgd  *	   broken by picking the highest pid.
   2015   1.49       cgd  *	3) The sleeper with the shortest sleep time is next.  With ties,
   2016   1.49       cgd  *	   we pick out just "short-term" sleepers (P_SINTR == 0).
   2017   1.49       cgd  *	4) Further ties are broken by picking the highest pid.
   2018   1.49       cgd  */
   2019   1.49       cgd #define ISRUN(p)	(((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
   2020   1.49       cgd #define TESTAB(a, b)    ((a)<<1 | (b))
   2021   1.49       cgd #define ONLYA   2
   2022   1.49       cgd #define ONLYB   1
   2023   1.49       cgd #define BOTH    3
   2024   1.49       cgd 
   2025   1.49       cgd static int
   2026   1.49       cgd proc_compare(p1, p2)
   2027   1.49       cgd 	register struct proc *p1, *p2;
   2028   1.49       cgd {
   2029   1.49       cgd 
   2030   1.49       cgd 	if (p1 == NULL)
   2031   1.49       cgd 		return (1);
   2032   1.49       cgd 	/*
   2033   1.49       cgd 	 * see if at least one of them is runnable
   2034   1.49       cgd 	 */
   2035   1.49       cgd 	switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
   2036   1.49       cgd 	case ONLYA:
   2037   1.49       cgd 		return (0);
   2038   1.49       cgd 	case ONLYB:
   2039   1.49       cgd 		return (1);
   2040   1.49       cgd 	case BOTH:
   2041   1.49       cgd 		/*
   2042   1.49       cgd 		 * tie - favor one with highest recent cpu utilization
   2043   1.49       cgd 		 */
   2044   1.49       cgd 		if (p2->p_estcpu > p1->p_estcpu)
   2045   1.49       cgd 			return (1);
   2046   1.49       cgd 		if (p1->p_estcpu > p2->p_estcpu)
   2047   1.49       cgd 			return (0);
   2048   1.49       cgd 		return (p2->p_pid > p1->p_pid);	/* tie - return highest pid */
   2049   1.49       cgd 	}
   2050   1.49       cgd 	/*
   2051   1.49       cgd  	 * weed out zombies
   2052   1.49       cgd 	 */
   2053  1.114   thorpej 	switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
   2054   1.49       cgd 	case ONLYA:
   2055   1.49       cgd 		return (1);
   2056   1.49       cgd 	case ONLYB:
   2057   1.49       cgd 		return (0);
   2058   1.49       cgd 	case BOTH:
   2059   1.49       cgd 		return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
   2060   1.49       cgd 	}
   2061   1.49       cgd 	/*
   2062   1.49       cgd 	 * pick the one with the smallest sleep time
   2063   1.49       cgd 	 */
   2064   1.49       cgd 	if (p2->p_slptime > p1->p_slptime)
   2065   1.49       cgd 		return (0);
   2066   1.49       cgd 	if (p1->p_slptime > p2->p_slptime)
   2067   1.49       cgd 		return (1);
   2068   1.49       cgd 	/*
   2069   1.49       cgd 	 * favor one sleeping in a non-interruptible sleep
   2070   1.49       cgd 	 */
   2071   1.49       cgd 	if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
   2072   1.49       cgd 		return (1);
   2073   1.49       cgd 	if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
   2074   1.49       cgd 		return (0);
   2075   1.49       cgd 	return (p2->p_pid > p1->p_pid);		/* tie - return highest pid */
   2076   1.49       cgd }
   2077   1.49       cgd 
   2078   1.49       cgd /*
   2079   1.49       cgd  * Output char to tty; console putchar style.
   2080   1.49       cgd  */
   2081   1.49       cgd int
   2082   1.49       cgd tputchar(c, tp)
   2083   1.49       cgd 	int c;
   2084   1.49       cgd 	struct tty *tp;
   2085   1.49       cgd {
   2086   1.49       cgd 	register int s;
   2087   1.49       cgd 
   2088   1.49       cgd 	s = spltty();
   2089   1.49       cgd 	if (ISSET(tp->t_state,
   2090   1.49       cgd 	    TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) {
   2091   1.49       cgd 		splx(s);
   2092   1.49       cgd 		return (-1);
   2093   1.49       cgd 	}
   2094   1.49       cgd 	if (c == '\n')
   2095   1.49       cgd 		(void)ttyoutput('\r', tp);
   2096   1.49       cgd 	(void)ttyoutput(c, tp);
   2097   1.49       cgd 	ttstart(tp);
   2098   1.49       cgd 	splx(s);
   2099   1.49       cgd 	return (0);
   2100   1.49       cgd }
   2101   1.49       cgd 
   2102   1.49       cgd /*
   2103   1.49       cgd  * Sleep on chan, returning ERESTART if tty changed while we napped and
   2104   1.49       cgd  * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep.  If
   2105   1.49       cgd  * the tty is revoked, restarting a pending call will redo validation done
   2106   1.49       cgd  * at the start of the call.
   2107   1.49       cgd  */
   2108   1.49       cgd int
   2109   1.49       cgd ttysleep(tp, chan, pri, wmesg, timo)
   2110   1.49       cgd 	struct tty *tp;
   2111   1.49       cgd 	void *chan;
   2112   1.49       cgd 	int pri, timo;
   2113   1.97   mycroft 	const char *wmesg;
   2114   1.49       cgd {
   2115   1.49       cgd 	int error;
   2116   1.49       cgd 	short gen;
   2117   1.49       cgd 
   2118   1.49       cgd 	gen = tp->t_gen;
   2119   1.65  christos 	if ((error = tsleep(chan, pri, wmesg, timo)) != 0)
   2120   1.49       cgd 		return (error);
   2121   1.49       cgd 	return (tp->t_gen == gen ? 0 : ERESTART);
   2122   1.49       cgd }
   2123   1.49       cgd 
   2124   1.49       cgd /*
   2125   1.69       mrg  * Initialise the global tty list.
   2126   1.69       mrg  */
   2127   1.69       mrg void
   2128   1.69       mrg tty_init()
   2129   1.69       mrg {
   2130   1.71       cgd 
   2131   1.69       mrg 	TAILQ_INIT(&ttylist);
   2132   1.69       mrg 	tty_count = 0;
   2133  1.111   thorpej 
   2134  1.111   thorpej 	pool_init(&tty_pool, sizeof(struct tty), 0, 0, 0, "ttypl",
   2135  1.111   thorpej 	    0, pool_page_alloc_nointr, pool_page_free_nointr, M_TTYS);
   2136   1.69       mrg }
   2137   1.69       mrg 
   2138   1.69       mrg /*
   2139   1.69       mrg  * Attach a tty to the tty list.
   2140   1.72       mrg  *
   2141   1.72       mrg  * This should be called ONLY once per real tty (including pty's).
   2142   1.72       mrg  * eg, on the sparc, the keyboard and mouse have struct tty's that are
   2143   1.72       mrg  * distinctly NOT usable as tty's, and thus should not be attached to
   2144   1.72       mrg  * the ttylist.  This is why this call is not done from ttymalloc().
   2145   1.72       mrg  *
   2146   1.72       mrg  * Device drivers should attach tty's at a similar time that they are
   2147   1.72       mrg  * ttymalloc()'ed, or, for the case of statically allocated struct tty's
   2148   1.72       mrg  * either in the attach or (first) open routine.
   2149   1.69       mrg  */
   2150   1.69       mrg void
   2151   1.69       mrg tty_attach(tp)
   2152   1.69       mrg 	struct tty *tp;
   2153   1.69       mrg {
   2154   1.71       cgd 
   2155   1.69       mrg 	TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
   2156   1.69       mrg 	++tty_count;
   2157   1.69       mrg }
   2158   1.69       mrg 
   2159   1.69       mrg /*
   2160   1.69       mrg  * Remove a tty from the tty list.
   2161   1.69       mrg  */
   2162   1.69       mrg void
   2163   1.69       mrg tty_detach(tp)
   2164   1.69       mrg 	struct tty *tp;
   2165   1.69       mrg {
   2166   1.71       cgd 
   2167   1.69       mrg 	--tty_count;
   2168   1.69       mrg #ifdef DIAGNOSTIC
   2169   1.69       mrg 	if (tty_count < 0)
   2170   1.69       mrg 		panic("tty_detach: tty_count < 0");
   2171   1.69       mrg #endif
   2172   1.70       mrg 	TAILQ_REMOVE(&ttylist, tp, tty_link);
   2173   1.69       mrg }
   2174   1.69       mrg 
   2175   1.69       mrg /*
   2176   1.49       cgd  * Allocate a tty structure and its associated buffers.
   2177   1.49       cgd  */
   2178   1.49       cgd struct tty *
   2179   1.49       cgd ttymalloc()
   2180   1.49       cgd {
   2181   1.49       cgd 	struct tty *tp;
   2182   1.49       cgd 
   2183  1.111   thorpej 	tp = pool_get(&tty_pool, PR_WAITOK);
   2184  1.109     perry 	memset(tp, 0, sizeof(*tp));
   2185  1.116   thorpej 	callout_init(&tp->t_outq_ch);
   2186  1.116   thorpej 	callout_init(&tp->t_rstrt_ch);
   2187   1.84   mycroft 	/* XXX: default to 1024 chars for now */
   2188   1.84   mycroft 	clalloc(&tp->t_rawq, 1024, 1);
   2189   1.84   mycroft 	clalloc(&tp->t_canq, 1024, 1);
   2190   1.49       cgd 	/* output queue doesn't need quoting */
   2191   1.84   mycroft 	clalloc(&tp->t_outq, 1024, 0);
   2192   1.49       cgd 	return(tp);
   2193   1.49       cgd }
   2194   1.49       cgd 
   2195   1.49       cgd /*
   2196   1.49       cgd  * Free a tty structure and its buffers.
   2197   1.73       mrg  *
   2198   1.73       mrg  * Be sure to call tty_detach() for any tty that has been
   2199   1.73       mrg  * tty_attach()ed.
   2200   1.49       cgd  */
   2201   1.49       cgd void
   2202   1.49       cgd ttyfree(tp)
   2203   1.71       cgd 	struct tty *tp;
   2204   1.49       cgd {
   2205   1.71       cgd 
   2206  1.116   thorpej 	callout_stop(&tp->t_outq_ch);
   2207  1.116   thorpej 	callout_stop(&tp->t_rstrt_ch);
   2208   1.49       cgd 	clfree(&tp->t_rawq);
   2209   1.49       cgd 	clfree(&tp->t_canq);
   2210   1.49       cgd 	clfree(&tp->t_outq);
   2211  1.111   thorpej 	pool_put(&tty_pool, tp);
   2212   1.49       cgd }
   2213