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 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * @(#)tty.c 8.8 (Berkeley) 1/21/94
39 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
40 * $DragonFly: src/sys/kern/tty.c,v 1.11 2004/05/17 07:12:31 dillon Exp $
45 * o Fix races for sending the start char in ttyflush().
46 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
47 * With luck, there will be MIN chars before select() returns().
48 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
49 * o Don't allow input in TS_ZOMBIE case. It would be visible through
51 * o Do the new sio locking stuff here and use it to avoid special
54 * o Move EXTPROC and/or PENDIN to t_state?
55 * o Wrap most of ttioctl in spltty/splx.
56 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
57 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
58 * o Don't allow certain termios flags to affect disciplines other
59 * than TTYDISC. Cancel their effects before switch disciplines
60 * and ignore them if they are set while we are in another
62 * o Now that historical speed conversions are handled here, don't
64 * o Check for TS_CARR_ON being set while everything is closed and not
65 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
66 * so it would live until the next open even if carrier drops.
67 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
68 * only when _all_ openers leave open().
71 #include "opt_compat.h"
72 #include "opt_uconsole.h"
74 #include <sys/param.h>
75 #include <sys/systm.h>
76 #include <sys/filio.h>
77 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
78 #include <sys/ioctl_compat.h>
84 #include <sys/fcntl.h>
86 #include <sys/dkstat.h>
88 #include <sys/kernel.h>
89 #include <sys/vnode.h>
90 #include <sys/signalvar.h>
91 #include <sys/resourcevar.h>
92 #include <sys/malloc.h>
93 #include <sys/filedesc.h>
94 #include <sys/sysctl.h>
95 #include <sys/thread2.h>
100 #include <vm/vm_map.h>
102 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
104 static int proc_compare (struct proc *p1, struct proc *p2);
105 static int ttnread (struct tty *tp);
106 static void ttyecho (int c, struct tty *tp);
107 static int ttyoutput (int c, struct tty *tp);
108 static void ttypend (struct tty *tp);
109 static void ttyretype (struct tty *tp);
110 static void ttyrub (int c, struct tty *tp);
111 static void ttyrubo (struct tty *tp, int cnt);
112 static void ttyunblock (struct tty *tp);
113 static int ttywflush (struct tty *tp);
114 static int filt_ttyread (struct knote *kn, long hint);
115 static void filt_ttyrdetach (struct knote *kn);
116 static int filt_ttywrite (struct knote *kn, long hint);
117 static void filt_ttywdetach (struct knote *kn);
120 * Table with character classes and parity. The 8th bit indicates parity,
121 * the 7th bit indicates the character is an alphameric or underscore (for
122 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
123 * are 0 then the character needs no special processing on output; classes
124 * other than 0 might be translated or (not currently) require delays.
126 #define E 0x00 /* Even parity. */
127 #define O 0x80 /* Odd parity. */
128 #define PARITY(c) (char_type[c] & O)
130 #define ALPHA 0x40 /* Alpha or underscore. */
131 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
133 #define CCLASSMASK 0x3f
134 #define CCLASS(c) (char_type[c] & CCLASSMASK)
139 #define NA ORDINARY | ALPHA
145 static u_char const char_type[] = {
146 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
147 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
148 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
149 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
150 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
151 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
152 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
153 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
154 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
155 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
156 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
157 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
158 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
159 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
160 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
161 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
163 * Meta chars; should be settable per character set;
164 * for now, treat them all as normal characters.
166 NA, NA, NA, NA, NA, NA, NA, NA,
167 NA, NA, NA, NA, NA, NA, NA, NA,
168 NA, NA, NA, NA, NA, NA, NA, NA,
169 NA, NA, NA, NA, NA, NA, NA, NA,
170 NA, NA, NA, NA, NA, NA, NA, NA,
171 NA, NA, NA, NA, NA, NA, NA, NA,
172 NA, NA, NA, NA, NA, NA, NA, NA,
173 NA, NA, NA, NA, NA, NA, NA, NA,
174 NA, NA, NA, NA, NA, NA, NA, NA,
175 NA, NA, NA, NA, NA, NA, NA, NA,
176 NA, NA, NA, NA, NA, NA, NA, NA,
177 NA, NA, NA, NA, NA, NA, NA, NA,
178 NA, NA, NA, NA, NA, NA, NA, NA,
179 NA, NA, NA, NA, NA, NA, NA, NA,
180 NA, NA, NA, NA, NA, NA, NA, NA,
181 NA, NA, NA, NA, NA, NA, NA, NA,
192 /* Macros to clear/set/test flags. */
193 #define SET(t, f) (t) |= (f)
194 #define CLR(t, f) (t) &= ~(f)
195 #define ISSET(t, f) ((t) & (f))
197 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
198 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
201 * list of struct tty where pstat(8) can pick it up with sysctl
203 static SLIST_HEAD(, tty) tty_list;
206 * Initial open of tty, or (re)entry to standard tty line discipline.
217 if (!ISSET(tp->t_state, TS_ISOPEN)) {
218 SET(tp->t_state, TS_ISOPEN);
219 if (ISSET(tp->t_cflag, CLOCAL))
220 SET(tp->t_state, TS_CONNECTED);
221 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
229 * Handle close() on a tty line: flush and set to initial state,
230 * bumping generation number so that pending read/write calls
231 * can detect recycling of the tty.
232 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
233 * and l_close() should have flushed, but we repeat the spltty() and
234 * the flush in case there are buggy callers.
242 funsetown(tp->t_sigio);
247 ttyflush(tp, FREAD | FWRITE);
248 clist_free_cblocks(&tp->t_canq);
249 clist_free_cblocks(&tp->t_outq);
250 clist_free_cblocks(&tp->t_rawq);
253 tp->t_line = TTYDISC;
255 tp->t_session = NULL;
261 #define FLUSHQ(q) { \
263 ndflush(q, (q)->c_cc); \
266 /* Is 'c' a line delimiter ("break" character)? */
267 #define TTBREAKC(c, lflag) \
268 ((c) == '\n' || (((c) == cc[VEOF] || \
269 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
270 (c) != _POSIX_VDISABLE))
273 * Process input of a single character received on a tty.
280 tcflag_t iflag, lflag;
285 * If input is pending take it first.
288 if (ISSET(lflag, PENDIN))
293 if (ISSET(lflag, ICANON)) {
303 * Block further input iff:
304 * current input > threshold AND input is available to user program
305 * AND input flow control is enabled and not yet invoked.
306 * The 3 is slop for PARMRK.
309 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
310 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
311 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
312 !ISSET(tp->t_state, TS_TBLOCK))
315 /* Handle exceptional conditions (break, parity, framing). */
317 err = (ISSET(c, TTY_ERRORMASK));
319 CLR(c, TTY_ERRORMASK);
320 if (ISSET(err, TTY_BI)) {
321 if (ISSET(iflag, IGNBRK))
323 if (ISSET(iflag, BRKINT)) {
324 ttyflush(tp, FREAD | FWRITE);
325 pgsignal(tp->t_pgrp, SIGINT, 1);
328 if (ISSET(iflag, PARMRK))
330 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
331 || ISSET(err, TTY_FE)) {
332 if (ISSET(iflag, IGNPAR))
334 else if (ISSET(iflag, PARMRK)) {
336 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
339 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
340 (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
341 (void)putc(c | TTY_QUOTE, &tp->t_rawq);
348 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
350 if (!ISSET(lflag, EXTPROC)) {
352 * Check for literal nexting very first
354 if (ISSET(tp->t_state, TS_LNCH)) {
356 CLR(tp->t_state, TS_LNCH);
359 * Scan for special characters. This code
360 * is really just a big case statement with
361 * non-constant cases. The bottom of the
362 * case statement is labeled ``endcase'', so goto
363 * it after a case match, or similar.
367 * Control chars which aren't controlled
368 * by ICANON, ISIG, or IXON.
370 if (ISSET(lflag, IEXTEN)) {
371 if (CCEQ(cc[VLNEXT], c)) {
372 if (ISSET(lflag, ECHO)) {
373 if (ISSET(lflag, ECHOE)) {
374 (void)ttyoutput('^', tp);
375 (void)ttyoutput('\b', tp);
379 SET(tp->t_state, TS_LNCH);
382 if (CCEQ(cc[VDISCARD], c)) {
383 if (ISSET(lflag, FLUSHO))
384 CLR(tp->t_lflag, FLUSHO);
386 ttyflush(tp, FWRITE);
388 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
390 SET(tp->t_lflag, FLUSHO);
398 if (ISSET(lflag, ISIG)) {
399 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
400 if (!ISSET(lflag, NOFLSH))
401 ttyflush(tp, FREAD | FWRITE);
404 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
407 if (CCEQ(cc[VSUSP], c)) {
408 if (!ISSET(lflag, NOFLSH))
411 pgsignal(tp->t_pgrp, SIGTSTP, 1);
416 * Handle start/stop characters.
418 if (ISSET(iflag, IXON)) {
419 if (CCEQ(cc[VSTOP], c)) {
420 if (!ISSET(tp->t_state, TS_TTSTOP)) {
421 SET(tp->t_state, TS_TTSTOP);
422 (*tp->t_stop)(tp, 0);
425 if (!CCEQ(cc[VSTART], c))
428 * if VSTART == VSTOP then toggle
432 if (CCEQ(cc[VSTART], c))
436 * IGNCR, ICRNL, & INLCR
439 if (ISSET(iflag, IGNCR))
441 else if (ISSET(iflag, ICRNL))
443 } else if (c == '\n' && ISSET(iflag, INLCR))
446 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
448 * From here on down canonical mode character
449 * processing takes place.
452 * erase or erase2 (^H / ^?)
454 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
456 ttyrub(unputc(&tp->t_rawq), tp);
462 if (CCEQ(cc[VKILL], c)) {
463 if (ISSET(lflag, ECHOKE) &&
464 tp->t_rawq.c_cc == tp->t_rocount &&
465 !ISSET(lflag, ECHOPRT))
466 while (tp->t_rawq.c_cc)
467 ttyrub(unputc(&tp->t_rawq), tp);
470 if (ISSET(lflag, ECHOK) ||
471 ISSET(lflag, ECHOKE))
476 CLR(tp->t_state, TS_LOCAL);
482 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
488 while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
493 * erase last char of word and remember the
494 * next chars type (for ALTWERASE)
497 c = unputc(&tp->t_rawq);
500 if (c == ' ' || c == '\t') {
501 (void)putc(c, &tp->t_rawq);
510 c = unputc(&tp->t_rawq);
513 } while (c != ' ' && c != '\t' &&
514 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
515 (void)putc(c, &tp->t_rawq);
521 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
526 * ^T - kernel info and generate SIGINFO
528 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
529 if (ISSET(lflag, ISIG))
530 pgsignal(tp->t_pgrp, SIGINFO, 1);
531 if (!ISSET(lflag, NOKERNINFO))
535 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
536 if (ISSET(lflag, ISIG))
537 pgsignal(tp->t_pgrp, SIGCKPT, 1);
542 * Check for input buffer overflow
544 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
546 if (ISSET(iflag, IMAXBEL)) {
547 if (tp->t_outq.c_cc < tp->t_ohiwat)
548 (void)ttyoutput(CTRL('g'), tp);
553 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
554 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
555 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
558 * Put data char in q for user and
559 * wakeup on seeing a line delimiter.
561 if (putc(c, &tp->t_rawq) >= 0) {
562 if (!ISSET(lflag, ICANON)) {
567 if (TTBREAKC(c, lflag)) {
569 catq(&tp->t_rawq, &tp->t_canq);
571 } else if (tp->t_rocount++ == 0)
572 tp->t_rocol = tp->t_column;
573 if (ISSET(tp->t_state, TS_ERASE)) {
575 * end of prterase \.../
577 CLR(tp->t_state, TS_ERASE);
578 (void)ttyoutput('/', tp);
582 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
584 * Place the cursor over the '^' of the ^D.
586 i = imin(2, tp->t_column - i);
588 (void)ttyoutput('\b', tp);
595 * IXANY means allow any character to restart output.
597 if (ISSET(tp->t_state, TS_TTSTOP) &&
598 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
601 CLR(tp->t_lflag, FLUSHO);
602 CLR(tp->t_state, TS_TTSTOP);
604 return (ttstart(tp));
608 * Output a single character on a tty, doing output processing
609 * as needed (expanding tabs, newline processing, etc.).
610 * Returns < 0 if succeeds, otherwise returns char to resend.
622 if (!ISSET(oflag, OPOST)) {
623 if (ISSET(tp->t_lflag, FLUSHO))
625 if (putc(c, &tp->t_outq))
632 * Do tab expansion if OXTABS is set. Special case if we external
633 * processing, we don't do the tab expansion because we'll probably
634 * get it wrong. If tab expansion needs to be done, let it happen
637 CLR(c, ~TTY_CHARMASK);
639 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
640 c = 8 - (tp->t_column & 7);
641 if (!ISSET(tp->t_lflag, FLUSHO)) {
642 s = spltty(); /* Don't interrupt tabs. */
643 c -= b_to_q(" ", c, &tp->t_outq);
649 return (c ? -1 : '\t');
651 if (c == CEOT && ISSET(oflag, ONOEOT))
655 * Newline translation: if ONLCR is set,
656 * translate newline into "\r\n".
658 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
661 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
664 /* If OCRNL is set, translate "\r" into "\n". */
665 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
667 /* If ONOCR is set, don't transmit CRs when on column 0. */
668 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
673 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
685 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
695 col = (col + 8) & ~7;
703 * Ioctls for all tty devices. Called after line-discipline specific ioctl
704 * has been called to do discipline-specific functions and/or reject any
705 * of these ioctl commands.
709 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
711 struct thread *td = curthread;
712 struct proc *p = td->td_proc;
717 /* If the ioctl involves modification, hang if in the background. */
741 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
751 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
752 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
753 !SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
754 if (p->p_pgrp->pg_jobc == 0)
756 pgsignal(p->p_pgrp, SIGTTOU, 1);
757 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
765 switch (cmd) { /* Process the ioctl. */
766 case FIOASYNC: /* set/clear async i/o */
769 SET(tp->t_state, TS_ASYNC);
771 CLR(tp->t_state, TS_ASYNC);
774 case FIONBIO: /* set/clear non-blocking i/o */
775 break; /* XXX: delete. */
776 case FIONREAD: /* get # bytes to read */
778 *(int *)data = ttnread(tp);
784 * Policy -- Don't allow FIOSETOWN on someone else's
787 if (tp->t_session != NULL && !isctty(p, tp))
790 error = fsetown(*(int *)data, &tp->t_sigio);
795 if (tp->t_session != NULL && !isctty(p, tp))
797 *(int *)data = fgetown(tp->t_sigio);
800 case TIOCEXCL: /* set exclusive use of tty */
802 SET(tp->t_state, TS_XCLUDE);
805 case TIOCFLUSH: { /* flush buffers */
806 int flags = *(int *)data;
809 flags = FREAD | FWRITE;
811 flags &= FREAD | FWRITE;
815 case TIOCCONS: /* become virtual console */
817 if (constty && constty != tp &&
818 ISSET(constty->t_state, TS_CONNECTED))
821 if ((error = suser(td)) != 0)
825 } else if (tp == constty)
828 case TIOCDRAIN: /* wait till output drained */
833 case TIOCGETA: { /* get termios struct */
834 struct termios *t = (struct termios *)data;
836 bcopy(&tp->t_termios, t, sizeof(struct termios));
839 case TIOCGETD: /* get line discipline */
840 *(int *)data = tp->t_line;
842 case TIOCGWINSZ: /* get window size */
843 *(struct winsize *)data = tp->t_winsize;
845 case TIOCGPGRP: /* get pgrp of tty */
848 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
851 case TIOCHPCL: /* hang up on last close */
853 SET(tp->t_cflag, HUPCL);
857 case TIOCNXCL: /* reset exclusive use of tty */
859 CLR(tp->t_state, TS_XCLUDE);
862 case TIOCOUTQ: /* output queue size */
863 *(int *)data = tp->t_outq.c_cc;
865 case TIOCSETA: /* set termios struct */
866 case TIOCSETAW: /* drain output, set */
867 case TIOCSETAF: { /* drn out, fls in, set */
868 struct termios *t = (struct termios *)data;
870 if (t->c_ispeed == 0)
871 t->c_ispeed = t->c_ospeed;
872 if (t->c_ispeed == 0)
873 t->c_ispeed = tp->t_ospeed;
874 if (t->c_ispeed == 0)
877 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
883 if (cmd == TIOCSETAF)
886 if (!ISSET(t->c_cflag, CIGNORE)) {
888 * Set device hardware.
890 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
894 if (ISSET(t->c_cflag, CLOCAL) &&
895 !ISSET(tp->t_cflag, CLOCAL)) {
897 * XXX disconnections would be too hard to
898 * get rid of without this kludge. The only
899 * way to get rid of controlling terminals
900 * is to exit from the session leader.
902 CLR(tp->t_state, TS_ZOMBIE);
904 wakeup(TSA_CARR_ON(tp));
908 if ((ISSET(tp->t_state, TS_CARR_ON) ||
909 ISSET(t->c_cflag, CLOCAL)) &&
910 !ISSET(tp->t_state, TS_ZOMBIE))
911 SET(tp->t_state, TS_CONNECTED);
913 CLR(tp->t_state, TS_CONNECTED);
914 tp->t_cflag = t->c_cflag;
915 tp->t_ispeed = t->c_ispeed;
916 if (t->c_ospeed != 0)
917 tp->t_ospeed = t->c_ospeed;
920 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
922 if (ISSET(t->c_lflag, ICANON))
923 SET(tp->t_lflag, PENDIN);
926 * XXX we really shouldn't allow toggling
927 * ICANON while we're in a non-termios line
928 * discipline. Now we have to worry about
929 * panicing for a null queue.
931 if (tp->t_canq.c_cbreserved > 0 &&
932 tp->t_rawq.c_cbreserved > 0) {
933 catq(&tp->t_rawq, &tp->t_canq);
935 * XXX the queue limits may be
936 * different, so the old queue
937 * swapping method no longer works.
939 catq(&tp->t_canq, &tp->t_rawq);
941 CLR(tp->t_lflag, PENDIN);
945 tp->t_iflag = t->c_iflag;
946 tp->t_oflag = t->c_oflag;
948 * Make the EXTPROC bit read only.
950 if (ISSET(tp->t_lflag, EXTPROC))
951 SET(t->c_lflag, EXTPROC);
953 CLR(t->c_lflag, EXTPROC);
954 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
955 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
956 t->c_cc[VTIME] != tp->t_cc[VTIME])
958 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
962 case TIOCSETD: { /* set line discipline */
963 int t = *(int *)data;
964 dev_t device = tp->t_dev;
966 if ((u_int)t >= nlinesw)
968 if (t != tp->t_line) {
970 (*linesw[tp->t_line].l_close)(tp, flag);
971 error = (*linesw[t].l_open)(device, tp);
973 (void)(*linesw[tp->t_line].l_open)(device, tp);
982 case TIOCSTART: /* start output, like ^Q */
984 if (ISSET(tp->t_state, TS_TTSTOP) ||
985 ISSET(tp->t_lflag, FLUSHO)) {
986 CLR(tp->t_lflag, FLUSHO);
987 CLR(tp->t_state, TS_TTSTOP);
992 case TIOCSTI: /* simulate terminal input */
993 if ((flag & FREAD) == 0 && suser(td))
995 if (!isctty(p, tp) && suser(td))
998 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1001 case TIOCSTOP: /* stop output, like ^S */
1003 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1004 SET(tp->t_state, TS_TTSTOP);
1005 (*tp->t_stop)(tp, 0);
1009 case TIOCSCTTY: /* become controlling tty */
1010 /* Session ctty vnode pointer set in vnode layer. */
1011 if (!SESS_LEADER(p) ||
1012 ((p->p_session->s_ttyvp || tp->t_session) &&
1013 (tp->t_session != p->p_session)))
1015 tp->t_session = p->p_session;
1016 tp->t_pgrp = p->p_pgrp;
1017 p->p_session->s_ttyp = tp;
1018 p->p_flag |= P_CONTROLT;
1020 case TIOCSPGRP: { /* set pgrp of tty */
1021 struct pgrp *pgrp = pgfind(*(int *)data);
1025 else if (pgrp == NULL || pgrp->pg_session != p->p_session)
1030 case TIOCSTAT: /* simulate control-T */
1035 case TIOCSWINSZ: /* set window size */
1036 if (bcmp((caddr_t)&tp->t_winsize, data,
1037 sizeof (struct winsize))) {
1038 tp->t_winsize = *(struct winsize *)data;
1039 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1042 case TIOCSDRAINWAIT:
1046 tp->t_timeout = *(int *)data * hz;
1047 wakeup(TSA_OCOMPLETE(tp));
1048 wakeup(TSA_OLOWAT(tp));
1050 case TIOCGDRAINWAIT:
1051 *(int *)data = tp->t_timeout / hz;
1054 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1055 return (ttcompat(tp, cmd, data, flag));
1064 ttypoll(dev, events, td)
1074 if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
1075 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
1079 if (events & (POLLIN | POLLRDNORM)) {
1080 if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
1081 revents |= events & (POLLIN | POLLRDNORM);
1083 selrecord(td, &tp->t_rsel);
1085 if (events & (POLLOUT | POLLWRNORM)) {
1086 if ((tp->t_outq.c_cc <= tp->t_olowat &&
1087 ISSET(tp->t_state, TS_CONNECTED))
1088 || ISSET(tp->t_state, TS_ZOMBIE))
1089 revents |= events & (POLLOUT | POLLWRNORM);
1091 selrecord(td, &tp->t_wsel);
1097 static struct filterops ttyread_filtops =
1098 { 1, NULL, filt_ttyrdetach, filt_ttyread };
1099 static struct filterops ttywrite_filtops =
1100 { 1, NULL, filt_ttywdetach, filt_ttywrite };
1103 ttykqfilter(dev, kn)
1107 struct tty *tp = dev->si_tty;
1108 struct klist *klist;
1111 switch (kn->kn_filter) {
1113 klist = &tp->t_rsel.si_note;
1114 kn->kn_fop = &ttyread_filtops;
1117 klist = &tp->t_wsel.si_note;
1118 kn->kn_fop = &ttywrite_filtops;
1124 kn->kn_hook = (caddr_t)dev;
1127 SLIST_INSERT_HEAD(klist, kn, kn_selnext);
1134 filt_ttyrdetach(struct knote *kn)
1136 struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1139 SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
1144 filt_ttyread(struct knote *kn, long hint)
1146 struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1148 kn->kn_data = ttnread(tp);
1149 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1150 kn->kn_flags |= EV_EOF;
1153 return (kn->kn_data > 0);
1157 filt_ttywdetach(struct knote *kn)
1159 struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1162 SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
1167 filt_ttywrite(kn, hint)
1171 struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1173 kn->kn_data = tp->t_outq.c_cc;
1174 if (ISSET(tp->t_state, TS_ZOMBIE))
1176 return (kn->kn_data <= tp->t_olowat &&
1177 ISSET(tp->t_state, TS_CONNECTED));
1181 * Must be called at spltty().
1189 if (ISSET(tp->t_lflag, PENDIN))
1191 nread = tp->t_canq.c_cc;
1192 if (!ISSET(tp->t_lflag, ICANON)) {
1193 nread += tp->t_rawq.c_cc;
1194 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1201 * Wait for output to drain.
1211 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1212 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1214 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1215 ISSET(tp->t_state, TS_CONNECTED)) {
1216 SET(tp->t_state, TS_SO_OCOMPLETE);
1217 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1221 if (error == EWOULDBLOCK)
1228 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1235 * Flush if successfully wait.
1243 if ((error = ttywait(tp)) == 0)
1244 ttyflush(tp, FREAD);
1249 * Flush tty read and/or write queues, notifying anyone waiting.
1263 FLUSHQ(&tp->t_outq);
1264 CLR(tp->t_state, TS_TTSTOP);
1266 (*tp->t_stop)(tp, rw);
1268 FLUSHQ(&tp->t_canq);
1269 FLUSHQ(&tp->t_rawq);
1270 CLR(tp->t_lflag, PENDIN);
1273 CLR(tp->t_state, TS_LOCAL);
1275 if (ISSET(tp->t_state, TS_TBLOCK)) {
1277 FLUSHQ(&tp->t_outq);
1281 * Don't let leave any state that might clobber the
1282 * next line discipline (although we should do more
1283 * to send the START char). Not clearing the state
1284 * may have caused the "putc to a clist with no
1285 * reserved cblocks" panic/printf.
1287 CLR(tp->t_state, TS_TBLOCK);
1289 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1290 if (ISSET(tp->t_iflag, IXOFF)) {
1292 * XXX wait a bit in the hope that the stop
1293 * character (if any) will go out. Waiting
1294 * isn't good since it allows races. This
1295 * will be fixed when the stop character is
1296 * put in a special queue. Don't bother with
1297 * the checks in ttywait() since the timeout
1300 SET(tp->t_state, TS_SO_OCOMPLETE);
1301 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1304 * Don't try sending the stop character again.
1306 CLR(tp->t_state, TS_TBLOCK);
1313 FLUSHQ(&tp->t_outq);
1320 * Copy in the default termios characters.
1327 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1338 termioschars(&tp->t_termios);
1342 * Handle input high water. Send stop character for the IXOFF case. Turn
1343 * on our input flow control bit and propagate the changes to the driver.
1344 * XXX the stop character should be put in a special high priority queue.
1351 SET(tp->t_state, TS_TBLOCK);
1352 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1353 putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1354 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1359 * Handle input low water. Send start character for the IXOFF case. Turn
1360 * off our input flow control bit and propagate the changes to the driver.
1361 * XXX the start character should be put in a special high priority queue.
1368 CLR(tp->t_state, TS_TBLOCK);
1369 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1370 putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1371 SET(tp->t_state, TS_TBLOCK); /* try again later */
1376 /* Not used by any current (i386) drivers. */
1378 * Restart after an inter-char delay.
1387 KASSERT(tp_arg != NULL, ("ttrstrt"));
1392 CLR(tp->t_state, TS_TIMEOUT);
1404 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1410 * "close" a line discipline
1418 if (flag & FNONBLOCK || ttywflush(tp))
1419 ttyflush(tp, FREAD | FWRITE);
1424 * Handle modem control transition on a tty.
1425 * Flag indicates new state of carrier.
1426 * Returns 0 if the line should be turned off, otherwise 1.
1434 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1436 * MDMBUF: do flow control according to carrier flag
1437 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1438 * works if IXON and IXANY are clear.
1441 CLR(tp->t_state, TS_CAR_OFLOW);
1442 CLR(tp->t_state, TS_TTSTOP);
1444 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1445 SET(tp->t_state, TS_CAR_OFLOW);
1446 SET(tp->t_state, TS_TTSTOP);
1447 (*tp->t_stop)(tp, 0);
1449 } else if (flag == 0) {
1453 CLR(tp->t_state, TS_CARR_ON);
1454 if (ISSET(tp->t_state, TS_ISOPEN) &&
1455 !ISSET(tp->t_cflag, CLOCAL)) {
1456 SET(tp->t_state, TS_ZOMBIE);
1457 CLR(tp->t_state, TS_CONNECTED);
1458 if (tp->t_session && tp->t_session->s_leader)
1459 psignal(tp->t_session->s_leader, SIGHUP);
1460 ttyflush(tp, FREAD | FWRITE);
1467 SET(tp->t_state, TS_CARR_ON);
1468 if (!ISSET(tp->t_state, TS_ZOMBIE))
1469 SET(tp->t_state, TS_CONNECTED);
1470 wakeup(TSA_CARR_ON(tp));
1478 * Reinput pending characters after state switch
1488 CLR(tp->t_lflag, PENDIN);
1489 SET(tp->t_state, TS_TYPEN);
1491 * XXX this assumes too much about clist internals. It may even
1492 * fail if the cblock slush pool is empty. We can't allocate more
1493 * cblocks here because we are called from an interrupt handler
1494 * and clist_alloc_cblocks() can wait.
1497 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1498 tp->t_rawq.c_cbmax = tq.c_cbmax;
1499 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1500 while ((c = getc(&tq)) >= 0)
1502 CLR(tp->t_state, TS_TYPEN);
1506 * Process a read call on a tty device.
1509 ttread(tp, uio, flag)
1517 cc_t *cc = tp->t_cc;
1518 struct proc *p = curproc;
1519 int s, first, error = 0;
1520 int has_stime = 0, last_cc = 0;
1521 long slp = 0; /* XXX this should be renamed `timo'. */
1522 struct timeval stime;
1526 lflag = tp->t_lflag;
1528 * take pending input first
1530 if (ISSET(lflag, PENDIN)) {
1532 splx(s); /* reduce latency */
1534 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1538 * Hang process if it's in the background.
1540 if (isbackground(p, tp)) {
1542 if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
1543 SIGISMEMBER(p->p_sigmask, SIGTTIN) ||
1544 (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0)
1546 pgsignal(p->p_pgrp, SIGTTIN, 1);
1547 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1553 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1555 return (0); /* EOF */
1559 * If canonical, use the canonical queue,
1560 * else use the raw queue.
1562 * (should get rid of clists...)
1564 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1566 if (flag & IO_NDELAY) {
1569 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1574 return (EWOULDBLOCK);
1576 if (!ISSET(lflag, ICANON)) {
1579 struct timeval timecopy;
1582 * Check each of the four combinations.
1583 * (m > 0 && t == 0) is the normal read case.
1584 * It should be fairly efficient, so we check that and its
1585 * companion case (m == 0 && t == 0) first.
1586 * For the other two cases, we compute the target sleep time
1595 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1599 t *= 100000; /* time in us */
1600 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1601 ((t1).tv_usec - (t2).tv_usec))
1607 getmicrotime(&timecopy);
1609 /* first character, start timer */
1613 } else if (qp->c_cc > last_cc) {
1614 /* got a character, restart timer */
1618 /* nothing, check expiration */
1619 slp = t - diff(timecopy, stime);
1624 } else { /* m == 0 */
1627 getmicrotime(&timecopy);
1633 slp = t - diff(timecopy, stime);
1635 /* Timed out, but 0 is enough input. */
1643 * Rounding down may make us wake up just short
1644 * of the target, so we round up.
1645 * The formula is ceiling(slp * hz/1000000).
1646 * 32-bit arithmetic is enough for hz < 169.
1647 * XXX see tvtohz() for how to avoid overflow if hz
1648 * is large (divide by `tick' and/or arrange to
1649 * use tvtohz() if hz is large).
1651 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1654 if (qp->c_cc <= 0) {
1657 * There is no input, or not enough input and we can block.
1659 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1660 ISSET(tp->t_state, TS_CONNECTED) ?
1661 "ttyin" : "ttyhup", (int)slp);
1663 if (error == EWOULDBLOCK)
1668 * XXX what happens if another process eats some input
1669 * while we are asleep (not just here)? It would be
1670 * safest to detect changes and reset our state variables
1671 * (has_stime and last_cc).
1679 * Input present, check for input mapping and processing.
1682 if (ISSET(lflag, ICANON | ISIG))
1688 icc = imin(uio->uio_resid, IBUFSIZ);
1689 icc = q_to_b(qp, ibuf, icc);
1695 error = uiomove(ibuf, icc, uio);
1697 * XXX if there was an error then we should ungetc() the
1698 * unmoved chars and reduce icc here.
1702 if (uio->uio_resid == 0)
1716 * delayed suspend (^Y)
1718 if (CCEQ(cc[VDSUSP], c) &&
1719 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1720 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1722 error = ttysleep(tp, &lbolt, PCATCH,
1731 * Interpret EOF only in canonical mode.
1733 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1736 * Give user character.
1738 error = ureadc(c, uio);
1740 /* XXX should ungetc(c, qp). */
1742 if (uio->uio_resid == 0)
1745 * In canonical mode check for a "break character"
1746 * marking the end of a "line of input".
1748 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1755 * Look to unblock input now that (presumably)
1756 * the input queue has gone down.
1759 if (ISSET(tp->t_state, TS_TBLOCK) &&
1760 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1768 * Check the output queue on tp for space for a kernel message (from uprintf
1769 * or tprintf). Allow some space over the normal hiwater mark so we don't
1770 * lose messages due to normal flow control, but don't let the tty run amok.
1771 * Sleeps here are not interruptible, but we return prematurely if new signals
1775 ttycheckoutq(tp, wait)
1782 hiwat = tp->t_ohiwat;
1783 SIGEMPTYSET(oldmask);
1786 oldmask = curproc->p_siglist;
1787 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
1788 while (tp->t_outq.c_cc > hiwat) {
1790 if (tp->t_outq.c_cc <= hiwat)
1792 if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
1796 SET(tp->t_state, TS_SO_OLOWAT);
1797 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
1804 * Process a write call on a tty device.
1807 ttwrite(tp, uio, flag)
1815 int i, hiwat, cnt, error, s;
1818 hiwat = tp->t_ohiwat;
1819 cnt = uio->uio_resid;
1824 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1826 if (uio->uio_resid == cnt)
1830 if (!ISSET(tp->t_state, TS_CONNECTED)) {
1831 if (flag & IO_NDELAY) {
1833 error = EWOULDBLOCK;
1836 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
1844 * Hang the process if it's in the background.
1847 if (isbackground(p, tp) &&
1848 ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
1849 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
1850 !SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
1851 if (p->p_pgrp->pg_jobc == 0) {
1855 pgsignal(p->p_pgrp, SIGTTOU, 1);
1856 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
1862 * Process the user's data in at most OBUFSIZ chunks. Perform any
1863 * output translation. Keep track of high water mark, sleep on
1864 * overflow awaiting device aid in acquiring new space.
1866 while (uio->uio_resid > 0 || cc > 0) {
1867 if (ISSET(tp->t_lflag, FLUSHO)) {
1871 if (tp->t_outq.c_cc > hiwat)
1874 * Grab a hunk of data from the user, unless we have some
1875 * leftover from last time.
1878 cc = imin(uio->uio_resid, OBUFSIZ);
1880 error = uiomove(cp, cc, uio);
1887 * If nothing fancy need be done, grab those characters we
1888 * can handle without any of ttyoutput's processing and
1889 * just transfer them to the output q. For those chars
1890 * which require special processing (as indicated by the
1891 * bits in char_type), call ttyoutput. After processing
1892 * a hunk of data, look for FLUSHO so ^O's will take effect
1896 if (!ISSET(tp->t_oflag, OPOST))
1899 ce = cc - scanc((u_int)cc, (u_char *)cp,
1900 char_type, CCLASSMASK);
1902 * If ce is zero, then we're processing
1903 * a special character through ttyoutput.
1907 if (ttyoutput(*cp, tp) >= 0) {
1908 /* No Clists, wait a bit. */
1910 if (flag & IO_NDELAY) {
1911 error = EWOULDBLOCK;
1914 error = ttysleep(tp, &lbolt,
1923 if (ISSET(tp->t_lflag, FLUSHO) ||
1924 tp->t_outq.c_cc > hiwat)
1930 * A bunch of normal characters have been found.
1931 * Transfer them en masse to the output queue and
1932 * continue processing at the top of the loop.
1933 * If there are any further characters in this
1934 * <= OBUFSIZ chunk, the first should be a character
1935 * requiring special handling by ttyoutput.
1938 i = b_to_q(cp, ce, &tp->t_outq);
1941 cp += ce, cc -= ce, tk_nout += ce;
1944 /* No Clists, wait a bit. */
1946 if (flag & IO_NDELAY) {
1947 error = EWOULDBLOCK;
1950 error = ttysleep(tp, &lbolt, PCATCH,
1956 if (ISSET(tp->t_lflag, FLUSHO) ||
1957 tp->t_outq.c_cc > hiwat)
1964 * If cc is nonzero, we leave the uio structure inconsistent, as the
1965 * offset and iov pointers have moved forward, but it doesn't matter
1966 * (the call will either return short or restart with a new uio).
1968 uio->uio_resid += cc;
1975 * This can only occur if FLUSHO is set in t_lflag,
1976 * or if ttstart/oproc is synchronous (or very fast).
1978 if (tp->t_outq.c_cc <= hiwat) {
1982 if (flag & IO_NDELAY) {
1984 uio->uio_resid += cc;
1985 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
1987 SET(tp->t_state, TS_SO_OLOWAT);
1988 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
1990 if (error == EWOULDBLOCK)
1998 * Rubout one character from the rawq of tp
1999 * as cleanly as possible.
2010 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2012 CLR(tp->t_lflag, FLUSHO);
2013 if (ISSET(tp->t_lflag, ECHOE)) {
2014 if (tp->t_rocount == 0) {
2016 * Screwed by ttwrite; retype
2021 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2024 CLR(c, ~TTY_CHARMASK);
2025 switch (CCLASS(c)) {
2034 if (ISSET(tp->t_lflag, ECHOCTL))
2038 if (tp->t_rocount < tp->t_rawq.c_cc) {
2043 savecol = tp->t_column;
2044 SET(tp->t_state, TS_CNTTB);
2045 SET(tp->t_lflag, FLUSHO);
2046 tp->t_column = tp->t_rocol;
2047 cp = tp->t_rawq.c_cf;
2049 tabc = *cp; /* XXX FIX NEXTC */
2050 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2052 CLR(tp->t_lflag, FLUSHO);
2053 CLR(tp->t_state, TS_CNTTB);
2056 /* savecol will now be length of the tab. */
2057 savecol -= tp->t_column;
2058 tp->t_column += savecol;
2060 savecol = 8; /* overflow screw */
2061 while (--savecol >= 0)
2062 (void)ttyoutput('\b', tp);
2065 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2066 (void)printf(PANICSTR, c, CCLASS(c));
2068 panic(PANICSTR, c, CCLASS(c));
2072 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2073 if (!ISSET(tp->t_state, TS_ERASE)) {
2074 SET(tp->t_state, TS_ERASE);
2075 (void)ttyoutput('\\', tp);
2079 ttyecho(tp->t_cc[VERASE], tp);
2081 * This code may be executed not only when an ERASE key
2082 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2083 * So, I didn't think it was worthwhile to pass the extra
2084 * information (which would need an extra parameter,
2085 * changing every call) needed to distinguish the ERASE2
2086 * case from the ERASE.
2093 * Back over cnt characters, erasing them.
2102 (void)ttyoutput('\b', tp);
2103 (void)ttyoutput(' ', tp);
2104 (void)ttyoutput('\b', tp);
2110 * Reprint the rawq line. Note, it is assumed that c_cc has already
2120 /* Echo the reprint character. */
2121 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2122 ttyecho(tp->t_cc[VREPRINT], tp);
2124 (void)ttyoutput('\n', tp);
2128 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2129 * BIT OF FIRST CHAR.
2132 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2133 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2135 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2136 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2138 CLR(tp->t_state, TS_ERASE);
2141 tp->t_rocount = tp->t_rawq.c_cc;
2146 * Echo a typed character to the terminal.
2154 if (!ISSET(tp->t_state, TS_CNTTB))
2155 CLR(tp->t_lflag, FLUSHO);
2156 if ((!ISSET(tp->t_lflag, ECHO) &&
2157 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2158 ISSET(tp->t_lflag, EXTPROC))
2160 if (ISSET(tp->t_lflag, ECHOCTL) &&
2161 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2162 ISSET(c, TTY_CHARMASK) == 0177)) {
2163 (void)ttyoutput('^', tp);
2164 CLR(c, ~TTY_CHARMASK);
2170 (void)ttyoutput(c, tp);
2174 * Wake up any readers on a tty.
2181 if (tp->t_rsel.si_pid != 0)
2182 selwakeup(&tp->t_rsel);
2183 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2184 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2185 wakeup(TSA_HUP_OR_INPUT(tp));
2186 KNOTE(&tp->t_rsel.si_note, 0);
2190 * Wake up any writers on a tty.
2197 if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat)
2198 selwakeup(&tp->t_wsel);
2199 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2200 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2201 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2202 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2203 CLR(tp->t_state, TS_SO_OCOMPLETE);
2204 wakeup(TSA_OCOMPLETE(tp));
2206 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2207 tp->t_outq.c_cc <= tp->t_olowat) {
2208 CLR(tp->t_state, TS_SO_OLOWAT);
2209 wakeup(TSA_OLOWAT(tp));
2211 KNOTE(&tp->t_wsel.si_note, 0);
2215 * Look up a code for a specified speed in a conversion table;
2216 * used by drivers to map software speed values to hardware parameters.
2219 ttspeedtab(speed, table)
2221 struct speedtab *table;
2224 for ( ; table->sp_speed != -1; table++)
2225 if (table->sp_speed == speed)
2226 return (table->sp_code);
2231 * Set input and output watermarks and buffer sizes. For input, the
2232 * high watermark is about one second's worth of input above empty, the
2233 * low watermark is slightly below high water, and the buffer size is a
2234 * driver-dependent amount above high water. For output, the watermarks
2235 * are near the ends of the buffer, with about 1 second's worth of input
2236 * between them. All this only applies to the standard line discipline.
2242 int cps, ttmaxhiwat, x;
2245 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2246 switch (tp->t_ispeedwat) {
2248 cps = tp->t_ispeed / 10;
2252 * This case is for old drivers that don't know about
2253 * t_ispeedwat. Arrange for them to get the old buffer
2254 * sizes and watermarks.
2256 cps = TTYHOG - 2 * 256;
2257 tp->t_ififosize = 2 * 256;
2260 cps = tp->t_ispeedwat / 10;
2264 tp->t_ilowat = 7 * cps / 8;
2265 x = cps + tp->t_ififosize;
2266 clist_alloc_cblocks(&tp->t_rawq, x, x);
2269 switch (tp->t_ospeedwat) {
2271 cps = tp->t_ospeed / 10;
2272 ttmaxhiwat = 2 * TTMAXHIWAT;
2275 cps = tp->t_ospeed / 10;
2276 ttmaxhiwat = TTMAXHIWAT;
2279 cps = tp->t_ospeedwat / 10;
2280 ttmaxhiwat = 8 * TTMAXHIWAT;
2283 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2284 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2286 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2287 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2288 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2290 clist_alloc_cblocks(&tp->t_outq, x, x);
2295 * Report on state of foreground process group.
2301 struct proc *p, *pick;
2302 struct timeval utime, stime;
2305 if (ttycheckoutq(tp,0) == 0)
2309 * We always print the load average, then figure out what else to
2310 * print based on the state of the current process group.
2312 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2313 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2315 if (tp->t_session == NULL) {
2316 ttyprintf(tp, "not a controlling terminal\n");
2317 } else if (tp->t_pgrp == NULL) {
2318 ttyprintf(tp, "no foreground process group\n");
2319 } else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
2320 ttyprintf(tp, "empty foreground process group\n");
2323 * Pick an interesting process. Note that certain elements,
2324 * in particular the wmesg, require a critical section for
2325 * safe access (YYY and we are still not MP safe).
2327 * NOTE: p_wmesg is p_thread->td_wmesg, and p_comm is
2328 * p_thread->td_comm.
2338 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist)) {
2339 if (proc_compare(pick, p))
2344 * Figure out what wait/process-state message, and command
2347 if (pick->p_thread == NULL)
2349 else if (pick->p_stat == SRUN)
2351 else if (pick->p_wmesg) /* p_thread must not be NULL */
2352 str = pick->p_wmesg;
2356 snprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2357 (pick->p_thread ? pick->p_comm : "?"),
2361 * Calculate cpu usage, percent cpu, and cmsz. Note that
2362 * 'pick' becomes invalid the moment we exit the critical
2365 if (pick->p_thread && (pick->p_flag & P_INMEM)) {
2366 calcru(pick, &utime, &stime, NULL);
2372 pctcpu = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2374 if (pick->p_stat == SIDL || pick->p_stat == SZOMB)
2377 vmsz = pgtok(vmspace_resident_count(pick->p_vmspace));
2384 ttyprintf(tp, " %s ", buf);
2386 ttyprintf(tp, "%ld.%02ldu ",
2387 utime.tv_sec, utime.tv_usec / 10000);
2388 ttyprintf(tp, "%ld.%02lds ",
2389 stime.tv_sec, stime.tv_usec / 10000);
2391 ttyprintf(tp, "?.??u ?.??s ");
2393 ttyprintf(tp, "%d%% %ldk\n", pctcpu / 100, vmsz);
2395 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2399 * Returns 1 if p2 is "better" than p1
2401 * The algorithm for picking the "interesting" process is thus:
2403 * 1) Only foreground processes are eligible - implied.
2404 * 2) Runnable processes are favored over anything else. The runner
2405 * with the highest cpu utilization is picked (p_estcpu). Ties are
2406 * broken by picking the highest pid.
2407 * 3) The sleeper with the shortest sleep time is next. With ties,
2408 * we pick out just "short-term" sleepers (P_SINTR == 0).
2409 * 4) Further ties are broken by picking the highest pid.
2411 #define ISRUN(p) (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
2412 #define TESTAB(a, b) ((a)<<1 | (b))
2418 proc_compare(p1, p2)
2419 struct proc *p1, *p2;
2425 * see if at least one of them is runnable
2427 switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
2434 * tie - favor one with highest recent cpu utilization
2436 if (p2->p_estcpu > p1->p_estcpu)
2438 if (p1->p_estcpu > p2->p_estcpu)
2440 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2445 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2451 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2454 * pick the one with the smallest sleep time
2456 if (p2->p_slptime > p1->p_slptime)
2458 if (p1->p_slptime > p2->p_slptime)
2461 * favor one sleeping in a non-interruptible sleep
2463 if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
2465 if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
2467 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2471 * Output char to tty; console putchar style.
2481 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2486 (void)ttyoutput('\r', tp);
2487 (void)ttyoutput(c, tp);
2494 * Sleep on chan, returning ERESTART if tty changed while we napped and
2495 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2496 * the tty is revoked, restarting a pending call will redo validation done
2497 * at the start of the call.
2500 ttysleep(tp, chan, slpflags, wmesg, timo)
2510 error = tsleep(chan, slpflags, wmesg, timo);
2513 return (tp->t_gen == gen ? 0 : ERESTART);
2517 * Allocate a tty struct. Clists in the struct will be allocated by
2527 tp = malloc(sizeof *tp, M_TTYS, M_WAITOK);
2528 bzero(tp, sizeof *tp);
2533 #if 0 /* XXX not yet usable: session leader holds a ref (see kern_exit.c). */
2535 * Free a tty struct. Clists in the struct should have been freed by
2550 SLIST_INSERT_HEAD(&tty_list, tp, t_list);
2554 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2558 SLIST_FOREACH(tp, &tty_list, t_list) {
2561 t.t_dev = (dev_t)dev2udev(t.t_dev);
2562 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2569 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2570 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2582 ttyread(dev, uio, flag)
2592 return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
2596 ttywrite(dev, uio, flag)
2606 return ((*linesw[tp->t_line].l_write)(tp, uio, flag));