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.
10 * Copyright (c) 2002 Networks Associates Technologies, Inc.
11 * All rights reserved.
13 * Portions of this software were developed for the FreeBSD Project by
14 * ThinkSec AS and NAI Labs, the Security Research Division of Network
15 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
16 * ("CBOSS"), as part of the DARPA CHATS research program.
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 4. Neither the name of the University nor the names of its contributors
27 * may be used to endorse or promote products derived from this software
28 * without specific prior written permission.
30 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42 * @(#)tty.c 8.8 (Berkeley) 1/21/94
47 * o Fix races for sending the start char in ttyflush().
48 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
49 * With luck, there will be MIN chars before select() returns().
50 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
51 * o Don't allow input in TS_ZOMBIE case. It would be visible through
53 * o Do the new sio locking stuff here and use it to avoid special
56 * o Move EXTPROC and/or PENDIN to t_state?
57 * o Wrap most of ttioctl in spltty/splx.
58 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
59 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
60 * o Don't allow certain termios flags to affect disciplines other
61 * than TTYDISC. Cancel their effects before switch disciplines
62 * and ignore them if they are set while we are in another
64 * o Now that historical speed conversions are handled here, don't
66 * o Check for TS_CARR_ON being set while everything is closed and not
67 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
68 * so it would live until the next open even if carrier drops.
69 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
70 * only when _all_ openers leave open().
73 #include <sys/cdefs.h>
74 __FBSDID("$FreeBSD$");
76 #include "opt_compat.h"
79 #include <sys/param.h>
80 #include <sys/systm.h>
82 #include <sys/filio.h>
84 #include <sys/mutex.h>
85 #include <sys/namei.h>
87 #if defined(COMPAT_43TTY)
88 #include <sys/ioctl_compat.h>
95 #include <sys/fcntl.h>
98 #include <sys/kernel.h>
99 #include <sys/vnode.h>
100 #include <sys/serial.h>
101 #include <sys/signalvar.h>
102 #include <sys/resourcevar.h>
103 #include <sys/malloc.h>
104 #include <sys/filedesc.h>
105 #include <sys/sched.h>
106 #include <sys/sysctl.h>
107 #include <sys/timepps.h>
109 #include <machine/stdarg.h>
113 #include <vm/vm_map.h>
115 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
122 static d_open_t ttysopen;
123 static d_close_t ttysclose;
124 static d_read_t ttysrdwr;
125 static d_ioctl_t ttysioctl;
126 static d_purge_t ttypurge;
128 /* Default cdevsw for common tty devices */
129 static struct cdevsw tty_cdevsw = {
130 .d_version = D_VERSION,
136 .d_flags = D_TTY | D_NEEDGIANT,
139 /* Cdevsw for slave tty devices */
140 static struct cdevsw ttys_cdevsw = {
141 .d_version = D_VERSION,
143 .d_close = ttysclose,
146 .d_ioctl = ttysioctl,
148 .d_flags = D_TTY | D_NEEDGIANT,
151 static int proc_sum(struct proc *, int *);
152 static int proc_compare(struct proc *, struct proc *);
153 static int thread_compare(struct thread *, struct thread *);
154 static int ttnread(struct tty *tp);
155 static void ttyecho(int c, struct tty *tp);
156 static int ttyoutput(int c, struct tty *tp);
157 static void ttypend(struct tty *tp);
158 static void ttyretype(struct tty *tp);
159 static void ttyrub(int c, struct tty *tp);
160 static void ttyrubo(struct tty *tp, int cnt);
161 static void ttyunblock(struct tty *tp);
162 static int ttywflush(struct tty *tp);
163 static int filt_ttyread(struct knote *kn, long hint);
164 static void filt_ttyrdetach(struct knote *kn);
165 static int filt_ttywrite(struct knote *kn, long hint);
166 static void filt_ttywdetach(struct knote *kn);
169 * Table with character classes and parity. The 8th bit indicates parity,
170 * the 7th bit indicates the character is an alphameric or underscore (for
171 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
172 * are 0 then the character needs no special processing on output; classes
173 * other than 0 might be translated or (not currently) require delays.
175 #define E 0x00 /* Even parity. */
176 #define O 0x80 /* Odd parity. */
177 #define PARITY(c) (char_type[c] & O)
179 #define ALPHA 0x40 /* Alpha or underscore. */
180 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
182 #define CCLASSMASK 0x3f
183 #define CCLASS(c) (char_type[c] & CCLASSMASK)
188 #define NA ORDINARY | ALPHA
194 static u_char const char_type[] = {
195 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
196 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
197 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
198 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
199 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
200 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
201 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
202 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
203 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
204 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
205 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
206 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
207 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
208 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
209 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
210 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
212 * Meta chars; should be settable per character set;
213 * for now, treat them all as normal characters.
215 NA, NA, NA, NA, NA, NA, NA, NA,
216 NA, NA, NA, NA, NA, NA, NA, NA,
217 NA, NA, NA, NA, NA, NA, NA, NA,
218 NA, NA, NA, NA, NA, NA, NA, NA,
219 NA, NA, NA, NA, NA, NA, NA, NA,
220 NA, NA, NA, NA, NA, NA, NA, NA,
221 NA, NA, NA, NA, NA, NA, NA, NA,
222 NA, NA, NA, NA, NA, NA, NA, NA,
223 NA, NA, NA, NA, NA, NA, NA, NA,
224 NA, NA, NA, NA, NA, NA, NA, NA,
225 NA, NA, NA, NA, NA, NA, NA, NA,
226 NA, NA, NA, NA, NA, NA, NA, NA,
227 NA, NA, NA, NA, NA, NA, NA, NA,
228 NA, NA, NA, NA, NA, NA, NA, NA,
229 NA, NA, NA, NA, NA, NA, NA, NA,
230 NA, NA, NA, NA, NA, NA, NA, NA,
241 /* Macros to clear/set/test flags. */
242 #define SET(t, f) (t) |= (f)
243 #define CLR(t, f) (t) &= ~(f)
244 #define ISSET(t, f) ((t) & (f))
246 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
247 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
250 * list of struct tty where pstat(8) can pick it up with sysctl
252 * The lock order is to grab the list mutex before the tty mutex.
253 * Together with additions going on the tail of the list, this allows
254 * the sysctl to avoid doing retries.
256 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
257 static struct mtx tty_list_mutex;
258 MTX_SYSINIT(tty_list, &tty_list_mutex, "ttylist", MTX_DEF);
260 static struct unrhdr *tty_unit;
262 static int drainwait = 5*60;
263 SYSCTL_INT(_kern, OID_AUTO, drainwait, CTLFLAG_RW, &drainwait,
264 0, "Output drain timeout in seconds");
267 tty_gettp(struct cdev *dev)
272 csw = dev_refthread(dev);
275 KASSERT(csw->d_flags & D_TTY,
276 ("non D_TTY (%s) in tty code", devtoname(dev)));
280 ("no tty pointer on (%s) in tty code", devtoname(dev)));
285 * Initial open of tty, or (re)entry to standard tty line discipline.
288 tty_open(struct cdev *device, struct tty *tp)
295 if (!ISSET(tp->t_state, TS_ISOPEN)) {
297 SET(tp->t_state, TS_ISOPEN);
298 if (ISSET(tp->t_cflag, CLOCAL))
299 SET(tp->t_state, TS_CONNECTED);
300 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
302 /* XXX don't hang forever on output */
303 if (tp->t_timeout < 0)
304 tp->t_timeout = drainwait*hz;
311 * Handle close() on a tty line: flush and set to initial state,
312 * bumping generation number so that pending read/write calls
313 * can detect recycling of the tty.
314 * XXX our caller should have done `spltty(); l_close(); tty_close();'
315 * and l_close() should have flushed, but we repeat the spltty() and
316 * the flush in case there are buggy callers.
319 tty_close(struct tty *tp)
323 funsetown(&tp->t_sigio);
328 ttyflush(tp, FREAD | FWRITE);
329 clist_free_cblocks(&tp->t_canq);
330 clist_free_cblocks(&tp->t_outq);
331 clist_free_cblocks(&tp->t_rawq);
334 tp->t_line = TTYDISC;
337 tp->t_session = NULL;
338 ostate = tp->t_state;
340 knlist_clear(&tp->t_rsel.si_note, 0);
341 knlist_clear(&tp->t_wsel.si_note, 0);
343 * Both final close and revocation close might end up calling
344 * this method. Only the thread clearing TS_ISOPEN should
345 * release the reference to the tty.
347 if (ISSET(ostate, TS_ISOPEN))
353 #define FLUSHQ(q) { \
355 ndflush(q, (q)->c_cc); \
358 /* Is 'c' a line delimiter ("break" character)? */
359 #define TTBREAKC(c, lflag) \
360 ((c) == '\n' || (((c) == cc[VEOF] || \
361 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
362 (c) != _POSIX_VDISABLE))
365 * Process input of a single character received on a tty.
368 ttyinput(int c, struct tty *tp)
370 tcflag_t iflag, lflag;
375 * If input is pending take it first.
378 if (ISSET(lflag, PENDIN))
383 if (ISSET(lflag, ICANON)) {
393 * Block further input iff:
394 * current input > threshold AND input is available to user program
395 * AND input flow control is enabled and not yet invoked.
396 * The 3 is slop for PARMRK.
399 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
400 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
401 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
402 !ISSET(tp->t_state, TS_TBLOCK))
405 /* Handle exceptional conditions (break, parity, framing). */
407 err = (ISSET(c, TTY_ERRORMASK));
409 CLR(c, TTY_ERRORMASK);
410 if (ISSET(err, TTY_BI)) {
411 if (ISSET(iflag, IGNBRK))
413 if (ISSET(iflag, BRKINT)) {
414 ttyflush(tp, FREAD | FWRITE);
415 if (tp->t_pgrp != NULL) {
416 PGRP_LOCK(tp->t_pgrp);
417 pgsignal(tp->t_pgrp, SIGINT, 1);
418 PGRP_UNLOCK(tp->t_pgrp);
422 if (ISSET(iflag, PARMRK))
424 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
425 || ISSET(err, TTY_FE)) {
426 if (ISSET(iflag, IGNPAR))
428 else if (ISSET(iflag, PARMRK)) {
430 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
433 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
434 (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
435 (void)putc(c | TTY_QUOTE, &tp->t_rawq);
442 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
444 if (!ISSET(lflag, EXTPROC)) {
446 * Check for literal nexting very first
448 if (ISSET(tp->t_state, TS_LNCH)) {
450 CLR(tp->t_state, TS_LNCH);
453 * Scan for special characters. This code
454 * is really just a big case statement with
455 * non-constant cases. The bottom of the
456 * case statement is labeled ``endcase'', so goto
457 * it after a case match, or similar.
461 * Control chars which aren't controlled
462 * by ICANON, ISIG, or IXON.
464 if (ISSET(lflag, IEXTEN)) {
465 if (CCEQ(cc[VLNEXT], c)) {
466 if (ISSET(lflag, ECHO)) {
467 if (ISSET(lflag, ECHOE)) {
468 (void)ttyoutput('^', tp);
469 (void)ttyoutput('\b', tp);
473 SET(tp->t_state, TS_LNCH);
476 if (CCEQ(cc[VDISCARD], c)) {
477 if (ISSET(lflag, FLUSHO))
478 CLR(tp->t_lflag, FLUSHO);
480 ttyflush(tp, FWRITE);
482 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
484 SET(tp->t_lflag, FLUSHO);
492 if (ISSET(lflag, ISIG)) {
493 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
494 if (!ISSET(lflag, NOFLSH))
495 ttyflush(tp, FREAD | FWRITE);
497 if (tp->t_pgrp != NULL) {
498 PGRP_LOCK(tp->t_pgrp);
500 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
501 PGRP_UNLOCK(tp->t_pgrp);
505 if (CCEQ(cc[VSUSP], c)) {
506 if (!ISSET(lflag, NOFLSH))
509 if (tp->t_pgrp != NULL) {
510 PGRP_LOCK(tp->t_pgrp);
511 pgsignal(tp->t_pgrp, SIGTSTP, 1);
512 PGRP_UNLOCK(tp->t_pgrp);
518 * Handle start/stop characters.
520 if (ISSET(iflag, IXON)) {
521 if (CCEQ(cc[VSTOP], c)) {
522 if (!ISSET(tp->t_state, TS_TTSTOP)) {
523 SET(tp->t_state, TS_TTSTOP);
527 if (!CCEQ(cc[VSTART], c))
530 * if VSTART == VSTOP then toggle
534 if (CCEQ(cc[VSTART], c))
538 * IGNCR, ICRNL, & INLCR
541 if (ISSET(iflag, IGNCR))
543 else if (ISSET(iflag, ICRNL))
545 } else if (c == '\n' && ISSET(iflag, INLCR))
548 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
550 * From here on down canonical mode character
551 * processing takes place.
554 * erase or erase2 (^H / ^?)
556 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
558 ttyrub(unputc(&tp->t_rawq), tp);
564 if (CCEQ(cc[VKILL], c)) {
565 if (ISSET(lflag, ECHOKE) &&
566 tp->t_rawq.c_cc == tp->t_rocount &&
567 !ISSET(lflag, ECHOPRT))
568 while (tp->t_rawq.c_cc)
569 ttyrub(unputc(&tp->t_rawq), tp);
572 if (ISSET(lflag, ECHOK) ||
573 ISSET(lflag, ECHOKE))
578 CLR(tp->t_state, TS_LOCAL);
584 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
590 while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
595 * erase last char of word and remember the
596 * next chars type (for ALTWERASE)
599 c = unputc(&tp->t_rawq);
602 if (c == ' ' || c == '\t') {
603 (void)putc(c, &tp->t_rawq);
612 c = unputc(&tp->t_rawq);
615 } while (c != ' ' && c != '\t' &&
616 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
617 (void)putc(c, &tp->t_rawq);
623 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
628 * ^T - kernel info and generate SIGINFO
630 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
631 if (ISSET(lflag, ISIG) && tp->t_pgrp != NULL) {
632 PGRP_LOCK(tp->t_pgrp);
633 pgsignal(tp->t_pgrp, SIGINFO, 1);
634 PGRP_UNLOCK(tp->t_pgrp);
636 if (!ISSET(lflag, NOKERNINFO))
642 * Check for input buffer overflow
644 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
646 if (ISSET(iflag, IMAXBEL)) {
647 if (tp->t_outq.c_cc < tp->t_ohiwat)
648 (void)ttyoutput(CTRL('g'), tp);
653 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
654 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
655 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
658 * Put data char in q for user and
659 * wakeup on seeing a line delimiter.
661 if (putc(c, &tp->t_rawq) >= 0) {
662 if (!ISSET(lflag, ICANON)) {
667 if (TTBREAKC(c, lflag)) {
669 catq(&tp->t_rawq, &tp->t_canq);
671 } else if (tp->t_rocount++ == 0)
672 tp->t_rocol = tp->t_column;
673 if (ISSET(tp->t_state, TS_ERASE)) {
675 * end of prterase \.../
677 CLR(tp->t_state, TS_ERASE);
678 (void)ttyoutput('/', tp);
682 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
684 * Place the cursor over the '^' of the ^D.
686 i = imin(2, tp->t_column - i);
688 (void)ttyoutput('\b', tp);
695 * IXANY means allow any character to restart output.
697 if (ISSET(tp->t_state, TS_TTSTOP) &&
698 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
701 CLR(tp->t_lflag, FLUSHO);
702 CLR(tp->t_state, TS_TTSTOP);
704 return (ttstart(tp));
708 * Output a single character on a tty, doing output processing
709 * as needed (expanding tabs, newline processing, etc.).
710 * Returns < 0 if succeeds, otherwise returns char to resend.
714 ttyoutput(int c, struct tty *tp)
720 if (!ISSET(oflag, OPOST)) {
721 if (ISSET(tp->t_lflag, FLUSHO))
723 if (putc(c, &tp->t_outq))
730 * Do tab expansion if OXTABS is set. Special case if we external
731 * processing, we don't do the tab expansion because we'll probably
732 * get it wrong. If tab expansion needs to be done, let it happen
735 CLR(c, ~TTY_CHARMASK);
737 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
738 c = 8 - (tp->t_column & 7);
739 if (!ISSET(tp->t_lflag, FLUSHO)) {
740 s = spltty(); /* Don't interrupt tabs. */
741 c -= b_to_q(" ", c, &tp->t_outq);
747 return (c ? -1 : '\t');
749 if (c == CEOT && ISSET(oflag, ONOEOT))
753 * Newline translation: if ONLCR is set,
754 * translate newline into "\r\n".
756 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
759 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
762 /* If OCRNL is set, translate "\r" into "\n". */
763 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
765 /* If ONOCR is set, don't transmit CRs when on column 0. */
766 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
771 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
783 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
793 col = (col + 8) & ~7;
801 * Ioctls for all tty devices. Called after line-discipline specific ioctl
802 * has been called to do discipline-specific functions and/or reject any
803 * of these ioctl commands.
807 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
812 int s, error, bits, sig, sig2;
814 td = curthread; /* XXX */
817 /* If the ioctl involves modification, hang if in the background. */
841 #if defined(COMPAT_43TTY)
851 sx_slock(&proctree_lock);
853 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
854 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
855 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
858 if (pgrp->pg_jobc == 0) {
859 sx_sunlock(&proctree_lock);
863 sx_sunlock(&proctree_lock);
864 pgsignal(pgrp, SIGTTOU, 1);
866 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
870 sx_slock(&proctree_lock);
874 sx_sunlock(&proctree_lock);
879 if (tp->t_modem != NULL) {
882 tt_modem(tp, SER_DTR, 0);
885 tt_modem(tp, 0, SER_DTR);
889 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
890 sig2 = ((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1;
891 tt_modem(tp, sig, sig2);
895 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
896 tt_modem(tp, sig, 0);
900 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
901 tt_modem(tp, 0, sig);
904 sig = tt_modem(tp, 0, 0);
905 /* See <sys/serial.h. for the "<< 1" stuff */
906 bits = TIOCM_LE + (sig << 1);
914 if (tp->t_pps != NULL) {
915 error = pps_ioctl(cmd, data, tp->t_pps);
916 if (error != ENOIOCTL)
920 switch (cmd) { /* Process the ioctl. */
921 case FIOASYNC: /* set/clear async i/o */
924 SET(tp->t_state, TS_ASYNC);
926 CLR(tp->t_state, TS_ASYNC);
929 case FIONBIO: /* set/clear non-blocking i/o */
930 break; /* XXX: delete. */
931 case FIONREAD: /* get # bytes to read */
933 *(int *)data = ttnread(tp);
939 * Policy -- Don't allow FIOSETOWN on someone else's
942 if (tp->t_session != NULL && !isctty(p, tp))
945 error = fsetown(*(int *)data, &tp->t_sigio);
950 if (tp->t_session != NULL && !isctty(p, tp))
952 *(int *)data = fgetown(&tp->t_sigio);
955 case TIOCEXCL: /* set exclusive use of tty */
957 SET(tp->t_state, TS_XCLUDE);
960 case TIOCFLUSH: { /* flush buffers */
961 int flags = *(int *)data;
964 flags = FREAD | FWRITE;
966 flags &= FREAD | FWRITE;
970 case TIOCCONS: /* become virtual console */
972 struct nameidata nid;
974 if (constty && constty != tp &&
975 ISSET(constty->t_state, TS_CONNECTED))
978 /* Ensure user can open the real console. */
979 NDINIT(&nid, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE,
981 if ((error = namei(&nid)) != 0)
983 NDFREE(&nid, NDF_ONLY_PNBUF);
984 error = VOP_ACCESS(nid.ni_vp, VREAD, td->td_ucred, td);
990 } else if (tp == constty)
993 case TIOCDRAIN: /* wait till output drained */
998 case TIOCGETA: { /* get termios struct */
999 struct termios *t = (struct termios *)data;
1001 bcopy(&tp->t_termios, t, sizeof(struct termios));
1004 case TIOCGETD: /* get line discipline */
1005 *(int *)data = tp->t_line;
1007 case TIOCGWINSZ: /* get window size */
1008 *(struct winsize *)data = tp->t_winsize;
1010 case TIOCGPGRP: /* get pgrp of tty */
1013 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1015 case TIOCGSID: /* get sid of tty */
1018 *(int *)data = tp->t_session->s_sid;
1021 case TIOCHPCL: /* hang up on last close */
1023 SET(tp->t_cflag, HUPCL);
1028 *(int *)data = tp->t_dtr_wait * 100 / hz;
1031 /* must be root since the wait applies to following logins */
1032 error = priv_check(td, PRIV_TTY_DTRWAIT);
1035 tp->t_dtr_wait = *(int *)data * hz / 100;
1037 case TIOCNXCL: /* reset exclusive use of tty */
1039 CLR(tp->t_state, TS_XCLUDE);
1042 case TIOCOUTQ: /* output queue size */
1043 *(int *)data = tp->t_outq.c_cc;
1045 case TIOCSETA: /* set termios struct */
1046 case TIOCSETAW: /* drain output, set */
1047 case TIOCSETAF: { /* drn out, fls in, set */
1048 struct termios *t = (struct termios *)data;
1050 if (t->c_ispeed == 0)
1051 t->c_ispeed = t->c_ospeed;
1052 if (t->c_ispeed == 0)
1053 t->c_ispeed = tp->t_ospeed;
1054 if (t->c_ispeed == 0)
1057 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1058 error = ttywait(tp);
1063 if (cmd == TIOCSETAF)
1064 ttyflush(tp, FREAD);
1066 if (!ISSET(t->c_cflag, CIGNORE)) {
1068 * Set device hardware.
1070 error = tt_param(tp, t);
1075 if (ISSET(t->c_cflag, CLOCAL) &&
1076 !ISSET(tp->t_cflag, CLOCAL)) {
1078 * XXX disconnections would be too hard to
1079 * get rid of without this kludge. The only
1080 * way to get rid of controlling terminals
1081 * is to exit from the session leader.
1083 CLR(tp->t_state, TS_ZOMBIE);
1085 wakeup(TSA_CARR_ON(tp));
1089 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1090 ISSET(t->c_cflag, CLOCAL)) &&
1091 !ISSET(tp->t_state, TS_ZOMBIE))
1092 SET(tp->t_state, TS_CONNECTED);
1094 CLR(tp->t_state, TS_CONNECTED);
1095 tp->t_cflag = t->c_cflag;
1096 tp->t_ispeed = t->c_ispeed;
1097 if (t->c_ospeed != 0)
1098 tp->t_ospeed = t->c_ospeed;
1101 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1103 if (ISSET(t->c_lflag, ICANON))
1104 SET(tp->t_lflag, PENDIN);
1107 * XXX we really shouldn't allow toggling
1108 * ICANON while we're in a non-termios line
1109 * discipline. Now we have to worry about
1110 * panicing for a null queue.
1112 if (tp->t_canq.c_cbreserved > 0 &&
1113 tp->t_rawq.c_cbreserved > 0) {
1114 catq(&tp->t_rawq, &tp->t_canq);
1116 * XXX the queue limits may be
1117 * different, so the old queue
1118 * swapping method no longer works.
1120 catq(&tp->t_canq, &tp->t_rawq);
1122 CLR(tp->t_lflag, PENDIN);
1126 tp->t_iflag = t->c_iflag;
1127 tp->t_oflag = t->c_oflag;
1129 * Make the EXTPROC bit read only.
1131 if (ISSET(tp->t_lflag, EXTPROC))
1132 SET(t->c_lflag, EXTPROC);
1134 CLR(t->c_lflag, EXTPROC);
1135 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1136 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1137 t->c_cc[VTIME] != tp->t_cc[VTIME])
1139 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1143 case TIOCSETD: { /* set line discipline */
1144 int t = *(int *)data;
1146 if ((u_int)t >= nlinesw)
1148 if (t == tp->t_line)
1151 ttyld_close(tp, flag);
1153 /* XXX: we should use the correct cdev here */
1154 error = ttyld_open(tp, tp->t_dev);
1157 * If we fail to switch line discipline we cannot
1158 * fall back to the previous, because we can not
1159 * trust that ldisc to open successfully either.
1160 * Fall back to the default ldisc which we know
1161 * will allways succeed.
1163 tp->t_line = TTYDISC;
1164 (void)ttyld_open(tp, tp->t_dev);
1170 case TIOCSTART: /* start output, like ^Q */
1172 if (ISSET(tp->t_state, TS_TTSTOP) ||
1173 ISSET(tp->t_lflag, FLUSHO)) {
1174 CLR(tp->t_lflag, FLUSHO);
1175 CLR(tp->t_state, TS_TTSTOP);
1180 case TIOCSTI: /* simulate terminal input */
1181 if ((flag & FREAD) == 0 && priv_check(td, PRIV_TTY_STI))
1183 if (!isctty(p, tp) && priv_check(td, PRIV_TTY_STI))
1186 ttyld_rint(tp, *(u_char *)data);
1189 case TIOCSTOP: /* stop output, like ^S */
1191 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1192 SET(tp->t_state, TS_TTSTOP);
1197 case TIOCSCTTY: /* become controlling tty */
1198 /* Session ctty vnode pointer set in vnode layer. */
1199 sx_slock(&proctree_lock);
1200 if (!SESS_LEADER(p) ||
1201 ((p->p_session->s_ttyvp || tp->t_session) &&
1202 (tp->t_session != p->p_session))) {
1203 sx_sunlock(&proctree_lock);
1206 tp->t_session = p->p_session;
1207 tp->t_pgrp = p->p_pgrp;
1208 SESS_LOCK(p->p_session);
1209 ttyref(tp); /* ttyrel(): kern_proc.c:pgdelete() */
1210 p->p_session->s_ttyp = tp;
1211 SESS_UNLOCK(p->p_session);
1213 p->p_flag |= P_CONTROLT;
1215 sx_sunlock(&proctree_lock);
1217 case TIOCSPGRP: { /* set pgrp of tty */
1218 sx_slock(&proctree_lock);
1219 pgrp = pgfind(*(int *)data);
1220 if (!isctty(p, tp)) {
1223 sx_sunlock(&proctree_lock);
1227 sx_sunlock(&proctree_lock);
1231 if (pgrp->pg_session != p->p_session) {
1232 sx_sunlock(&proctree_lock);
1235 sx_sunlock(&proctree_lock);
1239 case TIOCSTAT: /* simulate control-T */
1244 case TIOCSWINSZ: /* set window size */
1245 if (bcmp((caddr_t)&tp->t_winsize, data,
1246 sizeof (struct winsize))) {
1247 tp->t_winsize = *(struct winsize *)data;
1248 if (tp->t_pgrp != NULL) {
1249 PGRP_LOCK(tp->t_pgrp);
1250 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1251 PGRP_UNLOCK(tp->t_pgrp);
1255 case TIOCSDRAINWAIT:
1256 error = priv_check(td, PRIV_TTY_DRAINWAIT);
1259 tp->t_timeout = *(int *)data * hz;
1260 wakeup(TSA_OCOMPLETE(tp));
1261 wakeup(TSA_OLOWAT(tp));
1263 case TIOCGDRAINWAIT:
1264 *(int *)data = tp->t_timeout / hz;
1267 return (tt_break(tp, 1));
1269 return (tt_break(tp, 0));
1271 #if defined(COMPAT_43TTY)
1272 return (ttcompat(tp, cmd, data, flag));
1281 ttypoll(struct cdev *dev, int events, struct thread *td)
1287 tp = tty_gettp(dev);
1289 if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
1290 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
1294 if (events & (POLLIN | POLLRDNORM)) {
1295 if (ISSET(tp->t_state, TS_ZOMBIE))
1296 revents |= (events & (POLLIN | POLLRDNORM)) |
1298 else if (ttnread(tp) > 0)
1299 revents |= events & (POLLIN | POLLRDNORM);
1301 selrecord(td, &tp->t_rsel);
1303 if (events & POLLOUT) {
1304 if (ISSET(tp->t_state, TS_ZOMBIE))
1306 else if (tp->t_outq.c_cc <= tp->t_olowat &&
1307 ISSET(tp->t_state, TS_CONNECTED))
1308 revents |= events & POLLOUT;
1310 selrecord(td, &tp->t_wsel);
1316 static struct filterops ttyread_filtops =
1317 { 1, NULL, filt_ttyrdetach, filt_ttyread };
1318 static struct filterops ttywrite_filtops =
1319 { 1, NULL, filt_ttywdetach, filt_ttywrite };
1322 ttykqfilter(struct cdev *dev, struct knote *kn)
1325 struct knlist *klist;
1328 tp = tty_gettp(dev);
1329 if (tp == NULL || (tp->t_state & TS_GONE))
1332 switch (kn->kn_filter) {
1334 klist = &tp->t_rsel.si_note;
1335 kn->kn_fop = &ttyread_filtops;
1338 klist = &tp->t_wsel.si_note;
1339 kn->kn_fop = &ttywrite_filtops;
1345 kn->kn_hook = (caddr_t)tp;
1348 knlist_add(klist, kn, 0);
1355 filt_ttyrdetach(struct knote *kn)
1357 struct tty *tp = (struct tty *)kn->kn_hook;
1360 knlist_remove(&tp->t_rsel.si_note, kn, 0);
1365 filt_ttyread(struct knote *kn, long hint)
1367 struct tty *tp = (struct tty *)kn->kn_hook;
1369 kn->kn_data = ttnread(tp);
1370 if ((tp->t_state & TS_GONE) || ISSET(tp->t_state, TS_ZOMBIE)) {
1371 kn->kn_flags |= EV_EOF;
1374 return (kn->kn_data > 0);
1378 filt_ttywdetach(struct knote *kn)
1380 struct tty *tp = (struct tty *)kn->kn_hook;
1383 knlist_remove(&tp->t_wsel.si_note, kn, 0);
1388 filt_ttywrite(struct knote *kn, long hint)
1390 struct tty *tp = (struct tty *)kn->kn_hook;
1392 kn->kn_data = tp->t_outq.c_cc;
1393 if ((tp->t_state & TS_GONE) || ISSET(tp->t_state, TS_ZOMBIE))
1395 return (kn->kn_data <= tp->t_olowat &&
1396 ISSET(tp->t_state, TS_CONNECTED));
1400 * Must be called at spltty().
1403 ttnread(struct tty *tp)
1407 if (ISSET(tp->t_lflag, PENDIN))
1409 nread = tp->t_canq.c_cc;
1410 if (!ISSET(tp->t_lflag, ICANON)) {
1411 nread += tp->t_rawq.c_cc;
1412 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1419 * Wait for output to drain.
1422 ttywait(struct tty *tp)
1428 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1429 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1431 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1432 ISSET(tp->t_state, TS_CONNECTED)) {
1433 SET(tp->t_state, TS_SO_OCOMPLETE);
1434 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1435 TTOPRI | PCATCH, "ttywai",
1438 if (error == EWOULDBLOCK)
1445 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1452 * Flush if successfully wait.
1455 ttywflush(struct tty *tp)
1459 if ((error = ttywait(tp)) == 0)
1460 ttyflush(tp, FREAD);
1465 * Flush tty read and/or write queues, notifying anyone waiting.
1468 ttyflush(struct tty *tp, int rw)
1477 FLUSHQ(&tp->t_outq);
1478 CLR(tp->t_state, TS_TTSTOP);
1482 FLUSHQ(&tp->t_canq);
1483 FLUSHQ(&tp->t_rawq);
1484 CLR(tp->t_lflag, PENDIN);
1487 CLR(tp->t_state, TS_LOCAL);
1489 if (ISSET(tp->t_state, TS_TBLOCK)) {
1491 FLUSHQ(&tp->t_outq);
1495 * Don't let leave any state that might clobber the
1496 * next line discipline (although we should do more
1497 * to send the START char). Not clearing the state
1498 * may have caused the "putc to a clist with no
1499 * reserved cblocks" panic/printf.
1501 CLR(tp->t_state, TS_TBLOCK);
1503 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1504 if (ISSET(tp->t_iflag, IXOFF)) {
1506 * XXX wait a bit in the hope that the stop
1507 * character (if any) will go out. Waiting
1508 * isn't good since it allows races. This
1509 * will be fixed when the stop character is
1510 * put in a special queue. Don't bother with
1511 * the checks in ttywait() since the timeout
1514 SET(tp->t_state, TS_SO_OCOMPLETE);
1515 ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
1518 * Don't try sending the stop character again.
1520 CLR(tp->t_state, TS_TBLOCK);
1527 FLUSHQ(&tp->t_outq);
1534 * Copy in the default termios characters.
1537 termioschars(struct termios *t)
1540 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1547 ttychars(struct tty *tp)
1550 termioschars(&tp->t_termios);
1554 * Handle input high water. Send stop character for the IXOFF case. Turn
1555 * on our input flow control bit and propagate the changes to the driver.
1556 * XXX the stop character should be put in a special high priority queue.
1559 ttyblock(struct tty *tp)
1562 SET(tp->t_state, TS_TBLOCK);
1563 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1564 putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1565 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1570 * Handle input low water. Send start character for the IXOFF case. Turn
1571 * off our input flow control bit and propagate the changes to the driver.
1572 * XXX the start character should be put in a special high priority queue.
1575 ttyunblock(struct tty *tp)
1578 CLR(tp->t_state, TS_TBLOCK);
1579 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1580 putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1581 SET(tp->t_state, TS_TBLOCK); /* try again later */
1586 /* Not used by any current (i386) drivers. */
1588 * Restart after an inter-char delay.
1591 ttrstrt(void *tp_arg)
1596 KASSERT(tp_arg != NULL, ("ttrstrt"));
1601 CLR(tp->t_state, TS_TIMEOUT);
1609 ttstart(struct tty *tp)
1617 * "close" a line discipline
1620 ttylclose(struct tty *tp, int flag)
1623 if (flag & FNONBLOCK || ttywflush(tp))
1624 ttyflush(tp, FREAD | FWRITE);
1629 * Handle modem control transition on a tty.
1630 * Flag indicates new state of carrier.
1631 * Returns 0 if the line should be turned off, otherwise 1.
1634 ttymodem(struct tty *tp, int flag)
1637 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1639 * MDMBUF: do flow control according to carrier flag
1640 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1641 * works if IXON and IXANY are clear.
1644 CLR(tp->t_state, TS_CAR_OFLOW);
1645 CLR(tp->t_state, TS_TTSTOP);
1647 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1648 SET(tp->t_state, TS_CAR_OFLOW);
1649 SET(tp->t_state, TS_TTSTOP);
1652 } else if (flag == 0) {
1656 CLR(tp->t_state, TS_CARR_ON);
1657 if (ISSET(tp->t_state, TS_ISOPEN) &&
1658 !ISSET(tp->t_cflag, CLOCAL)) {
1659 SET(tp->t_state, TS_ZOMBIE);
1660 CLR(tp->t_state, TS_CONNECTED);
1661 if (tp->t_session) {
1662 sx_slock(&proctree_lock);
1663 if (tp->t_session && tp->t_session->s_leader) {
1666 p = tp->t_session->s_leader;
1671 sx_sunlock(&proctree_lock);
1673 ttyflush(tp, FREAD | FWRITE);
1680 SET(tp->t_state, TS_CARR_ON);
1681 if (!ISSET(tp->t_state, TS_ZOMBIE))
1682 SET(tp->t_state, TS_CONNECTED);
1683 wakeup(TSA_CARR_ON(tp));
1691 * Reinput pending characters after state switch
1695 ttypend(struct tty *tp)
1700 CLR(tp->t_lflag, PENDIN);
1701 SET(tp->t_state, TS_TYPEN);
1703 * XXX this assumes too much about clist internals. It may even
1704 * fail if the cblock slush pool is empty. We can't allocate more
1705 * cblocks here because we are called from an interrupt handler
1706 * and clist_alloc_cblocks() can wait.
1709 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1710 tp->t_rawq.c_cbmax = tq.c_cbmax;
1711 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1712 while ((c = getc(&tq)) >= 0)
1714 CLR(tp->t_state, TS_TYPEN);
1718 * Process a read call on a tty device.
1721 ttread(struct tty *tp, struct uio *uio, int flag)
1726 cc_t *cc = tp->t_cc;
1729 int s, first, error = 0;
1730 int has_stime = 0, last_cc = 0;
1731 long slp = 0; /* XXX this should be renamed `timo'. */
1732 struct timeval stime = { 0, 0 };
1739 lflag = tp->t_lflag;
1741 * take pending input first
1743 if (ISSET(lflag, PENDIN)) {
1745 splx(s); /* reduce latency */
1747 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1751 * Hang process if it's in the background.
1753 if (isbackground(p, tp)) {
1755 sx_slock(&proctree_lock);
1757 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) ||
1758 SIGISMEMBER(td->td_sigmask, SIGTTIN) ||
1759 (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) {
1761 sx_sunlock(&proctree_lock);
1767 sx_sunlock(&proctree_lock);
1768 pgsignal(pg, SIGTTIN, 1);
1770 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
1776 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1778 return (0); /* EOF */
1782 * If canonical, use the canonical queue,
1783 * else use the raw queue.
1785 * (should get rid of clists...)
1787 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1789 if (flag & IO_NDELAY) {
1792 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1797 return (EWOULDBLOCK);
1799 if (!ISSET(lflag, ICANON)) {
1802 struct timeval timecopy;
1805 * Check each of the four combinations.
1806 * (m > 0 && t == 0) is the normal read case.
1807 * It should be fairly efficient, so we check that and its
1808 * companion case (m == 0 && t == 0) first.
1809 * For the other two cases, we compute the target sleep time
1818 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1822 t *= 100000; /* time in us */
1823 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1824 ((t1).tv_usec - (t2).tv_usec))
1830 getmicrotime(&timecopy);
1832 /* first character, start timer */
1836 } else if (qp->c_cc > last_cc) {
1837 /* got a character, restart timer */
1841 /* nothing, check expiration */
1842 slp = t - diff(timecopy, stime);
1847 } else { /* m == 0 */
1850 getmicrotime(&timecopy);
1856 slp = t - diff(timecopy, stime);
1858 /* Timed out, but 0 is enough input. */
1866 struct timeval tv; /* XXX style bug. */
1868 tv.tv_sec = slp / 1000000;
1869 tv.tv_usec = slp % 1000000;
1872 * XXX bad variable names. slp was the timeout in
1873 * usec. Now it is the timeout in ticks.
1878 if (qp->c_cc <= 0) {
1881 * There is no input, or not enough input and we can block.
1883 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
1884 ISSET(tp->t_state, TS_CONNECTED) ?
1885 "ttyin" : "ttyhup", (int)slp);
1887 if (error == EWOULDBLOCK)
1892 * XXX what happens if another process eats some input
1893 * while we are asleep (not just here)? It would be
1894 * safest to detect changes and reset our state variables
1895 * (has_stime and last_cc).
1903 * Input present, check for input mapping and processing.
1906 if (ISSET(lflag, ICANON | ISIG))
1912 icc = imin(uio->uio_resid, IBUFSIZ);
1913 icc = q_to_b(qp, ibuf, icc);
1919 error = uiomove(ibuf, icc, uio);
1921 * XXX if there was an error then we should ungetc() the
1922 * unmoved chars and reduce icc here.
1926 if (uio->uio_resid == 0)
1940 * delayed suspend (^Y)
1942 if (CCEQ(cc[VDSUSP], c) &&
1943 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1944 if (tp->t_pgrp != NULL) {
1945 PGRP_LOCK(tp->t_pgrp);
1946 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1947 PGRP_UNLOCK(tp->t_pgrp);
1950 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
1959 * Interpret EOF only in canonical mode.
1961 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1964 * Give user character.
1966 error = ureadc(c, uio);
1968 /* XXX should ungetc(c, qp). */
1970 if (uio->uio_resid == 0)
1973 * In canonical mode check for a "break character"
1974 * marking the end of a "line of input".
1976 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1983 * Look to unblock input now that (presumably)
1984 * the input queue has gone down.
1987 if (ISSET(tp->t_state, TS_TBLOCK) &&
1988 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1996 * Check the output queue on tp for space for a kernel message (from uprintf
1997 * or tprintf). Allow some space over the normal hiwater mark so we don't
1998 * lose messages due to normal flow control, but don't let the tty run amok.
1999 * Sleeps here are not interruptible, but we return prematurely if new signals
2003 ttycheckoutq(struct tty *tp, int wait)
2012 hiwat = tp->t_ohiwat;
2013 SIGEMPTYSET(oldmask);
2017 oldmask = td->td_siglist;
2020 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
2021 while (tp->t_outq.c_cc > hiwat) {
2023 if (tp->t_outq.c_cc <= hiwat)
2030 if (!SIGSETEQ(td->td_siglist, oldmask)) {
2036 SET(tp->t_state, TS_SO_OLOWAT);
2037 tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
2044 * Process a write call on a tty device.
2047 ttwrite(struct tty *tp, struct uio *uio, int flag)
2053 int i, hiwat, cnt, error, s;
2056 hiwat = tp->t_ohiwat;
2057 cnt = uio->uio_resid;
2064 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2066 if (uio->uio_resid == cnt)
2070 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2071 if (flag & IO_NDELAY) {
2073 error = EWOULDBLOCK;
2076 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
2085 * Hang the process if it's in the background.
2087 sx_slock(&proctree_lock);
2089 if (isbackground(p, tp) &&
2090 ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
2091 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
2092 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
2093 if (p->p_pgrp->pg_jobc == 0) {
2095 sx_sunlock(&proctree_lock);
2100 PGRP_LOCK(p->p_pgrp);
2101 sx_sunlock(&proctree_lock);
2102 pgsignal(p->p_pgrp, SIGTTOU, 1);
2103 PGRP_UNLOCK(p->p_pgrp);
2104 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
2110 sx_sunlock(&proctree_lock);
2113 * Process the user's data in at most OBUFSIZ chunks. Perform any
2114 * output translation. Keep track of high water mark, sleep on
2115 * overflow awaiting device aid in acquiring new space.
2117 while (uio->uio_resid > 0 || cc > 0) {
2118 if (ISSET(tp->t_lflag, FLUSHO)) {
2122 if (tp->t_outq.c_cc > hiwat)
2125 * Grab a hunk of data from the user, unless we have some
2126 * leftover from last time.
2129 cc = imin(uio->uio_resid, OBUFSIZ);
2131 error = uiomove(cp, cc, uio);
2138 * If nothing fancy need be done, grab those characters we
2139 * can handle without any of ttyoutput's processing and
2140 * just transfer them to the output q. For those chars
2141 * which require special processing (as indicated by the
2142 * bits in char_type), call ttyoutput. After processing
2143 * a hunk of data, look for FLUSHO so ^O's will take effect
2147 if (!ISSET(tp->t_oflag, OPOST))
2150 ce = cc - scanc((u_int)cc, (u_char *)cp,
2151 char_type, CCLASSMASK);
2153 * If ce is zero, then we're processing
2154 * a special character through ttyoutput.
2158 if (ttyoutput(*cp, tp) >= 0) {
2159 /* No Clists, wait a bit. */
2161 if (flag & IO_NDELAY) {
2162 error = EWOULDBLOCK;
2165 error = ttysleep(tp, &lbolt,
2174 if (ISSET(tp->t_lflag, FLUSHO) ||
2175 tp->t_outq.c_cc > hiwat)
2181 * A bunch of normal characters have been found.
2182 * Transfer them en masse to the output queue and
2183 * continue processing at the top of the loop.
2184 * If there are any further characters in this
2185 * <= OBUFSIZ chunk, the first should be a character
2186 * requiring special handling by ttyoutput.
2189 i = b_to_q(cp, ce, &tp->t_outq);
2192 cp += ce, cc -= ce, tk_nout += ce;
2195 /* No Clists, wait a bit. */
2197 if (flag & IO_NDELAY) {
2198 error = EWOULDBLOCK;
2201 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
2207 if (ISSET(tp->t_lflag, FLUSHO) ||
2208 tp->t_outq.c_cc > hiwat)
2215 * If cc is nonzero, we leave the uio structure inconsistent, as the
2216 * offset and iov pointers have moved forward, but it doesn't matter
2217 * (the call will either return short or restart with a new uio).
2219 uio->uio_resid += cc;
2226 * This can only occur if FLUSHO is set in t_lflag,
2227 * or if ttstart/oproc is synchronous (or very fast).
2229 if (tp->t_outq.c_cc <= hiwat) {
2233 if (flag & IO_NDELAY) {
2235 uio->uio_resid += cc;
2236 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2238 SET(tp->t_state, TS_SO_OLOWAT);
2239 error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
2242 if (error == EWOULDBLOCK)
2250 * Rubout one character from the rawq of tp
2251 * as cleanly as possible.
2254 ttyrub(int c, struct tty *tp)
2260 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2262 CLR(tp->t_lflag, FLUSHO);
2263 if (ISSET(tp->t_lflag, ECHOE)) {
2264 if (tp->t_rocount == 0) {
2266 * Screwed by ttwrite; retype
2271 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2274 CLR(c, ~TTY_CHARMASK);
2275 switch (CCLASS(c)) {
2284 if (ISSET(tp->t_lflag, ECHOCTL))
2288 if (tp->t_rocount < tp->t_rawq.c_cc) {
2293 savecol = tp->t_column;
2294 SET(tp->t_state, TS_CNTTB);
2295 SET(tp->t_lflag, FLUSHO);
2296 tp->t_column = tp->t_rocol;
2297 cp = tp->t_rawq.c_cf;
2299 tabc = *cp; /* XXX FIX NEXTC */
2300 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2302 CLR(tp->t_lflag, FLUSHO);
2303 CLR(tp->t_state, TS_CNTTB);
2306 /* savecol will now be length of the tab. */
2307 savecol -= tp->t_column;
2308 tp->t_column += savecol;
2310 savecol = 8; /* overflow screw */
2311 while (--savecol >= 0)
2312 (void)ttyoutput('\b', tp);
2315 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2316 (void)printf(PANICSTR, c, CCLASS(c));
2318 panic(PANICSTR, c, CCLASS(c));
2322 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2323 if (!ISSET(tp->t_state, TS_ERASE)) {
2324 SET(tp->t_state, TS_ERASE);
2325 (void)ttyoutput('\\', tp);
2329 ttyecho(tp->t_cc[VERASE], tp);
2331 * This code may be executed not only when an ERASE key
2332 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2333 * So, I didn't think it was worthwhile to pass the extra
2334 * information (which would need an extra parameter,
2335 * changing every call) needed to distinguish the ERASE2
2336 * case from the ERASE.
2343 * Back over cnt characters, erasing them.
2346 ttyrubo(struct tty *tp, int cnt)
2350 (void)ttyoutput('\b', tp);
2351 (void)ttyoutput(' ', tp);
2352 (void)ttyoutput('\b', tp);
2358 * Reprint the rawq line. Note, it is assumed that c_cc has already
2362 ttyretype(struct tty *tp)
2367 /* Echo the reprint character. */
2368 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2369 ttyecho(tp->t_cc[VREPRINT], tp);
2371 (void)ttyoutput('\n', tp);
2375 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2376 * BIT OF FIRST CHAR.
2379 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2380 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2382 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2383 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2385 CLR(tp->t_state, TS_ERASE);
2388 tp->t_rocount = tp->t_rawq.c_cc;
2393 * Echo a typed character to the terminal.
2396 ttyecho(int c, struct tty *tp)
2399 if (!ISSET(tp->t_state, TS_CNTTB))
2400 CLR(tp->t_lflag, FLUSHO);
2401 if ((!ISSET(tp->t_lflag, ECHO) &&
2402 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2403 ISSET(tp->t_lflag, EXTPROC))
2405 if (ISSET(tp->t_lflag, ECHOCTL) &&
2406 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2407 ISSET(c, TTY_CHARMASK) == 0177)) {
2408 (void)ttyoutput('^', tp);
2409 CLR(c, ~TTY_CHARMASK);
2415 (void)ttyoutput(c, tp);
2419 * Wake up any readers on a tty.
2422 ttwakeup(struct tty *tp)
2425 if (SEL_WAITING(&tp->t_rsel))
2426 selwakeuppri(&tp->t_rsel, TTIPRI);
2427 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2428 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2429 wakeup(TSA_HUP_OR_INPUT(tp));
2430 KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0);
2434 * Wake up any writers on a tty.
2437 ttwwakeup(struct tty *tp)
2440 if (SEL_WAITING(&tp->t_wsel) && tp->t_outq.c_cc <= tp->t_olowat)
2441 selwakeuppri(&tp->t_wsel, TTOPRI);
2442 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2443 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2444 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2445 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2446 CLR(tp->t_state, TS_SO_OCOMPLETE);
2447 wakeup(TSA_OCOMPLETE(tp));
2449 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2450 tp->t_outq.c_cc <= tp->t_olowat) {
2451 CLR(tp->t_state, TS_SO_OLOWAT);
2452 wakeup(TSA_OLOWAT(tp));
2454 KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0);
2458 * Look up a code for a specified speed in a conversion table;
2459 * used by drivers to map software speed values to hardware parameters.
2462 ttspeedtab(int speed, struct speedtab *table)
2465 for ( ; table->sp_speed != -1; table++)
2466 if (table->sp_speed == speed)
2467 return (table->sp_code);
2472 * Set input and output watermarks and buffer sizes. For input, the
2473 * high watermark is about one second's worth of input above empty, the
2474 * low watermark is slightly below high water, and the buffer size is a
2475 * driver-dependent amount above high water. For output, the watermarks
2476 * are near the ends of the buffer, with about 1 second's worth of input
2477 * between them. All this only applies to the standard line discipline.
2480 ttsetwater(struct tty *tp)
2482 int cps, ttmaxhiwat, x;
2485 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2486 switch (tp->t_ispeedwat) {
2488 cps = tp->t_ispeed / 10;
2492 * This case is for old drivers that don't know about
2493 * t_ispeedwat. Arrange for them to get the old buffer
2494 * sizes and watermarks.
2496 cps = TTYHOG - 2 * 256;
2497 tp->t_ififosize = 2 * 256;
2500 cps = tp->t_ispeedwat / 10;
2504 tp->t_ilowat = 7 * cps / 8;
2505 x = cps + tp->t_ififosize;
2506 clist_alloc_cblocks(&tp->t_rawq, x, x);
2509 switch (tp->t_ospeedwat) {
2511 cps = tp->t_ospeed / 10;
2512 ttmaxhiwat = 2 * TTMAXHIWAT;
2515 cps = tp->t_ospeed / 10;
2516 ttmaxhiwat = TTMAXHIWAT;
2519 cps = tp->t_ospeedwat / 10;
2520 ttmaxhiwat = 8 * TTMAXHIWAT;
2523 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2524 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2526 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2527 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2528 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2530 clist_alloc_cblocks(&tp->t_outq, x, x);
2535 * Report on state of foreground process group.
2538 ttyinfo(struct tty *tp)
2540 struct timeval utime, stime;
2541 struct proc *p, *pick;
2542 struct thread *td, *picktd;
2543 const char *stateprefix, *state;
2547 char comm[MAXCOMLEN + 1];
2550 if (ttycheckoutq(tp,0) == 0)
2553 /* Print load average. */
2554 load = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2555 ttyprintf(tp, "load: %d.%02d ", load / 100, load % 100);
2558 * On return following a ttyprintf(), we set tp->t_rocount to 0 so
2559 * that pending input will be retyped on BS.
2561 if (tp->t_session == NULL) {
2562 ttyprintf(tp, "not a controlling terminal\n");
2566 if (tp->t_pgrp == NULL) {
2567 ttyprintf(tp, "no foreground process group\n");
2571 PGRP_LOCK(tp->t_pgrp);
2572 if (LIST_EMPTY(&tp->t_pgrp->pg_members)) {
2573 PGRP_UNLOCK(tp->t_pgrp);
2574 ttyprintf(tp, "empty foreground process group\n");
2580 * Pick the most interesting process and copy some of its
2581 * state for printing later. This operation could rely on stale
2582 * data as we can't hold the proc slock or thread locks over the
2583 * whole list. However, we're guaranteed not to reference an exited
2584 * thread or proc since we hold the tty locked.
2587 LIST_FOREACH(p, &tp->t_pgrp->pg_members, p_pglist)
2588 if (proc_compare(pick, p))
2593 td = FIRST_THREAD_IN_PROC(pick);
2594 FOREACH_THREAD_IN_PROC(pick, td)
2595 if (thread_compare(picktd, td))
2600 if (TD_IS_RUNNING(td))
2602 else if (TD_ON_RUNQ(td) || TD_CAN_RUN(td))
2604 else if (TD_IS_SLEEPING(td)) {
2605 /* XXX: If we're sleeping, are we ever not in a queue? */
2606 if (TD_ON_SLEEPQ(td))
2607 state = td->td_wmesg;
2609 state = "sleeping without queue";
2610 } else if (TD_ON_LOCK(td)) {
2611 state = td->td_lockname;
2613 } else if (TD_IS_SUSPENDED(td))
2614 state = "suspended";
2615 else if (TD_AWAITING_INTR(td))
2619 pctcpu = (sched_pctcpu(td) * 10000 + FSCALE / 2) >> FSHIFT;
2621 if (pick->p_state == PRS_NEW || pick->p_state == PRS_ZOMBIE)
2624 rss = pgtok(vmspace_resident_count(pick->p_vmspace));
2627 PGRP_UNLOCK(tp->t_pgrp);
2628 rufetchcalc(pick, &ru, &utime, &stime);
2630 bcopy(pick->p_comm, comm, sizeof(comm));
2633 /* Print command, pid, state, utime, stime, %cpu, and rss. */
2635 " cmd: %s %d [%s%s] %ld.%02ldu %ld.%02lds %d%% %ldk\n",
2636 comm, pid, stateprefix, state,
2637 (long)utime.tv_sec, utime.tv_usec / 10000,
2638 (long)stime.tv_sec, stime.tv_usec / 10000,
2644 * Returns 1 if p2 is "better" than p1
2646 * The algorithm for picking the "interesting" process is thus:
2648 * 1) Only foreground processes are eligible - implied.
2649 * 2) Runnable processes are favored over anything else. The runner
2650 * with the highest cpu utilization is picked (p_estcpu). Ties are
2651 * broken by picking the highest pid.
2652 * 3) The sleeper with the shortest sleep time is next. With ties,
2653 * we pick out just "short-term" sleepers (P_SINTR == 0).
2654 * 4) Further ties are broken by picking the highest pid.
2657 #define TESTAB(a, b) ((a)<<1 | (b))
2663 proc_sum(struct proc *p, int *estcpup)
2671 FOREACH_THREAD_IN_PROC(p, td) {
2673 if (TD_ON_RUNQ(td) ||
2676 estcpu += sched_pctcpu(td);
2685 thread_compare(struct thread *td, struct thread *td2)
2695 * Fetch running stats, pctcpu usage, and interruptable flag.
2698 runa = TD_IS_RUNNING(td) | TD_ON_RUNQ(td);
2699 slpa = td->td_flags & TDF_SINTR;
2700 esta = sched_pctcpu(td);
2703 runb = TD_IS_RUNNING(td2) | TD_ON_RUNQ(td2);
2704 estb = sched_pctcpu(td2);
2705 slpb = td2->td_flags & TDF_SINTR;
2708 * see if at least one of them is runnable
2710 switch (TESTAB(runa, runb)) {
2719 * favor one with highest recent cpu utilization
2726 * favor one sleeping in a non-interruptible sleep
2728 switch (TESTAB(slpa, slpb)) {
2741 proc_compare(struct proc *p1, struct proc *p2)
2751 * Fetch various stats about these processes. After we drop the
2752 * lock the information could be stale but the race is unimportant.
2755 runa = proc_sum(p1, &esta);
2758 runb = proc_sum(p2, &estb);
2762 * see if at least one of them is runnable
2764 switch (TESTAB(runa, runb)) {
2773 * favor one with highest recent cpu utilization
2782 switch (TESTAB(p1->p_state == PRS_ZOMBIE, p2->p_state == PRS_ZOMBIE)) {
2791 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2795 * Output char to tty; console putchar style.
2798 tputchar(int c, struct tty *tp)
2803 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2808 (void)ttyoutput('\r', tp);
2809 (void)ttyoutput(c, tp);
2816 * Sleep on chan, returning ERESTART if tty changed while we napped and
2817 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2818 * the tty is revoked, restarting a pending call will redo validation done
2819 * at the start of the call.
2822 ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo)
2828 error = tsleep(chan, pri, wmesg, timo);
2829 if (tp->t_state & TS_GONE)
2833 return (tp->t_gen == gen ? 0 : ERESTART);
2837 * Gain a reference to a TTY
2840 ttyref(struct tty *tp)
2844 mtx_lock(&tp->t_mtx);
2845 KASSERT(tp->t_refcnt > 0,
2846 ("ttyref(): tty refcnt is %d (%s)",
2847 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2849 mtx_unlock(&tp->t_mtx);
2854 * Drop a reference to a TTY.
2855 * When reference count drops to zero, we free it.
2858 ttyrel(struct tty *tp)
2862 mtx_lock(&tty_list_mutex);
2863 mtx_lock(&tp->t_mtx);
2864 KASSERT(tp->t_refcnt > 0,
2865 ("ttyrel(): tty refcnt is %d (%s)",
2866 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2869 mtx_unlock(&tp->t_mtx);
2870 mtx_unlock(&tty_list_mutex);
2873 TAILQ_REMOVE(&tty_list, tp, t_list);
2874 mtx_unlock(&tp->t_mtx);
2875 mtx_unlock(&tty_list_mutex);
2876 knlist_destroy(&tp->t_rsel.si_note);
2877 knlist_destroy(&tp->t_wsel.si_note);
2878 mtx_destroy(&tp->t_mtx);
2884 * Allocate a tty struct. Clists in the struct will be allocated by
2892 tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO);
2893 mtx_init(&tp->t_mtx, "tty", NULL, MTX_DEF);
2896 * Set up the initial state
2900 tp->t_dtr_wait = 3 * hz;
2902 ttyinitmode(tp, 0, 0);
2903 bcopy(ttydefchars, tp->t_init_in.c_cc, sizeof tp->t_init_in.c_cc);
2905 /* Make callout the same as callin */
2906 tp->t_init_out = tp->t_init_in;
2908 mtx_lock(&tty_list_mutex);
2909 TAILQ_INSERT_TAIL(&tty_list, tp, t_list);
2910 mtx_unlock(&tty_list_mutex);
2911 knlist_init(&tp->t_rsel.si_note, &tp->t_mtx, NULL, NULL, NULL);
2912 knlist_init(&tp->t_wsel.si_note, &tp->t_mtx, NULL, NULL, NULL);
2917 ttypurge(struct cdev *dev)
2920 if (dev->si_tty == NULL)
2922 ttygone(dev->si_tty);
2928 * Create the device entries for this tty thereby opening it for business.
2930 * The flags argument controls if "cua" units are created.
2932 * The t_sc filed is copied to si_drv1 in the created cdevs. This
2933 * is particularly important for ->t_cioctl() users.
2935 * XXX: implement the init and lock devices by cloning.
2939 ttycreate(struct tty *tp, int flags, const char *fmt, ...)
2941 char namebuf[SPECNAMELEN - 3]; /* XXX space for "tty" */
2942 struct cdevsw *csw = NULL;
2946 int i, minor, sminor, sunit;
2948 mtx_assert(&Giant, MA_OWNED);
2950 if (tty_unit == NULL)
2951 tty_unit = new_unrhdr(0, 0xffff, NULL);
2953 sunit = alloc_unr(tty_unit);
2954 tp->t_devunit = sunit;
2960 KASSERT(csw->d_purge == NULL || csw->d_purge == ttypurge,
2961 ("tty should not have d_purge"));
2963 csw->d_purge = ttypurge;
2965 minor = unit2minor(unit);
2966 sminor = unit2minor(sunit);
2968 i = vsnrprintf(namebuf, sizeof namebuf, 32, fmt, ap);
2970 KASSERT(i < sizeof namebuf, ("Too long tty name (%s)", namebuf));
2972 cp = make_dev(csw, minor,
2973 UID_ROOT, GID_WHEEL, 0600, "tty%s", namebuf);
2977 cp->si_drv1 = tp->t_sc;
2979 cp = make_dev(&ttys_cdevsw, sminor | MINOR_INIT,
2980 UID_ROOT, GID_WHEEL, 0600, "tty%s.init", namebuf);
2981 dev_depends(tp->t_dev, cp);
2982 cp->si_drv1 = tp->t_sc;
2983 cp->si_drv2 = &tp->t_init_in;
2986 cp = make_dev(&ttys_cdevsw, sminor | MINOR_LOCK,
2987 UID_ROOT, GID_WHEEL, 0600, "tty%s.lock", namebuf);
2988 dev_depends(tp->t_dev, cp);
2989 cp->si_drv1 = tp->t_sc;
2990 cp->si_drv2 = &tp->t_lock_in;
2993 if (flags & TS_CALLOUT) {
2994 cp = make_dev(csw, minor | MINOR_CALLOUT,
2995 UID_UUCP, GID_DIALER, 0660, "cua%s", namebuf);
2996 dev_depends(tp->t_dev, cp);
2997 cp->si_drv1 = tp->t_sc;
3000 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_INIT,
3001 UID_UUCP, GID_DIALER, 0660, "cua%s.init", namebuf);
3002 dev_depends(tp->t_dev, cp);
3003 cp->si_drv1 = tp->t_sc;
3004 cp->si_drv2 = &tp->t_init_out;
3007 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_LOCK,
3008 UID_UUCP, GID_DIALER, 0660, "cua%s.lock", namebuf);
3009 dev_depends(tp->t_dev, cp);
3010 cp->si_drv1 = tp->t_sc;
3011 cp->si_drv2 = &tp->t_lock_out;
3019 * This function is called when the hardware disappears. We set a flag
3020 * and wake up stuff so all sleeping threads will notice.
3023 ttygone(struct tty *tp)
3026 tp->t_state |= TS_GONE;
3027 if (SEL_WAITING(&tp->t_rsel))
3028 selwakeuppri(&tp->t_rsel, TTIPRI);
3029 if (SEL_WAITING(&tp->t_wsel))
3030 selwakeuppri(&tp->t_wsel, TTOPRI);
3031 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
3032 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
3033 wakeup(&tp->t_dtr_wait);
3034 wakeup(TSA_CARR_ON(tp));
3035 wakeup(TSA_HUP_OR_INPUT(tp));
3036 wakeup(TSA_OCOMPLETE(tp));
3037 wakeup(TSA_OLOWAT(tp));
3038 KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0);
3039 KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0);
3046 * Called when the driver is ready to free the tty structure.
3048 * XXX: This shall sleep until all threads have left the driver.
3051 ttyfree(struct tty *tp)
3056 mtx_assert(&Giant, MA_OWNED);
3058 unit = tp->t_devunit;
3064 free_unr(tty_unit, unit);
3068 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
3070 struct tty *tp, *tp2;
3075 mtx_lock(&tty_list_mutex);
3076 tp = TAILQ_FIRST(&tty_list);
3079 while (tp != NULL) {
3080 if (tp->t_state & TS_GONE)
3082 bzero(&xt, sizeof xt);
3083 xt.xt_size = sizeof xt;
3084 #define XT_COPY(field) xt.xt_##field = tp->t_##field
3085 xt.xt_rawcc = tp->t_rawq.c_cc;
3086 xt.xt_cancc = tp->t_canq.c_cc;
3087 xt.xt_outcc = tp->t_outq.c_cc;
3091 * XXX: We hold the tty list lock while doing this to
3092 * work around a race with pty/pts tty destruction.
3093 * They set t_dev to NULL and then call ttyrel() to
3094 * free the structure which will block on the list
3095 * lock before they call destroy_dev() on the cdev
3098 * XXX: ttyfree() now does the same since it has been
3099 * fixed to not leak ttys.
3101 if (tp->t_dev != NULL)
3102 xt.xt_dev = dev2udev(tp->t_dev);
3106 if (tp->t_pgrp != NULL)
3107 xt.xt_pgid = tp->t_pgrp->pg_id;
3108 if (tp->t_session != NULL)
3109 xt.xt_sid = tp->t_session->s_sid;
3123 mtx_unlock(&tty_list_mutex);
3124 error = SYSCTL_OUT(req, &xt, sizeof xt);
3129 mtx_lock(&tty_list_mutex);
3130 nexttp: tp2 = TAILQ_NEXT(tp, t_list);
3133 mtx_unlock(&tty_list_mutex);
3136 mtx_lock(&tty_list_mutex);
3138 mtx_unlock(&tty_list_mutex);
3142 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
3143 0, 0, sysctl_kern_ttys, "S,xtty", "All ttys");
3144 SYSCTL_LONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD,
3145 &tk_nin, 0, "Total TTY in characters");
3146 SYSCTL_LONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD,
3147 &tk_nout, 0, "Total TTY out characters");
3150 nottystop(struct tty *tp, int rw)
3157 ttyopen(struct cdev *dev, int flag, int mode, struct thread *td)
3167 * We jump to this label after all non-interrupted sleeps to pick
3168 * up any changes of the device state.
3171 if (tp->t_state & TS_GONE)
3173 error = ttydtrwaitsleep(tp);
3176 if (tp->t_state & TS_ISOPEN) {
3178 * The device is open, so everything has been initialized.
3181 if (ISCALLOUT(dev) && !tp->t_actout)
3183 if (tp->t_actout && !ISCALLOUT(dev)) {
3184 if (flag & O_NONBLOCK)
3186 error = tsleep(&tp->t_actout,
3187 TTIPRI | PCATCH, "ttybi", 0);
3188 if (error != 0 || (tp->t_state & TS_GONE))
3192 if (tp->t_state & TS_XCLUDE && priv_check(td,
3193 PRIV_TTY_EXCLUSIVE))
3197 * The device isn't open, so there are no conflicts.
3198 * Initialize it. Initialization is done twice in many
3199 * cases: to preempt sleeping callin opens if we are
3200 * callout, and to complete a callin open after DCD rises.
3202 tp->t_termios = ISCALLOUT(dev) ? tp->t_init_out : tp->t_init_in;
3203 tp->t_cflag = tp->t_termios.c_cflag;
3204 if (tp->t_modem != NULL)
3205 tt_modem(tp, SER_DTR | SER_RTS, 0);
3207 error = tt_param(tp, &tp->t_termios);
3210 error = tt_open(tp, dev);
3213 if (ISCALLOUT(dev) || (tt_modem(tp, 0, 0) & SER_DCD))
3217 * Wait for DCD if necessary.
3219 if (!(tp->t_state & TS_CARR_ON) && !ISCALLOUT(dev)
3220 && !(tp->t_cflag & CLOCAL) && !(flag & O_NONBLOCK)) {
3222 error = tsleep(TSA_CARR_ON(tp), TTIPRI | PCATCH, "ttydcd", 0);
3224 if (error != 0 || (tp->t_state & TS_GONE))
3228 error = ttyld_open(tp, dev);
3230 if (tp->t_state & TS_ISOPEN && ISCALLOUT(dev))
3231 tp->t_actout = TRUE;
3234 if (!(tp->t_state & TS_ISOPEN) && tp->t_wopeners == 0)
3240 ttyclose(struct cdev *dev, int flag, int mode, struct thread *td)
3245 ttyld_close(tp, flag);
3248 tp->t_do_timestamp = 0;
3249 if (tp->t_pps != NULL)
3250 tp->t_pps->ppsparam.mode = 0;
3256 ttyread(struct cdev *dev, struct uio *uio, int flag)
3260 tp = tty_gettp(dev);
3262 if (tp == NULL || (tp->t_state & TS_GONE))
3264 return (ttyld_read(tp, uio, flag));
3268 ttywrite(struct cdev *dev, struct uio *uio, int flag)
3272 tp = tty_gettp(dev);
3274 if (tp == NULL || (tp->t_state & TS_GONE))
3276 return (ttyld_write(tp, uio, flag));
3280 ttyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
3287 if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
3289 struct termios *dt = (struct termios *)data;
3290 struct termios *lt =
3291 ISCALLOUT(dev) ? &tp->t_lock_out : &tp->t_lock_in;
3293 dt->c_iflag = (tp->t_iflag & lt->c_iflag)
3294 | (dt->c_iflag & ~lt->c_iflag);
3295 dt->c_oflag = (tp->t_oflag & lt->c_oflag)
3296 | (dt->c_oflag & ~lt->c_oflag);
3297 dt->c_cflag = (tp->t_cflag & lt->c_cflag)
3298 | (dt->c_cflag & ~lt->c_cflag);
3299 dt->c_lflag = (tp->t_lflag & lt->c_lflag)
3300 | (dt->c_lflag & ~lt->c_lflag);
3301 for (cc = 0; cc < NCCS; ++cc)
3302 if (lt->c_cc[cc] != 0)
3303 dt->c_cc[cc] = tp->t_cc[cc];
3304 if (lt->c_ispeed != 0)
3305 dt->c_ispeed = tp->t_ispeed;
3306 if (lt->c_ospeed != 0)
3307 dt->c_ospeed = tp->t_ospeed;
3310 error = ttyld_ioctl(tp, cmd, data, flag, td);
3311 if (error == ENOIOCTL)
3312 error = ttioctl(tp, cmd, data, flag);
3314 if (error != ENOIOCTL)
3320 ttyldoptim(struct tty *tp)
3325 if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))
3326 && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK))
3327 && (!(t->c_iflag & PARMRK)
3328 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))
3329 && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))
3330 && linesw[tp->t_line]->l_rint == ttyinput)
3331 tp->t_state |= TS_CAN_BYPASS_L_RINT;
3333 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
3337 ttydtrwaitwakeup(void *arg)
3342 tp->t_state &= ~TS_DTR_WAIT;
3343 wakeup(&tp->t_dtr_wait);
3348 ttydtrwaitstart(struct tty *tp)
3351 if (tp->t_dtr_wait == 0)
3353 if (tp->t_state & TS_DTR_WAIT)
3355 timeout(ttydtrwaitwakeup, tp, tp->t_dtr_wait);
3356 tp->t_state |= TS_DTR_WAIT;
3360 ttydtrwaitsleep(struct tty *tp)
3365 while (error == 0) {
3366 if (tp->t_state & TS_GONE)
3368 else if (!(tp->t_state & TS_DTR_WAIT))
3371 error = tsleep(&tp->t_dtr_wait, TTIPRI | PCATCH,
3378 ttysopen(struct cdev *dev, int flag, int mode, struct thread *td)
3384 ("ttysopen(): no tty pointer on device (%s)", devtoname(dev)));
3385 if (tp->t_state & TS_GONE)
3391 ttysclose(struct cdev *dev, int flag, int mode, struct thread *td)
3398 ttysrdwr(struct cdev *dev, struct uio *uio, int flag)
3405 ttysioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
3413 ("ttysopen(): no tty pointer on device (%s)", devtoname(dev)));
3414 if (tp->t_state & TS_GONE)
3419 error = priv_check(td, PRIV_TTY_SETA);
3422 *ct = *(struct termios *)data;
3425 *(struct termios *)data = *ct;
3428 *(int *)data = TTYDISC;
3431 bzero(data, sizeof(struct winsize));
3434 if (tp->t_cioctl != NULL)
3435 return(tp->t_cioctl(dev, cmd, data, flag, td));
3441 * Initialize a tty to sane modes.
3444 ttyinitmode(struct tty *tp, int echo, int speed)
3448 speed = TTYDEF_SPEED;
3449 tp->t_init_in.c_iflag = TTYDEF_IFLAG;
3450 tp->t_init_in.c_oflag = TTYDEF_OFLAG;
3451 tp->t_init_in.c_cflag = TTYDEF_CFLAG;
3453 tp->t_init_in.c_lflag = TTYDEF_LFLAG_ECHO;
3455 tp->t_init_in.c_lflag = TTYDEF_LFLAG_NOECHO;
3457 tp->t_init_in.c_ispeed = tp->t_init_in.c_ospeed = speed;
3458 termioschars(&tp->t_init_in);
3459 tp->t_init_out = tp->t_init_in;
3460 tp->t_termios = tp->t_init_in;
3464 * Use more "normal" termios paramters for consoles.
3467 ttyconsolemode(struct tty *tp, int speed)
3471 speed = TTYDEF_SPEED;
3472 ttyinitmode(tp, 1, speed);
3473 tp->t_init_in.c_cflag |= CLOCAL;
3474 tp->t_lock_out.c_cflag = tp->t_lock_in.c_cflag = CLOCAL;
3475 tp->t_lock_out.c_ispeed = tp->t_lock_out.c_ospeed =
3476 tp->t_lock_in.c_ispeed = tp->t_lock_in.c_ospeed = speed;
3477 tp->t_init_out = tp->t_init_in;
3478 tp->t_termios = tp->t_init_in;
3483 * Record the relationship between the serial ports notion of modem control
3484 * signals and the one used in certain ioctls in a way the compiler can enforce
3485 * XXX: We should define TIOCM_* in terms of SER_ if we can limit the
3486 * XXX: consequences of the #include work that would take.
3488 CTASSERT(SER_DTR == TIOCM_DTR / 2);
3489 CTASSERT(SER_RTS == TIOCM_RTS / 2);
3490 CTASSERT(SER_STX == TIOCM_ST / 2);
3491 CTASSERT(SER_SRX == TIOCM_SR / 2);
3492 CTASSERT(SER_CTS == TIOCM_CTS / 2);
3493 CTASSERT(SER_DCD == TIOCM_DCD / 2);
3494 CTASSERT(SER_RI == TIOCM_RI / 2);
3495 CTASSERT(SER_DSR == TIOCM_DSR / 2);