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