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. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * @(#)tty.c 8.8 (Berkeley) 1/21/94
37 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
42 * Almost all functions in this file are acquiring the tty token due to their
43 * access and modifications of the 'tp' (struct tty) objects.
48 * o Fix races for sending the start char in ttyflush().
49 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
50 * With luck, there will be MIN chars before select() returns().
51 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
52 * o Don't allow input in TS_ZOMBIE case. It would be visible through
54 * o Do the new sio locking stuff here and use it to avoid special
57 * o Move EXTPROC and/or PENDIN to t_state?
58 * o Wrap most of ttioctl in spltty/splx.
59 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
60 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
61 * o Don't allow certain termios flags to affect disciplines other
62 * than TTYDISC. Cancel their effects before switch disciplines
63 * and ignore them if they are set while we are in another
65 * o Now that historical speed conversions are handled here, don't
67 * o Check for TS_CARR_ON being set while everything is closed and not
68 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
69 * so it would live until the next open even if carrier drops.
70 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
71 * only when _all_ openers leave open().
74 #include "opt_uconsole.h"
76 #include <sys/param.h>
77 #include <sys/systm.h>
79 #include <sys/filio.h>
80 #include <sys/malloc.h>
85 #include <sys/ttydefaults.h> /* for ttydefchars, CEOT */
87 #include <sys/fcntl.h>
89 #include <sys/dkstat.h>
90 #include <sys/kernel.h>
91 #include <sys/vnode.h>
92 #include <sys/signalvar.h>
93 #include <sys/signal2.h>
94 #include <sys/resourcevar.h>
95 #include <sys/filedesc.h>
96 #include <sys/sysctl.h>
97 #include <sys/thread2.h>
100 #include <sys/lock.h>
102 #include <vm/vm_map.h>
103 #include <vm/vm_extern.h>
105 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
107 static int proc_compare (struct proc *p1, struct proc *p2);
108 static int ttnread (struct tty *tp);
109 static void ttyecho (int c, struct tty *tp);
110 static int ttyoutput (int c, struct tty *tp);
111 static void ttypend (struct tty *tp);
112 static void ttyretype (struct tty *tp);
113 static void ttyrub (int c, struct tty *tp);
114 static void ttyrubo (struct tty *tp, int cnt);
115 static void ttyunblock (struct tty *tp);
116 static int ttywflush (struct tty *tp);
117 static int filt_ttyread (struct knote *kn, long hint);
118 static void filt_ttyrdetach (struct knote *kn);
119 static int filt_ttywrite (struct knote *kn, long hint);
120 static void filt_ttywdetach (struct knote *kn);
123 * Table with character classes and parity. The 8th bit indicates parity,
124 * the 7th bit indicates the character is an alphameric or underscore (for
125 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
126 * are 0 then the character needs no special processing on output; classes
127 * other than 0 might be translated or (not currently) require delays.
129 #define E 0x00 /* Even parity. */
130 #define O 0x80 /* Odd parity. */
131 #define PARITY(c) (char_type[c] & O)
133 #define ALPHA 0x40 /* Alpha or underscore. */
134 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
136 #define CCLASSMASK 0x3f
137 #define CCLASS(c) (char_type[c] & CCLASSMASK)
142 #define NA ORDINARY | ALPHA
148 static u_char const char_type[] = {
149 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
150 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
151 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
152 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
153 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
154 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
155 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
156 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
157 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
158 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
159 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
160 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
161 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
162 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
163 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
164 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
166 * Meta chars; should be settable per character set;
167 * for now, treat them all as normal characters.
169 NA, NA, NA, NA, NA, NA, NA, NA,
170 NA, NA, NA, NA, NA, NA, NA, NA,
171 NA, NA, NA, NA, NA, NA, NA, NA,
172 NA, NA, NA, NA, NA, NA, NA, NA,
173 NA, NA, NA, NA, NA, NA, NA, NA,
174 NA, NA, NA, NA, NA, NA, NA, NA,
175 NA, NA, NA, NA, NA, NA, NA, NA,
176 NA, NA, NA, NA, NA, NA, NA, NA,
177 NA, NA, NA, NA, NA, NA, NA, NA,
178 NA, NA, NA, NA, NA, NA, NA, NA,
179 NA, NA, NA, NA, NA, NA, NA, NA,
180 NA, NA, NA, NA, NA, NA, NA, NA,
181 NA, NA, NA, NA, NA, NA, NA, NA,
182 NA, NA, NA, NA, NA, NA, NA, NA,
183 NA, NA, NA, NA, NA, NA, NA, NA,
184 NA, NA, NA, NA, NA, NA, NA, NA,
195 /* Macros to clear/set/test flags. */
196 #define SET(t, f) (t) |= (f)
197 #define CLR(t, f) (t) &= ~(f)
198 #define ISSET(t, f) ((t) & (f))
200 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
201 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
204 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
205 "LU", "TTY input statistic");
207 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
208 "LU", "TTY output statistic");
212 * list of struct tty where pstat(8) can pick it up with sysctl
214 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
217 * Initial open of tty, or (re)entry to standard tty line discipline.
220 ttyopen(cdev_t device, struct tty *tp)
222 lwkt_gettoken(&tp->t_token);
224 if (!ISSET(tp->t_state, TS_ISOPEN)) {
225 SET(tp->t_state, TS_ISOPEN);
226 if (ISSET(tp->t_cflag, CLOCAL)) {
227 SET(tp->t_state, TS_CONNECTED);
229 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
232 lwkt_reltoken(&tp->t_token);
238 * Handle close() on a tty line: flush and set to initial state,
239 * bumping generation number so that pending read/write calls
240 * can detect recycling of the tty.
242 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
243 * and l_close() should have flushed, but we repeat the spltty() and
244 * the flush in case there are buggy callers.
247 ttyclose(struct tty *tp)
249 lwkt_gettoken(&tp->t_token);
250 funsetown(&tp->t_sigio);
254 ttyflush(tp, FREAD | FWRITE);
255 clist_free_cblocks(&tp->t_canq);
256 clist_free_cblocks(&tp->t_outq);
257 clist_free_cblocks(&tp->t_rawq);
260 tp->t_line = TTYDISC;
262 tp->t_state &= TS_REGISTERED; /* clear all bits except */
263 lwkt_reltoken(&tp->t_token);
269 * Disassociate the tty from its session. Traditionally this has only been
270 * a half-close, meaning that the session was still allowed to point at the
271 * tty (resulting in the tty in the ps command showing something like 'p0-'),
272 * even though the tty is no longer pointing at the session.
274 * The half close seems to be useful only for 'ps' output but there is as
275 * yet no reason to remove the feature. The full-close code is currently
276 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
279 ttyclearsession(struct tty *tp)
282 struct procglob *prg;
285 lwkt_gettoken(&tp->t_token);
294 if ((sp = tp->t_session) != NULL) {
296 lwkt_gettoken(&prg->proc_token);
297 if (sp != tp->t_session) {
298 lwkt_reltoken(&prg->proc_token);
301 tp->t_session = NULL;
303 #ifdef TTY_DO_FULL_CLOSE
304 /* FULL CLOSE (not yet) */
305 if (sp->s_ttyp == tp) {
309 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
310 "%p/%p\n", sp->s_ttyp, tp);
313 lwkt_reltoken(&prg->proc_token);
315 lwkt_reltoken(&tp->t_token);
319 * Release the tty vnode association for a session. This is the
320 * 'other half' of the close. Because multiple opens of /dev/tty
321 * only generate a single open to the actual tty, the file modes
322 * are locked to FREAD|FWRITE.
324 * If dorevoke is non-zero, the session is also revoked. We have to
325 * close the vnode if VCTTYISOPEN is set.
328 ttyclosesession(struct session *sp, int dorevoke)
331 struct procglob *prg;
334 lwkt_gettoken(&prg->proc_token);
337 * There may not be a controlling terminal or it may have been closed
340 if ((vp = sp->s_ttyvp) == NULL) {
341 lwkt_reltoken(&prg->proc_token);
346 * We need a lock if we have to close or revoke.
348 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
350 if (vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM)) {
356 * Retry if the vnode was ripped out from under us
358 if (vp != sp->s_ttyvp) {
365 * Close and revoke as needed
368 if (vp->v_flag & VCTTYISOPEN) {
369 vclrflags(vp, VCTTYISOPEN);
370 VOP_CLOSE(vp, FREAD|FWRITE, NULL);
374 vrevoke(vp, proc0.p_ucred);
380 lwkt_reltoken(&prg->proc_token);
383 #define FLUSHQ(q) { \
385 ndflush(q, (q)->c_cc); \
388 /* Is 'c' a line delimiter ("break" character)? */
389 #define TTBREAKC(c, lflag) \
390 ((c) == '\n' || (((c) == cc[VEOF] || \
391 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
392 (c) != _POSIX_VDISABLE))
395 * Process input of a single character received on a tty.
398 ttyinput(int c, struct tty *tp)
400 tcflag_t iflag, lflag;
404 lwkt_gettoken(&tp->t_token);
406 * If input is pending take it first.
409 if (ISSET(lflag, PENDIN))
414 if (ISSET(lflag, ICANON))
421 * Block further input iff:
422 * current input > threshold AND input is available to user program
423 * AND input flow control is enabled and not yet invoked.
424 * The 3 is slop for PARMRK.
427 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
428 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
429 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
430 !ISSET(tp->t_state, TS_TBLOCK))
433 /* Handle exceptional conditions (break, parity, framing). */
435 err = (ISSET(c, TTY_ERRORMASK));
437 CLR(c, TTY_ERRORMASK);
438 if (ISSET(err, TTY_BI)) {
439 if (ISSET(iflag, IGNBRK)) {
440 lwkt_reltoken(&tp->t_token);
443 if (ISSET(iflag, BRKINT)) {
444 ttyflush(tp, FREAD | FWRITE);
445 pgsignal(tp->t_pgrp, SIGINT, 1);
448 if (ISSET(iflag, PARMRK))
450 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
451 || ISSET(err, TTY_FE)) {
452 if (ISSET(iflag, IGNPAR)) {
453 lwkt_reltoken(&tp->t_token);
456 else if (ISSET(iflag, PARMRK)) {
458 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
461 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
462 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
463 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
470 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
472 if (!ISSET(lflag, EXTPROC)) {
474 * Check for literal nexting very first
476 if (ISSET(tp->t_state, TS_LNCH)) {
478 CLR(tp->t_state, TS_LNCH);
481 * Scan for special characters. This code
482 * is really just a big case statement with
483 * non-constant cases. The bottom of the
484 * case statement is labeled ``endcase'', so goto
485 * it after a case match, or similar.
489 * Control chars which aren't controlled
490 * by ICANON, ISIG, or IXON.
492 if (ISSET(lflag, IEXTEN)) {
493 if (CCEQ(cc[VLNEXT], c)) {
494 if (ISSET(lflag, ECHO)) {
495 if (ISSET(lflag, ECHOE)) {
496 (void)ttyoutput('^', tp);
497 (void)ttyoutput('\b', tp);
501 SET(tp->t_state, TS_LNCH);
504 if (CCEQ(cc[VDISCARD], c)) {
505 if (ISSET(lflag, FLUSHO))
506 CLR(tp->t_lflag, FLUSHO);
508 ttyflush(tp, FWRITE);
510 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
512 SET(tp->t_lflag, FLUSHO);
520 if (ISSET(lflag, ISIG)) {
521 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
522 if (!ISSET(lflag, NOFLSH))
523 ttyflush(tp, FREAD | FWRITE);
526 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
529 if (CCEQ(cc[VSUSP], c)) {
530 if (!ISSET(lflag, NOFLSH))
533 pgsignal(tp->t_pgrp, SIGTSTP, 1);
538 * Handle start/stop characters.
540 if (ISSET(iflag, IXON)) {
541 if (CCEQ(cc[VSTOP], c)) {
542 if (!ISSET(tp->t_state, TS_TTSTOP)) {
543 SET(tp->t_state, TS_TTSTOP);
544 (*tp->t_stop)(tp, 0);
545 lwkt_reltoken(&tp->t_token);
548 if (!CCEQ(cc[VSTART], c)) {
549 lwkt_reltoken(&tp->t_token);
553 * if VSTART == VSTOP then toggle
557 if (CCEQ(cc[VSTART], c))
561 * IGNCR, ICRNL, & INLCR
564 if (ISSET(iflag, IGNCR)) {
565 lwkt_reltoken(&tp->t_token);
568 else if (ISSET(iflag, ICRNL))
570 } else if (c == '\n' && ISSET(iflag, INLCR))
573 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
575 * From here on down canonical mode character
576 * processing takes place.
579 * erase or erase2 (^H / ^?)
581 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
583 ttyrub(clist_unputc(&tp->t_rawq), tp);
589 if (CCEQ(cc[VKILL], c)) {
590 if (ISSET(lflag, ECHOKE) &&
591 tp->t_rawq.c_cc == tp->t_rocount &&
592 !ISSET(lflag, ECHOPRT))
593 while (tp->t_rawq.c_cc)
594 ttyrub(clist_unputc(&tp->t_rawq), tp);
597 if (ISSET(lflag, ECHOK) ||
598 ISSET(lflag, ECHOKE))
603 CLR(tp->t_state, TS_LOCAL);
609 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
615 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
620 * erase last char of word and remember the
621 * next chars type (for ALTWERASE)
624 c = clist_unputc(&tp->t_rawq);
627 if (c == ' ' || c == '\t') {
628 clist_putc(c, &tp->t_rawq);
637 c = clist_unputc(&tp->t_rawq);
640 } while (c != ' ' && c != '\t' &&
641 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
642 clist_putc(c, &tp->t_rawq);
648 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
653 * ^T - kernel info and generate SIGINFO
655 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
656 if (ISSET(lflag, ISIG))
657 pgsignal(tp->t_pgrp, SIGINFO, 1);
658 if (!ISSET(lflag, NOKERNINFO))
662 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
663 if (ISSET(lflag, ISIG))
664 pgsignal(tp->t_pgrp, SIGCKPT, 1);
669 * Check for input buffer overflow
671 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
673 if (ISSET(iflag, IMAXBEL)) {
674 if (tp->t_outq.c_cc < tp->t_ohiwat)
675 (void)ttyoutput(CTRL('g'), tp);
680 if (c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP) &&
681 ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR)) {
682 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
686 * Put data char in q for user and
687 * wakeup on seeing a line delimiter.
689 if (clist_putc(c, &tp->t_rawq) >= 0) {
690 if (!ISSET(lflag, ICANON)) {
695 if (TTBREAKC(c, lflag)) {
697 clist_catq(&tp->t_rawq, &tp->t_canq);
699 } else if (tp->t_rocount++ == 0)
700 tp->t_rocol = tp->t_column;
701 if (ISSET(tp->t_state, TS_ERASE)) {
703 * end of prterase \.../
705 CLR(tp->t_state, TS_ERASE);
706 (void)ttyoutput('/', tp);
710 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
712 * Place the cursor over the '^' of the ^D.
714 i = imin(2, tp->t_column - i);
716 (void)ttyoutput('\b', tp);
723 * IXANY means allow any character to restart output.
725 if (ISSET(tp->t_state, TS_TTSTOP) &&
726 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
727 lwkt_reltoken(&tp->t_token);
731 CLR(tp->t_lflag, FLUSHO);
732 CLR(tp->t_state, TS_TTSTOP);
734 lwkt_reltoken(&tp->t_token);
735 return (ttstart(tp));
739 * Output a single character on a tty, doing output processing
740 * as needed (expanding tabs, newline processing, etc.).
741 * Returns < 0 if succeeds, otherwise returns char to resend.
745 ttyoutput(int c, struct tty *tp)
750 lwkt_gettoken(&tp->t_token);
752 if (!ISSET(oflag, OPOST)) {
753 if (ISSET(tp->t_lflag, FLUSHO)) {
754 lwkt_reltoken(&tp->t_token);
757 if (clist_putc(c, &tp->t_outq)) {
758 lwkt_reltoken(&tp->t_token);
763 lwkt_reltoken(&tp->t_token);
767 * Do tab expansion if OXTABS aka TAB3 is set. Special case if we
768 * external processing, we don't do the tab expansion because we'll
769 * probably get it wrong. If tab expansion needs to be done, let
770 * it happen externally.
772 CLR(c, ~TTY_CHARMASK);
774 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
775 c = 8 - (tp->t_column & 7);
776 if (!ISSET(tp->t_lflag, FLUSHO)) {
777 c -= clist_btoq(" ", c, &tp->t_outq);
782 lwkt_reltoken(&tp->t_token);
783 return (c ? -1 : '\t');
785 if (c == CEOT && ISSET(oflag, ONOEOT)) {
786 lwkt_reltoken(&tp->t_token);
791 * Newline translation: if ONLCR is set,
792 * translate newline into "\r\n".
794 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
797 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
798 lwkt_reltoken(&tp->t_token);
802 /* If OCRNL is set, translate "\r" into "\n". */
803 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
805 /* If ONOCR is set, don't transmit CRs when on column 0. */
806 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
807 lwkt_reltoken(&tp->t_token);
813 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
814 lwkt_reltoken(&tp->t_token);
827 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
837 col = (col + 8) & ~7;
841 lwkt_reltoken(&tp->t_token);
847 * Ioctls for all tty devices. Called after line-discipline specific ioctl
848 * has been called to do discipline-specific functions and/or reject any
849 * of these ioctl commands.
853 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
855 struct thread *td = curthread;
856 struct lwp *lp = td->td_lwp;
857 struct proc *p = td->td_proc;
863 lwkt_gettoken(&tp->t_token);
864 lwkt_gettoken(&p->p_token);
866 /* If the ioctl involves modification, hang if in the background. */
890 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) &&
891 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
892 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
893 if (p->p_pgrp->pg_jobc == 0) {
894 lwkt_reltoken(&p->p_token);
895 lwkt_reltoken(&tp->t_token);
898 pgsignal(p->p_pgrp, SIGTTOU, 1);
899 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
902 lwkt_reltoken(&p->p_token);
903 lwkt_reltoken(&tp->t_token);
910 switch (cmd) { /* Process the ioctl. */
911 case FIOASYNC: /* set/clear async i/o */
913 SET(tp->t_state, TS_ASYNC);
915 CLR(tp->t_state, TS_ASYNC);
917 case FIONREAD: /* get # bytes to read */
918 *(int *)data = ttnread(tp);
923 * Policy -- Don't allow FIOSETOWN on someone else's
926 if (tp->t_session != NULL && !isctty(p, tp)) {
927 lwkt_reltoken(&p->p_token);
928 lwkt_reltoken(&tp->t_token);
932 error = fsetown(*(int *)data, &tp->t_sigio);
934 lwkt_reltoken(&p->p_token);
935 lwkt_reltoken(&tp->t_token);
940 if (tp->t_session != NULL && !isctty(p, tp)) {
941 lwkt_reltoken(&p->p_token);
942 lwkt_reltoken(&tp->t_token);
945 *(int *)data = fgetown(&tp->t_sigio);
948 case TIOCEXCL: /* set exclusive use of tty */
949 SET(tp->t_state, TS_XCLUDE);
951 case TIOCFLUSH: { /* flush buffers */
952 int flags = *(int *)data;
955 flags = FREAD | FWRITE;
957 flags &= FREAD | FWRITE;
961 case TIOCCONS: /* become virtual console */
963 if (constty && constty != tp &&
964 ISSET(constty->t_state, TS_CONNECTED)) {
965 lwkt_reltoken(&p->p_token);
966 lwkt_reltoken(&tp->t_token);
970 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
971 lwkt_reltoken(&p->p_token);
972 lwkt_reltoken(&tp->t_token);
977 } else if (tp == constty)
980 case TIOCDRAIN: /* wait till output drained */
983 lwkt_reltoken(&p->p_token);
984 lwkt_reltoken(&tp->t_token);
988 case TIOCGETA: { /* get termios struct */
989 struct termios *t = (struct termios *)data;
991 bcopy(&tp->t_termios, t, sizeof(struct termios));
994 case TIOCGETD: /* get line discipline */
995 *(int *)data = tp->t_line;
997 case TIOCGWINSZ: /* get window size */
998 *(struct winsize *)data = tp->t_winsize;
1000 case TIOCGPGRP: /* get pgrp of tty */
1001 if (!isctty(p, tp)) {
1002 lwkt_reltoken(&p->p_token);
1003 lwkt_reltoken(&tp->t_token);
1006 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1008 case TIOCGSID: /* get sid of tty */
1009 if (!isctty(p, tp)) {
1010 lwkt_reltoken(&p->p_token);
1011 lwkt_reltoken(&tp->t_token);
1014 *(int *)data = tp->t_session->s_sid;
1017 case TIOCHPCL: /* hang up on last close */
1018 SET(tp->t_cflag, HUPCL);
1021 case TIOCNXCL: /* reset exclusive use of tty */
1022 CLR(tp->t_state, TS_XCLUDE);
1024 case TIOCOUTQ: /* output queue size */
1025 *(int *)data = tp->t_outq.c_cc;
1027 case TIOCSETA: /* set termios struct */
1028 case TIOCSETAW: /* drain output, set */
1029 case TIOCSETAF: { /* drn out, fls in, set */
1030 struct termios *t = (struct termios *)data;
1032 if (t->c_ispeed == 0)
1033 t->c_ispeed = t->c_ospeed;
1034 if (t->c_ispeed == 0)
1035 t->c_ispeed = tp->t_ospeed;
1036 if (t->c_ispeed == 0) {
1037 lwkt_reltoken(&p->p_token);
1038 lwkt_reltoken(&tp->t_token);
1041 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1042 error = ttywait(tp);
1044 lwkt_reltoken(&p->p_token);
1045 lwkt_reltoken(&tp->t_token);
1048 if (cmd == TIOCSETAF)
1049 ttyflush(tp, FREAD);
1051 if (!ISSET(t->c_cflag, CIGNORE)) {
1053 * Set device hardware.
1055 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1056 lwkt_reltoken(&p->p_token);
1057 lwkt_reltoken(&tp->t_token);
1060 if (ISSET(t->c_cflag, CLOCAL) &&
1061 !ISSET(tp->t_cflag, CLOCAL)) {
1063 * XXX disconnections would be too hard to
1064 * get rid of without this kludge. The only
1065 * way to get rid of controlling terminals
1066 * is to exit from the session leader.
1068 CLR(tp->t_state, TS_ZOMBIE);
1070 wakeup(TSA_CARR_ON(tp));
1074 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1075 ISSET(t->c_cflag, CLOCAL)) &&
1076 !ISSET(tp->t_state, TS_ZOMBIE))
1077 SET(tp->t_state, TS_CONNECTED);
1079 CLR(tp->t_state, TS_CONNECTED);
1080 tp->t_cflag = t->c_cflag;
1081 tp->t_ispeed = t->c_ispeed;
1082 if (t->c_ospeed != 0)
1083 tp->t_ospeed = t->c_ospeed;
1086 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1088 if (ISSET(t->c_lflag, ICANON))
1089 SET(tp->t_lflag, PENDIN);
1092 * XXX we really shouldn't allow toggling
1093 * ICANON while we're in a non-termios line
1094 * discipline. Now we have to worry about
1095 * panicing for a null queue.
1097 if (tp->t_canq.c_ccmax > 0 &&
1098 tp->t_rawq.c_ccmax > 0) {
1099 clist_catq(&tp->t_rawq, &tp->t_canq);
1101 * XXX the queue limits may be
1102 * different, so the old queue
1103 * swapping method no longer works.
1105 clist_catq(&tp->t_canq, &tp->t_rawq);
1107 CLR(tp->t_lflag, PENDIN);
1111 tp->t_iflag = t->c_iflag;
1112 tp->t_oflag = t->c_oflag;
1114 * Make the EXTPROC bit read only.
1116 if (ISSET(tp->t_lflag, EXTPROC))
1117 SET(t->c_lflag, EXTPROC);
1119 CLR(t->c_lflag, EXTPROC);
1120 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1121 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1122 t->c_cc[VTIME] != tp->t_cc[VTIME])
1124 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1127 case TIOCSETD: { /* set line discipline */
1128 int t = *(int *)data;
1129 cdev_t device = tp->t_dev;
1131 if ((u_int)t >= nlinesw) {
1132 lwkt_reltoken(&p->p_token);
1133 lwkt_reltoken(&tp->t_token);
1136 if (t != tp->t_line) {
1137 (*linesw[tp->t_line].l_close)(tp, flag);
1138 error = (*linesw[t].l_open)(device, tp);
1140 (void)(*linesw[tp->t_line].l_open)(device, tp);
1141 lwkt_reltoken(&p->p_token);
1142 lwkt_reltoken(&tp->t_token);
1149 case TIOCSTART: /* start output, like ^Q */
1150 if (ISSET(tp->t_state, TS_TTSTOP) ||
1151 ISSET(tp->t_lflag, FLUSHO)) {
1152 CLR(tp->t_lflag, FLUSHO);
1153 CLR(tp->t_state, TS_TTSTOP);
1157 case TIOCSTI: /* simulate terminal input */
1158 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1159 lwkt_reltoken(&p->p_token);
1160 lwkt_reltoken(&tp->t_token);
1163 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1164 lwkt_reltoken(&p->p_token);
1165 lwkt_reltoken(&tp->t_token);
1168 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1170 case TIOCSTOP: /* stop output, like ^S */
1171 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1172 SET(tp->t_state, TS_TTSTOP);
1173 (*tp->t_stop)(tp, 0);
1176 case TIOCSCTTY: /* become controlling tty */
1177 /* Session ctty vnode pointer set in vnode layer. */
1178 if (!SESS_LEADER(p) ||
1179 ((p->p_session->s_ttyvp || tp->t_session) &&
1180 (tp->t_session != p->p_session))) {
1181 lwkt_reltoken(&p->p_token);
1182 lwkt_reltoken(&tp->t_token);
1186 tp->t_session = p->p_session;
1189 tp->t_pgrp = p->p_pgrp;
1190 otp = p->p_session->s_ttyp;
1191 p->p_session->s_ttyp = tp;
1192 p->p_flags |= P_CONTROLT;
1200 case TIOCSPGRP: { /* set pgrp of tty */
1201 pid_t pgid = *(int *)data;
1203 if (!isctty(p, tp)) {
1204 lwkt_reltoken(&p->p_token);
1205 lwkt_reltoken(&tp->t_token);
1208 else if (pgid < 1 || pgid > PID_MAX) {
1209 lwkt_reltoken(&p->p_token);
1210 lwkt_reltoken(&tp->t_token);
1213 struct pgrp *pgrp = pgfind(pgid);
1214 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1217 lwkt_reltoken(&p->p_token);
1218 lwkt_reltoken(&tp->t_token);
1230 case TIOCSTAT: /* simulate control-T */
1233 case TIOCSWINSZ: /* set window size */
1234 if (bcmp((caddr_t)&tp->t_winsize, data,
1235 sizeof (struct winsize))) {
1236 tp->t_winsize = *(struct winsize *)data;
1237 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1240 case TIOCSDRAINWAIT:
1241 error = priv_check(td, PRIV_ROOT);
1243 lwkt_reltoken(&p->p_token);
1244 lwkt_reltoken(&tp->t_token);
1247 tp->t_timeout = *(int *)data * hz;
1248 wakeup(TSA_OCOMPLETE(tp));
1249 wakeup(TSA_OLOWAT(tp));
1251 case TIOCGDRAINWAIT:
1252 *(int *)data = tp->t_timeout / hz;
1255 lwkt_reltoken(&p->p_token);
1256 lwkt_reltoken(&tp->t_token);
1259 lwkt_reltoken(&p->p_token);
1260 lwkt_reltoken(&tp->t_token);
1264 static struct filterops ttyread_filtops =
1265 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread };
1266 static struct filterops ttywrite_filtops =
1267 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite };
1270 ttykqfilter(struct dev_kqfilter_args *ap)
1272 cdev_t dev = ap->a_head.a_dev;
1273 struct knote *kn = ap->a_kn;
1274 struct tty *tp = dev->si_tty;
1275 struct klist *klist;
1279 lwkt_gettoken(&tp->t_token);
1280 switch (kn->kn_filter) {
1282 klist = &tp->t_rkq.ki_note;
1283 kn->kn_fop = &ttyread_filtops;
1286 klist = &tp->t_wkq.ki_note;
1287 kn->kn_fop = &ttywrite_filtops;
1290 ap->a_result = EOPNOTSUPP;
1291 lwkt_reltoken(&tp->t_token);
1294 lwkt_reltoken(&tp->t_token);
1295 kn->kn_hook = (caddr_t)dev;
1296 knote_insert(klist, kn);
1302 filt_ttyrdetach(struct knote *kn)
1304 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1306 lwkt_gettoken(&tp->t_token);
1307 knote_remove(&tp->t_rkq.ki_note, kn);
1308 lwkt_reltoken(&tp->t_token);
1312 filt_ttyread(struct knote *kn, long hint)
1314 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1316 lwkt_gettoken(&tp->t_token);
1317 kn->kn_data = ttnread(tp);
1318 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1319 kn->kn_flags |= (EV_EOF | EV_NODATA);
1320 lwkt_reltoken(&tp->t_token);
1323 lwkt_reltoken(&tp->t_token);
1324 return (kn->kn_data > 0);
1328 filt_ttywdetach(struct knote *kn)
1330 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1332 lwkt_gettoken(&tp->t_token);
1333 knote_remove(&tp->t_wkq.ki_note, kn);
1334 lwkt_reltoken(&tp->t_token);
1338 filt_ttywrite(struct knote *kn, long hint)
1340 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1343 lwkt_gettoken(&tp->t_token);
1344 kn->kn_data = tp->t_outq.c_cc;
1345 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1346 lwkt_reltoken(&tp->t_token);
1349 ret = (kn->kn_data <= tp->t_olowat &&
1350 ISSET(tp->t_state, TS_CONNECTED));
1351 lwkt_reltoken(&tp->t_token);
1356 * NOTE: tp->t_token must be held.
1359 ttnread(struct tty *tp)
1363 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
1364 if (ISSET(tp->t_lflag, PENDIN))
1366 nread = tp->t_canq.c_cc;
1367 if (!ISSET(tp->t_lflag, ICANON)) {
1368 nread += tp->t_rawq.c_cc;
1369 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1376 * Wait for output to drain.
1379 ttywait(struct tty *tp)
1384 lwkt_gettoken(&tp->t_token);
1385 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1386 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1388 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1389 ISSET(tp->t_state, TS_CONNECTED)) {
1390 SET(tp->t_state, TS_SO_OCOMPLETE);
1391 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1395 if (error == EWOULDBLOCK)
1402 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1404 lwkt_reltoken(&tp->t_token);
1410 * Flush if successfully wait.
1413 ttywflush(struct tty *tp)
1417 if ((error = ttywait(tp)) == 0)
1418 ttyflush(tp, FREAD);
1423 * Flush tty read and/or write queues, notifying anyone waiting.
1426 ttyflush(struct tty *tp, int rw)
1428 lwkt_gettoken(&tp->t_token);
1433 FLUSHQ(&tp->t_outq);
1434 CLR(tp->t_state, TS_TTSTOP);
1436 (*tp->t_stop)(tp, rw);
1438 FLUSHQ(&tp->t_canq);
1439 FLUSHQ(&tp->t_rawq);
1440 CLR(tp->t_lflag, PENDIN);
1443 CLR(tp->t_state, TS_LOCAL);
1445 if (ISSET(tp->t_state, TS_TBLOCK)) {
1447 FLUSHQ(&tp->t_outq);
1451 * Don't let leave any state that might clobber the
1452 * next line discipline (although we should do more
1453 * to send the START char). Not clearing the state
1454 * may have caused the "putc to a clist with no
1455 * reserved cblocks" panic/kprintf.
1457 CLR(tp->t_state, TS_TBLOCK);
1459 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1460 if (ISSET(tp->t_iflag, IXOFF)) {
1462 * XXX wait a bit in the hope that the stop
1463 * character (if any) will go out. Waiting
1464 * isn't good since it allows races. This
1465 * will be fixed when the stop character is
1466 * put in a special queue. Don't bother with
1467 * the checks in ttywait() since the timeout
1470 SET(tp->t_state, TS_SO_OCOMPLETE);
1471 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1474 * Don't try sending the stop character again.
1476 CLR(tp->t_state, TS_TBLOCK);
1483 FLUSHQ(&tp->t_outq);
1486 lwkt_reltoken(&tp->t_token);
1490 * Copy in the default termios characters.
1493 termioschars(struct termios *t)
1495 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1502 ttychars(struct tty *tp)
1504 lwkt_gettoken(&tp->t_token);
1505 termioschars(&tp->t_termios);
1506 lwkt_reltoken(&tp->t_token);
1510 * Handle input high water. Send stop character for the IXOFF case. Turn
1511 * on our input flow control bit and propagate the changes to the driver.
1512 * XXX the stop character should be put in a special high priority queue.
1515 ttyblock(struct tty *tp)
1517 lwkt_gettoken(&tp->t_token);
1518 SET(tp->t_state, TS_TBLOCK);
1519 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1520 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1521 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1523 lwkt_reltoken(&tp->t_token);
1527 * Handle input low water. Send start character for the IXOFF case. Turn
1528 * off our input flow control bit and propagate the changes to the driver.
1529 * XXX the start character should be put in a special high priority queue.
1532 ttyunblock(struct tty *tp)
1534 lwkt_gettoken(&tp->t_token);
1535 CLR(tp->t_state, TS_TBLOCK);
1536 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1537 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1538 SET(tp->t_state, TS_TBLOCK); /* try again later */
1540 lwkt_reltoken(&tp->t_token);
1544 ttstart(struct tty *tp)
1546 lwkt_gettoken(&tp->t_token);
1547 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1549 lwkt_reltoken(&tp->t_token);
1554 * "close" a line discipline
1557 ttylclose(struct tty *tp, int flag)
1559 lwkt_gettoken(&tp->t_token);
1560 if (flag & FNONBLOCK || ttywflush(tp))
1561 ttyflush(tp, FREAD | FWRITE);
1562 lwkt_reltoken(&tp->t_token);
1567 ttyhold(struct tty *tp)
1569 lwkt_gettoken(&tp->t_token);
1571 lwkt_reltoken(&tp->t_token);
1575 ttyunhold(struct tty *tp)
1577 lwkt_gettoken(&tp->t_token);
1582 lwkt_reltoken(&tp->t_token);
1586 * Handle modem control transition on a tty.
1587 * Flag indicates new state of carrier.
1588 * Returns 0 if the line should be turned off, otherwise 1.
1591 ttymodem(struct tty *tp, int flag)
1593 lwkt_gettoken(&tp->t_token);
1594 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1596 * MDMBUF: do flow control according to carrier flag
1597 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1598 * works if IXON and IXANY are clear.
1601 CLR(tp->t_state, TS_CAR_OFLOW);
1602 CLR(tp->t_state, TS_TTSTOP);
1604 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1605 SET(tp->t_state, TS_CAR_OFLOW);
1606 SET(tp->t_state, TS_TTSTOP);
1607 (*tp->t_stop)(tp, 0);
1609 } else if (flag == 0) {
1613 CLR(tp->t_state, TS_CARR_ON);
1614 if (ISSET(tp->t_state, TS_ISOPEN) &&
1615 !ISSET(tp->t_cflag, CLOCAL)) {
1616 SET(tp->t_state, TS_ZOMBIE);
1617 CLR(tp->t_state, TS_CONNECTED);
1618 if (tp->t_session && tp->t_session->s_leader)
1619 ksignal(tp->t_session->s_leader, SIGHUP);
1620 ttyflush(tp, FREAD | FWRITE);
1621 lwkt_reltoken(&tp->t_token);
1628 SET(tp->t_state, TS_CARR_ON);
1629 if (!ISSET(tp->t_state, TS_ZOMBIE))
1630 SET(tp->t_state, TS_CONNECTED);
1631 wakeup(TSA_CARR_ON(tp));
1635 lwkt_reltoken(&tp->t_token);
1640 * Reinput pending characters after state switch
1643 ttypend(struct tty *tp)
1648 lwkt_gettoken(&tp->t_token);
1649 CLR(tp->t_lflag, PENDIN);
1650 SET(tp->t_state, TS_TYPEN);
1652 * XXX this assumes too much about clist internals. It may even
1653 * fail if the cblock slush pool is empty. We can't allocate more
1654 * cblocks here because we are called from an interrupt handler
1655 * and clist_alloc_cblocks() can wait.
1658 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1659 clist_alloc_cblocks(&tp->t_rawq, tq.c_ccmax);
1660 while ((c = clist_getc(&tq)) >= 0)
1662 CLR(tp->t_state, TS_TYPEN);
1663 clist_free_cblocks(&tq);
1664 lwkt_reltoken(&tp->t_token);
1668 * Process a read call on a tty device.
1671 ttread(struct tty *tp, struct uio *uio, int flag)
1676 cc_t *cc = tp->t_cc;
1679 int first, error = 0;
1680 int has_stime = 0, last_cc = 0;
1681 long slp = 0; /* XXX this should be renamed `timo'. */
1682 struct timeval stime;
1684 lp = curthread->td_lwp;
1685 stime.tv_sec = 0; /* fix compiler warnings */
1688 lwkt_gettoken(&tp->t_token);
1690 lflag = tp->t_lflag;
1692 * take pending input first
1694 if (ISSET(lflag, PENDIN)) {
1696 splz(); /* reduce latency */
1697 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1701 * Hang process if it's in the background.
1703 if ((pp = curproc) != NULL)
1704 lwkt_gettoken(&pp->p_token);
1705 if (pp && isbackground(pp, tp)) {
1706 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1707 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1708 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1709 lwkt_reltoken(&pp->p_token);
1710 lwkt_reltoken(&tp->t_token);
1713 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1714 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1716 lwkt_reltoken(&pp->p_token);
1717 lwkt_reltoken(&tp->t_token);
1720 lwkt_reltoken(&pp->p_token);
1724 lwkt_reltoken(&pp->p_token);
1726 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1727 lwkt_reltoken(&tp->t_token);
1728 return (0); /* EOF */
1732 * If canonical, use the canonical queue,
1733 * else use the raw queue.
1735 * (should get rid of clists...)
1737 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1739 if (flag & IO_NDELAY) {
1742 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1743 lwkt_reltoken(&tp->t_token);
1746 lwkt_reltoken(&tp->t_token);
1747 return (EWOULDBLOCK);
1749 if (!ISSET(lflag, ICANON)) {
1752 struct timeval timecopy;
1755 * Check each of the four combinations.
1756 * (m > 0 && t == 0) is the normal read case.
1757 * It should be fairly efficient, so we check that and its
1758 * companion case (m == 0 && t == 0) first.
1759 * For the other two cases, we compute the target sleep time
1768 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1769 lwkt_reltoken(&tp->t_token);
1772 t *= 100000; /* time in us */
1773 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1774 ((t1).tv_usec - (t2).tv_usec))
1780 getmicrotime(&timecopy);
1781 if (has_stime == 0) {
1782 /* first character, start timer */
1786 } else if (qp->c_cc > last_cc) {
1787 /* got a character, restart timer */
1791 /* nothing, check expiration */
1792 slp = t - diff(timecopy, stime);
1797 } else { /* m == 0 */
1800 getmicrotime(&timecopy);
1801 if (has_stime == 0) {
1806 slp = t - diff(timecopy, stime);
1808 /* Timed out, but 0 is enough input. */
1809 lwkt_reltoken(&tp->t_token);
1816 * Rounding down may make us wake up just short
1817 * of the target, so we round up.
1818 * The formula is ceiling(slp * hz/1000000).
1819 * 32-bit arithmetic is enough for hz < 169.
1820 * XXX see tvtohz() for how to avoid overflow if hz
1821 * is large (divide by `tick' and/or arrange to
1822 * use tvtohz() if hz is large).
1824 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1827 if (qp->c_cc <= 0) {
1830 * There is no input, or not enough input and we can block.
1832 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1833 ISSET(tp->t_state, TS_CONNECTED) ?
1834 "ttyin" : "ttyhup", (int)slp);
1835 if (error == EWOULDBLOCK)
1838 lwkt_reltoken(&tp->t_token);
1842 * XXX what happens if another process eats some input
1843 * while we are asleep (not just here)? It would be
1844 * safest to detect changes and reset our state variables
1845 * (has_stime and last_cc).
1852 * Input present, check for input mapping and processing.
1855 if (ISSET(lflag, ICANON | ISIG))
1861 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1862 icc = clist_qtob(qp, ibuf, icc);
1868 error = uiomove(ibuf, (size_t)icc, uio);
1870 * XXX if there was an error then we should ungetc() the
1871 * unmoved chars and reduce icc here.
1875 if (uio->uio_resid == 0)
1889 * delayed suspend (^Y)
1891 if (CCEQ(cc[VDSUSP], c) &&
1892 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1893 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1895 error = ttysleep(tp, &lbolt, PCATCH,
1904 * Interpret EOF only in canonical mode.
1906 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1909 * Give user character.
1911 error = ureadc(c, uio);
1913 /* XXX should ungetc(c, qp). */
1915 if (uio->uio_resid == 0)
1918 * In canonical mode check for a "break character"
1919 * marking the end of a "line of input".
1921 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1928 * Look to unblock input now that (presumably)
1929 * the input queue has gone down.
1931 if (ISSET(tp->t_state, TS_TBLOCK) &&
1932 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat) {
1936 lwkt_reltoken(&tp->t_token);
1941 * Check the output queue on tp for space for a kernel message (from uprintf
1942 * or tprintf). Allow some space over the normal hiwater mark so we don't
1943 * lose messages due to normal flow control, but don't let the tty run amok.
1944 * Sleeps here are not interruptible, but we return prematurely if new signals
1948 ttycheckoutq(struct tty *tp, int wait)
1950 struct lwp *lp = curthread->td_lwp;
1952 sigset_t oldset, newset;
1954 lwkt_gettoken(&tp->t_token);
1955 hiwat = tp->t_ohiwat;
1956 SIGEMPTYSET(oldset);
1957 SIGEMPTYSET(newset);
1959 oldset = lwp_sigpend(lp);
1960 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
1961 while (tp->t_outq.c_cc > hiwat) {
1963 if (tp->t_outq.c_cc <= hiwat)
1966 newset = lwp_sigpend(lp);
1967 if (!wait || SIGSETNEQ(oldset, newset)) {
1968 lwkt_reltoken(&tp->t_token);
1971 SET(tp->t_state, TS_SO_OLOWAT);
1972 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
1975 lwkt_reltoken(&tp->t_token);
1980 * Process a write call on a tty device.
1983 ttwrite(struct tty *tp, struct uio *uio, int flag)
1989 int i, hiwat, error;
1994 lwkt_gettoken(&tp->t_token);
1995 lp = curthread->td_lwp;
1996 hiwat = tp->t_ohiwat;
1997 cnt = uio->uio_resid;
2001 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2002 if (uio->uio_resid == cnt)
2006 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2007 if (flag & IO_NDELAY) {
2008 error = EWOULDBLOCK;
2011 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2018 * Hang the process if it's in the background.
2020 if ((pp = curproc) != NULL)
2021 lwkt_gettoken(&pp->p_token);
2022 if (pp && isbackground(pp, tp) &&
2023 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) &&
2024 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2025 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2026 if (pp->p_pgrp->pg_jobc == 0) {
2028 lwkt_reltoken(&pp->p_token);
2031 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2032 lwkt_reltoken(&pp->p_token);
2033 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2039 lwkt_reltoken(&pp->p_token);
2041 * Process the user's data in at most OBUFSIZ chunks. Perform any
2042 * output translation. Keep track of high water mark, sleep on
2043 * overflow awaiting device aid in acquiring new space.
2045 while (uio->uio_resid > 0 || cc > 0) {
2046 if (ISSET(tp->t_lflag, FLUSHO)) {
2048 lwkt_reltoken(&tp->t_token);
2051 if (tp->t_outq.c_cc > hiwat)
2054 * Grab a hunk of data from the user, unless we have some
2055 * leftover from last time.
2058 cc = szmin(uio->uio_resid, OBUFSIZ);
2060 error = uiomove(cp, (size_t)cc, uio);
2067 * If nothing fancy need be done, grab those characters we
2068 * can handle without any of ttyoutput's processing and
2069 * just transfer them to the output q. For those chars
2070 * which require special processing (as indicated by the
2071 * bits in char_type), call ttyoutput. After processing
2072 * a hunk of data, look for FLUSHO so ^O's will take effect
2076 if (!ISSET(tp->t_oflag, OPOST))
2079 ce = cc - scanc((u_int)cc, (u_char *)cp,
2080 char_type, CCLASSMASK);
2082 * If ce is zero, then we're processing
2083 * a special character through ttyoutput.
2087 if (ttyoutput(*cp, tp) >= 0) {
2088 /* No Clists, wait a bit. */
2090 if (flag & IO_NDELAY) {
2091 error = EWOULDBLOCK;
2094 error = ttysleep(tp, &lbolt,
2103 if (ISSET(tp->t_lflag, FLUSHO) ||
2104 tp->t_outq.c_cc > hiwat)
2110 * A bunch of normal characters have been found.
2111 * Transfer them en masse to the output queue and
2112 * continue processing at the top of the loop.
2113 * If there are any further characters in this
2114 * <= OBUFSIZ chunk, the first should be a character
2115 * requiring special handling by ttyoutput.
2118 i = clist_btoq(cp, ce, &tp->t_outq);
2121 cp += ce, cc -= ce, tk_nout += ce;
2124 /* No Clists, wait a bit. */
2126 if (flag & IO_NDELAY) {
2127 error = EWOULDBLOCK;
2130 error = ttysleep(tp, &lbolt, PCATCH,
2136 if (ISSET(tp->t_lflag, FLUSHO) ||
2137 tp->t_outq.c_cc > hiwat)
2144 * If cc is nonzero, we leave the uio structure inconsistent, as the
2145 * offset and iov pointers have moved forward, but it doesn't matter
2146 * (the call will either return short or restart with a new uio).
2148 uio->uio_resid += cc;
2149 lwkt_reltoken(&tp->t_token);
2155 * This can only occur if FLUSHO is set in t_lflag,
2156 * or if ttstart/oproc is synchronous (or very fast).
2158 if (tp->t_outq.c_cc <= hiwat) {
2161 if (flag & IO_NDELAY) {
2162 uio->uio_resid += cc;
2163 lwkt_reltoken(&tp->t_token);
2164 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2166 SET(tp->t_state, TS_SO_OLOWAT);
2167 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2168 if (error == EWOULDBLOCK)
2176 * Rubout one character from the rawq of tp
2177 * as cleanly as possible.
2178 * NOTE: Must be called with tp->t_token held
2181 ttyrub(int c, struct tty *tp)
2187 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2188 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2190 CLR(tp->t_lflag, FLUSHO);
2191 if (ISSET(tp->t_lflag, ECHOE)) {
2192 if (tp->t_rocount == 0) {
2194 * Screwed by ttwrite; retype
2199 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2202 CLR(c, ~TTY_CHARMASK);
2203 switch (CCLASS(c)) {
2212 if (ISSET(tp->t_lflag, ECHOCTL))
2216 if (tp->t_rocount < tp->t_rawq.c_cc) {
2220 savecol = tp->t_column;
2221 SET(tp->t_state, TS_CNTTB);
2222 SET(tp->t_lflag, FLUSHO);
2223 tp->t_column = tp->t_rocol;
2225 cp = clist_nextc(&tp->t_rawq, NULL, &tabc);
2228 cp = clist_nextc(&tp->t_rawq,
2231 CLR(tp->t_lflag, FLUSHO);
2232 CLR(tp->t_state, TS_CNTTB);
2234 /* savecol will now be length of the tab. */
2235 savecol -= tp->t_column;
2236 tp->t_column += savecol;
2238 savecol = 8; /* overflow screw */
2239 while (--savecol >= 0)
2240 (void)ttyoutput('\b', tp);
2243 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2244 (void)kprintf(PANICSTR, c, CCLASS(c));
2246 panic(PANICSTR, c, CCLASS(c));
2250 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2251 if (!ISSET(tp->t_state, TS_ERASE)) {
2252 SET(tp->t_state, TS_ERASE);
2253 (void)ttyoutput('\\', tp);
2257 ttyecho(tp->t_cc[VERASE], tp);
2259 * This code may be executed not only when an ERASE key
2260 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2261 * So, I didn't think it was worthwhile to pass the extra
2262 * information (which would need an extra parameter,
2263 * changing every call) needed to distinguish the ERASE2
2264 * case from the ERASE.
2271 * Back over cnt characters, erasing them.
2272 * NOTE: Must be called with tp->t_token held
2275 ttyrubo(struct tty *tp, int cnt)
2277 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2279 (void)ttyoutput('\b', tp);
2280 (void)ttyoutput(' ', tp);
2281 (void)ttyoutput('\b', tp);
2287 * Reprint the rawq line. Note, it is assumed that c_cc has already
2289 * NOTE: Must be called with tp->t_token held
2292 ttyretype(struct tty *tp)
2297 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2298 /* Echo the reprint character. */
2299 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2300 ttyecho(tp->t_cc[VREPRINT], tp);
2302 (void)ttyoutput('\n', tp);
2306 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2307 * BIT OF FIRST CHAR.
2309 cp = clist_nextc(&tp->t_canq, NULL, &c);
2312 cp = clist_nextc(&tp->t_canq, cp, &c);
2314 cp = clist_nextc(&tp->t_rawq, NULL, &c);
2317 cp = clist_nextc(&tp->t_rawq, cp, &c);
2319 CLR(tp->t_state, TS_ERASE);
2321 tp->t_rocount = tp->t_rawq.c_cc;
2326 * Echo a typed character to the terminal.
2327 * NOTE: Must be called with tp->t_token held
2330 ttyecho(int c, struct tty *tp)
2332 ASSERT_LWKT_TOKEN_HELD(&tp->t_token);
2334 if (!ISSET(tp->t_state, TS_CNTTB))
2335 CLR(tp->t_lflag, FLUSHO);
2336 if ((!ISSET(tp->t_lflag, ECHO) &&
2337 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2338 ISSET(tp->t_lflag, EXTPROC))
2340 if (ISSET(tp->t_lflag, ECHOCTL) &&
2341 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2342 ISSET(c, TTY_CHARMASK) == 0177)) {
2343 (void)ttyoutput('^', tp);
2344 CLR(c, ~TTY_CHARMASK);
2350 (void)ttyoutput(c, tp);
2354 * Wake up any readers on a tty.
2357 ttwakeup(struct tty *tp)
2359 lwkt_gettoken(&tp->t_token);
2360 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2361 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2362 wakeup(TSA_HUP_OR_INPUT(tp));
2363 KNOTE(&tp->t_rkq.ki_note, 0);
2364 lwkt_reltoken(&tp->t_token);
2368 * Wake up any writers on a tty.
2371 ttwwakeup(struct tty *tp)
2373 lwkt_gettoken(&tp->t_token);
2374 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2375 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2376 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2377 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2378 CLR(tp->t_state, TS_SO_OCOMPLETE);
2379 wakeup(TSA_OCOMPLETE(tp));
2381 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2382 tp->t_outq.c_cc <= tp->t_olowat) {
2383 CLR(tp->t_state, TS_SO_OLOWAT);
2384 wakeup(TSA_OLOWAT(tp));
2386 KNOTE(&tp->t_wkq.ki_note, 0);
2387 lwkt_reltoken(&tp->t_token);
2391 * Look up a code for a specified speed in a conversion table;
2392 * used by drivers to map software speed values to hardware parameters.
2396 ttspeedtab(int speed, struct speedtab *table)
2399 for ( ; table->sp_speed != -1; table++)
2400 if (table->sp_speed == speed)
2401 return (table->sp_code);
2406 * Set input and output watermarks and buffer sizes. For input, the
2407 * high watermark is about one second's worth of input above empty, the
2408 * low watermark is slightly below high water, and the buffer size is a
2409 * driver-dependent amount above high water. For output, the watermarks
2410 * are near the ends of the buffer, with about 1 second's worth of input
2411 * between them. All this only applies to the standard line discipline.
2413 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2416 ttsetwater(struct tty *tp)
2418 int ttmaxhiwat; /* maximum high water mark */
2419 int cps; /* characters per second */
2422 lwkt_gettoken(&tp->t_token);
2427 * Calculate nominal low and high water marks, leave a little
2428 * room to absorb flow control latencies.
2430 clist_alloc_cblocks(&tp->t_canq, TTYHOG);
2432 switch (tp->t_ispeedwat) {
2434 cps = tp->t_ispeed / 10;
2438 * This case is for old drivers that don't know about
2439 * t_ispeedwat. Arrange for them to get the old buffer
2440 * sizes and watermarks.
2442 cps = TTYHOG - 2 * 256;
2443 tp->t_ififosize = 2 * 2048;
2446 cps = tp->t_ispeedwat / 10;
2450 tp->t_ilowat = 7 * cps / 8;
2451 x = cps + tp->t_ififosize;
2452 clist_alloc_cblocks(&tp->t_rawq, x);
2457 * Calculate nominal low and high water marks, and make the
2458 * actual buffer just a tad larger to absorb flow control latencies.
2460 switch (tp->t_ospeedwat) {
2462 cps = tp->t_ospeed / 10;
2463 ttmaxhiwat = 2 * TTMAXHIWAT;
2466 cps = tp->t_ospeed / 10;
2467 ttmaxhiwat = TTMAXHIWAT;
2470 cps = tp->t_ospeedwat / 10;
2471 ttmaxhiwat = 8 * TTMAXHIWAT;
2475 x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2479 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT);
2482 x = imax(tp->t_ohiwat, TTMAXHIWAT);
2484 clist_alloc_cblocks(&tp->t_outq, x);
2486 lwkt_reltoken(&tp->t_token);
2492 * Report on state of foreground process group.
2495 ttyinfo(struct tty *tp)
2498 struct proc *p, *pick;
2508 if (ttycheckoutq(tp,0) == 0)
2511 lwkt_gettoken(&tp->t_token);
2514 * We always print the load average, then figure out what else to
2515 * print based on the state of the current process group.
2517 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2518 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2520 if (tp->t_session == NULL) {
2521 ttyprintf(tp, "not a controlling terminal\n");
2524 if ((pgrp = tp->t_pgrp) == NULL) {
2525 ttyprintf(tp, "no foreground process group\n");
2530 * Pick an interesting process. Note that certain elements,
2531 * in particular the wmesg.
2533 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2536 lwkt_gettoken(&pgrp->pg_token);
2539 for (p = LIST_FIRST(&pgrp->pg_members);
2541 p = LIST_NEXT(p, p_pglist)) {
2543 if (proc_compare(pick, p)) {
2552 ttyprintf(tp, "empty foreground process group\n");
2557 * Pick an interesting LWP (XXX)
2561 lp = FIRST_LWP_IN_PROC(pick);
2564 ttyprintf(tp, "foreground process without lwp\n");
2569 * Figure out what wait/process-state message, and command
2573 * XXX lwp This is a horrible mixture. We need to rework this
2574 * as soon as lwps have their own runnable status.
2577 if (pick->p_flags & P_WEXIT)
2579 else if (lp->lwp_stat == LSRUN)
2581 else if (pick->p_stat == SIDL)
2583 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2584 str = lp->lwp_wmesg;
2588 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2589 pick->p_comm, pick->p_pid, str);
2592 * Calculate cpu usage, percent cpu, and cmsz. Note that
2593 * 'pick' becomes invalid the moment we release the token.
2596 calcru_proc(pick, &ru);
2598 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2603 * NOTE: vmspace should be protected from destruction by the
2604 * combination of pg_token and the fact that we are not
2605 * flagged as a zombie.
2607 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) {
2609 } else if ((vm = pick->p_vmspace) == NULL) {
2613 vmsz = pgtok(vmspace_resident_count(vm));
2621 ttyprintf(tp, " %s ",
2623 ttyprintf(tp, "%ld.%02ldu ",
2624 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2625 ttyprintf(tp, "%ld.%02lds ",
2626 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2627 ttyprintf(tp, "%d%% %ldk\n",
2628 pctcpu / 100, vmsz);
2631 lwkt_reltoken(&pgrp->pg_token);
2634 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2635 lwkt_reltoken(&tp->t_token);
2639 * Returns 1 if p2 is "better" than p1
2641 * The algorithm for picking the "interesting" process is thus:
2643 * 1) Only foreground processes are eligible - implied.
2644 * 2) Runnable processes are favored over anything else. The runner
2645 * with the highest cpu utilization is picked (p_cpticks). Ties are
2646 * broken by picking the highest pid.
2647 * 3) The sleeper with the shortest sleep time is next. With ties,
2648 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2649 * 4) Further ties are broken by picking the highest pid.
2651 * NOTE: must be called with p1 and p2 held.
2653 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2654 #define TESTAB(a, b) ((a)<<1 | (b))
2660 proc_compare(struct proc *p1, struct proc *p2)
2662 struct lwp *lp1, *lp2;
2667 if (lwkt_trytoken(&p1->p_token) == 0)
2669 if (lwkt_trytoken(&p2->p_token) == 0) {
2670 lwkt_reltoken(&p1->p_token);
2677 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2685 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2691 /* XXX choose the best lwp? */
2692 lp1 = FIRST_LWP_IN_PROC(p1);
2693 lp2 = FIRST_LWP_IN_PROC(p2);
2696 * Favor one with LWPs verses one that has none (is exiting).
2708 * see if at least one of them is runnable
2710 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2719 * tie - favor one with highest recent cpu utilization
2721 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2723 else if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2726 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */
2733 * Pick the one with the smallest sleep time
2735 if (lp2->lwp_slptime > lp1->lwp_slptime) {
2739 if (lp1->lwp_slptime > lp2->lwp_slptime) {
2745 * Favor one sleeping in a non-interruptible sleep
2747 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0)
2750 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0)
2753 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2757 lwkt_reltoken(&p2->p_token);
2758 lwkt_reltoken(&p1->p_token);
2763 * Output char to tty; console putchar style.
2766 tputchar(int c, struct tty *tp)
2768 lwkt_gettoken(&tp->t_token);
2769 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2770 lwkt_reltoken(&tp->t_token);
2774 (void)ttyoutput('\r', tp);
2775 (void)ttyoutput(c, tp);
2777 lwkt_reltoken(&tp->t_token);
2783 * Sleep on chan, returning ERESTART if tty changed while we napped and
2784 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2785 * the tty is revoked, restarting a pending call will redo validation done
2786 * at the start of the call.
2789 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2795 error = tsleep(chan, slpflags, wmesg, timo);
2798 return (tp->t_gen == gen ? 0 : ERESTART);
2804 * We bump the gen to force any ttysleep()'s to return with ERESTART
2805 * and flush the tty. The related fp's should already have been
2806 * replaced so the tty will close when the last references on the
2807 * original fp's go away.
2810 ttyrevoke(struct dev_revoke_args *ap)
2814 tp = ap->a_head.a_dev->si_tty;
2815 lwkt_gettoken(&tp->t_token);
2817 ttyflush(tp, FREAD | FWRITE);
2818 wakeup(TSA_CARR_ON(tp));
2821 lwkt_reltoken(&tp->t_token);
2827 * Allocate a tty struct. Clists in the struct will be allocated by
2828 * ttyopen(). The tty itself is protected by tp->t_token. tty_token
2829 * is primarily used to interlock the NULL test and for registration.
2831 * by convention, once allocated, tty structures are never freed. This
2832 * saves us from numerous release race scenarios that can occur due to the
2833 * token being embedded in the tty structure.
2836 ttymalloc(struct tty **tpp)
2840 if ((tp = *tpp) == NULL) {
2841 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2842 lwkt_gettoken(&tty_token);
2843 if (*tpp == NULL) { /* recheck after blocking kmalloc */
2850 lwkt_reltoken(&tty_token);
2856 * Caller must hold tp->t_token
2859 ttyunregister(struct tty *tp)
2861 lwkt_gettoken(&tty_token);
2862 if (ISSET(tp->t_state, TS_REGISTERED)) {
2863 CLR(tp->t_state, TS_REGISTERED);
2864 TAILQ_REMOVE(&tty_list, tp, t_list);
2866 lwkt_reltoken(&tty_token);
2870 ttyinit(struct tty *tp)
2872 lwkt_token_init(&tp->t_token, "tp");
2876 ttyregister(struct tty *tp)
2878 lwkt_gettoken(&tty_token);
2879 if (!ISSET(tp->t_state, TS_REGISTERED)) {
2880 SET(tp->t_state, TS_REGISTERED);
2881 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2883 lwkt_reltoken(&tty_token);
2887 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2894 bzero(&marker, sizeof(marker));
2895 marker.t_state = TS_MARKER;
2898 lwkt_gettoken(&tty_token);
2900 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2901 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2902 TAILQ_REMOVE(&tty_list, &marker, t_list);
2903 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2904 if (tp->t_state & TS_MARKER)
2908 t.t_dev = (cdev_t)(uintptr_t)devid_from_dev(t.t_dev);
2909 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2913 TAILQ_REMOVE(&tty_list, &marker, t_list);
2914 lwkt_reltoken(&tty_token);
2918 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2919 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2922 nottystop(struct tty *tp, int rw)
2928 ttyread(struct dev_read_args *ap)
2933 tp = ap->a_head.a_dev->si_tty;
2936 lwkt_gettoken(&tp->t_token);
2937 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2938 lwkt_reltoken(&tp->t_token);
2944 ttywrite(struct dev_write_args *ap)
2949 tp = ap->a_head.a_dev->si_tty;
2952 lwkt_gettoken(&tp->t_token);
2953 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2954 lwkt_reltoken(&tp->t_token);