4 * Copyright (c) 1982, 1986, 1990, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by the University of
23 * California, Berkeley and its contributors.
24 * 4. Neither the name of the University nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 * @(#)tty.c 8.8 (Berkeley) 1/21/94
41 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
42 * $DragonFly: src/sys/kern/tty.c,v 1.46 2008/09/10 09:50:09 y0netan1 Exp $
47 * Almost all functions in this file are acquiring the tty token due to their
48 * access and modifications of the 'tp' (struct tty) objects.
53 * o Fix races for sending the start char in ttyflush().
54 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
55 * With luck, there will be MIN chars before select() returns().
56 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
57 * o Don't allow input in TS_ZOMBIE case. It would be visible through
59 * o Do the new sio locking stuff here and use it to avoid special
62 * o Move EXTPROC and/or PENDIN to t_state?
63 * o Wrap most of ttioctl in spltty/splx.
64 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
65 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
66 * o Don't allow certain termios flags to affect disciplines other
67 * than TTYDISC. Cancel their effects before switch disciplines
68 * and ignore them if they are set while we are in another
70 * o Now that historical speed conversions are handled here, don't
72 * o Check for TS_CARR_ON being set while everything is closed and not
73 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
74 * so it would live until the next open even if carrier drops.
75 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
76 * only when _all_ openers leave open().
79 #include "opt_compat.h"
80 #include "opt_uconsole.h"
82 #include <sys/param.h>
83 #include <sys/systm.h>
84 #include <sys/filio.h>
85 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
86 #include <sys/ioctl_compat.h>
92 #include <sys/clist.h>
94 #include <sys/fcntl.h>
96 #include <sys/dkstat.h>
97 #include <sys/kernel.h>
98 #include <sys/vnode.h>
99 #include <sys/signalvar.h>
100 #include <sys/signal2.h>
101 #include <sys/resourcevar.h>
102 #include <sys/malloc.h>
103 #include <sys/filedesc.h>
104 #include <sys/sysctl.h>
105 #include <sys/thread2.h>
108 #include <sys/lock.h>
110 #include <vm/vm_map.h>
112 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
114 static int proc_compare (struct proc *p1, struct proc *p2);
115 static int ttnread (struct tty *tp);
116 static void ttyecho (int c, struct tty *tp);
117 static int ttyoutput (int c, struct tty *tp);
118 static void ttypend (struct tty *tp);
119 static void ttyretype (struct tty *tp);
120 static void ttyrub (int c, struct tty *tp);
121 static void ttyrubo (struct tty *tp, int cnt);
122 static void ttyunblock (struct tty *tp);
123 static int ttywflush (struct tty *tp);
124 static int filt_ttyread (struct knote *kn, long hint);
125 static void filt_ttyrdetach (struct knote *kn);
126 static int filt_ttywrite (struct knote *kn, long hint);
127 static void filt_ttywdetach (struct knote *kn);
130 * Table with character classes and parity. The 8th bit indicates parity,
131 * the 7th bit indicates the character is an alphameric or underscore (for
132 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
133 * are 0 then the character needs no special processing on output; classes
134 * other than 0 might be translated or (not currently) require delays.
136 #define E 0x00 /* Even parity. */
137 #define O 0x80 /* Odd parity. */
138 #define PARITY(c) (char_type[c] & O)
140 #define ALPHA 0x40 /* Alpha or underscore. */
141 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
143 #define CCLASSMASK 0x3f
144 #define CCLASS(c) (char_type[c] & CCLASSMASK)
149 #define NA ORDINARY | ALPHA
155 static u_char const char_type[] = {
156 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
157 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
158 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
159 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
160 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
161 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
162 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
163 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
164 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
165 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
166 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
167 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
168 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
169 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
170 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
171 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
173 * Meta chars; should be settable per character set;
174 * for now, treat them all as normal characters.
176 NA, NA, NA, NA, NA, NA, NA, NA,
177 NA, NA, NA, NA, NA, NA, NA, NA,
178 NA, NA, NA, NA, NA, NA, NA, NA,
179 NA, NA, NA, NA, NA, NA, NA, NA,
180 NA, NA, NA, NA, NA, NA, NA, NA,
181 NA, NA, NA, NA, NA, NA, NA, NA,
182 NA, NA, NA, NA, NA, NA, NA, NA,
183 NA, NA, NA, NA, NA, NA, NA, NA,
184 NA, NA, NA, NA, NA, NA, NA, NA,
185 NA, NA, NA, NA, NA, NA, NA, NA,
186 NA, NA, NA, NA, NA, NA, NA, NA,
187 NA, NA, NA, NA, NA, NA, NA, NA,
188 NA, NA, NA, NA, NA, NA, NA, NA,
189 NA, NA, NA, NA, NA, NA, NA, NA,
190 NA, NA, NA, NA, NA, NA, NA, NA,
191 NA, NA, NA, NA, NA, NA, NA, NA,
202 /* Macros to clear/set/test flags. */
203 #define SET(t, f) (t) |= (f)
204 #define CLR(t, f) (t) &= ~(f)
205 #define ISSET(t, f) ((t) & (f))
207 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
208 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
211 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
212 "LU", "TTY input statistic");
214 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
215 "LU", "TTY output statistic");
219 * list of struct tty where pstat(8) can pick it up with sysctl
221 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
224 * Initial open of tty, or (re)entry to standard tty line discipline.
227 ttyopen(cdev_t device, struct tty *tp)
230 lwkt_gettoken(&tty_token);
232 if (!ISSET(tp->t_state, TS_ISOPEN)) {
233 SET(tp->t_state, TS_ISOPEN);
234 if (ISSET(tp->t_cflag, CLOCAL)) {
235 SET(tp->t_state, TS_CONNECTED);
237 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
240 lwkt_reltoken(&tty_token);
246 * Handle close() on a tty line: flush and set to initial state,
247 * bumping generation number so that pending read/write calls
248 * can detect recycling of the tty.
250 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
251 * and l_close() should have flushed, but we repeat the spltty() and
252 * the flush in case there are buggy callers.
255 ttyclose(struct tty *tp)
258 lwkt_gettoken(&tty_token);
259 funsetown(tp->t_sigio);
263 ttyflush(tp, FREAD | FWRITE);
264 clist_free_cblocks(&tp->t_canq);
265 clist_free_cblocks(&tp->t_outq);
266 clist_free_cblocks(&tp->t_rawq);
269 tp->t_line = TTYDISC;
271 tp->t_state &= TS_REGISTERED; /* clear all bits except */
272 lwkt_reltoken(&tty_token);
278 * Disassociate the tty from its session. Traditionally this has only been
279 * a half-close, meaning that the session was still allowed to point at the
280 * tty (resulting in the tty in the ps command showing something like 'p0-'),
281 * even though the tty is no longer pointing at the session.
283 * The half close seems to be useful only for 'ps' output but there is as
284 * yet no reason to remove the feature. The full-close code is currently
285 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
288 ttyclearsession(struct tty *tp)
292 lwkt_gettoken(&tty_token);
294 if ((sp = tp->t_session) != NULL) {
295 tp->t_session = NULL;
296 #ifdef TTY_DO_FULL_CLOSE
297 /* FULL CLOSE (not yet) */
298 if (sp->s_ttyp == tp) {
302 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
303 "%p/%p\n", sp->s_ttyp, tp);
307 lwkt_reltoken(&tty_token);
311 * Release the tty vnode association for a session. This is the
312 * 'other half' of the close. Because multiple opens of /dev/tty
313 * only generate a single open to the actual tty, the file modes
314 * are locked to FREAD|FWRITE.
316 * If dorevoke is non-zero, the session is also revoked. We have to
317 * close the vnode if VCTTYISOPEN is set.
320 ttyclosesession(struct session *sp, int dorevoke)
324 lwkt_gettoken(&tty_token);
327 * There may not be a controlling terminal or it may have been closed
330 if ((vp = sp->s_ttyvp) == NULL) {
331 lwkt_reltoken(&tty_token);
336 * We need a lock if we have to close or revoke.
338 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
340 if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY)) {
346 * Retry if the vnode was ripped out from under us
348 if (vp != sp->s_ttyvp) {
355 * Close and revoke as needed
358 if (vp->v_flag & VCTTYISOPEN) {
359 vclrflags(vp, VCTTYISOPEN);
360 VOP_CLOSE(vp, FREAD|FWRITE);
364 vrevoke(vp, proc0.p_ucred);
370 lwkt_reltoken(&tty_token);
373 #define FLUSHQ(q) { \
375 ndflush(q, (q)->c_cc); \
378 /* Is 'c' a line delimiter ("break" character)? */
379 #define TTBREAKC(c, lflag) \
380 ((c) == '\n' || (((c) == cc[VEOF] || \
381 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
382 (c) != _POSIX_VDISABLE))
385 * Process input of a single character received on a tty.
388 ttyinput(int c, struct tty *tp)
390 tcflag_t iflag, lflag;
394 lwkt_gettoken(&tty_token);
396 * If input is pending take it first.
399 if (ISSET(lflag, PENDIN))
404 if (ISSET(lflag, ICANON))
411 * Block further input iff:
412 * current input > threshold AND input is available to user program
413 * AND input flow control is enabled and not yet invoked.
414 * The 3 is slop for PARMRK.
417 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
418 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
419 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
420 !ISSET(tp->t_state, TS_TBLOCK))
423 /* Handle exceptional conditions (break, parity, framing). */
425 err = (ISSET(c, TTY_ERRORMASK));
427 CLR(c, TTY_ERRORMASK);
428 if (ISSET(err, TTY_BI)) {
429 if (ISSET(iflag, IGNBRK)) {
430 lwkt_reltoken(&tty_token);
433 if (ISSET(iflag, BRKINT)) {
434 ttyflush(tp, FREAD | FWRITE);
435 pgsignal(tp->t_pgrp, SIGINT, 1);
438 if (ISSET(iflag, PARMRK))
440 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
441 || ISSET(err, TTY_FE)) {
442 if (ISSET(iflag, IGNPAR)) {
443 lwkt_reltoken(&tty_token);
446 else if (ISSET(iflag, PARMRK)) {
448 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
451 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
452 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
453 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
460 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
462 if (!ISSET(lflag, EXTPROC)) {
464 * Check for literal nexting very first
466 if (ISSET(tp->t_state, TS_LNCH)) {
468 CLR(tp->t_state, TS_LNCH);
471 * Scan for special characters. This code
472 * is really just a big case statement with
473 * non-constant cases. The bottom of the
474 * case statement is labeled ``endcase'', so goto
475 * it after a case match, or similar.
479 * Control chars which aren't controlled
480 * by ICANON, ISIG, or IXON.
482 if (ISSET(lflag, IEXTEN)) {
483 if (CCEQ(cc[VLNEXT], c)) {
484 if (ISSET(lflag, ECHO)) {
485 if (ISSET(lflag, ECHOE)) {
486 (void)ttyoutput('^', tp);
487 (void)ttyoutput('\b', tp);
491 SET(tp->t_state, TS_LNCH);
494 if (CCEQ(cc[VDISCARD], c)) {
495 if (ISSET(lflag, FLUSHO))
496 CLR(tp->t_lflag, FLUSHO);
498 ttyflush(tp, FWRITE);
500 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
502 SET(tp->t_lflag, FLUSHO);
510 if (ISSET(lflag, ISIG)) {
511 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
512 if (!ISSET(lflag, NOFLSH))
513 ttyflush(tp, FREAD | FWRITE);
516 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
519 if (CCEQ(cc[VSUSP], c)) {
520 if (!ISSET(lflag, NOFLSH))
523 pgsignal(tp->t_pgrp, SIGTSTP, 1);
528 * Handle start/stop characters.
530 if (ISSET(iflag, IXON)) {
531 if (CCEQ(cc[VSTOP], c)) {
532 if (!ISSET(tp->t_state, TS_TTSTOP)) {
533 SET(tp->t_state, TS_TTSTOP);
534 (*tp->t_stop)(tp, 0);
535 lwkt_reltoken(&tty_token);
538 if (!CCEQ(cc[VSTART], c)) {
539 lwkt_reltoken(&tty_token);
543 * if VSTART == VSTOP then toggle
547 if (CCEQ(cc[VSTART], c))
551 * IGNCR, ICRNL, & INLCR
554 if (ISSET(iflag, IGNCR)) {
555 lwkt_reltoken(&tty_token);
558 else if (ISSET(iflag, ICRNL))
560 } else if (c == '\n' && ISSET(iflag, INLCR))
563 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
565 * From here on down canonical mode character
566 * processing takes place.
569 * erase or erase2 (^H / ^?)
571 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
573 ttyrub(clist_unputc(&tp->t_rawq), tp);
579 if (CCEQ(cc[VKILL], c)) {
580 if (ISSET(lflag, ECHOKE) &&
581 tp->t_rawq.c_cc == tp->t_rocount &&
582 !ISSET(lflag, ECHOPRT))
583 while (tp->t_rawq.c_cc)
584 ttyrub(clist_unputc(&tp->t_rawq), tp);
587 if (ISSET(lflag, ECHOK) ||
588 ISSET(lflag, ECHOKE))
593 CLR(tp->t_state, TS_LOCAL);
599 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
605 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
610 * erase last char of word and remember the
611 * next chars type (for ALTWERASE)
614 c = clist_unputc(&tp->t_rawq);
617 if (c == ' ' || c == '\t') {
618 clist_putc(c, &tp->t_rawq);
627 c = clist_unputc(&tp->t_rawq);
630 } while (c != ' ' && c != '\t' &&
631 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
632 clist_putc(c, &tp->t_rawq);
638 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
643 * ^T - kernel info and generate SIGINFO
645 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
646 if (ISSET(lflag, ISIG))
647 pgsignal(tp->t_pgrp, SIGINFO, 1);
648 if (!ISSET(lflag, NOKERNINFO))
652 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
653 if (ISSET(lflag, ISIG))
654 pgsignal(tp->t_pgrp, SIGCKPT, 1);
659 * Check for input buffer overflow
661 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
663 if (ISSET(iflag, IMAXBEL)) {
664 if (tp->t_outq.c_cc < tp->t_ohiwat)
665 (void)ttyoutput(CTRL('g'), tp);
670 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
671 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
672 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
675 * Put data char in q for user and
676 * wakeup on seeing a line delimiter.
678 if (clist_putc(c, &tp->t_rawq) >= 0) {
679 if (!ISSET(lflag, ICANON)) {
684 if (TTBREAKC(c, lflag)) {
686 catq(&tp->t_rawq, &tp->t_canq);
688 } else if (tp->t_rocount++ == 0)
689 tp->t_rocol = tp->t_column;
690 if (ISSET(tp->t_state, TS_ERASE)) {
692 * end of prterase \.../
694 CLR(tp->t_state, TS_ERASE);
695 (void)ttyoutput('/', tp);
699 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
701 * Place the cursor over the '^' of the ^D.
703 i = imin(2, tp->t_column - i);
705 (void)ttyoutput('\b', tp);
712 * IXANY means allow any character to restart output.
714 if (ISSET(tp->t_state, TS_TTSTOP) &&
715 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
716 lwkt_reltoken(&tty_token);
720 CLR(tp->t_lflag, FLUSHO);
721 CLR(tp->t_state, TS_TTSTOP);
723 lwkt_reltoken(&tty_token);
724 return (ttstart(tp));
728 * Output a single character on a tty, doing output processing
729 * as needed (expanding tabs, newline processing, etc.).
730 * Returns < 0 if succeeds, otherwise returns char to resend.
734 ttyoutput(int c, struct tty *tp)
739 lwkt_gettoken(&tty_token);
741 if (!ISSET(oflag, OPOST)) {
742 if (ISSET(tp->t_lflag, FLUSHO)) {
743 lwkt_reltoken(&tty_token);
746 if (clist_putc(c, &tp->t_outq)) {
747 lwkt_reltoken(&tty_token);
752 lwkt_reltoken(&tty_token);
756 * Do tab expansion if OXTABS is set. Special case if we external
757 * processing, we don't do the tab expansion because we'll probably
758 * get it wrong. If tab expansion needs to be done, let it happen
761 CLR(c, ~TTY_CHARMASK);
763 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
764 c = 8 - (tp->t_column & 7);
765 if (!ISSET(tp->t_lflag, FLUSHO)) {
766 crit_enter(); /* Don't interrupt tabs. */
767 c -= b_to_q(" ", c, &tp->t_outq);
773 lwkt_reltoken(&tty_token);
774 return (c ? -1 : '\t');
776 if (c == CEOT && ISSET(oflag, ONOEOT)) {
777 lwkt_reltoken(&tty_token);
782 * Newline translation: if ONLCR is set,
783 * translate newline into "\r\n".
785 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
788 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
789 lwkt_reltoken(&tty_token);
793 /* If OCRNL is set, translate "\r" into "\n". */
794 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
796 /* If ONOCR is set, don't transmit CRs when on column 0. */
797 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
798 lwkt_reltoken(&tty_token);
804 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
805 lwkt_reltoken(&tty_token);
818 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
828 col = (col + 8) & ~7;
832 lwkt_reltoken(&tty_token);
837 * Ioctls for all tty devices. Called after line-discipline specific ioctl
838 * has been called to do discipline-specific functions and/or reject any
839 * of these ioctl commands.
843 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
845 struct thread *td = curthread;
846 struct lwp *lp = td->td_lwp;
847 struct proc *p = td->td_proc;
852 lwkt_gettoken(&tty_token);
853 lwkt_gettoken(&proc_token);
855 /* If the ioctl involves modification, hang if in the background. */
879 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
889 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
890 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
891 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
892 if (p->p_pgrp->pg_jobc == 0) {
893 lwkt_reltoken(&proc_token);
894 lwkt_reltoken(&tty_token);
897 pgsignal(p->p_pgrp, SIGTTOU, 1);
898 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
901 lwkt_reltoken(&proc_token);
902 lwkt_reltoken(&tty_token);
909 switch (cmd) { /* Process the ioctl. */
910 case FIOASYNC: /* set/clear async i/o */
913 SET(tp->t_state, TS_ASYNC);
915 CLR(tp->t_state, TS_ASYNC);
918 case FIONREAD: /* get # bytes to read */
920 *(int *)data = ttnread(tp);
926 * Policy -- Don't allow FIOSETOWN on someone else's
929 if (tp->t_session != NULL && !isctty(p, tp)) {
930 lwkt_reltoken(&proc_token);
931 lwkt_reltoken(&tty_token);
935 error = fsetown(*(int *)data, &tp->t_sigio);
937 lwkt_reltoken(&proc_token);
938 lwkt_reltoken(&tty_token);
943 if (tp->t_session != NULL && !isctty(p, tp)) {
944 lwkt_reltoken(&proc_token);
945 lwkt_reltoken(&tty_token);
948 *(int *)data = fgetown(tp->t_sigio);
951 case TIOCEXCL: /* set exclusive use of tty */
953 SET(tp->t_state, TS_XCLUDE);
956 case TIOCFLUSH: { /* flush buffers */
957 int flags = *(int *)data;
960 flags = FREAD | FWRITE;
962 flags &= FREAD | FWRITE;
966 case TIOCCONS: /* become virtual console */
968 if (constty && constty != tp &&
969 ISSET(constty->t_state, TS_CONNECTED)) {
970 lwkt_reltoken(&proc_token);
971 lwkt_reltoken(&tty_token);
975 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
976 lwkt_reltoken(&proc_token);
977 lwkt_reltoken(&tty_token);
982 } else if (tp == constty)
985 case TIOCDRAIN: /* wait till output drained */
988 lwkt_reltoken(&proc_token);
989 lwkt_reltoken(&tty_token);
993 case TIOCGETA: { /* get termios struct */
994 struct termios *t = (struct termios *)data;
996 bcopy(&tp->t_termios, t, sizeof(struct termios));
999 case TIOCGETD: /* get line discipline */
1000 *(int *)data = tp->t_line;
1002 case TIOCGWINSZ: /* get window size */
1003 *(struct winsize *)data = tp->t_winsize;
1005 case TIOCGPGRP: /* get pgrp of tty */
1006 if (!isctty(p, tp)) {
1007 lwkt_reltoken(&proc_token);
1008 lwkt_reltoken(&tty_token);
1011 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1013 case TIOCGSID: /* get sid of tty */
1014 if (!isctty(p, tp)) {
1015 lwkt_reltoken(&proc_token);
1016 lwkt_reltoken(&tty_token);
1019 *(int *)data = tp->t_session->s_sid;
1022 case TIOCHPCL: /* hang up on last close */
1024 SET(tp->t_cflag, HUPCL);
1028 case TIOCNXCL: /* reset exclusive use of tty */
1030 CLR(tp->t_state, TS_XCLUDE);
1033 case TIOCOUTQ: /* output queue size */
1034 *(int *)data = tp->t_outq.c_cc;
1036 case TIOCSETA: /* set termios struct */
1037 case TIOCSETAW: /* drain output, set */
1038 case TIOCSETAF: { /* drn out, fls in, set */
1039 struct termios *t = (struct termios *)data;
1041 if (t->c_ispeed == 0)
1042 t->c_ispeed = t->c_ospeed;
1043 if (t->c_ispeed == 0)
1044 t->c_ispeed = tp->t_ospeed;
1045 if (t->c_ispeed == 0) {
1046 lwkt_reltoken(&proc_token);
1047 lwkt_reltoken(&tty_token);
1051 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1052 error = ttywait(tp);
1055 lwkt_reltoken(&proc_token);
1056 lwkt_reltoken(&tty_token);
1059 if (cmd == TIOCSETAF)
1060 ttyflush(tp, FREAD);
1062 if (!ISSET(t->c_cflag, CIGNORE)) {
1064 * Set device hardware.
1066 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1068 lwkt_reltoken(&proc_token);
1069 lwkt_reltoken(&tty_token);
1072 if (ISSET(t->c_cflag, CLOCAL) &&
1073 !ISSET(tp->t_cflag, CLOCAL)) {
1075 * XXX disconnections would be too hard to
1076 * get rid of without this kludge. The only
1077 * way to get rid of controlling terminals
1078 * is to exit from the session leader.
1080 CLR(tp->t_state, TS_ZOMBIE);
1082 wakeup(TSA_CARR_ON(tp));
1086 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1087 ISSET(t->c_cflag, CLOCAL)) &&
1088 !ISSET(tp->t_state, TS_ZOMBIE))
1089 SET(tp->t_state, TS_CONNECTED);
1091 CLR(tp->t_state, TS_CONNECTED);
1092 tp->t_cflag = t->c_cflag;
1093 tp->t_ispeed = t->c_ispeed;
1094 if (t->c_ospeed != 0)
1095 tp->t_ospeed = t->c_ospeed;
1098 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1100 if (ISSET(t->c_lflag, ICANON))
1101 SET(tp->t_lflag, PENDIN);
1104 * XXX we really shouldn't allow toggling
1105 * ICANON while we're in a non-termios line
1106 * discipline. Now we have to worry about
1107 * panicing for a null queue.
1109 if (tp->t_canq.c_cbreserved > 0 &&
1110 tp->t_rawq.c_cbreserved > 0) {
1111 catq(&tp->t_rawq, &tp->t_canq);
1113 * XXX the queue limits may be
1114 * different, so the old queue
1115 * swapping method no longer works.
1117 catq(&tp->t_canq, &tp->t_rawq);
1119 CLR(tp->t_lflag, PENDIN);
1123 tp->t_iflag = t->c_iflag;
1124 tp->t_oflag = t->c_oflag;
1126 * Make the EXTPROC bit read only.
1128 if (ISSET(tp->t_lflag, EXTPROC))
1129 SET(t->c_lflag, EXTPROC);
1131 CLR(t->c_lflag, EXTPROC);
1132 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1133 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1134 t->c_cc[VTIME] != tp->t_cc[VTIME])
1136 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1140 case TIOCSETD: { /* set line discipline */
1141 int t = *(int *)data;
1142 cdev_t device = tp->t_dev;
1144 if ((u_int)t >= nlinesw) {
1145 lwkt_reltoken(&proc_token);
1146 lwkt_reltoken(&tty_token);
1149 if (t != tp->t_line) {
1151 (*linesw[tp->t_line].l_close)(tp, flag);
1152 error = (*linesw[t].l_open)(device, tp);
1154 (void)(*linesw[tp->t_line].l_open)(device, tp);
1156 lwkt_reltoken(&proc_token);
1157 lwkt_reltoken(&tty_token);
1165 case TIOCSTART: /* start output, like ^Q */
1167 if (ISSET(tp->t_state, TS_TTSTOP) ||
1168 ISSET(tp->t_lflag, FLUSHO)) {
1169 CLR(tp->t_lflag, FLUSHO);
1170 CLR(tp->t_state, TS_TTSTOP);
1175 case TIOCSTI: /* simulate terminal input */
1176 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1177 lwkt_reltoken(&proc_token);
1178 lwkt_reltoken(&tty_token);
1181 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1182 lwkt_reltoken(&proc_token);
1183 lwkt_reltoken(&tty_token);
1187 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1190 case TIOCSTOP: /* stop output, like ^S */
1192 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1193 SET(tp->t_state, TS_TTSTOP);
1194 (*tp->t_stop)(tp, 0);
1198 case TIOCSCTTY: /* become controlling tty */
1199 /* Session ctty vnode pointer set in vnode layer. */
1200 if (!SESS_LEADER(p) ||
1201 ((p->p_session->s_ttyvp || tp->t_session) &&
1202 (tp->t_session != p->p_session))) {
1203 lwkt_reltoken(&proc_token);
1204 lwkt_reltoken(&tty_token);
1208 tp->t_session = p->p_session;
1209 tp->t_pgrp = p->p_pgrp;
1210 otp = p->p_session->s_ttyp;
1211 p->p_session->s_ttyp = tp;
1214 p->p_flag |= P_CONTROLT;
1216 case TIOCSPGRP: { /* set pgrp of tty */
1217 pid_t pgid = *(int *)data;
1219 if (!isctty(p, tp)) {
1220 lwkt_reltoken(&proc_token);
1221 lwkt_reltoken(&tty_token);
1224 else if (pgid < 1 || pgid > PID_MAX) {
1225 lwkt_reltoken(&proc_token);
1226 lwkt_reltoken(&tty_token);
1229 struct pgrp *pgrp = pgfind(pgid);
1230 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1231 lwkt_reltoken(&proc_token);
1232 lwkt_reltoken(&tty_token);
1240 case TIOCSTAT: /* simulate control-T */
1245 case TIOCSWINSZ: /* set window size */
1246 if (bcmp((caddr_t)&tp->t_winsize, data,
1247 sizeof (struct winsize))) {
1248 tp->t_winsize = *(struct winsize *)data;
1249 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1252 case TIOCSDRAINWAIT:
1253 error = priv_check(td, PRIV_ROOT);
1255 lwkt_reltoken(&proc_token);
1256 lwkt_reltoken(&tty_token);
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 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1268 lwkt_reltoken(&proc_token);
1269 lwkt_reltoken(&tty_token);
1270 return (ttcompat(tp, cmd, data, flag));
1272 lwkt_reltoken(&proc_token);
1273 lwkt_reltoken(&tty_token);
1277 lwkt_reltoken(&proc_token);
1278 lwkt_reltoken(&tty_token);
1282 static struct filterops ttyread_filtops =
1283 { FILTEROP_ISFD, NULL, filt_ttyrdetach, filt_ttyread };
1284 static struct filterops ttywrite_filtops =
1285 { FILTEROP_ISFD, NULL, filt_ttywdetach, filt_ttywrite };
1288 ttykqfilter(struct dev_kqfilter_args *ap)
1290 cdev_t dev = ap->a_head.a_dev;
1291 struct knote *kn = ap->a_kn;
1292 struct tty *tp = dev->si_tty;
1293 struct klist *klist;
1297 lwkt_gettoken(&tty_token);
1298 switch (kn->kn_filter) {
1300 klist = &tp->t_rkq.ki_note;
1301 kn->kn_fop = &ttyread_filtops;
1304 klist = &tp->t_wkq.ki_note;
1305 kn->kn_fop = &ttywrite_filtops;
1308 ap->a_result = EOPNOTSUPP;
1309 lwkt_reltoken(&tty_token);
1312 lwkt_reltoken(&tty_token);
1313 kn->kn_hook = (caddr_t)dev;
1314 knote_insert(klist, kn);
1320 filt_ttyrdetach(struct knote *kn)
1322 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1324 lwkt_gettoken(&tty_token);
1325 knote_remove(&tp->t_rkq.ki_note, kn);
1326 lwkt_reltoken(&tty_token);
1330 filt_ttyread(struct knote *kn, long hint)
1332 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1334 lwkt_gettoken(&tty_token);
1335 kn->kn_data = ttnread(tp);
1336 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1337 kn->kn_flags |= EV_EOF;
1338 lwkt_reltoken(&tty_token);
1341 lwkt_reltoken(&tty_token);
1342 return (kn->kn_data > 0);
1346 filt_ttywdetach(struct knote *kn)
1348 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1350 lwkt_gettoken(&tty_token);
1351 knote_remove(&tp->t_wkq.ki_note, kn);
1352 lwkt_reltoken(&tty_token);
1356 filt_ttywrite(struct knote *kn, long hint)
1358 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1361 lwkt_gettoken(&tty_token);
1362 kn->kn_data = tp->t_outq.c_cc;
1363 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1364 lwkt_reltoken(&tty_token);
1367 ret = (kn->kn_data <= tp->t_olowat &&
1368 ISSET(tp->t_state, TS_CONNECTED));
1369 lwkt_reltoken(&tty_token);
1374 * Must be called while in a critical section.
1375 * NOTE: tty_token must be held.
1378 ttnread(struct tty *tp)
1382 ASSERT_LWKT_TOKEN_HELD(&tty_token);
1383 if (ISSET(tp->t_lflag, PENDIN))
1385 nread = tp->t_canq.c_cc;
1386 if (!ISSET(tp->t_lflag, ICANON)) {
1387 nread += tp->t_rawq.c_cc;
1388 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1395 * Wait for output to drain.
1398 ttywait(struct tty *tp)
1404 lwkt_gettoken(&tty_token);
1405 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1406 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1408 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1409 ISSET(tp->t_state, TS_CONNECTED)) {
1410 SET(tp->t_state, TS_SO_OCOMPLETE);
1411 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1415 if (error == EWOULDBLOCK)
1422 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1424 lwkt_reltoken(&tty_token);
1430 * Flush if successfully wait.
1433 ttywflush(struct tty *tp)
1437 if ((error = ttywait(tp)) == 0)
1438 ttyflush(tp, FREAD);
1443 * Flush tty read and/or write queues, notifying anyone waiting.
1446 ttyflush(struct tty *tp, int rw)
1449 lwkt_gettoken(&tty_token);
1454 FLUSHQ(&tp->t_outq);
1455 CLR(tp->t_state, TS_TTSTOP);
1457 (*tp->t_stop)(tp, rw);
1459 FLUSHQ(&tp->t_canq);
1460 FLUSHQ(&tp->t_rawq);
1461 CLR(tp->t_lflag, PENDIN);
1464 CLR(tp->t_state, TS_LOCAL);
1466 if (ISSET(tp->t_state, TS_TBLOCK)) {
1468 FLUSHQ(&tp->t_outq);
1472 * Don't let leave any state that might clobber the
1473 * next line discipline (although we should do more
1474 * to send the START char). Not clearing the state
1475 * may have caused the "putc to a clist with no
1476 * reserved cblocks" panic/kprintf.
1478 CLR(tp->t_state, TS_TBLOCK);
1480 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1481 if (ISSET(tp->t_iflag, IXOFF)) {
1483 * XXX wait a bit in the hope that the stop
1484 * character (if any) will go out. Waiting
1485 * isn't good since it allows races. This
1486 * will be fixed when the stop character is
1487 * put in a special queue. Don't bother with
1488 * the checks in ttywait() since the timeout
1491 SET(tp->t_state, TS_SO_OCOMPLETE);
1492 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1495 * Don't try sending the stop character again.
1497 CLR(tp->t_state, TS_TBLOCK);
1504 FLUSHQ(&tp->t_outq);
1507 lwkt_reltoken(&tty_token);
1512 * Copy in the default termios characters.
1515 termioschars(struct termios *t)
1517 lwkt_gettoken(&tty_token);
1518 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1519 lwkt_reltoken(&tty_token);
1526 ttychars(struct tty *tp)
1528 lwkt_gettoken(&tty_token);
1529 termioschars(&tp->t_termios);
1530 lwkt_reltoken(&tty_token);
1534 * Handle input high water. Send stop character for the IXOFF case. Turn
1535 * on our input flow control bit and propagate the changes to the driver.
1536 * XXX the stop character should be put in a special high priority queue.
1539 ttyblock(struct tty *tp)
1541 lwkt_gettoken(&tty_token);
1542 SET(tp->t_state, TS_TBLOCK);
1543 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1544 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1545 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1547 lwkt_reltoken(&tty_token);
1551 * Handle input low water. Send start character for the IXOFF case. Turn
1552 * off our input flow control bit and propagate the changes to the driver.
1553 * XXX the start character should be put in a special high priority queue.
1556 ttyunblock(struct tty *tp)
1558 lwkt_gettoken(&tty_token);
1559 CLR(tp->t_state, TS_TBLOCK);
1560 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1561 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1562 SET(tp->t_state, TS_TBLOCK); /* try again later */
1564 lwkt_reltoken(&tty_token);
1568 /* Not used by any current (i386) drivers. */
1570 * Restart after an inter-char delay.
1573 ttrstrt(void *tp_arg)
1577 KASSERT(tp_arg != NULL, ("ttrstrt"));
1581 lwkt_gettoken(&tty_token);
1582 CLR(tp->t_state, TS_TIMEOUT);
1584 lwkt_reltoken(&tty_token);
1590 ttstart(struct tty *tp)
1592 lwkt_gettoken(&tty_token);
1593 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1595 lwkt_reltoken(&tty_token);
1600 * "close" a line discipline
1603 ttylclose(struct tty *tp, int flag)
1605 lwkt_gettoken(&tty_token);
1606 if (flag & FNONBLOCK || ttywflush(tp))
1607 ttyflush(tp, FREAD | FWRITE);
1608 lwkt_reltoken(&tty_token);
1613 ttyhold(struct tty *tp)
1619 ttyunhold(struct tty *tp)
1628 * Handle modem control transition on a tty.
1629 * Flag indicates new state of carrier.
1630 * Returns 0 if the line should be turned off, otherwise 1.
1633 ttymodem(struct tty *tp, int flag)
1635 lwkt_gettoken(&tty_token);
1636 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1638 * MDMBUF: do flow control according to carrier flag
1639 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1640 * works if IXON and IXANY are clear.
1643 CLR(tp->t_state, TS_CAR_OFLOW);
1644 CLR(tp->t_state, TS_TTSTOP);
1646 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1647 SET(tp->t_state, TS_CAR_OFLOW);
1648 SET(tp->t_state, TS_TTSTOP);
1649 (*tp->t_stop)(tp, 0);
1651 } else if (flag == 0) {
1655 CLR(tp->t_state, TS_CARR_ON);
1656 if (ISSET(tp->t_state, TS_ISOPEN) &&
1657 !ISSET(tp->t_cflag, CLOCAL)) {
1658 SET(tp->t_state, TS_ZOMBIE);
1659 CLR(tp->t_state, TS_CONNECTED);
1660 if (tp->t_session && tp->t_session->s_leader)
1661 ksignal(tp->t_session->s_leader, SIGHUP);
1662 ttyflush(tp, FREAD | FWRITE);
1663 lwkt_reltoken(&tty_token);
1670 SET(tp->t_state, TS_CARR_ON);
1671 if (!ISSET(tp->t_state, TS_ZOMBIE))
1672 SET(tp->t_state, TS_CONNECTED);
1673 wakeup(TSA_CARR_ON(tp));
1677 lwkt_reltoken(&tty_token);
1682 * Reinput pending characters after state switch
1683 * call from a critical section.
1686 ttypend(struct tty *tp)
1691 lwkt_gettoken(&tty_token);
1692 CLR(tp->t_lflag, PENDIN);
1693 SET(tp->t_state, TS_TYPEN);
1695 * XXX this assumes too much about clist internals. It may even
1696 * fail if the cblock slush pool is empty. We can't allocate more
1697 * cblocks here because we are called from an interrupt handler
1698 * and clist_alloc_cblocks() can wait.
1701 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1702 tp->t_rawq.c_cbmax = tq.c_cbmax;
1703 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1704 while ((c = clist_getc(&tq)) >= 0)
1706 CLR(tp->t_state, TS_TYPEN);
1707 lwkt_reltoken(&tty_token);
1711 * Process a read call on a tty device.
1714 ttread(struct tty *tp, struct uio *uio, int flag)
1719 cc_t *cc = tp->t_cc;
1722 int first, error = 0;
1723 int has_stime = 0, last_cc = 0;
1724 long slp = 0; /* XXX this should be renamed `timo'. */
1725 struct timeval stime;
1727 lp = curthread->td_lwp;
1728 stime.tv_sec = 0; /* fix compiler warnings */
1731 lwkt_gettoken(&tty_token);
1734 lflag = tp->t_lflag;
1736 * take pending input first
1738 if (ISSET(lflag, PENDIN)) {
1740 splz(); /* reduce latency */
1741 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1745 * Hang process if it's in the background.
1747 lwkt_gettoken(&proc_token);
1748 if ((pp = curproc) && isbackground(pp, tp)) {
1750 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1751 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1752 (pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1753 lwkt_reltoken(&proc_token);
1754 lwkt_reltoken(&tty_token);
1757 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1758 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1760 lwkt_reltoken(&proc_token);
1761 lwkt_reltoken(&tty_token);
1764 lwkt_reltoken(&proc_token);
1767 lwkt_reltoken(&proc_token);
1769 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1771 lwkt_reltoken(&tty_token);
1772 return (0); /* EOF */
1776 * If canonical, use the canonical queue,
1777 * else use the raw queue.
1779 * (should get rid of clists...)
1781 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1783 if (flag & IO_NDELAY) {
1786 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1788 lwkt_reltoken(&tty_token);
1792 lwkt_reltoken(&tty_token);
1793 return (EWOULDBLOCK);
1795 if (!ISSET(lflag, ICANON)) {
1798 struct timeval timecopy;
1801 * Check each of the four combinations.
1802 * (m > 0 && t == 0) is the normal read case.
1803 * It should be fairly efficient, so we check that and its
1804 * companion case (m == 0 && t == 0) first.
1805 * For the other two cases, we compute the target sleep time
1814 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1816 lwkt_reltoken(&tty_token);
1819 t *= 100000; /* time in us */
1820 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1821 ((t1).tv_usec - (t2).tv_usec))
1827 getmicrotime(&timecopy);
1828 if (has_stime == 0) {
1829 /* first character, start timer */
1833 } else if (qp->c_cc > last_cc) {
1834 /* got a character, restart timer */
1838 /* nothing, check expiration */
1839 slp = t - diff(timecopy, stime);
1844 } else { /* m == 0 */
1847 getmicrotime(&timecopy);
1848 if (has_stime == 0) {
1853 slp = t - diff(timecopy, stime);
1855 /* Timed out, but 0 is enough input. */
1857 lwkt_reltoken(&tty_token);
1864 * Rounding down may make us wake up just short
1865 * of the target, so we round up.
1866 * The formula is ceiling(slp * hz/1000000).
1867 * 32-bit arithmetic is enough for hz < 169.
1868 * XXX see tvtohz() for how to avoid overflow if hz
1869 * is large (divide by `tick' and/or arrange to
1870 * use tvtohz() if hz is large).
1872 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1875 if (qp->c_cc <= 0) {
1878 * There is no input, or not enough input and we can block.
1880 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1881 ISSET(tp->t_state, TS_CONNECTED) ?
1882 "ttyin" : "ttyhup", (int)slp);
1884 if (error == EWOULDBLOCK)
1887 lwkt_reltoken(&tty_token);
1891 * XXX what happens if another process eats some input
1892 * while we are asleep (not just here)? It would be
1893 * safest to detect changes and reset our state variables
1894 * (has_stime and last_cc).
1902 * Input present, check for input mapping and processing.
1905 if (ISSET(lflag, ICANON | ISIG))
1911 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1912 icc = q_to_b(qp, ibuf, icc);
1918 error = uiomove(ibuf, (size_t)icc, uio);
1920 * XXX if there was an error then we should ungetc() the
1921 * unmoved chars and reduce icc here.
1925 if (uio->uio_resid == 0)
1939 * delayed suspend (^Y)
1941 if (CCEQ(cc[VDSUSP], c) &&
1942 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1943 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1945 error = ttysleep(tp, &lbolt, PCATCH,
1954 * Interpret EOF only in canonical mode.
1956 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1959 * Give user character.
1961 error = ureadc(c, uio);
1963 /* XXX should ungetc(c, qp). */
1965 if (uio->uio_resid == 0)
1968 * In canonical mode check for a "break character"
1969 * marking the end of a "line of input".
1971 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1978 * Look to unblock input now that (presumably)
1979 * the input queue has gone down.
1982 if (ISSET(tp->t_state, TS_TBLOCK) &&
1983 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1987 lwkt_reltoken(&tty_token);
1992 * Check the output queue on tp for space for a kernel message (from uprintf
1993 * or tprintf). Allow some space over the normal hiwater mark so we don't
1994 * lose messages due to normal flow control, but don't let the tty run amok.
1995 * Sleeps here are not interruptible, but we return prematurely if new signals
1999 ttycheckoutq(struct tty *tp, int wait)
2001 struct lwp *lp = curthread->td_lwp;
2003 sigset_t oldset, newset;
2005 lwkt_gettoken(&tty_token);
2006 hiwat = tp->t_ohiwat;
2007 SIGEMPTYSET(oldset);
2008 SIGEMPTYSET(newset);
2011 oldset = lwp_sigpend(lp);
2012 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
2013 while (tp->t_outq.c_cc > hiwat) {
2015 if (tp->t_outq.c_cc <= hiwat)
2018 newset = lwp_sigpend(lp);
2019 if (!wait || SIGSETNEQ(oldset, newset)) {
2021 lwkt_reltoken(&tty_token);
2024 SET(tp->t_state, TS_SO_OLOWAT);
2025 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
2029 lwkt_reltoken(&tty_token);
2034 * Process a write call on a tty device.
2037 ttwrite(struct tty *tp, struct uio *uio, int flag)
2043 int i, hiwat, error;
2048 lwkt_gettoken(&tty_token);
2049 lp = curthread->td_lwp;
2050 hiwat = tp->t_ohiwat;
2051 cnt = uio->uio_resid;
2056 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2058 if (uio->uio_resid == cnt)
2062 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2063 if (flag & IO_NDELAY) {
2065 error = EWOULDBLOCK;
2068 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2077 * Hang the process if it's in the background.
2079 lwkt_gettoken(&proc_token);
2080 if ((pp = curproc) && isbackground(pp, tp) &&
2081 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flag & P_PPWAIT) &&
2082 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2083 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2084 if (pp->p_pgrp->pg_jobc == 0) {
2086 lwkt_reltoken(&proc_token);
2089 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2090 lwkt_reltoken(&proc_token);
2091 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2096 lwkt_reltoken(&proc_token);
2098 * Process the user's data in at most OBUFSIZ chunks. Perform any
2099 * output translation. Keep track of high water mark, sleep on
2100 * overflow awaiting device aid in acquiring new space.
2102 while (uio->uio_resid > 0 || cc > 0) {
2103 if (ISSET(tp->t_lflag, FLUSHO)) {
2105 lwkt_reltoken(&tty_token);
2108 if (tp->t_outq.c_cc > hiwat)
2111 * Grab a hunk of data from the user, unless we have some
2112 * leftover from last time.
2115 cc = szmin(uio->uio_resid, OBUFSIZ);
2117 error = uiomove(cp, (size_t)cc, uio);
2124 * If nothing fancy need be done, grab those characters we
2125 * can handle without any of ttyoutput's processing and
2126 * just transfer them to the output q. For those chars
2127 * which require special processing (as indicated by the
2128 * bits in char_type), call ttyoutput. After processing
2129 * a hunk of data, look for FLUSHO so ^O's will take effect
2133 if (!ISSET(tp->t_oflag, OPOST))
2136 ce = cc - scanc((u_int)cc, (u_char *)cp,
2137 char_type, CCLASSMASK);
2139 * If ce is zero, then we're processing
2140 * a special character through ttyoutput.
2144 if (ttyoutput(*cp, tp) >= 0) {
2145 /* No Clists, wait a bit. */
2147 if (flag & IO_NDELAY) {
2148 error = EWOULDBLOCK;
2151 error = ttysleep(tp, &lbolt,
2160 if (ISSET(tp->t_lflag, FLUSHO) ||
2161 tp->t_outq.c_cc > hiwat)
2167 * A bunch of normal characters have been found.
2168 * Transfer them en masse to the output queue and
2169 * continue processing at the top of the loop.
2170 * If there are any further characters in this
2171 * <= OBUFSIZ chunk, the first should be a character
2172 * requiring special handling by ttyoutput.
2175 i = b_to_q(cp, ce, &tp->t_outq);
2178 cp += ce, cc -= ce, tk_nout += ce;
2181 /* No Clists, wait a bit. */
2183 if (flag & IO_NDELAY) {
2184 error = EWOULDBLOCK;
2187 error = ttysleep(tp, &lbolt, PCATCH,
2193 if (ISSET(tp->t_lflag, FLUSHO) ||
2194 tp->t_outq.c_cc > hiwat)
2201 * If cc is nonzero, we leave the uio structure inconsistent, as the
2202 * offset and iov pointers have moved forward, but it doesn't matter
2203 * (the call will either return short or restart with a new uio).
2205 uio->uio_resid += cc;
2206 lwkt_reltoken(&tty_token);
2213 * This can only occur if FLUSHO is set in t_lflag,
2214 * or if ttstart/oproc is synchronous (or very fast).
2216 if (tp->t_outq.c_cc <= hiwat) {
2220 if (flag & IO_NDELAY) {
2222 uio->uio_resid += cc;
2223 lwkt_reltoken(&tty_token);
2224 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2226 SET(tp->t_state, TS_SO_OLOWAT);
2227 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2229 if (error == EWOULDBLOCK)
2237 * Rubout one character from the rawq of tp
2238 * as cleanly as possible.
2239 * NOTE: Must be called with tty_token held
2242 ttyrub(int c, struct tty *tp)
2248 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2249 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2251 CLR(tp->t_lflag, FLUSHO);
2252 if (ISSET(tp->t_lflag, ECHOE)) {
2253 if (tp->t_rocount == 0) {
2255 * Screwed by ttwrite; retype
2260 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2263 CLR(c, ~TTY_CHARMASK);
2264 switch (CCLASS(c)) {
2273 if (ISSET(tp->t_lflag, ECHOCTL))
2277 if (tp->t_rocount < tp->t_rawq.c_cc) {
2282 savecol = tp->t_column;
2283 SET(tp->t_state, TS_CNTTB);
2284 SET(tp->t_lflag, FLUSHO);
2285 tp->t_column = tp->t_rocol;
2286 cp = tp->t_rawq.c_cf;
2288 tabc = *cp; /* XXX FIX NEXTC */
2289 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2291 CLR(tp->t_lflag, FLUSHO);
2292 CLR(tp->t_state, TS_CNTTB);
2295 /* savecol will now be length of the tab. */
2296 savecol -= tp->t_column;
2297 tp->t_column += savecol;
2299 savecol = 8; /* overflow screw */
2300 while (--savecol >= 0)
2301 (void)ttyoutput('\b', tp);
2304 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2305 (void)kprintf(PANICSTR, c, CCLASS(c));
2307 panic(PANICSTR, c, CCLASS(c));
2311 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2312 if (!ISSET(tp->t_state, TS_ERASE)) {
2313 SET(tp->t_state, TS_ERASE);
2314 (void)ttyoutput('\\', tp);
2318 ttyecho(tp->t_cc[VERASE], tp);
2320 * This code may be executed not only when an ERASE key
2321 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2322 * So, I didn't think it was worthwhile to pass the extra
2323 * information (which would need an extra parameter,
2324 * changing every call) needed to distinguish the ERASE2
2325 * case from the ERASE.
2332 * Back over cnt characters, erasing them.
2333 * NOTE: Must be called with tty_token held
2336 ttyrubo(struct tty *tp, int cnt)
2338 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2340 (void)ttyoutput('\b', tp);
2341 (void)ttyoutput(' ', tp);
2342 (void)ttyoutput('\b', tp);
2348 * Reprint the rawq line. Note, it is assumed that c_cc has already
2350 * NOTE: Must be called with tty_token held
2353 ttyretype(struct tty *tp)
2358 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2359 /* Echo the reprint character. */
2360 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2361 ttyecho(tp->t_cc[VREPRINT], tp);
2363 (void)ttyoutput('\n', tp);
2367 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2368 * BIT OF FIRST CHAR.
2371 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2372 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2374 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2375 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2377 CLR(tp->t_state, TS_ERASE);
2380 tp->t_rocount = tp->t_rawq.c_cc;
2385 * Echo a typed character to the terminal.
2386 * NOTE: Must be called with tty_token held
2389 ttyecho(int c, struct tty *tp)
2391 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2393 if (!ISSET(tp->t_state, TS_CNTTB))
2394 CLR(tp->t_lflag, FLUSHO);
2395 if ((!ISSET(tp->t_lflag, ECHO) &&
2396 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2397 ISSET(tp->t_lflag, EXTPROC))
2399 if (ISSET(tp->t_lflag, ECHOCTL) &&
2400 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2401 ISSET(c, TTY_CHARMASK) == 0177)) {
2402 (void)ttyoutput('^', tp);
2403 CLR(c, ~TTY_CHARMASK);
2409 (void)ttyoutput(c, tp);
2413 * Wake up any readers on a tty.
2416 ttwakeup(struct tty *tp)
2418 lwkt_gettoken(&tty_token);
2419 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2420 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2421 wakeup(TSA_HUP_OR_INPUT(tp));
2422 KNOTE(&tp->t_rkq.ki_note, 0);
2423 lwkt_reltoken(&tty_token);
2427 * Wake up any writers on a tty.
2430 ttwwakeup(struct tty *tp)
2432 lwkt_gettoken(&tty_token);
2433 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2434 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2435 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2436 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2437 CLR(tp->t_state, TS_SO_OCOMPLETE);
2438 wakeup(TSA_OCOMPLETE(tp));
2440 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2441 tp->t_outq.c_cc <= tp->t_olowat) {
2442 CLR(tp->t_state, TS_SO_OLOWAT);
2443 wakeup(TSA_OLOWAT(tp));
2445 KNOTE(&tp->t_wkq.ki_note, 0);
2446 lwkt_reltoken(&tty_token);
2450 * Look up a code for a specified speed in a conversion table;
2451 * used by drivers to map software speed values to hardware parameters.
2455 ttspeedtab(int speed, struct speedtab *table)
2458 for ( ; table->sp_speed != -1; table++)
2459 if (table->sp_speed == speed)
2460 return (table->sp_code);
2465 * Set input and output watermarks and buffer sizes. For input, the
2466 * high watermark is about one second's worth of input above empty, the
2467 * low watermark is slightly below high water, and the buffer size is a
2468 * driver-dependent amount above high water. For output, the watermarks
2469 * are near the ends of the buffer, with about 1 second's worth of input
2470 * between them. All this only applies to the standard line discipline.
2473 ttsetwater(struct tty *tp)
2475 int cps, ttmaxhiwat, x;
2477 lwkt_gettoken(&tty_token);
2479 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2480 switch (tp->t_ispeedwat) {
2482 cps = tp->t_ispeed / 10;
2486 * This case is for old drivers that don't know about
2487 * t_ispeedwat. Arrange for them to get the old buffer
2488 * sizes and watermarks.
2490 cps = TTYHOG - 2 * 256;
2491 tp->t_ififosize = 2 * 2048;
2494 cps = tp->t_ispeedwat / 10;
2498 tp->t_ilowat = 7 * cps / 8;
2499 x = cps + tp->t_ififosize;
2500 clist_alloc_cblocks(&tp->t_rawq, x, x);
2503 switch (tp->t_ospeedwat) {
2505 cps = tp->t_ospeed / 10;
2506 ttmaxhiwat = 2 * TTMAXHIWAT;
2509 cps = tp->t_ospeed / 10;
2510 ttmaxhiwat = TTMAXHIWAT;
2513 cps = tp->t_ospeedwat / 10;
2514 ttmaxhiwat = 8 * TTMAXHIWAT;
2517 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2518 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2520 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2521 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2522 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2524 clist_alloc_cblocks(&tp->t_outq, x, x);
2526 lwkt_reltoken(&tty_token);
2530 * Report on state of foreground process group.
2533 ttyinfo(struct tty *tp)
2535 struct proc *p, *pick;
2540 if (ttycheckoutq(tp,0) == 0)
2543 lwkt_gettoken(&tty_token);
2544 lwkt_gettoken(&proc_token);
2546 * We always print the load average, then figure out what else to
2547 * print based on the state of the current process group.
2549 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2550 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2552 if (tp->t_session == NULL) {
2553 ttyprintf(tp, "not a controlling terminal\n");
2554 } else if (tp->t_pgrp == NULL) {
2555 ttyprintf(tp, "no foreground process group\n");
2556 } else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
2557 ttyprintf(tp, "empty foreground process group\n");
2560 * Pick an interesting process. Note that certain elements,
2561 * in particular the wmesg, require a critical section for
2562 * safe access (YYY and we are still not MP safe).
2564 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2573 /* XXX lwp should compare lwps */
2575 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist)) {
2576 if (proc_compare(pick, p))
2581 lp = FIRST_LWP_IN_PROC(pick);
2583 ttyprintf(tp, "foreground process without lwp\n");
2586 lwkt_reltoken(&proc_token);
2587 lwkt_reltoken(&tty_token);
2592 * Figure out what wait/process-state message, and command
2596 * XXX lwp This is a horrible mixture. We need to rework this
2597 * as soon as lwps have their own runnable status.
2599 if (pick->p_flag & P_WEXIT)
2601 else if (lp->lwp_stat == LSRUN)
2603 else if (pick->p_stat == SIDL)
2605 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2606 str = lp->lwp_wmesg;
2610 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2611 pick->p_comm, pick->p_pid, str);
2614 * Calculate cpu usage, percent cpu, and cmsz. Note that
2615 * 'pick' becomes invalid the moment we exit the critical
2618 if (lp->lwp_thread && (pick->p_flag & P_SWAPPEDOUT) == 0)
2619 calcru_proc(pick, &ru);
2621 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2623 if (pick->p_stat == SIDL || pick->p_stat == SZOMB)
2626 vmsz = pgtok(vmspace_resident_count(pick->p_vmspace));
2633 ttyprintf(tp, " %s ", buf);
2634 ttyprintf(tp, "%ld.%02ldu ",
2635 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2636 ttyprintf(tp, "%ld.%02lds ",
2637 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2638 ttyprintf(tp, "%d%% %ldk\n", pctcpu / 100, vmsz);
2640 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2641 lwkt_reltoken(&proc_token);
2642 lwkt_reltoken(&tty_token);
2646 * Returns 1 if p2 is "better" than p1
2648 * The algorithm for picking the "interesting" process is thus:
2650 * 1) Only foreground processes are eligible - implied.
2651 * 2) Runnable processes are favored over anything else. The runner
2652 * with the highest cpu utilization is picked (p_cpticks). Ties are
2653 * broken by picking the highest pid.
2654 * 3) The sleeper with the shortest sleep time is next. With ties,
2655 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2656 * 4) Further ties are broken by picking the highest pid.
2658 * NOTE: must be called with proc_token held.
2660 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2661 #define TESTAB(a, b) ((a)<<1 | (b))
2667 proc_compare(struct proc *p1, struct proc *p2)
2669 struct lwp *lp1, *lp2;
2671 ASSERT_LWKT_TOKEN_HELD(&proc_token);
2679 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2685 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2689 lp1 = FIRST_LWP_IN_PROC(p1);
2690 lp2 = FIRST_LWP_IN_PROC(p2);
2693 * see if at least one of them is runnable
2695 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2702 * tie - favor one with highest recent cpu utilization
2704 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2706 if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2708 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2711 * pick the one with the smallest sleep time
2713 if (lp2->lwp_slptime > lp1->lwp_slptime)
2715 if (lp1->lwp_slptime > lp2->lwp_slptime)
2718 * favor one sleeping in a non-interruptible sleep
2720 if (lp1->lwp_flag & LWP_SINTR && (lp2->lwp_flag & LWP_SINTR) == 0)
2722 if (lp2->lwp_flag & LWP_SINTR && (lp1->lwp_flag & LWP_SINTR) == 0)
2724 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2728 * Output char to tty; console putchar style.
2731 tputchar(int c, struct tty *tp)
2734 lwkt_gettoken(&tty_token);
2735 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2736 lwkt_reltoken(&tty_token);
2741 (void)ttyoutput('\r', tp);
2742 (void)ttyoutput(c, tp);
2744 lwkt_reltoken(&tty_token);
2750 * Sleep on chan, returning ERESTART if tty changed while we napped and
2751 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2752 * the tty is revoked, restarting a pending call will redo validation done
2753 * at the start of the call.
2756 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2762 error = tsleep(chan, slpflags, wmesg, timo);
2765 return (tp->t_gen == gen ? 0 : ERESTART);
2771 * We bump the gen to force any ttysleep()'s to return with ERESTART
2772 * and flush the tty. The related fp's should already have been
2773 * replaced so the tty will close when the last references on the
2774 * original fp's go away.
2777 ttyrevoke(struct dev_revoke_args *ap)
2781 lwkt_gettoken(&tty_token);
2782 tp = ap->a_head.a_dev->si_tty;
2784 ttyflush(tp, FREAD | FWRITE);
2785 wakeup(TSA_CARR_ON(tp));
2788 lwkt_reltoken(&tty_token);
2793 * Allocate a tty struct. Clists in the struct will be allocated by
2797 ttymalloc(struct tty *tp)
2803 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2809 ttyunregister(struct tty *tp)
2811 lwkt_gettoken(&tty_token);
2812 KKASSERT(ISSET(tp->t_state, TS_REGISTERED));
2813 CLR(tp->t_state, TS_REGISTERED);
2814 TAILQ_REMOVE(&tty_list, tp, t_list);
2815 lwkt_reltoken(&tty_token);
2819 ttyregister(struct tty *tp)
2821 lwkt_gettoken(&tty_token);
2822 KKASSERT(!ISSET(tp->t_state, TS_REGISTERED));
2823 SET(tp->t_state, TS_REGISTERED);
2824 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2825 lwkt_reltoken(&tty_token);
2829 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2836 bzero(&marker, sizeof(marker));
2837 marker.t_state = TS_MARKER;
2840 lwkt_gettoken(&tty_token);
2842 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2843 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2844 TAILQ_REMOVE(&tty_list, &marker, t_list);
2845 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2846 if (tp->t_state & TS_MARKER)
2850 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev);
2851 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2855 TAILQ_REMOVE(&tty_list, &marker, t_list);
2856 lwkt_reltoken(&tty_token);
2860 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2861 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2864 nottystop(struct tty *tp, int rw)
2870 ttyread(struct dev_read_args *ap)
2875 tp = ap->a_head.a_dev->si_tty;
2878 lwkt_gettoken(&tty_token);
2879 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2880 lwkt_reltoken(&tty_token);
2886 ttywrite(struct dev_write_args *ap)
2891 tp = ap->a_head.a_dev->si_tty;
2894 lwkt_gettoken(&tty_token);
2895 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2896 lwkt_reltoken(&tty_token);