xref: /dragonfly/sys/kern/tty.c (revision 23265324)
1 /*-
2  * Copyright (c) 1982, 1986, 1990, 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *	This product includes software developed by the University of
21  *	California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *	@(#)tty.c	8.8 (Berkeley) 1/21/94
39  * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
40  * $DragonFly: src/sys/kern/tty.c,v 1.39 2007/02/18 16:15:23 corecode Exp $
41  */
42 
43 /*-
44  * TODO:
45  *	o Fix races for sending the start char in ttyflush().
46  *	o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
47  *	  With luck, there will be MIN chars before select() returns().
48  *	o Handle CLOCAL consistently for ptys.  Perhaps disallow setting it.
49  *	o Don't allow input in TS_ZOMBIE case.  It would be visible through
50  *	  FIONREAD.
51  *	o Do the new sio locking stuff here and use it to avoid special
52  *	  case for EXTPROC?
53  *	o Lock PENDIN too?
54  *	o Move EXTPROC and/or PENDIN to t_state?
55  *	o Wrap most of ttioctl in spltty/splx.
56  *	o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
57  *	o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
58  *	o Don't allow certain termios flags to affect disciplines other
59  *	  than TTYDISC.  Cancel their effects before switch disciplines
60  *	  and ignore them if they are set while we are in another
61  *	  discipline.
62  *	o Now that historical speed conversions are handled here, don't
63  *	  do them in drivers.
64  *	o Check for TS_CARR_ON being set while everything is closed and not
65  *	  waiting for carrier.  TS_CARR_ON isn't cleared if nothing is open,
66  *	  so it would live until the next open even if carrier drops.
67  *	o Restore TS_WOPEN since it is useful in pstat.  It must be cleared
68  *	  only when _all_ openers leave open().
69  */
70 
71 #include "opt_compat.h"
72 #include "opt_uconsole.h"
73 
74 #include <sys/param.h>
75 #include <sys/systm.h>
76 #include <sys/filio.h>
77 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
78 #include <sys/ioctl_compat.h>
79 #endif
80 #include <sys/proc.h>
81 #define	TTYDEFCHARS
82 #include <sys/tty.h>
83 #include <sys/clist.h>
84 #undef	TTYDEFCHARS
85 #include <sys/fcntl.h>
86 #include <sys/conf.h>
87 #include <sys/dkstat.h>
88 #include <sys/poll.h>
89 #include <sys/kernel.h>
90 #include <sys/vnode.h>
91 #include <sys/signalvar.h>
92 #include <sys/resourcevar.h>
93 #include <sys/malloc.h>
94 #include <sys/filedesc.h>
95 #include <sys/sysctl.h>
96 #include <sys/thread2.h>
97 
98 #include <vm/vm.h>
99 #include <sys/lock.h>
100 #include <vm/pmap.h>
101 #include <vm/vm_map.h>
102 
103 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
104 
105 static int	proc_compare (struct proc *p1, struct proc *p2);
106 static int	ttnread (struct tty *tp);
107 static void	ttyecho (int c, struct tty *tp);
108 static int	ttyoutput (int c, struct tty *tp);
109 static void	ttypend (struct tty *tp);
110 static void	ttyretype (struct tty *tp);
111 static void	ttyrub (int c, struct tty *tp);
112 static void	ttyrubo (struct tty *tp, int cnt);
113 static void	ttyunblock (struct tty *tp);
114 static int	ttywflush (struct tty *tp);
115 static int	filt_ttyread (struct knote *kn, long hint);
116 static void 	filt_ttyrdetach (struct knote *kn);
117 static int	filt_ttywrite (struct knote *kn, long hint);
118 static void 	filt_ttywdetach (struct knote *kn);
119 
120 /*
121  * Table with character classes and parity. The 8th bit indicates parity,
122  * the 7th bit indicates the character is an alphameric or underscore (for
123  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
124  * are 0 then the character needs no special processing on output; classes
125  * other than 0 might be translated or (not currently) require delays.
126  */
127 #define	E	0x00	/* Even parity. */
128 #define	O	0x80	/* Odd parity. */
129 #define	PARITY(c)	(char_type[c] & O)
130 
131 #define	ALPHA	0x40	/* Alpha or underscore. */
132 #define	ISALPHA(c)	(char_type[(c) & TTY_CHARMASK] & ALPHA)
133 
134 #define	CCLASSMASK	0x3f
135 #define	CCLASS(c)	(char_type[c] & CCLASSMASK)
136 
137 #define	BS	BACKSPACE
138 #define	CC	CONTROL
139 #define	CR	RETURN
140 #define	NA	ORDINARY | ALPHA
141 #define	NL	NEWLINE
142 #define	NO	ORDINARY
143 #define	TB	TAB
144 #define	VT	VTAB
145 
146 static u_char const char_type[] = {
147 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC,	/* nul - bel */
148 	O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
149 	O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
150 	E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
151 	O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
152 	E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
153 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
154 	O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
155 	O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
156 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
157 	E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
158 	O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
159 	E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
160 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
161 	O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
162 	E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
163 	/*
164 	 * Meta chars; should be settable per character set;
165 	 * for now, treat them all as normal characters.
166 	 */
167 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
168 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
169 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
170 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
171 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
172 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
173 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
174 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
175 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
176 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
177 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
178 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
179 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
180 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
181 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
182 	NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
183 };
184 #undef	BS
185 #undef	CC
186 #undef	CR
187 #undef	NA
188 #undef	NL
189 #undef	NO
190 #undef	TB
191 #undef	VT
192 
193 /* Macros to clear/set/test flags. */
194 #define	SET(t, f)	(t) |= (f)
195 #define	CLR(t, f)	(t) &= ~(f)
196 #define	ISSET(t, f)	((t) & (f))
197 
198 #undef MAX_INPUT		/* XXX wrong in <sys/syslimits.h> */
199 #define	MAX_INPUT	TTYHOG	/* XXX limit is usually larger for !ICANON */
200 
201 uint64_t tk_nin;
202 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
203     "LU", "TTY input statistic");
204 uint64_t tk_nout;
205 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
206     "LU", "TTY output statistic");
207 uint64_t tk_rawcc;
208 
209 /*
210  * list of struct tty where pstat(8) can pick it up with sysctl
211  */
212 static SLIST_HEAD(, tty) tty_list;
213 
214 /*
215  * Initial open of tty, or (re)entry to standard tty line discipline.
216  */
217 int
218 ttyopen(cdev_t device, struct tty *tp)
219 {
220 	crit_enter();
221 	tp->t_dev = device;
222 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
223 		SET(tp->t_state, TS_ISOPEN);
224 		if (ISSET(tp->t_cflag, CLOCAL))
225 			SET(tp->t_state, TS_CONNECTED);
226 		bzero(&tp->t_winsize, sizeof(tp->t_winsize));
227 	}
228 	ttsetwater(tp);
229 	crit_exit();
230 	return (0);
231 }
232 
233 /*
234  * Handle close() on a tty line: flush and set to initial state,
235  * bumping generation number so that pending read/write calls
236  * can detect recycling of the tty.
237  *
238  * XXX our caller should have done `spltty(); l_close(); ttyclose();'
239  * and l_close() should have flushed, but we repeat the spltty() and
240  * the flush in case there are buggy callers.
241  */
242 int
243 ttyclose(struct tty *tp)
244 {
245 	funsetown(tp->t_sigio);
246 	crit_enter();
247 	if (constty == tp)
248 		constty = NULL;
249 
250 	ttyflush(tp, FREAD | FWRITE);
251 	clist_free_cblocks(&tp->t_canq);
252 	clist_free_cblocks(&tp->t_outq);
253 	clist_free_cblocks(&tp->t_rawq);
254 
255 	tp->t_gen++;
256 	tp->t_line = TTYDISC;
257 	ttyclearsession(tp);
258 	tp->t_state = 0;
259 	crit_exit();
260 	return (0);
261 }
262 
263 /*
264  * Disassociate the tty from its session.  Traditionally this has only been
265  * a half-close, meaning that the session was still allowed to point at the
266  * tty (resulting in the tty in the ps command showing something like 'p0-'),
267  * even though the tty is no longer pointing at the session.
268  *
269  * The half close seems to be useful only for 'ps' output but there is as
270  * yet no reason to remove the feature.  The full-close code is currently
271  * #if 0'd out.  See also sess_rele() in kern/kern_proc.c.
272  */
273 void
274 ttyclearsession(struct tty *tp)
275 {
276 	struct session *sp;
277 
278 	tp->t_pgrp = NULL;
279 	if ((sp = tp->t_session) != NULL) {
280 		tp->t_session = NULL;
281 #ifdef TTY_DO_FULL_CLOSE
282 		/* FULL CLOSE (not yet) */
283 		if (sp->s_ttyp == tp) {
284 			sp->s_ttyp = NULL;
285 		} else {
286 			kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
287 				"%p/%p\n", sp->s_ttyp, tp);
288 		}
289 #endif
290 	}
291 }
292 
293 /*
294  * Terminate the tty vnode association for a session.  This is the
295  * 'other half' of the close.  Because multiple opens of /dev/tty
296  * only generate a single open to the actual tty, the file modes
297  * are locked to FREAD|FWRITE.
298  */
299 void
300 ttyclosesession(struct session *sp, int dorele)
301 {
302 	struct vnode *vp;
303 
304 	if ((vp = sp->s_ttyvp) == NULL)
305 		return;
306 	sp->s_ttyvp = NULL;
307 	if (vp->v_flag & VCTTYISOPEN) {
308 		if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY) == 0) {
309 			vclrflags(vp, VCTTYISOPEN);
310 			VOP_CLOSE(vp, FREAD|FWRITE);
311 			vn_unlock(vp);
312 		}
313 	}
314 	if (dorele)
315 		vrele(vp);
316 }
317 
318 
319 #define	FLUSHQ(q) {							\
320 	if ((q)->c_cc)							\
321 		ndflush(q, (q)->c_cc);					\
322 }
323 
324 /* Is 'c' a line delimiter ("break" character)? */
325 #define	TTBREAKC(c, lflag)							\
326 	((c) == '\n' || (((c) == cc[VEOF] ||				\
327 	  (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) &&	\
328 	 (c) != _POSIX_VDISABLE))
329 
330 /*
331  * Process input of a single character received on a tty.
332  */
333 int
334 ttyinput(int c, struct tty *tp)
335 {
336 	tcflag_t iflag, lflag;
337 	cc_t *cc;
338 	int i, err;
339 
340 	/*
341 	 * If input is pending take it first.
342 	 */
343 	lflag = tp->t_lflag;
344 	if (ISSET(lflag, PENDIN))
345 		ttypend(tp);
346 	/*
347 	 * Gather stats.
348 	 */
349 	if (ISSET(lflag, ICANON))
350 		++tp->t_cancc;
351 	else
352 		++tp->t_rawcc;
353 	++tk_nin;
354 
355 	/*
356 	 * Block further input iff:
357 	 * current input > threshold AND input is available to user program
358 	 * AND input flow control is enabled and not yet invoked.
359 	 * The 3 is slop for PARMRK.
360 	 */
361 	iflag = tp->t_iflag;
362 	if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
363 	    (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
364 	    (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
365 	    !ISSET(tp->t_state, TS_TBLOCK))
366 		ttyblock(tp);
367 
368 	/* Handle exceptional conditions (break, parity, framing). */
369 	cc = tp->t_cc;
370 	err = (ISSET(c, TTY_ERRORMASK));
371 	if (err) {
372 		CLR(c, TTY_ERRORMASK);
373 		if (ISSET(err, TTY_BI)) {
374 			if (ISSET(iflag, IGNBRK))
375 				return (0);
376 			if (ISSET(iflag, BRKINT)) {
377 				ttyflush(tp, FREAD | FWRITE);
378 				pgsignal(tp->t_pgrp, SIGINT, 1);
379 				goto endcase;
380 			}
381 			if (ISSET(iflag, PARMRK))
382 				goto parmrk;
383 		} else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
384 			|| ISSET(err, TTY_FE)) {
385 			if (ISSET(iflag, IGNPAR))
386 				return (0);
387 			else if (ISSET(iflag, PARMRK)) {
388 parmrk:
389 				if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
390 				    MAX_INPUT - 3)
391 					goto input_overflow;
392 				clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
393 				clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
394 				clist_putc(c | TTY_QUOTE, &tp->t_rawq);
395 				goto endcase;
396 			} else
397 				c = 0;
398 		}
399 	}
400 
401 	if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
402 		CLR(c, 0x80);
403 	if (!ISSET(lflag, EXTPROC)) {
404 		/*
405 		 * Check for literal nexting very first
406 		 */
407 		if (ISSET(tp->t_state, TS_LNCH)) {
408 			SET(c, TTY_QUOTE);
409 			CLR(tp->t_state, TS_LNCH);
410 		}
411 		/*
412 		 * Scan for special characters.  This code
413 		 * is really just a big case statement with
414 		 * non-constant cases.  The bottom of the
415 		 * case statement is labeled ``endcase'', so goto
416 		 * it after a case match, or similar.
417 		 */
418 
419 		/*
420 		 * Control chars which aren't controlled
421 		 * by ICANON, ISIG, or IXON.
422 		 */
423 		if (ISSET(lflag, IEXTEN)) {
424 			if (CCEQ(cc[VLNEXT], c)) {
425 				if (ISSET(lflag, ECHO)) {
426 					if (ISSET(lflag, ECHOE)) {
427 						(void)ttyoutput('^', tp);
428 						(void)ttyoutput('\b', tp);
429 					} else
430 						ttyecho(c, tp);
431 				}
432 				SET(tp->t_state, TS_LNCH);
433 				goto endcase;
434 			}
435 			if (CCEQ(cc[VDISCARD], c)) {
436 				if (ISSET(lflag, FLUSHO))
437 					CLR(tp->t_lflag, FLUSHO);
438 				else {
439 					ttyflush(tp, FWRITE);
440 					ttyecho(c, tp);
441 					if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
442 						ttyretype(tp);
443 					SET(tp->t_lflag, FLUSHO);
444 				}
445 				goto startoutput;
446 			}
447 		}
448 		/*
449 		 * Signals.
450 		 */
451 		if (ISSET(lflag, ISIG)) {
452 			if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
453 				if (!ISSET(lflag, NOFLSH))
454 					ttyflush(tp, FREAD | FWRITE);
455 				ttyecho(c, tp);
456 				pgsignal(tp->t_pgrp,
457 				    CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
458 				goto endcase;
459 			}
460 			if (CCEQ(cc[VSUSP], c)) {
461 				if (!ISSET(lflag, NOFLSH))
462 					ttyflush(tp, FREAD);
463 				ttyecho(c, tp);
464 				pgsignal(tp->t_pgrp, SIGTSTP, 1);
465 				goto endcase;
466 			}
467 		}
468 		/*
469 		 * Handle start/stop characters.
470 		 */
471 		if (ISSET(iflag, IXON)) {
472 			if (CCEQ(cc[VSTOP], c)) {
473 				if (!ISSET(tp->t_state, TS_TTSTOP)) {
474 					SET(tp->t_state, TS_TTSTOP);
475 					(*tp->t_stop)(tp, 0);
476 					return (0);
477 				}
478 				if (!CCEQ(cc[VSTART], c))
479 					return (0);
480 				/*
481 				 * if VSTART == VSTOP then toggle
482 				 */
483 				goto endcase;
484 			}
485 			if (CCEQ(cc[VSTART], c))
486 				goto restartoutput;
487 		}
488 		/*
489 		 * IGNCR, ICRNL, & INLCR
490 		 */
491 		if (c == '\r') {
492 			if (ISSET(iflag, IGNCR))
493 				return (0);
494 			else if (ISSET(iflag, ICRNL))
495 				c = '\n';
496 		} else if (c == '\n' && ISSET(iflag, INLCR))
497 			c = '\r';
498 	}
499 	if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
500 		/*
501 		 * From here on down canonical mode character
502 		 * processing takes place.
503 		 */
504 		/*
505 		 * erase or erase2 (^H / ^?)
506 		 */
507 		if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
508 			if (tp->t_rawq.c_cc)
509 				ttyrub(clist_unputc(&tp->t_rawq), tp);
510 			goto endcase;
511 		}
512 		/*
513 		 * kill (^U)
514 		 */
515 		if (CCEQ(cc[VKILL], c)) {
516 			if (ISSET(lflag, ECHOKE) &&
517 			    tp->t_rawq.c_cc == tp->t_rocount &&
518 			    !ISSET(lflag, ECHOPRT))
519 				while (tp->t_rawq.c_cc)
520 					ttyrub(clist_unputc(&tp->t_rawq), tp);
521 			else {
522 				ttyecho(c, tp);
523 				if (ISSET(lflag, ECHOK) ||
524 				    ISSET(lflag, ECHOKE))
525 					ttyecho('\n', tp);
526 				FLUSHQ(&tp->t_rawq);
527 				tp->t_rocount = 0;
528 			}
529 			CLR(tp->t_state, TS_LOCAL);
530 			goto endcase;
531 		}
532 		/*
533 		 * word erase (^W)
534 		 */
535 		if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
536 			int ctype;
537 
538 			/*
539 			 * erase whitespace
540 			 */
541 			while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
542 				ttyrub(c, tp);
543 			if (c == -1)
544 				goto endcase;
545 			/*
546 			 * erase last char of word and remember the
547 			 * next chars type (for ALTWERASE)
548 			 */
549 			ttyrub(c, tp);
550 			c = clist_unputc(&tp->t_rawq);
551 			if (c == -1)
552 				goto endcase;
553 			if (c == ' ' || c == '\t') {
554 				clist_putc(c, &tp->t_rawq);
555 				goto endcase;
556 			}
557 			ctype = ISALPHA(c);
558 			/*
559 			 * erase rest of word
560 			 */
561 			do {
562 				ttyrub(c, tp);
563 				c = clist_unputc(&tp->t_rawq);
564 				if (c == -1)
565 					goto endcase;
566 			} while (c != ' ' && c != '\t' &&
567 			    (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
568 			clist_putc(c, &tp->t_rawq);
569 			goto endcase;
570 		}
571 		/*
572 		 * reprint line (^R)
573 		 */
574 		if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
575 			ttyretype(tp);
576 			goto endcase;
577 		}
578 		/*
579 		 * ^T - kernel info and generate SIGINFO
580 		 */
581 		if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
582 			if (ISSET(lflag, ISIG))
583 				pgsignal(tp->t_pgrp, SIGINFO, 1);
584 			if (!ISSET(lflag, NOKERNINFO))
585 				ttyinfo(tp);
586 			goto endcase;
587 		}
588 		if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
589 			if (ISSET(lflag, ISIG))
590 				pgsignal(tp->t_pgrp, SIGCKPT, 1);
591 			goto endcase;
592 		}
593 	}
594 	/*
595 	 * Check for input buffer overflow
596 	 */
597 	if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
598 input_overflow:
599 		if (ISSET(iflag, IMAXBEL)) {
600 			if (tp->t_outq.c_cc < tp->t_ohiwat)
601 				(void)ttyoutput(CTRL('g'), tp);
602 		}
603 		goto endcase;
604 	}
605 
606 	if (   c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
607 	     && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
608 		clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
609 
610 	/*
611 	 * Put data char in q for user and
612 	 * wakeup on seeing a line delimiter.
613 	 */
614 	if (clist_putc(c, &tp->t_rawq) >= 0) {
615 		if (!ISSET(lflag, ICANON)) {
616 			ttwakeup(tp);
617 			ttyecho(c, tp);
618 			goto endcase;
619 		}
620 		if (TTBREAKC(c, lflag)) {
621 			tp->t_rocount = 0;
622 			catq(&tp->t_rawq, &tp->t_canq);
623 			ttwakeup(tp);
624 		} else if (tp->t_rocount++ == 0)
625 			tp->t_rocol = tp->t_column;
626 		if (ISSET(tp->t_state, TS_ERASE)) {
627 			/*
628 			 * end of prterase \.../
629 			 */
630 			CLR(tp->t_state, TS_ERASE);
631 			(void)ttyoutput('/', tp);
632 		}
633 		i = tp->t_column;
634 		ttyecho(c, tp);
635 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
636 			/*
637 			 * Place the cursor over the '^' of the ^D.
638 			 */
639 			i = imin(2, tp->t_column - i);
640 			while (i > 0) {
641 				(void)ttyoutput('\b', tp);
642 				i--;
643 			}
644 		}
645 	}
646 endcase:
647 	/*
648 	 * IXANY means allow any character to restart output.
649 	 */
650 	if (ISSET(tp->t_state, TS_TTSTOP) &&
651 	    !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
652 		return (0);
653 restartoutput:
654 	CLR(tp->t_lflag, FLUSHO);
655 	CLR(tp->t_state, TS_TTSTOP);
656 startoutput:
657 	return (ttstart(tp));
658 }
659 
660 /*
661  * Output a single character on a tty, doing output processing
662  * as needed (expanding tabs, newline processing, etc.).
663  * Returns < 0 if succeeds, otherwise returns char to resend.
664  * Must be recursive.
665  */
666 static int
667 ttyoutput(int c, struct tty *tp)
668 {
669 	tcflag_t oflag;
670 	int col;
671 
672 	oflag = tp->t_oflag;
673 	if (!ISSET(oflag, OPOST)) {
674 		if (ISSET(tp->t_lflag, FLUSHO))
675 			return (-1);
676 		if (clist_putc(c, &tp->t_outq))
677 			return (c);
678 		tk_nout++;
679 		tp->t_outcc++;
680 		return (-1);
681 	}
682 	/*
683 	 * Do tab expansion if OXTABS is set.  Special case if we external
684 	 * processing, we don't do the tab expansion because we'll probably
685 	 * get it wrong.  If tab expansion needs to be done, let it happen
686 	 * externally.
687 	 */
688 	CLR(c, ~TTY_CHARMASK);
689 	if (c == '\t' &&
690 	    ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
691 		c = 8 - (tp->t_column & 7);
692 		if (!ISSET(tp->t_lflag, FLUSHO)) {
693 			crit_enter();		/* Don't interrupt tabs. */
694 			c -= b_to_q("        ", c, &tp->t_outq);
695 			tk_nout += c;
696 			tp->t_outcc += c;
697 			crit_exit();
698 		}
699 		tp->t_column += c;
700 		return (c ? -1 : '\t');
701 	}
702 	if (c == CEOT && ISSET(oflag, ONOEOT))
703 		return (-1);
704 
705 	/*
706 	 * Newline translation: if ONLCR is set,
707 	 * translate newline into "\r\n".
708 	 */
709 	if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
710 		tk_nout++;
711 		tp->t_outcc++;
712 		if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq))
713 			return (c);
714 	}
715 	/* If OCRNL is set, translate "\r" into "\n". */
716 	else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
717 		c = '\n';
718 	/* If ONOCR is set, don't transmit CRs when on column 0. */
719 	else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
720 		return (-1);
721 
722 	tk_nout++;
723 	tp->t_outcc++;
724 	if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq))
725 		return (c);
726 
727 	col = tp->t_column;
728 	switch (CCLASS(c)) {
729 	case BACKSPACE:
730 		if (col > 0)
731 			--col;
732 		break;
733 	case CONTROL:
734 		break;
735 	case NEWLINE:
736 		if (ISSET(tp->t_oflag, ONLCR | ONLRET))
737 			col = 0;
738 		break;
739 	case RETURN:
740 		col = 0;
741 		break;
742 	case ORDINARY:
743 		++col;
744 		break;
745 	case TAB:
746 		col = (col + 8) & ~7;
747 		break;
748 	}
749 	tp->t_column = col;
750 	return (-1);
751 }
752 
753 /*
754  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
755  * has been called to do discipline-specific functions and/or reject any
756  * of these ioctl commands.
757  */
758 /* ARGSUSED */
759 int
760 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
761 {
762 	struct thread *td = curthread;
763 	struct lwp *lp = td->td_lwp;
764 	struct proc *p = td->td_proc;
765 	int error;
766 
767 	KKASSERT(p);
768 
769 	/* If the ioctl involves modification, hang if in the background. */
770 	switch (cmd) {
771 	case  TIOCCBRK:
772 	case  TIOCCONS:
773 	case  TIOCDRAIN:
774 	case  TIOCEXCL:
775 	case  TIOCFLUSH:
776 #ifdef TIOCHPCL
777 	case  TIOCHPCL:
778 #endif
779 	case  TIOCNXCL:
780 	case  TIOCSBRK:
781 	case  TIOCSCTTY:
782 	case  TIOCSDRAINWAIT:
783 	case  TIOCSETA:
784 	case  TIOCSETAF:
785 	case  TIOCSETAW:
786 	case  TIOCSETD:
787 	case  TIOCSPGRP:
788 	case  TIOCSTART:
789 	case  TIOCSTAT:
790 	case  TIOCSTI:
791 	case  TIOCSTOP:
792 	case  TIOCSWINSZ:
793 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
794 	case  TIOCLBIC:
795 	case  TIOCLBIS:
796 	case  TIOCLSET:
797 	case  TIOCSETC:
798 	case OTIOCSETD:
799 	case  TIOCSETN:
800 	case  TIOCSETP:
801 	case  TIOCSLTC:
802 #endif
803 		while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
804 		    !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
805 		    !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
806 			if (p->p_pgrp->pg_jobc == 0)
807 				return (EIO);
808 			pgsignal(p->p_pgrp, SIGTTOU, 1);
809 			error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
810 					 0);
811 			if (error)
812 				return (error);
813 		}
814 		break;
815 	}
816 
817 	switch (cmd) {			/* Process the ioctl. */
818 	case FIOASYNC:			/* set/clear async i/o */
819 		crit_enter();
820 		if (*(int *)data)
821 			SET(tp->t_state, TS_ASYNC);
822 		else
823 			CLR(tp->t_state, TS_ASYNC);
824 		crit_exit();
825 		break;
826 	case FIONREAD:			/* get # bytes to read */
827 		crit_enter();
828 		*(int *)data = ttnread(tp);
829 		crit_exit();
830 		break;
831 
832 	case FIOSETOWN:
833 		/*
834 		 * Policy -- Don't allow FIOSETOWN on someone else's
835 		 *           controlling tty
836 		 */
837 		if (tp->t_session != NULL && !isctty(p, tp))
838 			return (ENOTTY);
839 
840 		error = fsetown(*(int *)data, &tp->t_sigio);
841 		if (error)
842 			return (error);
843 		break;
844 	case FIOGETOWN:
845 		if (tp->t_session != NULL && !isctty(p, tp))
846 			return (ENOTTY);
847 		*(int *)data = fgetown(tp->t_sigio);
848 		break;
849 
850 	case TIOCEXCL:			/* set exclusive use of tty */
851 		crit_enter();
852 		SET(tp->t_state, TS_XCLUDE);
853 		crit_exit();
854 		break;
855 	case TIOCFLUSH: {		/* flush buffers */
856 		int flags = *(int *)data;
857 
858 		if (flags == 0)
859 			flags = FREAD | FWRITE;
860 		else
861 			flags &= FREAD | FWRITE;
862 		ttyflush(tp, flags);
863 		break;
864 	}
865 	case TIOCCONS:			/* become virtual console */
866 		if (*(int *)data) {
867 			if (constty && constty != tp &&
868 			    ISSET(constty->t_state, TS_CONNECTED))
869 				return (EBUSY);
870 #ifndef	UCONSOLE
871 			if ((error = suser(td)) != 0)
872 				return (error);
873 #endif
874 			constty = tp;
875 		} else if (tp == constty)
876 			constty = NULL;
877 		break;
878 	case TIOCDRAIN:			/* wait till output drained */
879 		error = ttywait(tp);
880 		if (error)
881 			return (error);
882 		break;
883 	case TIOCGETA: {		/* get termios struct */
884 		struct termios *t = (struct termios *)data;
885 
886 		bcopy(&tp->t_termios, t, sizeof(struct termios));
887 		break;
888 	}
889 	case TIOCGETD:			/* get line discipline */
890 		*(int *)data = tp->t_line;
891 		break;
892 	case TIOCGWINSZ:		/* get window size */
893 		*(struct winsize *)data = tp->t_winsize;
894 		break;
895 	case TIOCGPGRP:			/* get pgrp of tty */
896 		if (!isctty(p, tp))
897 			return (ENOTTY);
898 		*(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
899 		break;
900 #ifdef TIOCHPCL
901 	case TIOCHPCL:			/* hang up on last close */
902 		crit_enter();
903 		SET(tp->t_cflag, HUPCL);
904 		crit_exit();
905 		break;
906 #endif
907 	case TIOCNXCL:			/* reset exclusive use of tty */
908 		crit_enter();
909 		CLR(tp->t_state, TS_XCLUDE);
910 		crit_exit();
911 		break;
912 	case TIOCOUTQ:			/* output queue size */
913 		*(int *)data = tp->t_outq.c_cc;
914 		break;
915 	case TIOCSETA:			/* set termios struct */
916 	case TIOCSETAW:			/* drain output, set */
917 	case TIOCSETAF: {		/* drn out, fls in, set */
918 		struct termios *t = (struct termios *)data;
919 
920 		if (t->c_ispeed == 0)
921 			t->c_ispeed = t->c_ospeed;
922 		if (t->c_ispeed == 0)
923 			t->c_ispeed = tp->t_ospeed;
924 		if (t->c_ispeed == 0)
925 			return (EINVAL);
926 		crit_enter();
927 		if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
928 			error = ttywait(tp);
929 			if (error) {
930 				crit_exit();
931 				return (error);
932 			}
933 			if (cmd == TIOCSETAF)
934 				ttyflush(tp, FREAD);
935 		}
936 		if (!ISSET(t->c_cflag, CIGNORE)) {
937 			/*
938 			 * Set device hardware.
939 			 */
940 			if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
941 				crit_exit();
942 				return (error);
943 			}
944 			if (ISSET(t->c_cflag, CLOCAL) &&
945 			    !ISSET(tp->t_cflag, CLOCAL)) {
946 				/*
947 				 * XXX disconnections would be too hard to
948 				 * get rid of without this kludge.  The only
949 				 * way to get rid of controlling terminals
950 				 * is to exit from the session leader.
951 				 */
952 				CLR(tp->t_state, TS_ZOMBIE);
953 
954 				wakeup(TSA_CARR_ON(tp));
955 				ttwakeup(tp);
956 				ttwwakeup(tp);
957 			}
958 			if ((ISSET(tp->t_state, TS_CARR_ON) ||
959 			     ISSET(t->c_cflag, CLOCAL)) &&
960 			    !ISSET(tp->t_state, TS_ZOMBIE))
961 				SET(tp->t_state, TS_CONNECTED);
962 			else
963 				CLR(tp->t_state, TS_CONNECTED);
964 			tp->t_cflag = t->c_cflag;
965 			tp->t_ispeed = t->c_ispeed;
966 			if (t->c_ospeed != 0)
967 				tp->t_ospeed = t->c_ospeed;
968 			ttsetwater(tp);
969 		}
970 		if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
971 		    cmd != TIOCSETAF) {
972 			if (ISSET(t->c_lflag, ICANON))
973 				SET(tp->t_lflag, PENDIN);
974 			else {
975 				/*
976 				 * XXX we really shouldn't allow toggling
977 				 * ICANON while we're in a non-termios line
978 				 * discipline.  Now we have to worry about
979 				 * panicing for a null queue.
980 				 */
981 				if (tp->t_canq.c_cbreserved > 0 &&
982 				    tp->t_rawq.c_cbreserved > 0) {
983 					catq(&tp->t_rawq, &tp->t_canq);
984 					/*
985 					 * XXX the queue limits may be
986 					 * different, so the old queue
987 					 * swapping method no longer works.
988 					 */
989 					catq(&tp->t_canq, &tp->t_rawq);
990 				}
991 				CLR(tp->t_lflag, PENDIN);
992 			}
993 			ttwakeup(tp);
994 		}
995 		tp->t_iflag = t->c_iflag;
996 		tp->t_oflag = t->c_oflag;
997 		/*
998 		 * Make the EXTPROC bit read only.
999 		 */
1000 		if (ISSET(tp->t_lflag, EXTPROC))
1001 			SET(t->c_lflag, EXTPROC);
1002 		else
1003 			CLR(t->c_lflag, EXTPROC);
1004 		tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1005 		if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1006 		    t->c_cc[VTIME] != tp->t_cc[VTIME])
1007 			ttwakeup(tp);
1008 		bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1009 		crit_exit();
1010 		break;
1011 	}
1012 	case TIOCSETD: {		/* set line discipline */
1013 		int t = *(int *)data;
1014 		cdev_t device = tp->t_dev;
1015 
1016 		if ((u_int)t >= nlinesw)
1017 			return (ENXIO);
1018 		if (t != tp->t_line) {
1019 			crit_enter();
1020 			(*linesw[tp->t_line].l_close)(tp, flag);
1021 			error = (*linesw[t].l_open)(device, tp);
1022 			if (error) {
1023 				(void)(*linesw[tp->t_line].l_open)(device, tp);
1024 				crit_exit();
1025 				return (error);
1026 			}
1027 			tp->t_line = t;
1028 			crit_exit();
1029 		}
1030 		break;
1031 	}
1032 	case TIOCSTART:			/* start output, like ^Q */
1033 		crit_enter();
1034 		if (ISSET(tp->t_state, TS_TTSTOP) ||
1035 		    ISSET(tp->t_lflag, FLUSHO)) {
1036 			CLR(tp->t_lflag, FLUSHO);
1037 			CLR(tp->t_state, TS_TTSTOP);
1038 			ttstart(tp);
1039 		}
1040 		crit_exit();
1041 		break;
1042 	case TIOCSTI:			/* simulate terminal input */
1043 		if ((flag & FREAD) == 0 && suser(td))
1044 			return (EPERM);
1045 		if (!isctty(p, tp) && suser(td))
1046 			return (EACCES);
1047 		crit_enter();
1048 		(*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1049 		crit_exit();
1050 		break;
1051 	case TIOCSTOP:			/* stop output, like ^S */
1052 		crit_enter();
1053 		if (!ISSET(tp->t_state, TS_TTSTOP)) {
1054 			SET(tp->t_state, TS_TTSTOP);
1055 			(*tp->t_stop)(tp, 0);
1056 		}
1057 		crit_exit();
1058 		break;
1059 	case TIOCSCTTY:			/* become controlling tty */
1060 		/* Session ctty vnode pointer set in vnode layer. */
1061 		if (!SESS_LEADER(p) ||
1062 		    ((p->p_session->s_ttyvp || tp->t_session) &&
1063 		    (tp->t_session != p->p_session)))
1064 			return (EPERM);
1065 		tp->t_session = p->p_session;
1066 		tp->t_pgrp = p->p_pgrp;
1067 		p->p_session->s_ttyp = tp;
1068 		p->p_flag |= P_CONTROLT;
1069 		break;
1070 	case TIOCSPGRP: {		/* set pgrp of tty */
1071 		struct pgrp *pgrp = pgfind(*(int *)data);
1072 
1073 		if (!isctty(p, tp))
1074 			return (ENOTTY);
1075 		else if (pgrp == NULL || pgrp->pg_session != p->p_session)
1076 			return (EPERM);
1077 		tp->t_pgrp = pgrp;
1078 		break;
1079 	}
1080 	case TIOCSTAT:			/* simulate control-T */
1081 		crit_enter();
1082 		ttyinfo(tp);
1083 		crit_exit();
1084 		break;
1085 	case TIOCSWINSZ:		/* set window size */
1086 		if (bcmp((caddr_t)&tp->t_winsize, data,
1087 		    sizeof (struct winsize))) {
1088 			tp->t_winsize = *(struct winsize *)data;
1089 			pgsignal(tp->t_pgrp, SIGWINCH, 1);
1090 		}
1091 		break;
1092 	case TIOCSDRAINWAIT:
1093 		error = suser(td);
1094 		if (error)
1095 			return (error);
1096 		tp->t_timeout = *(int *)data * hz;
1097 		wakeup(TSA_OCOMPLETE(tp));
1098 		wakeup(TSA_OLOWAT(tp));
1099 		break;
1100 	case TIOCGDRAINWAIT:
1101 		*(int *)data = tp->t_timeout / hz;
1102 		break;
1103 	default:
1104 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1105 		return (ttcompat(tp, cmd, data, flag));
1106 #else
1107 		return (ENOIOCTL);
1108 #endif
1109 	}
1110 	return (0);
1111 }
1112 
1113 int
1114 ttypoll(struct dev_poll_args *ap)
1115 {
1116 	cdev_t dev = ap->a_head.a_dev;
1117 	int events = ap->a_events;
1118 	int revents = 0;
1119 	struct tty *tp;
1120 
1121 	tp = dev->si_tty;
1122 	/* XXX used to return ENXIO, but that means true! */
1123 	if (tp == NULL) {
1124 		ap->a_events = (events & (POLLIN | POLLOUT | POLLRDNORM |
1125 				POLLWRNORM)) | POLLHUP;
1126 		return(0);
1127 	}
1128 
1129 	crit_enter();
1130 	if (events & (POLLIN | POLLRDNORM)) {
1131 		if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
1132 			revents |= events & (POLLIN | POLLRDNORM);
1133 		else
1134 			selrecord(curthread, &tp->t_rsel);
1135 	}
1136 	if (events & (POLLOUT | POLLWRNORM)) {
1137 		if ((tp->t_outq.c_cc <= tp->t_olowat &&
1138 		     ISSET(tp->t_state, TS_CONNECTED))
1139 		    || ISSET(tp->t_state, TS_ZOMBIE))
1140 			revents |= events & (POLLOUT | POLLWRNORM);
1141 		else
1142 			selrecord(curthread, &tp->t_wsel);
1143 	}
1144 	crit_exit();
1145 	ap->a_events = revents;
1146 	return (0);
1147 }
1148 
1149 static struct filterops ttyread_filtops =
1150 	{ 1, NULL, filt_ttyrdetach, filt_ttyread };
1151 static struct filterops ttywrite_filtops =
1152 	{ 1, NULL, filt_ttywdetach, filt_ttywrite };
1153 
1154 int
1155 ttykqfilter(struct dev_kqfilter_args *ap)
1156 {
1157 	cdev_t dev = ap->a_head.a_dev;
1158 	struct knote *kn = ap->a_kn;
1159 	struct tty *tp = dev->si_tty;
1160 	struct klist *klist;
1161 
1162 	ap->a_result = 0;
1163 	switch (kn->kn_filter) {
1164 	case EVFILT_READ:
1165 		klist = &tp->t_rsel.si_note;
1166 		kn->kn_fop = &ttyread_filtops;
1167 		break;
1168 	case EVFILT_WRITE:
1169 		klist = &tp->t_wsel.si_note;
1170 		kn->kn_fop = &ttywrite_filtops;
1171 		break;
1172 	default:
1173 		ap->a_result = 1;
1174 		return (0);
1175 	}
1176 
1177 	kn->kn_hook = (caddr_t)dev;
1178 
1179 	crit_enter();
1180 	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
1181 	crit_exit();
1182 
1183 	return (0);
1184 }
1185 
1186 static void
1187 filt_ttyrdetach(struct knote *kn)
1188 {
1189 	struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1190 
1191 	crit_enter();
1192 	SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
1193 	crit_exit();
1194 }
1195 
1196 static int
1197 filt_ttyread(struct knote *kn, long hint)
1198 {
1199 	struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1200 
1201 	kn->kn_data = ttnread(tp);
1202 	if (ISSET(tp->t_state, TS_ZOMBIE)) {
1203 		kn->kn_flags |= EV_EOF;
1204 		return (1);
1205 	}
1206 	return (kn->kn_data > 0);
1207 }
1208 
1209 static void
1210 filt_ttywdetach(struct knote *kn)
1211 {
1212 	struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1213 
1214 	crit_enter();
1215 	SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
1216 	crit_exit();
1217 }
1218 
1219 static int
1220 filt_ttywrite(struct knote *kn, long hint)
1221 {
1222 	struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1223 
1224 	kn->kn_data = tp->t_outq.c_cc;
1225 	if (ISSET(tp->t_state, TS_ZOMBIE))
1226 		return (1);
1227 	return (kn->kn_data <= tp->t_olowat &&
1228 	    ISSET(tp->t_state, TS_CONNECTED));
1229 }
1230 
1231 /*
1232  * Must be called while in a critical section.
1233  */
1234 static int
1235 ttnread(struct tty *tp)
1236 {
1237 	int nread;
1238 
1239 	if (ISSET(tp->t_lflag, PENDIN))
1240 		ttypend(tp);
1241 	nread = tp->t_canq.c_cc;
1242 	if (!ISSET(tp->t_lflag, ICANON)) {
1243 		nread += tp->t_rawq.c_cc;
1244 		if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1245 			nread = 0;
1246 	}
1247 	return (nread);
1248 }
1249 
1250 /*
1251  * Wait for output to drain.
1252  */
1253 int
1254 ttywait(struct tty *tp)
1255 {
1256 	int error;
1257 
1258 	error = 0;
1259 	crit_enter();
1260 	while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1261 	       ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1262 		(*tp->t_oproc)(tp);
1263 		if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1264 		    ISSET(tp->t_state, TS_CONNECTED)) {
1265 			SET(tp->t_state, TS_SO_OCOMPLETE);
1266 			error = ttysleep(tp, TSA_OCOMPLETE(tp),
1267 					 PCATCH, "ttywai",
1268 					 tp->t_timeout);
1269 			if (error) {
1270 				if (error == EWOULDBLOCK)
1271 					error = EIO;
1272 				break;
1273 			}
1274 		} else
1275 			break;
1276 	}
1277 	if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1278 		error = EIO;
1279 	crit_exit();
1280 	return (error);
1281 }
1282 
1283 /*
1284  * Flush if successfully wait.
1285  */
1286 static int
1287 ttywflush(struct tty *tp)
1288 {
1289 	int error;
1290 
1291 	if ((error = ttywait(tp)) == 0)
1292 		ttyflush(tp, FREAD);
1293 	return (error);
1294 }
1295 
1296 /*
1297  * Flush tty read and/or write queues, notifying anyone waiting.
1298  */
1299 void
1300 ttyflush(struct tty *tp, int rw)
1301 {
1302 	crit_enter();
1303 #if 0
1304 again:
1305 #endif
1306 	if (rw & FWRITE) {
1307 		FLUSHQ(&tp->t_outq);
1308 		CLR(tp->t_state, TS_TTSTOP);
1309 	}
1310 	(*tp->t_stop)(tp, rw);
1311 	if (rw & FREAD) {
1312 		FLUSHQ(&tp->t_canq);
1313 		FLUSHQ(&tp->t_rawq);
1314 		CLR(tp->t_lflag, PENDIN);
1315 		tp->t_rocount = 0;
1316 		tp->t_rocol = 0;
1317 		CLR(tp->t_state, TS_LOCAL);
1318 		ttwakeup(tp);
1319 		if (ISSET(tp->t_state, TS_TBLOCK)) {
1320 			if (rw & FWRITE)
1321 				FLUSHQ(&tp->t_outq);
1322 			ttyunblock(tp);
1323 
1324 			/*
1325 			 * Don't let leave any state that might clobber the
1326 			 * next line discipline (although we should do more
1327 			 * to send the START char).  Not clearing the state
1328 			 * may have caused the "putc to a clist with no
1329 			 * reserved cblocks" panic/kprintf.
1330 			 */
1331 			CLR(tp->t_state, TS_TBLOCK);
1332 
1333 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1334 			if (ISSET(tp->t_iflag, IXOFF)) {
1335 				/*
1336 				 * XXX wait a bit in the hope that the stop
1337 				 * character (if any) will go out.  Waiting
1338 				 * isn't good since it allows races.  This
1339 				 * will be fixed when the stop character is
1340 				 * put in a special queue.  Don't bother with
1341 				 * the checks in ttywait() since the timeout
1342 				 * will save us.
1343 				 */
1344 				SET(tp->t_state, TS_SO_OCOMPLETE);
1345 				ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1346 					 "ttyfls", hz / 10);
1347 				/*
1348 				 * Don't try sending the stop character again.
1349 				 */
1350 				CLR(tp->t_state, TS_TBLOCK);
1351 				goto again;
1352 			}
1353 #endif
1354 		}
1355 	}
1356 	if (rw & FWRITE) {
1357 		FLUSHQ(&tp->t_outq);
1358 		ttwwakeup(tp);
1359 	}
1360 	crit_exit();
1361 }
1362 
1363 /*
1364  * Copy in the default termios characters.
1365  */
1366 void
1367 termioschars(struct termios *t)
1368 {
1369 
1370 	bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1371 }
1372 
1373 /*
1374  * Old interface.
1375  */
1376 void
1377 ttychars(struct tty *tp)
1378 {
1379 
1380 	termioschars(&tp->t_termios);
1381 }
1382 
1383 /*
1384  * Handle input high water.  Send stop character for the IXOFF case.  Turn
1385  * on our input flow control bit and propagate the changes to the driver.
1386  * XXX the stop character should be put in a special high priority queue.
1387  */
1388 void
1389 ttyblock(struct tty *tp)
1390 {
1391 
1392 	SET(tp->t_state, TS_TBLOCK);
1393 	if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1394 	    clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1395 		CLR(tp->t_state, TS_TBLOCK);	/* try again later */
1396 	ttstart(tp);
1397 }
1398 
1399 /*
1400  * Handle input low water.  Send start character for the IXOFF case.  Turn
1401  * off our input flow control bit and propagate the changes to the driver.
1402  * XXX the start character should be put in a special high priority queue.
1403  */
1404 static void
1405 ttyunblock(struct tty *tp)
1406 {
1407 
1408 	CLR(tp->t_state, TS_TBLOCK);
1409 	if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1410 	    clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1411 		SET(tp->t_state, TS_TBLOCK);	/* try again later */
1412 	ttstart(tp);
1413 }
1414 
1415 #ifdef notyet
1416 /* Not used by any current (i386) drivers. */
1417 /*
1418  * Restart after an inter-char delay.
1419  */
1420 void
1421 ttrstrt(void *tp_arg)
1422 {
1423 	struct tty *tp;
1424 
1425 	KASSERT(tp_arg != NULL, ("ttrstrt"));
1426 
1427 	tp = tp_arg;
1428 	crit_enter();
1429 	CLR(tp->t_state, TS_TIMEOUT);
1430 	ttstart(tp);
1431 	crit_exit();
1432 }
1433 #endif
1434 
1435 int
1436 ttstart(struct tty *tp)
1437 {
1438 
1439 	if (tp->t_oproc != NULL)	/* XXX: Kludge for pty. */
1440 		(*tp->t_oproc)(tp);
1441 	return (0);
1442 }
1443 
1444 /*
1445  * "close" a line discipline
1446  */
1447 int
1448 ttylclose(struct tty *tp, int flag)
1449 {
1450 
1451 	if (flag & FNONBLOCK || ttywflush(tp))
1452 		ttyflush(tp, FREAD | FWRITE);
1453 	return (0);
1454 }
1455 
1456 /*
1457  * Handle modem control transition on a tty.
1458  * Flag indicates new state of carrier.
1459  * Returns 0 if the line should be turned off, otherwise 1.
1460  */
1461 int
1462 ttymodem(struct tty *tp, int flag)
1463 {
1464 
1465 	if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1466 		/*
1467 		 * MDMBUF: do flow control according to carrier flag
1468 		 * XXX TS_CAR_OFLOW doesn't do anything yet.  TS_TTSTOP
1469 		 * works if IXON and IXANY are clear.
1470 		 */
1471 		if (flag) {
1472 			CLR(tp->t_state, TS_CAR_OFLOW);
1473 			CLR(tp->t_state, TS_TTSTOP);
1474 			ttstart(tp);
1475 		} else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1476 			SET(tp->t_state, TS_CAR_OFLOW);
1477 			SET(tp->t_state, TS_TTSTOP);
1478 			(*tp->t_stop)(tp, 0);
1479 		}
1480 	} else if (flag == 0) {
1481 		/*
1482 		 * Lost carrier.
1483 		 */
1484 		CLR(tp->t_state, TS_CARR_ON);
1485 		if (ISSET(tp->t_state, TS_ISOPEN) &&
1486 		    !ISSET(tp->t_cflag, CLOCAL)) {
1487 			SET(tp->t_state, TS_ZOMBIE);
1488 			CLR(tp->t_state, TS_CONNECTED);
1489 			if (tp->t_session && tp->t_session->s_leader)
1490 				ksignal(tp->t_session->s_leader, SIGHUP);
1491 			ttyflush(tp, FREAD | FWRITE);
1492 			return (0);
1493 		}
1494 	} else {
1495 		/*
1496 		 * Carrier now on.
1497 		 */
1498 		SET(tp->t_state, TS_CARR_ON);
1499 		if (!ISSET(tp->t_state, TS_ZOMBIE))
1500 			SET(tp->t_state, TS_CONNECTED);
1501 		wakeup(TSA_CARR_ON(tp));
1502 		ttwakeup(tp);
1503 		ttwwakeup(tp);
1504 	}
1505 	return (1);
1506 }
1507 
1508 /*
1509  * Reinput pending characters after state switch
1510  * call from a critical section.
1511  */
1512 static void
1513 ttypend(struct tty *tp)
1514 {
1515 	struct clist tq;
1516 	int c;
1517 
1518 	CLR(tp->t_lflag, PENDIN);
1519 	SET(tp->t_state, TS_TYPEN);
1520 	/*
1521 	 * XXX this assumes too much about clist internals.  It may even
1522 	 * fail if the cblock slush pool is empty.  We can't allocate more
1523 	 * cblocks here because we are called from an interrupt handler
1524 	 * and clist_alloc_cblocks() can wait.
1525 	 */
1526 	tq = tp->t_rawq;
1527 	bzero(&tp->t_rawq, sizeof tp->t_rawq);
1528 	tp->t_rawq.c_cbmax = tq.c_cbmax;
1529 	tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1530 	while ((c = clist_getc(&tq)) >= 0)
1531 		ttyinput(c, tp);
1532 	CLR(tp->t_state, TS_TYPEN);
1533 }
1534 
1535 /*
1536  * Process a read call on a tty device.
1537  */
1538 int
1539 ttread(struct tty *tp, struct uio *uio, int flag)
1540 {
1541 	struct clist *qp;
1542 	int c;
1543 	tcflag_t lflag;
1544 	cc_t *cc = tp->t_cc;
1545 	struct proc *pp;
1546 	struct lwp *lp;
1547 	int first, error = 0;
1548 	int has_stime = 0, last_cc = 0;
1549 	long slp = 0;		/* XXX this should be renamed `timo'. */
1550 	struct timeval stime;
1551 
1552 	lp = curthread->td_lwp;
1553 
1554 loop:
1555 	crit_enter();
1556 	lflag = tp->t_lflag;
1557 	/*
1558 	 * take pending input first
1559 	 */
1560 	if (ISSET(lflag, PENDIN)) {
1561 		ttypend(tp);
1562 		splz();		/* reduce latency */
1563 		lflag = tp->t_lflag;	/* XXX ttypend() clobbers it */
1564 	}
1565 
1566 	/*
1567 	 * Hang process if it's in the background.
1568 	 */
1569 	if ((pp = curproc) && isbackground(pp, tp)) {
1570 		crit_exit();
1571 		if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1572 		    SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1573 		    (pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0)
1574 			return (EIO);
1575 		pgsignal(pp->p_pgrp, SIGTTIN, 1);
1576 		error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1577 		if (error)
1578 			return (error);
1579 		goto loop;
1580 	}
1581 
1582 	if (ISSET(tp->t_state, TS_ZOMBIE)) {
1583 		crit_exit();
1584 		return (0);	/* EOF */
1585 	}
1586 
1587 	/*
1588 	 * If canonical, use the canonical queue,
1589 	 * else use the raw queue.
1590 	 *
1591 	 * (should get rid of clists...)
1592 	 */
1593 	qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1594 
1595 	if (flag & IO_NDELAY) {
1596 		if (qp->c_cc > 0)
1597 			goto read;
1598 		if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1599 			crit_exit();
1600 			return (0);
1601 		}
1602 		crit_exit();
1603 		return (EWOULDBLOCK);
1604 	}
1605 	if (!ISSET(lflag, ICANON)) {
1606 		int m = cc[VMIN];
1607 		long t = cc[VTIME];
1608 		struct timeval timecopy;
1609 
1610 		/*
1611 		 * Check each of the four combinations.
1612 		 * (m > 0 && t == 0) is the normal read case.
1613 		 * It should be fairly efficient, so we check that and its
1614 		 * companion case (m == 0 && t == 0) first.
1615 		 * For the other two cases, we compute the target sleep time
1616 		 * into slp.
1617 		 */
1618 		if (t == 0) {
1619 			if (qp->c_cc < m)
1620 				goto sleep;
1621 			if (qp->c_cc > 0)
1622 				goto read;
1623 
1624 			/* m, t and qp->c_cc are all 0.  0 is enough input. */
1625 			crit_exit();
1626 			return (0);
1627 		}
1628 		t *= 100000;		/* time in us */
1629 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1630 			 ((t1).tv_usec - (t2).tv_usec))
1631 		if (m > 0) {
1632 			if (qp->c_cc <= 0)
1633 				goto sleep;
1634 			if (qp->c_cc >= m)
1635 				goto read;
1636 			getmicrotime(&timecopy);
1637 			if (!has_stime) {
1638 				/* first character, start timer */
1639 				has_stime = 1;
1640 				stime = timecopy;
1641 				slp = t;
1642 			} else if (qp->c_cc > last_cc) {
1643 				/* got a character, restart timer */
1644 				stime = timecopy;
1645 				slp = t;
1646 			} else {
1647 				/* nothing, check expiration */
1648 				slp = t - diff(timecopy, stime);
1649 				if (slp <= 0)
1650 					goto read;
1651 			}
1652 			last_cc = qp->c_cc;
1653 		} else {	/* m == 0 */
1654 			if (qp->c_cc > 0)
1655 				goto read;
1656 			getmicrotime(&timecopy);
1657 			if (!has_stime) {
1658 				has_stime = 1;
1659 				stime = timecopy;
1660 				slp = t;
1661 			} else {
1662 				slp = t - diff(timecopy, stime);
1663 				if (slp <= 0) {
1664 					/* Timed out, but 0 is enough input. */
1665 					crit_exit();
1666 					return (0);
1667 				}
1668 			}
1669 		}
1670 #undef diff
1671 		/*
1672 		 * Rounding down may make us wake up just short
1673 		 * of the target, so we round up.
1674 		 * The formula is ceiling(slp * hz/1000000).
1675 		 * 32-bit arithmetic is enough for hz < 169.
1676 		 * XXX see tvtohz() for how to avoid overflow if hz
1677 		 * is large (divide by `tick' and/or arrange to
1678 		 * use tvtohz() if hz is large).
1679 		 */
1680 		slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1681 		goto sleep;
1682 	}
1683 	if (qp->c_cc <= 0) {
1684 sleep:
1685 		/*
1686 		 * There is no input, or not enough input and we can block.
1687 		 */
1688 		error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1689 				 ISSET(tp->t_state, TS_CONNECTED) ?
1690 				 "ttyin" : "ttyhup", (int)slp);
1691 		crit_exit();
1692 		if (error == EWOULDBLOCK)
1693 			error = 0;
1694 		else if (error)
1695 			return (error);
1696 		/*
1697 		 * XXX what happens if another process eats some input
1698 		 * while we are asleep (not just here)?  It would be
1699 		 * safest to detect changes and reset our state variables
1700 		 * (has_stime and last_cc).
1701 		 */
1702 		slp = 0;
1703 		goto loop;
1704 	}
1705 read:
1706 	crit_exit();
1707 	/*
1708 	 * Input present, check for input mapping and processing.
1709 	 */
1710 	first = 1;
1711 	if (ISSET(lflag, ICANON | ISIG))
1712 		goto slowcase;
1713 	for (;;) {
1714 		char ibuf[IBUFSIZ];
1715 		int icc;
1716 
1717 		icc = imin(uio->uio_resid, IBUFSIZ);
1718 		icc = q_to_b(qp, ibuf, icc);
1719 		if (icc <= 0) {
1720 			if (first)
1721 				goto loop;
1722 			break;
1723 		}
1724 		error = uiomove(ibuf, icc, uio);
1725 		/*
1726 		 * XXX if there was an error then we should ungetc() the
1727 		 * unmoved chars and reduce icc here.
1728 		 */
1729 		if (error)
1730 			break;
1731  		if (uio->uio_resid == 0)
1732 			break;
1733 		first = 0;
1734 	}
1735 	goto out;
1736 slowcase:
1737 	for (;;) {
1738 		c = clist_getc(qp);
1739 		if (c < 0) {
1740 			if (first)
1741 				goto loop;
1742 			break;
1743 		}
1744 		/*
1745 		 * delayed suspend (^Y)
1746 		 */
1747 		if (CCEQ(cc[VDSUSP], c) &&
1748 		    ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1749 			pgsignal(tp->t_pgrp, SIGTSTP, 1);
1750 			if (first) {
1751 				error = ttysleep(tp, &lbolt, PCATCH,
1752 						 "ttybg3", 0);
1753 				if (error)
1754 					break;
1755 				goto loop;
1756 			}
1757 			break;
1758 		}
1759 		/*
1760 		 * Interpret EOF only in canonical mode.
1761 		 */
1762 		if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1763 			break;
1764 		/*
1765 		 * Give user character.
1766 		 */
1767  		error = ureadc(c, uio);
1768 		if (error)
1769 			/* XXX should ungetc(c, qp). */
1770 			break;
1771  		if (uio->uio_resid == 0)
1772 			break;
1773 		/*
1774 		 * In canonical mode check for a "break character"
1775 		 * marking the end of a "line of input".
1776 		 */
1777 		if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1778 			break;
1779 		first = 0;
1780 	}
1781 
1782 out:
1783 	/*
1784 	 * Look to unblock input now that (presumably)
1785 	 * the input queue has gone down.
1786 	 */
1787 	crit_enter();
1788 	if (ISSET(tp->t_state, TS_TBLOCK) &&
1789 	    tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1790 		ttyunblock(tp);
1791 	crit_exit();
1792 
1793 	return (error);
1794 }
1795 
1796 /*
1797  * Check the output queue on tp for space for a kernel message (from uprintf
1798  * or tprintf).  Allow some space over the normal hiwater mark so we don't
1799  * lose messages due to normal flow control, but don't let the tty run amok.
1800  * Sleeps here are not interruptible, but we return prematurely if new signals
1801  * arrive.
1802  */
1803 int
1804 ttycheckoutq(struct tty *tp, int wait)
1805 {
1806 	int hiwat;
1807 	sigset_t oldmask;
1808 
1809 	hiwat = tp->t_ohiwat;
1810 	SIGEMPTYSET(oldmask);
1811 	crit_enter();
1812 	if (wait)
1813 		oldmask = curproc->p_siglist;
1814 	if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
1815 		while (tp->t_outq.c_cc > hiwat) {
1816 			ttstart(tp);
1817 			if (tp->t_outq.c_cc <= hiwat)
1818 				break;
1819 			if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
1820 				crit_exit();
1821 				return (0);
1822 			}
1823 			SET(tp->t_state, TS_SO_OLOWAT);
1824 			tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
1825 		}
1826 	}
1827 	crit_exit();
1828 	return (1);
1829 }
1830 
1831 /*
1832  * Process a write call on a tty device.
1833  */
1834 int
1835 ttwrite(struct tty *tp, struct uio *uio, int flag)
1836 {
1837 	char *cp = NULL;
1838 	int cc, ce;
1839 	struct proc *pp;
1840 	struct lwp *lp;
1841 	int i, hiwat, cnt, error;
1842 	char obuf[OBUFSIZ];
1843 
1844 	lp = curthread->td_lwp;
1845 	hiwat = tp->t_ohiwat;
1846 	cnt = uio->uio_resid;
1847 	error = 0;
1848 	cc = 0;
1849 loop:
1850 	crit_enter();
1851 	if (ISSET(tp->t_state, TS_ZOMBIE)) {
1852 		crit_exit();
1853 		if (uio->uio_resid == cnt)
1854 			error = EIO;
1855 		goto out;
1856 	}
1857 	if (!ISSET(tp->t_state, TS_CONNECTED)) {
1858 		if (flag & IO_NDELAY) {
1859 			crit_exit();
1860 			error = EWOULDBLOCK;
1861 			goto out;
1862 		}
1863 		error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
1864 		crit_exit();
1865 		if (error)
1866 			goto out;
1867 		goto loop;
1868 	}
1869 	crit_exit();
1870 
1871 	/*
1872 	 * Hang the process if it's in the background.
1873 	 */
1874 	if ((pp = curproc) && isbackground(pp, tp) &&
1875 	    ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flag & P_PPWAIT) &&
1876 	    !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
1877 	    !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
1878 		if (pp->p_pgrp->pg_jobc == 0) {
1879 			error = EIO;
1880 			goto out;
1881 		}
1882 		pgsignal(pp->p_pgrp, SIGTTOU, 1);
1883 		error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
1884 		if (error)
1885 			goto out;
1886 		goto loop;
1887 	}
1888 	/*
1889 	 * Process the user's data in at most OBUFSIZ chunks.  Perform any
1890 	 * output translation.  Keep track of high water mark, sleep on
1891 	 * overflow awaiting device aid in acquiring new space.
1892 	 */
1893 	while (uio->uio_resid > 0 || cc > 0) {
1894 		if (ISSET(tp->t_lflag, FLUSHO)) {
1895 			uio->uio_resid = 0;
1896 			return (0);
1897 		}
1898 		if (tp->t_outq.c_cc > hiwat)
1899 			goto ovhiwat;
1900 		/*
1901 		 * Grab a hunk of data from the user, unless we have some
1902 		 * leftover from last time.
1903 		 */
1904 		if (cc == 0) {
1905 			cc = imin(uio->uio_resid, OBUFSIZ);
1906 			cp = obuf;
1907 			error = uiomove(cp, cc, uio);
1908 			if (error) {
1909 				cc = 0;
1910 				break;
1911 			}
1912 		}
1913 		/*
1914 		 * If nothing fancy need be done, grab those characters we
1915 		 * can handle without any of ttyoutput's processing and
1916 		 * just transfer them to the output q.  For those chars
1917 		 * which require special processing (as indicated by the
1918 		 * bits in char_type), call ttyoutput.  After processing
1919 		 * a hunk of data, look for FLUSHO so ^O's will take effect
1920 		 * immediately.
1921 		 */
1922 		while (cc > 0) {
1923 			if (!ISSET(tp->t_oflag, OPOST))
1924 				ce = cc;
1925 			else {
1926 				ce = cc - scanc((u_int)cc, (u_char *)cp,
1927 						char_type, CCLASSMASK);
1928 				/*
1929 				 * If ce is zero, then we're processing
1930 				 * a special character through ttyoutput.
1931 				 */
1932 				if (ce == 0) {
1933 					tp->t_rocount = 0;
1934 					if (ttyoutput(*cp, tp) >= 0) {
1935 						/* No Clists, wait a bit. */
1936 						ttstart(tp);
1937 						if (flag & IO_NDELAY) {
1938 							error = EWOULDBLOCK;
1939 							goto out;
1940 						}
1941 						error = ttysleep(tp, &lbolt,
1942 								 PCATCH,
1943 								 "ttybf1", 0);
1944 						if (error)
1945 							goto out;
1946 						goto loop;
1947 					}
1948 					cp++;
1949 					cc--;
1950 					if (ISSET(tp->t_lflag, FLUSHO) ||
1951 					    tp->t_outq.c_cc > hiwat)
1952 						goto ovhiwat;
1953 					continue;
1954 				}
1955 			}
1956 			/*
1957 			 * A bunch of normal characters have been found.
1958 			 * Transfer them en masse to the output queue and
1959 			 * continue processing at the top of the loop.
1960 			 * If there are any further characters in this
1961 			 * <= OBUFSIZ chunk, the first should be a character
1962 			 * requiring special handling by ttyoutput.
1963 			 */
1964 			tp->t_rocount = 0;
1965 			i = b_to_q(cp, ce, &tp->t_outq);
1966 			ce -= i;
1967 			tp->t_column += ce;
1968 			cp += ce, cc -= ce, tk_nout += ce;
1969 			tp->t_outcc += ce;
1970 			if (i > 0) {
1971 				/* No Clists, wait a bit. */
1972 				ttstart(tp);
1973 				if (flag & IO_NDELAY) {
1974 					error = EWOULDBLOCK;
1975 					goto out;
1976 				}
1977 				error = ttysleep(tp, &lbolt, PCATCH,
1978 						 "ttybf2", 0);
1979 				if (error)
1980 					goto out;
1981 				goto loop;
1982 			}
1983 			if (ISSET(tp->t_lflag, FLUSHO) ||
1984 			    tp->t_outq.c_cc > hiwat)
1985 				break;
1986 		}
1987 		ttstart(tp);
1988 	}
1989 out:
1990 	/*
1991 	 * If cc is nonzero, we leave the uio structure inconsistent, as the
1992 	 * offset and iov pointers have moved forward, but it doesn't matter
1993 	 * (the call will either return short or restart with a new uio).
1994 	 */
1995 	uio->uio_resid += cc;
1996 	return (error);
1997 
1998 ovhiwat:
1999 	ttstart(tp);
2000 	crit_enter();
2001 	/*
2002 	 * This can only occur if FLUSHO is set in t_lflag,
2003 	 * or if ttstart/oproc is synchronous (or very fast).
2004 	 */
2005 	if (tp->t_outq.c_cc <= hiwat) {
2006 		crit_exit();
2007 		goto loop;
2008 	}
2009 	if (flag & IO_NDELAY) {
2010 		crit_exit();
2011 		uio->uio_resid += cc;
2012 		return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2013 	}
2014 	SET(tp->t_state, TS_SO_OLOWAT);
2015 	error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2016 	crit_exit();
2017 	if (error == EWOULDBLOCK)
2018 		error = EIO;
2019 	if (error)
2020 		goto out;
2021 	goto loop;
2022 }
2023 
2024 /*
2025  * Rubout one character from the rawq of tp
2026  * as cleanly as possible.
2027  */
2028 static void
2029 ttyrub(int c, struct tty *tp)
2030 {
2031 	char *cp;
2032 	int savecol;
2033 	int tabc;
2034 
2035 	if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2036 		return;
2037 	CLR(tp->t_lflag, FLUSHO);
2038 	if (ISSET(tp->t_lflag, ECHOE)) {
2039 		if (tp->t_rocount == 0) {
2040 			/*
2041 			 * Screwed by ttwrite; retype
2042 			 */
2043 			ttyretype(tp);
2044 			return;
2045 		}
2046 		if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2047 			ttyrubo(tp, 2);
2048 		else {
2049 			CLR(c, ~TTY_CHARMASK);
2050 			switch (CCLASS(c)) {
2051 			case ORDINARY:
2052 				ttyrubo(tp, 1);
2053 				break;
2054 			case BACKSPACE:
2055 			case CONTROL:
2056 			case NEWLINE:
2057 			case RETURN:
2058 			case VTAB:
2059 				if (ISSET(tp->t_lflag, ECHOCTL))
2060 					ttyrubo(tp, 2);
2061 				break;
2062 			case TAB:
2063 				if (tp->t_rocount < tp->t_rawq.c_cc) {
2064 					ttyretype(tp);
2065 					return;
2066 				}
2067 				crit_enter();
2068 				savecol = tp->t_column;
2069 				SET(tp->t_state, TS_CNTTB);
2070 				SET(tp->t_lflag, FLUSHO);
2071 				tp->t_column = tp->t_rocol;
2072 				cp = tp->t_rawq.c_cf;
2073 				if (cp)
2074 					tabc = *cp;	/* XXX FIX NEXTC */
2075 				for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2076 					ttyecho(tabc, tp);
2077 				CLR(tp->t_lflag, FLUSHO);
2078 				CLR(tp->t_state, TS_CNTTB);
2079 				crit_exit();
2080 
2081 				/* savecol will now be length of the tab. */
2082 				savecol -= tp->t_column;
2083 				tp->t_column += savecol;
2084 				if (savecol > 8)
2085 					savecol = 8;	/* overflow screw */
2086 				while (--savecol >= 0)
2087 					(void)ttyoutput('\b', tp);
2088 				break;
2089 			default:			/* XXX */
2090 #define	PANICSTR	"ttyrub: would panic c = %d, val = %d\n"
2091 				(void)kprintf(PANICSTR, c, CCLASS(c));
2092 #ifdef notdef
2093 				panic(PANICSTR, c, CCLASS(c));
2094 #endif
2095 			}
2096 		}
2097 	} else if (ISSET(tp->t_lflag, ECHOPRT)) {
2098 		if (!ISSET(tp->t_state, TS_ERASE)) {
2099 			SET(tp->t_state, TS_ERASE);
2100 			(void)ttyoutput('\\', tp);
2101 		}
2102 		ttyecho(c, tp);
2103 	} else {
2104 		ttyecho(tp->t_cc[VERASE], tp);
2105 		/*
2106 		 * This code may be executed not only when an ERASE key
2107 		 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2108 		 * So, I didn't think it was worthwhile to pass the extra
2109 		 * information (which would need an extra parameter,
2110 		 * changing every call) needed to distinguish the ERASE2
2111 		 * case from the ERASE.
2112 		 */
2113 	}
2114 	--tp->t_rocount;
2115 }
2116 
2117 /*
2118  * Back over cnt characters, erasing them.
2119  */
2120 static void
2121 ttyrubo(struct tty *tp, int cnt)
2122 {
2123 
2124 	while (cnt-- > 0) {
2125 		(void)ttyoutput('\b', tp);
2126 		(void)ttyoutput(' ', tp);
2127 		(void)ttyoutput('\b', tp);
2128 	}
2129 }
2130 
2131 /*
2132  * ttyretype --
2133  *	Reprint the rawq line.  Note, it is assumed that c_cc has already
2134  *	been checked.
2135  */
2136 static void
2137 ttyretype(struct tty *tp)
2138 {
2139 	char *cp;
2140 	int c;
2141 
2142 	/* Echo the reprint character. */
2143 	if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2144 		ttyecho(tp->t_cc[VREPRINT], tp);
2145 
2146 	(void)ttyoutput('\n', tp);
2147 
2148 	/*
2149 	 * XXX
2150 	 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2151 	 * BIT OF FIRST CHAR.
2152 	 */
2153 	crit_enter();
2154 	for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2155 	    cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2156 		ttyecho(c, tp);
2157 	for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2158 	    cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2159 		ttyecho(c, tp);
2160 	CLR(tp->t_state, TS_ERASE);
2161 	crit_exit();
2162 
2163 	tp->t_rocount = tp->t_rawq.c_cc;
2164 	tp->t_rocol = 0;
2165 }
2166 
2167 /*
2168  * Echo a typed character to the terminal.
2169  */
2170 static void
2171 ttyecho(int c, struct tty *tp)
2172 {
2173 
2174 	if (!ISSET(tp->t_state, TS_CNTTB))
2175 		CLR(tp->t_lflag, FLUSHO);
2176 	if ((!ISSET(tp->t_lflag, ECHO) &&
2177 	     (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2178 	    ISSET(tp->t_lflag, EXTPROC))
2179 		return;
2180 	if (ISSET(tp->t_lflag, ECHOCTL) &&
2181 	    ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2182 	    ISSET(c, TTY_CHARMASK) == 0177)) {
2183 		(void)ttyoutput('^', tp);
2184 		CLR(c, ~TTY_CHARMASK);
2185 		if (c == 0177)
2186 			c = '?';
2187 		else
2188 			c += 'A' - 1;
2189 	}
2190 	(void)ttyoutput(c, tp);
2191 }
2192 
2193 /*
2194  * Wake up any readers on a tty.
2195  */
2196 void
2197 ttwakeup(struct tty *tp)
2198 {
2199 
2200 	if (tp->t_rsel.si_pid != 0)
2201 		selwakeup(&tp->t_rsel);
2202 	if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2203 		pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2204 	wakeup(TSA_HUP_OR_INPUT(tp));
2205 	KNOTE(&tp->t_rsel.si_note, 0);
2206 }
2207 
2208 /*
2209  * Wake up any writers on a tty.
2210  */
2211 void
2212 ttwwakeup(struct tty *tp)
2213 {
2214 
2215 	if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat)
2216 		selwakeup(&tp->t_wsel);
2217 	if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2218 		pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2219 	if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2220 	    TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2221 		CLR(tp->t_state, TS_SO_OCOMPLETE);
2222 		wakeup(TSA_OCOMPLETE(tp));
2223 	}
2224 	if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2225 	    tp->t_outq.c_cc <= tp->t_olowat) {
2226 		CLR(tp->t_state, TS_SO_OLOWAT);
2227 		wakeup(TSA_OLOWAT(tp));
2228 	}
2229 	KNOTE(&tp->t_wsel.si_note, 0);
2230 }
2231 
2232 /*
2233  * Look up a code for a specified speed in a conversion table;
2234  * used by drivers to map software speed values to hardware parameters.
2235  */
2236 int
2237 ttspeedtab(int speed, struct speedtab *table)
2238 {
2239 
2240 	for ( ; table->sp_speed != -1; table++)
2241 		if (table->sp_speed == speed)
2242 			return (table->sp_code);
2243 	return (-1);
2244 }
2245 
2246 /*
2247  * Set input and output watermarks and buffer sizes.  For input, the
2248  * high watermark is about one second's worth of input above empty, the
2249  * low watermark is slightly below high water, and the buffer size is a
2250  * driver-dependent amount above high water.  For output, the watermarks
2251  * are near the ends of the buffer, with about 1 second's worth of input
2252  * between them.  All this only applies to the standard line discipline.
2253  */
2254 void
2255 ttsetwater(struct tty *tp)
2256 {
2257 	int cps, ttmaxhiwat, x;
2258 
2259 	/* Input. */
2260 	clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2261 	switch (tp->t_ispeedwat) {
2262 	case (speed_t)-1:
2263 		cps = tp->t_ispeed / 10;
2264 		break;
2265 	case 0:
2266 		/*
2267 		 * This case is for old drivers that don't know about
2268 		 * t_ispeedwat.  Arrange for them to get the old buffer
2269 		 * sizes and watermarks.
2270 		 */
2271 		cps = TTYHOG - 2 * 256;
2272 		tp->t_ififosize = 2 * 256;
2273 		break;
2274 	default:
2275 		cps = tp->t_ispeedwat / 10;
2276 		break;
2277 	}
2278 	tp->t_ihiwat = cps;
2279 	tp->t_ilowat = 7 * cps / 8;
2280 	x = cps + tp->t_ififosize;
2281 	clist_alloc_cblocks(&tp->t_rawq, x, x);
2282 
2283 	/* Output. */
2284 	switch (tp->t_ospeedwat) {
2285 	case (speed_t)-1:
2286 		cps = tp->t_ospeed / 10;
2287 		ttmaxhiwat = 2 * TTMAXHIWAT;
2288 		break;
2289 	case 0:
2290 		cps = tp->t_ospeed / 10;
2291 		ttmaxhiwat = TTMAXHIWAT;
2292 		break;
2293 	default:
2294 		cps = tp->t_ospeedwat / 10;
2295 		ttmaxhiwat = 8 * TTMAXHIWAT;
2296 		break;
2297 	}
2298 #define CLAMP(x, h, l)	((x) > h ? h : ((x) < l) ? l : (x))
2299 	tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2300 	x += cps;
2301 	x = CLAMP(x, ttmaxhiwat, TTMINHIWAT);	/* XXX clamps are too magic */
2302 	tp->t_ohiwat = roundup(x, CBSIZE);	/* XXX for compat */
2303 	x = imax(tp->t_ohiwat, TTMAXHIWAT);	/* XXX for compat/safety */
2304 	x += OBUFSIZ + 100;
2305 	clist_alloc_cblocks(&tp->t_outq, x, x);
2306 #undef	CLAMP
2307 }
2308 
2309 /*
2310  * Report on state of foreground process group.
2311  */
2312 void
2313 ttyinfo(struct tty *tp)
2314 {
2315 	struct proc *p, *pick;
2316 	struct lwp *lp;
2317 	struct rusage ru;
2318 	int tmp;
2319 
2320 	if (ttycheckoutq(tp,0) == 0)
2321 		return;
2322 
2323 	/*
2324 	 * We always print the load average, then figure out what else to
2325 	 * print based on the state of the current process group.
2326 	 */
2327 	tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2328 	ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2329 
2330 	if (tp->t_session == NULL) {
2331 		ttyprintf(tp, "not a controlling terminal\n");
2332 	} else if (tp->t_pgrp == NULL) {
2333 		ttyprintf(tp, "no foreground process group\n");
2334 	} else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
2335 		ttyprintf(tp, "empty foreground process group\n");
2336 	} else {
2337 		/*
2338 		 * Pick an interesting process.  Note that certain elements,
2339 		 * in particular the wmesg, require a critical section for
2340 		 * safe access (YYY and we are still not MP safe).
2341 		 *
2342 		 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2343 		 */
2344 		char buf[64];
2345 		const char *str;
2346 		int isinmem;
2347 		long vmsz;
2348 		int pctcpu;
2349 
2350 		crit_enter();
2351 
2352 		/* XXX lwp should compare lwps */
2353 
2354 		for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist)) {
2355 			if (proc_compare(pick, p))
2356 				pick = p;
2357 		}
2358 
2359 		/* XXX lwp */
2360 		lp = FIRST_LWP_IN_PROC(pick);
2361 		if (lp == NULL) {
2362 			ttyprintf(tp, "foreground process without lwp\n");
2363 			tp->t_rocount = 0;
2364 			return;
2365 		}
2366 
2367 		/*
2368 		 * Figure out what wait/process-state message, and command
2369 		 * buffer to present
2370 		 */
2371 		/*
2372 		 * XXX lwp This is a horrible mixture.  We need to rework this
2373 		 * as soon as lwps have their own runnable status.
2374 		 */
2375 		if (pick->p_flag & P_WEXIT)
2376 			str = "exiting";
2377 		else if (lp->lwp_stat == LSRUN)
2378 			str = "running";
2379 		else if (pick->p_stat == SIDL)
2380 			str = "spawning";
2381 		else if (lp->lwp_wmesg)	/* lwp_thread must not be NULL */
2382 			str = lp->lwp_wmesg;
2383 		else
2384 			str = "iowait";
2385 
2386 		ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2387 			pick->p_comm, pick->p_pid, str);
2388 
2389 		/*
2390 		 * Calculate cpu usage, percent cpu, and cmsz.  Note that
2391 		 * 'pick' becomes invalid the moment we exit the critical
2392 		 * section.
2393 		 */
2394 		if (lp->lwp_thread && (pick->p_flag & P_SWAPPEDOUT) == 0) {
2395 			calcru_proc(pick, &ru);
2396 			isinmem = 1;
2397 		} else {
2398 			isinmem = 0;
2399 		}
2400 
2401 		pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2402 
2403 		if (pick->p_stat == SIDL || pick->p_stat == SZOMB)
2404 		    vmsz = 0;
2405 		else
2406 		    vmsz = pgtok(vmspace_resident_count(pick->p_vmspace));
2407 
2408 		crit_exit();
2409 
2410 		/*
2411 		 * Dump the output
2412 		 */
2413 		ttyprintf(tp, " %s ", buf);
2414 		ttyprintf(tp, "%ld.%02ldu ",
2415 			ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2416 		ttyprintf(tp, "%ld.%02lds ",
2417 			ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2418 		ttyprintf(tp, "%d%% %ldk\n", pctcpu / 100, vmsz);
2419 	}
2420 	tp->t_rocount = 0;	/* so pending input will be retyped if BS */
2421 }
2422 
2423 /*
2424  * Returns 1 if p2 is "better" than p1
2425  *
2426  * The algorithm for picking the "interesting" process is thus:
2427  *
2428  *	1) Only foreground processes are eligible - implied.
2429  *	2) Runnable processes are favored over anything else.  The runner
2430  *	   with the highest cpu utilization is picked (p_cpticks).  Ties are
2431  *	   broken by picking the highest pid.
2432  *	3) The sleeper with the shortest sleep time is next.  With ties,
2433  *	   we pick out just "short-term" sleepers (LWP_SINTR == 0).
2434  *	4) Further ties are broken by picking the highest pid.
2435  */
2436 #define ISRUN(lp)	((lp)->lwp_stat == LSRUN)
2437 #define TESTAB(a, b)    ((a)<<1 | (b))
2438 #define ONLYA   2
2439 #define ONLYB   1
2440 #define BOTH    3
2441 
2442 static int
2443 proc_compare(struct proc *p1, struct proc *p2)
2444 {
2445 	struct lwp *lp1, *lp2;
2446 	if (p1 == NULL)
2447 		return (1);
2448 
2449 	/* XXX lwp */
2450 	lp1 = FIRST_LWP_IN_PROC(p1);
2451 	lp2 = FIRST_LWP_IN_PROC(p2);
2452 
2453 	/*
2454 	 * see if at least one of them is runnable
2455 	 */
2456 	switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2457 	case ONLYA:
2458 		return (0);
2459 	case ONLYB:
2460 		return (1);
2461 	case BOTH:
2462 		/*
2463 		 * tie - favor one with highest recent cpu utilization
2464 		 */
2465 		if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2466 			return (1);
2467 		if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2468 			return (0);
2469 		return (p2->p_pid > p1->p_pid);	/* tie - return highest pid */
2470 	}
2471 	/*
2472  	 * weed out zombies
2473 	 */
2474 	switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2475 	case ONLYA:
2476 		return (1);
2477 	case ONLYB:
2478 		return (0);
2479 	case BOTH:
2480 		return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2481 	}
2482 	/*
2483 	 * pick the one with the smallest sleep time
2484 	 */
2485 	if (lp2->lwp_slptime > lp1->lwp_slptime)
2486 		return (0);
2487 	if (lp1->lwp_slptime > lp2->lwp_slptime)
2488 		return (1);
2489 	/*
2490 	 * favor one sleeping in a non-interruptible sleep
2491 	 */
2492 	if (lp1->lwp_flag & LWP_SINTR && (lp2->lwp_flag & LWP_SINTR) == 0)
2493 		return (1);
2494 	if (lp2->lwp_flag & LWP_SINTR && (lp1->lwp_flag & LWP_SINTR) == 0)
2495 		return (0);
2496 	return (p2->p_pid > p1->p_pid);		/* tie - return highest pid */
2497 }
2498 
2499 /*
2500  * Output char to tty; console putchar style.
2501  */
2502 int
2503 tputchar(int c, struct tty *tp)
2504 {
2505 	crit_enter();
2506 	if (!ISSET(tp->t_state, TS_CONNECTED)) {
2507 		crit_exit();
2508 		return (-1);
2509 	}
2510 	if (c == '\n')
2511 		(void)ttyoutput('\r', tp);
2512 	(void)ttyoutput(c, tp);
2513 	ttstart(tp);
2514 	crit_exit();
2515 	return (0);
2516 }
2517 
2518 /*
2519  * Sleep on chan, returning ERESTART if tty changed while we napped and
2520  * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep.  If
2521  * the tty is revoked, restarting a pending call will redo validation done
2522  * at the start of the call.
2523  */
2524 int
2525 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2526 {
2527 	int error;
2528 	int gen;
2529 
2530 	gen = tp->t_gen;
2531 	error = tsleep(chan, slpflags, wmesg, timo);
2532 	if (error)
2533 		return (error);
2534 	return (tp->t_gen == gen ? 0 : ERESTART);
2535 }
2536 
2537 /*
2538  * Allocate a tty struct.  Clists in the struct will be allocated by
2539  * ttyopen().
2540  */
2541 struct tty *
2542 ttymalloc(struct tty *tp)
2543 {
2544 
2545 	if (tp)
2546 		return(tp);
2547         tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2548 	ttyregister(tp);
2549         return (tp);
2550 }
2551 
2552 #if 0
2553 /*
2554  * Free a tty struct.  Clists in the struct should have been freed by
2555  * ttyclose().
2556  *
2557  * XXX not yet usable: since we support a half-closed state and do not
2558  * ref count the tty reference from the session, it is possible for a
2559  * session to hold a ref on the tty.  See TTY_DO_FULL_CLOSE.
2560  */
2561 void
2562 ttyfree(struct tty *tp)
2563 {
2564         kfree(tp, M_TTYS);
2565 }
2566 #endif /* 0 */
2567 
2568 void
2569 ttyregister(struct tty *tp)
2570 {
2571 	SLIST_INSERT_HEAD(&tty_list, tp, t_list);
2572 }
2573 
2574 static int
2575 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2576 {
2577 	int error;
2578 	struct tty *tp, t;
2579 	SLIST_FOREACH(tp, &tty_list, t_list) {
2580 		t = *tp;
2581 		if (t.t_dev)
2582 			t.t_dev = (cdev_t)dev2udev(t.t_dev);
2583 		error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2584 		if (error)
2585 			return (error);
2586 	}
2587 	return (0);
2588 }
2589 
2590 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2591 	0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2592 
2593 void
2594 nottystop(struct tty *tp, int rw)
2595 {
2596 
2597 	return;
2598 }
2599 
2600 int
2601 ttyread(struct dev_read_args *ap)
2602 {
2603 	struct tty *tp;
2604 
2605 	tp = ap->a_head.a_dev->si_tty;
2606 	if (tp == NULL)
2607 		return (ENODEV);
2608 	return ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2609 }
2610 
2611 int
2612 ttywrite(struct dev_write_args *ap)
2613 {
2614 	struct tty *tp;
2615 
2616 	tp = ap->a_head.a_dev->si_tty;
2617 	if (tp == NULL)
2618 		return (ENODEV);
2619 	return ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2620 }
2621