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_compat.h"
75 #include "opt_uconsole.h"
77 #include <sys/param.h>
78 #include <sys/systm.h>
79 #include <sys/filio.h>
80 #if defined(COMPAT_43)
81 #include <sys/ioctl_compat.h>
87 #include <sys/clist.h>
89 #include <sys/fcntl.h>
91 #include <sys/dkstat.h>
92 #include <sys/kernel.h>
93 #include <sys/vnode.h>
94 #include <sys/signalvar.h>
95 #include <sys/signal2.h>
96 #include <sys/resourcevar.h>
97 #include <sys/malloc.h>
98 #include <sys/filedesc.h>
99 #include <sys/sysctl.h>
100 #include <sys/thread2.h>
103 #include <sys/lock.h>
105 #include <vm/vm_map.h>
106 #include <vm/vm_extern.h>
108 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
110 static int proc_compare (struct proc *p1, struct proc *p2);
111 static int ttnread (struct tty *tp);
112 static void ttyecho (int c, struct tty *tp);
113 static int ttyoutput (int c, struct tty *tp);
114 static void ttypend (struct tty *tp);
115 static void ttyretype (struct tty *tp);
116 static void ttyrub (int c, struct tty *tp);
117 static void ttyrubo (struct tty *tp, int cnt);
118 static void ttyunblock (struct tty *tp);
119 static int ttywflush (struct tty *tp);
120 static int filt_ttyread (struct knote *kn, long hint);
121 static void filt_ttyrdetach (struct knote *kn);
122 static int filt_ttywrite (struct knote *kn, long hint);
123 static void filt_ttywdetach (struct knote *kn);
126 * Table with character classes and parity. The 8th bit indicates parity,
127 * the 7th bit indicates the character is an alphameric or underscore (for
128 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
129 * are 0 then the character needs no special processing on output; classes
130 * other than 0 might be translated or (not currently) require delays.
132 #define E 0x00 /* Even parity. */
133 #define O 0x80 /* Odd parity. */
134 #define PARITY(c) (char_type[c] & O)
136 #define ALPHA 0x40 /* Alpha or underscore. */
137 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
139 #define CCLASSMASK 0x3f
140 #define CCLASS(c) (char_type[c] & CCLASSMASK)
145 #define NA ORDINARY | ALPHA
151 static u_char const char_type[] = {
152 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
153 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
154 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
155 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
156 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
157 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
158 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
159 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
160 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
161 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
162 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
163 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
164 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
165 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
166 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
167 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
169 * Meta chars; should be settable per character set;
170 * for now, treat them all as normal characters.
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,
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,
198 /* Macros to clear/set/test flags. */
199 #define SET(t, f) (t) |= (f)
200 #define CLR(t, f) (t) &= ~(f)
201 #define ISSET(t, f) ((t) & (f))
203 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
204 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
207 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
208 "LU", "TTY input statistic");
210 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
211 "LU", "TTY output statistic");
215 * list of struct tty where pstat(8) can pick it up with sysctl
217 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
220 * Initial open of tty, or (re)entry to standard tty line discipline.
223 ttyopen(cdev_t device, struct tty *tp)
226 lwkt_gettoken(&tty_token);
228 if (!ISSET(tp->t_state, TS_ISOPEN)) {
229 SET(tp->t_state, TS_ISOPEN);
230 if (ISSET(tp->t_cflag, CLOCAL)) {
231 SET(tp->t_state, TS_CONNECTED);
233 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
236 lwkt_reltoken(&tty_token);
242 * Handle close() on a tty line: flush and set to initial state,
243 * bumping generation number so that pending read/write calls
244 * can detect recycling of the tty.
246 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
247 * and l_close() should have flushed, but we repeat the spltty() and
248 * the flush in case there are buggy callers.
251 ttyclose(struct tty *tp)
254 lwkt_gettoken(&tty_token);
255 funsetown(&tp->t_sigio);
259 ttyflush(tp, FREAD | FWRITE);
260 clist_free_cblocks(&tp->t_canq);
261 clist_free_cblocks(&tp->t_outq);
262 clist_free_cblocks(&tp->t_rawq);
265 tp->t_line = TTYDISC;
267 tp->t_state &= TS_REGISTERED; /* clear all bits except */
268 lwkt_reltoken(&tty_token);
274 * Disassociate the tty from its session. Traditionally this has only been
275 * a half-close, meaning that the session was still allowed to point at the
276 * tty (resulting in the tty in the ps command showing something like 'p0-'),
277 * even though the tty is no longer pointing at the session.
279 * The half close seems to be useful only for 'ps' output but there is as
280 * yet no reason to remove the feature. The full-close code is currently
281 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
284 ttyclearsession(struct tty *tp)
289 lwkt_gettoken(&tty_token);
297 if ((sp = tp->t_session) != NULL) {
298 tp->t_session = NULL;
299 #ifdef TTY_DO_FULL_CLOSE
300 /* FULL CLOSE (not yet) */
301 if (sp->s_ttyp == tp) {
305 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
306 "%p/%p\n", sp->s_ttyp, tp);
310 lwkt_reltoken(&tty_token);
314 * Release the tty vnode association for a session. This is the
315 * 'other half' of the close. Because multiple opens of /dev/tty
316 * only generate a single open to the actual tty, the file modes
317 * are locked to FREAD|FWRITE.
319 * If dorevoke is non-zero, the session is also revoked. We have to
320 * close the vnode if VCTTYISOPEN is set.
323 ttyclosesession(struct session *sp, int dorevoke)
327 lwkt_gettoken(&tty_token);
330 * There may not be a controlling terminal or it may have been closed
333 if ((vp = sp->s_ttyvp) == NULL) {
334 lwkt_reltoken(&tty_token);
339 * We need a lock if we have to close or revoke.
341 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
343 if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY)) {
349 * Retry if the vnode was ripped out from under us
351 if (vp != sp->s_ttyvp) {
358 * Close and revoke as needed
361 if (vp->v_flag & VCTTYISOPEN) {
362 vclrflags(vp, VCTTYISOPEN);
363 VOP_CLOSE(vp, FREAD|FWRITE);
367 vrevoke(vp, proc0.p_ucred);
373 lwkt_reltoken(&tty_token);
376 #define FLUSHQ(q) { \
378 ndflush(q, (q)->c_cc); \
381 /* Is 'c' a line delimiter ("break" character)? */
382 #define TTBREAKC(c, lflag) \
383 ((c) == '\n' || (((c) == cc[VEOF] || \
384 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
385 (c) != _POSIX_VDISABLE))
388 * Process input of a single character received on a tty.
391 ttyinput(int c, struct tty *tp)
393 tcflag_t iflag, lflag;
397 lwkt_gettoken(&tty_token);
399 * If input is pending take it first.
402 if (ISSET(lflag, PENDIN))
407 if (ISSET(lflag, ICANON))
414 * Block further input iff:
415 * current input > threshold AND input is available to user program
416 * AND input flow control is enabled and not yet invoked.
417 * The 3 is slop for PARMRK.
420 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
421 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
422 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
423 !ISSET(tp->t_state, TS_TBLOCK))
426 /* Handle exceptional conditions (break, parity, framing). */
428 err = (ISSET(c, TTY_ERRORMASK));
430 CLR(c, TTY_ERRORMASK);
431 if (ISSET(err, TTY_BI)) {
432 if (ISSET(iflag, IGNBRK)) {
433 lwkt_reltoken(&tty_token);
436 if (ISSET(iflag, BRKINT)) {
437 ttyflush(tp, FREAD | FWRITE);
438 pgsignal(tp->t_pgrp, SIGINT, 1);
441 if (ISSET(iflag, PARMRK))
443 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
444 || ISSET(err, TTY_FE)) {
445 if (ISSET(iflag, IGNPAR)) {
446 lwkt_reltoken(&tty_token);
449 else if (ISSET(iflag, PARMRK)) {
451 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
454 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
455 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
456 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
463 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
465 if (!ISSET(lflag, EXTPROC)) {
467 * Check for literal nexting very first
469 if (ISSET(tp->t_state, TS_LNCH)) {
471 CLR(tp->t_state, TS_LNCH);
474 * Scan for special characters. This code
475 * is really just a big case statement with
476 * non-constant cases. The bottom of the
477 * case statement is labeled ``endcase'', so goto
478 * it after a case match, or similar.
482 * Control chars which aren't controlled
483 * by ICANON, ISIG, or IXON.
485 if (ISSET(lflag, IEXTEN)) {
486 if (CCEQ(cc[VLNEXT], c)) {
487 if (ISSET(lflag, ECHO)) {
488 if (ISSET(lflag, ECHOE)) {
489 (void)ttyoutput('^', tp);
490 (void)ttyoutput('\b', tp);
494 SET(tp->t_state, TS_LNCH);
497 if (CCEQ(cc[VDISCARD], c)) {
498 if (ISSET(lflag, FLUSHO))
499 CLR(tp->t_lflag, FLUSHO);
501 ttyflush(tp, FWRITE);
503 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
505 SET(tp->t_lflag, FLUSHO);
513 if (ISSET(lflag, ISIG)) {
514 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
515 if (!ISSET(lflag, NOFLSH))
516 ttyflush(tp, FREAD | FWRITE);
519 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
522 if (CCEQ(cc[VSUSP], c)) {
523 if (!ISSET(lflag, NOFLSH))
526 pgsignal(tp->t_pgrp, SIGTSTP, 1);
531 * Handle start/stop characters.
533 if (ISSET(iflag, IXON)) {
534 if (CCEQ(cc[VSTOP], c)) {
535 if (!ISSET(tp->t_state, TS_TTSTOP)) {
536 SET(tp->t_state, TS_TTSTOP);
537 (*tp->t_stop)(tp, 0);
538 lwkt_reltoken(&tty_token);
541 if (!CCEQ(cc[VSTART], c)) {
542 lwkt_reltoken(&tty_token);
546 * if VSTART == VSTOP then toggle
550 if (CCEQ(cc[VSTART], c))
554 * IGNCR, ICRNL, & INLCR
557 if (ISSET(iflag, IGNCR)) {
558 lwkt_reltoken(&tty_token);
561 else if (ISSET(iflag, ICRNL))
563 } else if (c == '\n' && ISSET(iflag, INLCR))
566 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
568 * From here on down canonical mode character
569 * processing takes place.
572 * erase or erase2 (^H / ^?)
574 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
576 ttyrub(clist_unputc(&tp->t_rawq), tp);
582 if (CCEQ(cc[VKILL], c)) {
583 if (ISSET(lflag, ECHOKE) &&
584 tp->t_rawq.c_cc == tp->t_rocount &&
585 !ISSET(lflag, ECHOPRT))
586 while (tp->t_rawq.c_cc)
587 ttyrub(clist_unputc(&tp->t_rawq), tp);
590 if (ISSET(lflag, ECHOK) ||
591 ISSET(lflag, ECHOKE))
596 CLR(tp->t_state, TS_LOCAL);
602 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
608 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
613 * erase last char of word and remember the
614 * next chars type (for ALTWERASE)
617 c = clist_unputc(&tp->t_rawq);
620 if (c == ' ' || c == '\t') {
621 clist_putc(c, &tp->t_rawq);
630 c = clist_unputc(&tp->t_rawq);
633 } while (c != ' ' && c != '\t' &&
634 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
635 clist_putc(c, &tp->t_rawq);
641 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
646 * ^T - kernel info and generate SIGINFO
648 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
649 if (ISSET(lflag, ISIG))
650 pgsignal(tp->t_pgrp, SIGINFO, 1);
651 if (!ISSET(lflag, NOKERNINFO))
655 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
656 if (ISSET(lflag, ISIG))
657 pgsignal(tp->t_pgrp, SIGCKPT, 1);
662 * Check for input buffer overflow
664 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
666 if (ISSET(iflag, IMAXBEL)) {
667 if (tp->t_outq.c_cc < tp->t_ohiwat)
668 (void)ttyoutput(CTRL('g'), tp);
673 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
674 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
675 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
678 * Put data char in q for user and
679 * wakeup on seeing a line delimiter.
681 if (clist_putc(c, &tp->t_rawq) >= 0) {
682 if (!ISSET(lflag, ICANON)) {
687 if (TTBREAKC(c, lflag)) {
689 catq(&tp->t_rawq, &tp->t_canq);
691 } else if (tp->t_rocount++ == 0)
692 tp->t_rocol = tp->t_column;
693 if (ISSET(tp->t_state, TS_ERASE)) {
695 * end of prterase \.../
697 CLR(tp->t_state, TS_ERASE);
698 (void)ttyoutput('/', tp);
702 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
704 * Place the cursor over the '^' of the ^D.
706 i = imin(2, tp->t_column - i);
708 (void)ttyoutput('\b', tp);
715 * IXANY means allow any character to restart output.
717 if (ISSET(tp->t_state, TS_TTSTOP) &&
718 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
719 lwkt_reltoken(&tty_token);
723 CLR(tp->t_lflag, FLUSHO);
724 CLR(tp->t_state, TS_TTSTOP);
726 lwkt_reltoken(&tty_token);
727 return (ttstart(tp));
731 * Output a single character on a tty, doing output processing
732 * as needed (expanding tabs, newline processing, etc.).
733 * Returns < 0 if succeeds, otherwise returns char to resend.
737 ttyoutput(int c, struct tty *tp)
742 lwkt_gettoken(&tty_token);
744 if (!ISSET(oflag, OPOST)) {
745 if (ISSET(tp->t_lflag, FLUSHO)) {
746 lwkt_reltoken(&tty_token);
749 if (clist_putc(c, &tp->t_outq)) {
750 lwkt_reltoken(&tty_token);
755 lwkt_reltoken(&tty_token);
759 * Do tab expansion if OXTABS is set. Special case if we external
760 * processing, we don't do the tab expansion because we'll probably
761 * get it wrong. If tab expansion needs to be done, let it happen
764 CLR(c, ~TTY_CHARMASK);
766 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
767 c = 8 - (tp->t_column & 7);
768 if (!ISSET(tp->t_lflag, FLUSHO)) {
769 crit_enter(); /* Don't interrupt tabs. */
770 c -= b_to_q(" ", c, &tp->t_outq);
776 lwkt_reltoken(&tty_token);
777 return (c ? -1 : '\t');
779 if (c == CEOT && ISSET(oflag, ONOEOT)) {
780 lwkt_reltoken(&tty_token);
785 * Newline translation: if ONLCR is set,
786 * translate newline into "\r\n".
788 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
791 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
792 lwkt_reltoken(&tty_token);
796 /* If OCRNL is set, translate "\r" into "\n". */
797 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
799 /* If ONOCR is set, don't transmit CRs when on column 0. */
800 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
801 lwkt_reltoken(&tty_token);
807 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
808 lwkt_reltoken(&tty_token);
821 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
831 col = (col + 8) & ~7;
835 lwkt_reltoken(&tty_token);
840 * Ioctls for all tty devices. Called after line-discipline specific ioctl
841 * has been called to do discipline-specific functions and/or reject any
842 * of these ioctl commands.
846 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
848 struct thread *td = curthread;
849 struct lwp *lp = td->td_lwp;
850 struct proc *p = td->td_proc;
856 lwkt_gettoken(&tty_token);
857 lwkt_gettoken(&proc_token);
858 lwkt_gettoken(&p->p_token);
860 /* If the ioctl involves modification, hang if in the background. */
884 #if defined(COMPAT_43)
894 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) &&
895 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
896 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
897 if (p->p_pgrp->pg_jobc == 0) {
898 lwkt_reltoken(&p->p_token);
899 lwkt_reltoken(&proc_token);
900 lwkt_reltoken(&tty_token);
903 pgsignal(p->p_pgrp, SIGTTOU, 1);
904 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
907 lwkt_reltoken(&p->p_token);
908 lwkt_reltoken(&proc_token);
909 lwkt_reltoken(&tty_token);
916 switch (cmd) { /* Process the ioctl. */
917 case FIOASYNC: /* set/clear async i/o */
920 SET(tp->t_state, TS_ASYNC);
922 CLR(tp->t_state, TS_ASYNC);
925 case FIONREAD: /* get # bytes to read */
927 *(int *)data = ttnread(tp);
933 * Policy -- Don't allow FIOSETOWN on someone else's
936 if (tp->t_session != NULL && !isctty(p, tp)) {
937 lwkt_reltoken(&p->p_token);
938 lwkt_reltoken(&proc_token);
939 lwkt_reltoken(&tty_token);
943 error = fsetown(*(int *)data, &tp->t_sigio);
945 lwkt_reltoken(&p->p_token);
946 lwkt_reltoken(&proc_token);
947 lwkt_reltoken(&tty_token);
952 if (tp->t_session != NULL && !isctty(p, tp)) {
953 lwkt_reltoken(&p->p_token);
954 lwkt_reltoken(&proc_token);
955 lwkt_reltoken(&tty_token);
958 *(int *)data = fgetown(&tp->t_sigio);
961 case TIOCEXCL: /* set exclusive use of tty */
963 SET(tp->t_state, TS_XCLUDE);
966 case TIOCFLUSH: { /* flush buffers */
967 int flags = *(int *)data;
970 flags = FREAD | FWRITE;
972 flags &= FREAD | FWRITE;
976 case TIOCCONS: /* become virtual console */
978 if (constty && constty != tp &&
979 ISSET(constty->t_state, TS_CONNECTED)) {
980 lwkt_reltoken(&p->p_token);
981 lwkt_reltoken(&proc_token);
982 lwkt_reltoken(&tty_token);
986 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
987 lwkt_reltoken(&p->p_token);
988 lwkt_reltoken(&proc_token);
989 lwkt_reltoken(&tty_token);
994 } else if (tp == constty)
997 case TIOCDRAIN: /* wait till output drained */
1000 lwkt_reltoken(&p->p_token);
1001 lwkt_reltoken(&proc_token);
1002 lwkt_reltoken(&tty_token);
1006 case TIOCGETA: { /* get termios struct */
1007 struct termios *t = (struct termios *)data;
1009 bcopy(&tp->t_termios, t, sizeof(struct termios));
1012 case TIOCGETD: /* get line discipline */
1013 *(int *)data = tp->t_line;
1015 case TIOCGWINSZ: /* get window size */
1016 *(struct winsize *)data = tp->t_winsize;
1018 case TIOCGPGRP: /* get pgrp of tty */
1019 if (!isctty(p, tp)) {
1020 lwkt_reltoken(&p->p_token);
1021 lwkt_reltoken(&proc_token);
1022 lwkt_reltoken(&tty_token);
1025 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1027 case TIOCGSID: /* get sid of tty */
1028 if (!isctty(p, tp)) {
1029 lwkt_reltoken(&p->p_token);
1030 lwkt_reltoken(&proc_token);
1031 lwkt_reltoken(&tty_token);
1034 *(int *)data = tp->t_session->s_sid;
1037 case TIOCHPCL: /* hang up on last close */
1039 SET(tp->t_cflag, HUPCL);
1043 case TIOCNXCL: /* reset exclusive use of tty */
1045 CLR(tp->t_state, TS_XCLUDE);
1048 case TIOCOUTQ: /* output queue size */
1049 *(int *)data = tp->t_outq.c_cc;
1051 case TIOCSETA: /* set termios struct */
1052 case TIOCSETAW: /* drain output, set */
1053 case TIOCSETAF: { /* drn out, fls in, set */
1054 struct termios *t = (struct termios *)data;
1056 if (t->c_ispeed == 0)
1057 t->c_ispeed = t->c_ospeed;
1058 if (t->c_ispeed == 0)
1059 t->c_ispeed = tp->t_ospeed;
1060 if (t->c_ispeed == 0) {
1061 lwkt_reltoken(&p->p_token);
1062 lwkt_reltoken(&proc_token);
1063 lwkt_reltoken(&tty_token);
1067 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1068 error = ttywait(tp);
1071 lwkt_reltoken(&p->p_token);
1072 lwkt_reltoken(&proc_token);
1073 lwkt_reltoken(&tty_token);
1076 if (cmd == TIOCSETAF)
1077 ttyflush(tp, FREAD);
1079 if (!ISSET(t->c_cflag, CIGNORE)) {
1081 * Set device hardware.
1083 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1085 lwkt_reltoken(&p->p_token);
1086 lwkt_reltoken(&proc_token);
1087 lwkt_reltoken(&tty_token);
1090 if (ISSET(t->c_cflag, CLOCAL) &&
1091 !ISSET(tp->t_cflag, CLOCAL)) {
1093 * XXX disconnections would be too hard to
1094 * get rid of without this kludge. The only
1095 * way to get rid of controlling terminals
1096 * is to exit from the session leader.
1098 CLR(tp->t_state, TS_ZOMBIE);
1100 wakeup(TSA_CARR_ON(tp));
1104 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1105 ISSET(t->c_cflag, CLOCAL)) &&
1106 !ISSET(tp->t_state, TS_ZOMBIE))
1107 SET(tp->t_state, TS_CONNECTED);
1109 CLR(tp->t_state, TS_CONNECTED);
1110 tp->t_cflag = t->c_cflag;
1111 tp->t_ispeed = t->c_ispeed;
1112 if (t->c_ospeed != 0)
1113 tp->t_ospeed = t->c_ospeed;
1116 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1118 if (ISSET(t->c_lflag, ICANON))
1119 SET(tp->t_lflag, PENDIN);
1122 * XXX we really shouldn't allow toggling
1123 * ICANON while we're in a non-termios line
1124 * discipline. Now we have to worry about
1125 * panicing for a null queue.
1127 if (tp->t_canq.c_cbreserved > 0 &&
1128 tp->t_rawq.c_cbreserved > 0) {
1129 catq(&tp->t_rawq, &tp->t_canq);
1131 * XXX the queue limits may be
1132 * different, so the old queue
1133 * swapping method no longer works.
1135 catq(&tp->t_canq, &tp->t_rawq);
1137 CLR(tp->t_lflag, PENDIN);
1141 tp->t_iflag = t->c_iflag;
1142 tp->t_oflag = t->c_oflag;
1144 * Make the EXTPROC bit read only.
1146 if (ISSET(tp->t_lflag, EXTPROC))
1147 SET(t->c_lflag, EXTPROC);
1149 CLR(t->c_lflag, EXTPROC);
1150 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1151 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1152 t->c_cc[VTIME] != tp->t_cc[VTIME])
1154 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1158 case TIOCSETD: { /* set line discipline */
1159 int t = *(int *)data;
1160 cdev_t device = tp->t_dev;
1162 if ((u_int)t >= nlinesw) {
1163 lwkt_reltoken(&p->p_token);
1164 lwkt_reltoken(&proc_token);
1165 lwkt_reltoken(&tty_token);
1168 if (t != tp->t_line) {
1170 (*linesw[tp->t_line].l_close)(tp, flag);
1171 error = (*linesw[t].l_open)(device, tp);
1173 (void)(*linesw[tp->t_line].l_open)(device, tp);
1175 lwkt_reltoken(&p->p_token);
1176 lwkt_reltoken(&proc_token);
1177 lwkt_reltoken(&tty_token);
1185 case TIOCSTART: /* start output, like ^Q */
1187 if (ISSET(tp->t_state, TS_TTSTOP) ||
1188 ISSET(tp->t_lflag, FLUSHO)) {
1189 CLR(tp->t_lflag, FLUSHO);
1190 CLR(tp->t_state, TS_TTSTOP);
1195 case TIOCSTI: /* simulate terminal input */
1196 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1197 lwkt_reltoken(&p->p_token);
1198 lwkt_reltoken(&proc_token);
1199 lwkt_reltoken(&tty_token);
1202 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1203 lwkt_reltoken(&p->p_token);
1204 lwkt_reltoken(&proc_token);
1205 lwkt_reltoken(&tty_token);
1209 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1212 case TIOCSTOP: /* stop output, like ^S */
1214 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1215 SET(tp->t_state, TS_TTSTOP);
1216 (*tp->t_stop)(tp, 0);
1220 case TIOCSCTTY: /* become controlling tty */
1221 /* Session ctty vnode pointer set in vnode layer. */
1222 if (!SESS_LEADER(p) ||
1223 ((p->p_session->s_ttyvp || tp->t_session) &&
1224 (tp->t_session != p->p_session))) {
1225 lwkt_reltoken(&p->p_token);
1226 lwkt_reltoken(&proc_token);
1227 lwkt_reltoken(&tty_token);
1231 tp->t_session = p->p_session;
1234 tp->t_pgrp = p->p_pgrp;
1235 otp = p->p_session->s_ttyp;
1236 p->p_session->s_ttyp = tp;
1237 p->p_flags |= P_CONTROLT;
1245 case TIOCSPGRP: { /* set pgrp of tty */
1246 pid_t pgid = *(int *)data;
1248 if (!isctty(p, tp)) {
1249 lwkt_reltoken(&p->p_token);
1250 lwkt_reltoken(&proc_token);
1251 lwkt_reltoken(&tty_token);
1254 else if (pgid < 1 || pgid > PID_MAX) {
1255 lwkt_reltoken(&p->p_token);
1256 lwkt_reltoken(&proc_token);
1257 lwkt_reltoken(&tty_token);
1260 struct pgrp *pgrp = pgfind(pgid);
1261 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1264 lwkt_reltoken(&p->p_token);
1265 lwkt_reltoken(&proc_token);
1266 lwkt_reltoken(&tty_token);
1278 case TIOCSTAT: /* simulate control-T */
1283 case TIOCSWINSZ: /* set window size */
1284 if (bcmp((caddr_t)&tp->t_winsize, data,
1285 sizeof (struct winsize))) {
1286 tp->t_winsize = *(struct winsize *)data;
1287 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1290 case TIOCSDRAINWAIT:
1291 error = priv_check(td, PRIV_ROOT);
1293 lwkt_reltoken(&p->p_token);
1294 lwkt_reltoken(&proc_token);
1295 lwkt_reltoken(&tty_token);
1298 tp->t_timeout = *(int *)data * hz;
1299 wakeup(TSA_OCOMPLETE(tp));
1300 wakeup(TSA_OLOWAT(tp));
1302 case TIOCGDRAINWAIT:
1303 *(int *)data = tp->t_timeout / hz;
1306 lwkt_reltoken(&p->p_token);
1307 lwkt_reltoken(&proc_token);
1308 lwkt_reltoken(&tty_token);
1309 #if defined(COMPAT_43)
1310 return (ttcompat(tp, cmd, data, flag));
1315 lwkt_reltoken(&p->p_token);
1316 lwkt_reltoken(&proc_token);
1317 lwkt_reltoken(&tty_token);
1321 static struct filterops ttyread_filtops =
1322 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread };
1323 static struct filterops ttywrite_filtops =
1324 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite };
1327 ttykqfilter(struct dev_kqfilter_args *ap)
1329 cdev_t dev = ap->a_head.a_dev;
1330 struct knote *kn = ap->a_kn;
1331 struct tty *tp = dev->si_tty;
1332 struct klist *klist;
1336 lwkt_gettoken(&tty_token);
1337 switch (kn->kn_filter) {
1339 klist = &tp->t_rkq.ki_note;
1340 kn->kn_fop = &ttyread_filtops;
1343 klist = &tp->t_wkq.ki_note;
1344 kn->kn_fop = &ttywrite_filtops;
1347 ap->a_result = EOPNOTSUPP;
1348 lwkt_reltoken(&tty_token);
1351 lwkt_reltoken(&tty_token);
1352 kn->kn_hook = (caddr_t)dev;
1353 knote_insert(klist, kn);
1359 filt_ttyrdetach(struct knote *kn)
1361 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1363 lwkt_gettoken(&tty_token);
1364 knote_remove(&tp->t_rkq.ki_note, kn);
1365 lwkt_reltoken(&tty_token);
1369 filt_ttyread(struct knote *kn, long hint)
1371 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1373 lwkt_gettoken(&tty_token);
1374 kn->kn_data = ttnread(tp);
1375 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1376 kn->kn_flags |= (EV_EOF | EV_NODATA);
1377 lwkt_reltoken(&tty_token);
1380 lwkt_reltoken(&tty_token);
1381 return (kn->kn_data > 0);
1385 filt_ttywdetach(struct knote *kn)
1387 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1389 lwkt_gettoken(&tty_token);
1390 knote_remove(&tp->t_wkq.ki_note, kn);
1391 lwkt_reltoken(&tty_token);
1395 filt_ttywrite(struct knote *kn, long hint)
1397 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1400 lwkt_gettoken(&tty_token);
1401 kn->kn_data = tp->t_outq.c_cc;
1402 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1403 lwkt_reltoken(&tty_token);
1406 ret = (kn->kn_data <= tp->t_olowat &&
1407 ISSET(tp->t_state, TS_CONNECTED));
1408 lwkt_reltoken(&tty_token);
1413 * Must be called while in a critical section.
1414 * NOTE: tty_token must be held.
1417 ttnread(struct tty *tp)
1421 ASSERT_LWKT_TOKEN_HELD(&tty_token);
1422 if (ISSET(tp->t_lflag, PENDIN))
1424 nread = tp->t_canq.c_cc;
1425 if (!ISSET(tp->t_lflag, ICANON)) {
1426 nread += tp->t_rawq.c_cc;
1427 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1434 * Wait for output to drain.
1437 ttywait(struct tty *tp)
1443 lwkt_gettoken(&tty_token);
1444 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1445 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1447 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1448 ISSET(tp->t_state, TS_CONNECTED)) {
1449 SET(tp->t_state, TS_SO_OCOMPLETE);
1450 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1454 if (error == EWOULDBLOCK)
1461 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1463 lwkt_reltoken(&tty_token);
1469 * Flush if successfully wait.
1472 ttywflush(struct tty *tp)
1476 if ((error = ttywait(tp)) == 0)
1477 ttyflush(tp, FREAD);
1482 * Flush tty read and/or write queues, notifying anyone waiting.
1485 ttyflush(struct tty *tp, int rw)
1488 lwkt_gettoken(&tty_token);
1493 FLUSHQ(&tp->t_outq);
1494 CLR(tp->t_state, TS_TTSTOP);
1496 (*tp->t_stop)(tp, rw);
1498 FLUSHQ(&tp->t_canq);
1499 FLUSHQ(&tp->t_rawq);
1500 CLR(tp->t_lflag, PENDIN);
1503 CLR(tp->t_state, TS_LOCAL);
1505 if (ISSET(tp->t_state, TS_TBLOCK)) {
1507 FLUSHQ(&tp->t_outq);
1511 * Don't let leave any state that might clobber the
1512 * next line discipline (although we should do more
1513 * to send the START char). Not clearing the state
1514 * may have caused the "putc to a clist with no
1515 * reserved cblocks" panic/kprintf.
1517 CLR(tp->t_state, TS_TBLOCK);
1519 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1520 if (ISSET(tp->t_iflag, IXOFF)) {
1522 * XXX wait a bit in the hope that the stop
1523 * character (if any) will go out. Waiting
1524 * isn't good since it allows races. This
1525 * will be fixed when the stop character is
1526 * put in a special queue. Don't bother with
1527 * the checks in ttywait() since the timeout
1530 SET(tp->t_state, TS_SO_OCOMPLETE);
1531 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1534 * Don't try sending the stop character again.
1536 CLR(tp->t_state, TS_TBLOCK);
1543 FLUSHQ(&tp->t_outq);
1546 lwkt_reltoken(&tty_token);
1551 * Copy in the default termios characters.
1554 termioschars(struct termios *t)
1556 lwkt_gettoken(&tty_token);
1557 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1558 lwkt_reltoken(&tty_token);
1565 ttychars(struct tty *tp)
1567 lwkt_gettoken(&tty_token);
1568 termioschars(&tp->t_termios);
1569 lwkt_reltoken(&tty_token);
1573 * Handle input high water. Send stop character for the IXOFF case. Turn
1574 * on our input flow control bit and propagate the changes to the driver.
1575 * XXX the stop character should be put in a special high priority queue.
1578 ttyblock(struct tty *tp)
1580 lwkt_gettoken(&tty_token);
1581 SET(tp->t_state, TS_TBLOCK);
1582 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1583 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1584 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1586 lwkt_reltoken(&tty_token);
1590 * Handle input low water. Send start character for the IXOFF case. Turn
1591 * off our input flow control bit and propagate the changes to the driver.
1592 * XXX the start character should be put in a special high priority queue.
1595 ttyunblock(struct tty *tp)
1597 lwkt_gettoken(&tty_token);
1598 CLR(tp->t_state, TS_TBLOCK);
1599 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1600 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1601 SET(tp->t_state, TS_TBLOCK); /* try again later */
1603 lwkt_reltoken(&tty_token);
1607 /* Not used by any current (i386) drivers. */
1609 * Restart after an inter-char delay.
1612 ttrstrt(void *tp_arg)
1616 KASSERT(tp_arg != NULL, ("ttrstrt"));
1620 lwkt_gettoken(&tty_token);
1621 CLR(tp->t_state, TS_TIMEOUT);
1623 lwkt_reltoken(&tty_token);
1629 ttstart(struct tty *tp)
1631 lwkt_gettoken(&tty_token);
1632 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1634 lwkt_reltoken(&tty_token);
1639 * "close" a line discipline
1642 ttylclose(struct tty *tp, int flag)
1644 lwkt_gettoken(&tty_token);
1645 if (flag & FNONBLOCK || ttywflush(tp))
1646 ttyflush(tp, FREAD | FWRITE);
1647 lwkt_reltoken(&tty_token);
1652 ttyhold(struct tty *tp)
1658 ttyunhold(struct tty *tp)
1667 * Handle modem control transition on a tty.
1668 * Flag indicates new state of carrier.
1669 * Returns 0 if the line should be turned off, otherwise 1.
1672 ttymodem(struct tty *tp, int flag)
1674 lwkt_gettoken(&tty_token);
1675 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1677 * MDMBUF: do flow control according to carrier flag
1678 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1679 * works if IXON and IXANY are clear.
1682 CLR(tp->t_state, TS_CAR_OFLOW);
1683 CLR(tp->t_state, TS_TTSTOP);
1685 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1686 SET(tp->t_state, TS_CAR_OFLOW);
1687 SET(tp->t_state, TS_TTSTOP);
1688 (*tp->t_stop)(tp, 0);
1690 } else if (flag == 0) {
1694 CLR(tp->t_state, TS_CARR_ON);
1695 if (ISSET(tp->t_state, TS_ISOPEN) &&
1696 !ISSET(tp->t_cflag, CLOCAL)) {
1697 SET(tp->t_state, TS_ZOMBIE);
1698 CLR(tp->t_state, TS_CONNECTED);
1699 if (tp->t_session && tp->t_session->s_leader)
1700 ksignal(tp->t_session->s_leader, SIGHUP);
1701 ttyflush(tp, FREAD | FWRITE);
1702 lwkt_reltoken(&tty_token);
1709 SET(tp->t_state, TS_CARR_ON);
1710 if (!ISSET(tp->t_state, TS_ZOMBIE))
1711 SET(tp->t_state, TS_CONNECTED);
1712 wakeup(TSA_CARR_ON(tp));
1716 lwkt_reltoken(&tty_token);
1721 * Reinput pending characters after state switch
1722 * call from a critical section.
1725 ttypend(struct tty *tp)
1730 lwkt_gettoken(&tty_token);
1731 CLR(tp->t_lflag, PENDIN);
1732 SET(tp->t_state, TS_TYPEN);
1734 * XXX this assumes too much about clist internals. It may even
1735 * fail if the cblock slush pool is empty. We can't allocate more
1736 * cblocks here because we are called from an interrupt handler
1737 * and clist_alloc_cblocks() can wait.
1740 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1741 tp->t_rawq.c_cbmax = tq.c_cbmax;
1742 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1743 while ((c = clist_getc(&tq)) >= 0)
1745 CLR(tp->t_state, TS_TYPEN);
1746 lwkt_reltoken(&tty_token);
1750 * Process a read call on a tty device.
1753 ttread(struct tty *tp, struct uio *uio, int flag)
1758 cc_t *cc = tp->t_cc;
1761 int first, error = 0;
1762 int has_stime = 0, last_cc = 0;
1763 long slp = 0; /* XXX this should be renamed `timo'. */
1764 struct timeval stime;
1766 lp = curthread->td_lwp;
1767 stime.tv_sec = 0; /* fix compiler warnings */
1770 lwkt_gettoken(&tty_token);
1773 lflag = tp->t_lflag;
1775 * take pending input first
1777 if (ISSET(lflag, PENDIN)) {
1779 splz(); /* reduce latency */
1780 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1784 * Hang process if it's in the background.
1786 lwkt_gettoken(&proc_token);
1787 if ((pp = curproc) && isbackground(pp, tp)) {
1789 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1790 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1791 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1792 lwkt_reltoken(&proc_token);
1793 lwkt_reltoken(&tty_token);
1796 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1797 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1799 lwkt_reltoken(&proc_token);
1800 lwkt_reltoken(&tty_token);
1803 lwkt_reltoken(&proc_token);
1806 lwkt_reltoken(&proc_token);
1808 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1810 lwkt_reltoken(&tty_token);
1811 return (0); /* EOF */
1815 * If canonical, use the canonical queue,
1816 * else use the raw queue.
1818 * (should get rid of clists...)
1820 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1822 if (flag & IO_NDELAY) {
1825 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1827 lwkt_reltoken(&tty_token);
1831 lwkt_reltoken(&tty_token);
1832 return (EWOULDBLOCK);
1834 if (!ISSET(lflag, ICANON)) {
1837 struct timeval timecopy;
1840 * Check each of the four combinations.
1841 * (m > 0 && t == 0) is the normal read case.
1842 * It should be fairly efficient, so we check that and its
1843 * companion case (m == 0 && t == 0) first.
1844 * For the other two cases, we compute the target sleep time
1853 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1855 lwkt_reltoken(&tty_token);
1858 t *= 100000; /* time in us */
1859 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1860 ((t1).tv_usec - (t2).tv_usec))
1866 getmicrotime(&timecopy);
1867 if (has_stime == 0) {
1868 /* first character, start timer */
1872 } else if (qp->c_cc > last_cc) {
1873 /* got a character, restart timer */
1877 /* nothing, check expiration */
1878 slp = t - diff(timecopy, stime);
1883 } else { /* m == 0 */
1886 getmicrotime(&timecopy);
1887 if (has_stime == 0) {
1892 slp = t - diff(timecopy, stime);
1894 /* Timed out, but 0 is enough input. */
1896 lwkt_reltoken(&tty_token);
1903 * Rounding down may make us wake up just short
1904 * of the target, so we round up.
1905 * The formula is ceiling(slp * hz/1000000).
1906 * 32-bit arithmetic is enough for hz < 169.
1907 * XXX see tvtohz() for how to avoid overflow if hz
1908 * is large (divide by `tick' and/or arrange to
1909 * use tvtohz() if hz is large).
1911 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1914 if (qp->c_cc <= 0) {
1917 * There is no input, or not enough input and we can block.
1919 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1920 ISSET(tp->t_state, TS_CONNECTED) ?
1921 "ttyin" : "ttyhup", (int)slp);
1923 if (error == EWOULDBLOCK)
1926 lwkt_reltoken(&tty_token);
1930 * XXX what happens if another process eats some input
1931 * while we are asleep (not just here)? It would be
1932 * safest to detect changes and reset our state variables
1933 * (has_stime and last_cc).
1941 * Input present, check for input mapping and processing.
1944 if (ISSET(lflag, ICANON | ISIG))
1950 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1951 icc = q_to_b(qp, ibuf, icc);
1957 error = uiomove(ibuf, (size_t)icc, uio);
1959 * XXX if there was an error then we should ungetc() the
1960 * unmoved chars and reduce icc here.
1964 if (uio->uio_resid == 0)
1978 * delayed suspend (^Y)
1980 if (CCEQ(cc[VDSUSP], c) &&
1981 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1982 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1984 error = ttysleep(tp, &lbolt, PCATCH,
1993 * Interpret EOF only in canonical mode.
1995 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1998 * Give user character.
2000 error = ureadc(c, uio);
2002 /* XXX should ungetc(c, qp). */
2004 if (uio->uio_resid == 0)
2007 * In canonical mode check for a "break character"
2008 * marking the end of a "line of input".
2010 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
2017 * Look to unblock input now that (presumably)
2018 * the input queue has gone down.
2021 if (ISSET(tp->t_state, TS_TBLOCK) &&
2022 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
2026 lwkt_reltoken(&tty_token);
2031 * Check the output queue on tp for space for a kernel message (from uprintf
2032 * or tprintf). Allow some space over the normal hiwater mark so we don't
2033 * lose messages due to normal flow control, but don't let the tty run amok.
2034 * Sleeps here are not interruptible, but we return prematurely if new signals
2038 ttycheckoutq(struct tty *tp, int wait)
2040 struct lwp *lp = curthread->td_lwp;
2042 sigset_t oldset, newset;
2044 lwkt_gettoken(&tty_token);
2045 hiwat = tp->t_ohiwat;
2046 SIGEMPTYSET(oldset);
2047 SIGEMPTYSET(newset);
2050 oldset = lwp_sigpend(lp);
2051 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
2052 while (tp->t_outq.c_cc > hiwat) {
2054 if (tp->t_outq.c_cc <= hiwat)
2057 newset = lwp_sigpend(lp);
2058 if (!wait || SIGSETNEQ(oldset, newset)) {
2060 lwkt_reltoken(&tty_token);
2063 SET(tp->t_state, TS_SO_OLOWAT);
2064 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
2068 lwkt_reltoken(&tty_token);
2073 * Process a write call on a tty device.
2076 ttwrite(struct tty *tp, struct uio *uio, int flag)
2082 int i, hiwat, error;
2087 lwkt_gettoken(&tty_token);
2088 lp = curthread->td_lwp;
2089 hiwat = tp->t_ohiwat;
2090 cnt = uio->uio_resid;
2095 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2097 if (uio->uio_resid == cnt)
2101 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2102 if (flag & IO_NDELAY) {
2104 error = EWOULDBLOCK;
2107 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2116 * Hang the process if it's in the background.
2118 lwkt_gettoken(&proc_token);
2119 if ((pp = curproc) && isbackground(pp, tp) &&
2120 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) &&
2121 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2122 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2123 if (pp->p_pgrp->pg_jobc == 0) {
2125 lwkt_reltoken(&proc_token);
2128 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2129 lwkt_reltoken(&proc_token);
2130 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2135 lwkt_reltoken(&proc_token);
2137 * Process the user's data in at most OBUFSIZ chunks. Perform any
2138 * output translation. Keep track of high water mark, sleep on
2139 * overflow awaiting device aid in acquiring new space.
2141 while (uio->uio_resid > 0 || cc > 0) {
2142 if (ISSET(tp->t_lflag, FLUSHO)) {
2144 lwkt_reltoken(&tty_token);
2147 if (tp->t_outq.c_cc > hiwat)
2150 * Grab a hunk of data from the user, unless we have some
2151 * leftover from last time.
2154 cc = szmin(uio->uio_resid, OBUFSIZ);
2156 error = uiomove(cp, (size_t)cc, uio);
2163 * If nothing fancy need be done, grab those characters we
2164 * can handle without any of ttyoutput's processing and
2165 * just transfer them to the output q. For those chars
2166 * which require special processing (as indicated by the
2167 * bits in char_type), call ttyoutput. After processing
2168 * a hunk of data, look for FLUSHO so ^O's will take effect
2172 if (!ISSET(tp->t_oflag, OPOST))
2175 ce = cc - scanc((u_int)cc, (u_char *)cp,
2176 char_type, CCLASSMASK);
2178 * If ce is zero, then we're processing
2179 * a special character through ttyoutput.
2183 if (ttyoutput(*cp, tp) >= 0) {
2184 /* No Clists, wait a bit. */
2186 if (flag & IO_NDELAY) {
2187 error = EWOULDBLOCK;
2190 error = ttysleep(tp, &lbolt,
2199 if (ISSET(tp->t_lflag, FLUSHO) ||
2200 tp->t_outq.c_cc > hiwat)
2206 * A bunch of normal characters have been found.
2207 * Transfer them en masse to the output queue and
2208 * continue processing at the top of the loop.
2209 * If there are any further characters in this
2210 * <= OBUFSIZ chunk, the first should be a character
2211 * requiring special handling by ttyoutput.
2214 i = b_to_q(cp, ce, &tp->t_outq);
2217 cp += ce, cc -= ce, tk_nout += ce;
2220 /* No Clists, wait a bit. */
2222 if (flag & IO_NDELAY) {
2223 error = EWOULDBLOCK;
2226 error = ttysleep(tp, &lbolt, PCATCH,
2232 if (ISSET(tp->t_lflag, FLUSHO) ||
2233 tp->t_outq.c_cc > hiwat)
2240 * If cc is nonzero, we leave the uio structure inconsistent, as the
2241 * offset and iov pointers have moved forward, but it doesn't matter
2242 * (the call will either return short or restart with a new uio).
2244 uio->uio_resid += cc;
2245 lwkt_reltoken(&tty_token);
2252 * This can only occur if FLUSHO is set in t_lflag,
2253 * or if ttstart/oproc is synchronous (or very fast).
2255 if (tp->t_outq.c_cc <= hiwat) {
2259 if (flag & IO_NDELAY) {
2261 uio->uio_resid += cc;
2262 lwkt_reltoken(&tty_token);
2263 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2265 SET(tp->t_state, TS_SO_OLOWAT);
2266 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2268 if (error == EWOULDBLOCK)
2276 * Rubout one character from the rawq of tp
2277 * as cleanly as possible.
2278 * NOTE: Must be called with tty_token held
2281 ttyrub(int c, struct tty *tp)
2287 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2288 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2290 CLR(tp->t_lflag, FLUSHO);
2291 if (ISSET(tp->t_lflag, ECHOE)) {
2292 if (tp->t_rocount == 0) {
2294 * Screwed by ttwrite; retype
2299 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2302 CLR(c, ~TTY_CHARMASK);
2303 switch (CCLASS(c)) {
2312 if (ISSET(tp->t_lflag, ECHOCTL))
2316 if (tp->t_rocount < tp->t_rawq.c_cc) {
2321 savecol = tp->t_column;
2322 SET(tp->t_state, TS_CNTTB);
2323 SET(tp->t_lflag, FLUSHO);
2324 tp->t_column = tp->t_rocol;
2325 cp = tp->t_rawq.c_cf;
2327 tabc = *cp; /* XXX FIX NEXTC */
2328 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2330 CLR(tp->t_lflag, FLUSHO);
2331 CLR(tp->t_state, TS_CNTTB);
2334 /* savecol will now be length of the tab. */
2335 savecol -= tp->t_column;
2336 tp->t_column += savecol;
2338 savecol = 8; /* overflow screw */
2339 while (--savecol >= 0)
2340 (void)ttyoutput('\b', tp);
2343 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2344 (void)kprintf(PANICSTR, c, CCLASS(c));
2346 panic(PANICSTR, c, CCLASS(c));
2350 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2351 if (!ISSET(tp->t_state, TS_ERASE)) {
2352 SET(tp->t_state, TS_ERASE);
2353 (void)ttyoutput('\\', tp);
2357 ttyecho(tp->t_cc[VERASE], tp);
2359 * This code may be executed not only when an ERASE key
2360 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2361 * So, I didn't think it was worthwhile to pass the extra
2362 * information (which would need an extra parameter,
2363 * changing every call) needed to distinguish the ERASE2
2364 * case from the ERASE.
2371 * Back over cnt characters, erasing them.
2372 * NOTE: Must be called with tty_token held
2375 ttyrubo(struct tty *tp, int cnt)
2377 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2379 (void)ttyoutput('\b', tp);
2380 (void)ttyoutput(' ', tp);
2381 (void)ttyoutput('\b', tp);
2387 * Reprint the rawq line. Note, it is assumed that c_cc has already
2389 * NOTE: Must be called with tty_token held
2392 ttyretype(struct tty *tp)
2397 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2398 /* Echo the reprint character. */
2399 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2400 ttyecho(tp->t_cc[VREPRINT], tp);
2402 (void)ttyoutput('\n', tp);
2406 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2407 * BIT OF FIRST CHAR.
2410 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2411 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2413 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2414 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2416 CLR(tp->t_state, TS_ERASE);
2419 tp->t_rocount = tp->t_rawq.c_cc;
2424 * Echo a typed character to the terminal.
2425 * NOTE: Must be called with tty_token held
2428 ttyecho(int c, struct tty *tp)
2430 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2432 if (!ISSET(tp->t_state, TS_CNTTB))
2433 CLR(tp->t_lflag, FLUSHO);
2434 if ((!ISSET(tp->t_lflag, ECHO) &&
2435 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2436 ISSET(tp->t_lflag, EXTPROC))
2438 if (ISSET(tp->t_lflag, ECHOCTL) &&
2439 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2440 ISSET(c, TTY_CHARMASK) == 0177)) {
2441 (void)ttyoutput('^', tp);
2442 CLR(c, ~TTY_CHARMASK);
2448 (void)ttyoutput(c, tp);
2452 * Wake up any readers on a tty.
2455 ttwakeup(struct tty *tp)
2457 lwkt_gettoken(&tty_token);
2458 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2459 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2460 wakeup(TSA_HUP_OR_INPUT(tp));
2461 KNOTE(&tp->t_rkq.ki_note, 0);
2462 lwkt_reltoken(&tty_token);
2466 * Wake up any writers on a tty.
2469 ttwwakeup(struct tty *tp)
2471 lwkt_gettoken(&tty_token);
2472 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2473 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2474 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2475 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2476 CLR(tp->t_state, TS_SO_OCOMPLETE);
2477 wakeup(TSA_OCOMPLETE(tp));
2479 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2480 tp->t_outq.c_cc <= tp->t_olowat) {
2481 CLR(tp->t_state, TS_SO_OLOWAT);
2482 wakeup(TSA_OLOWAT(tp));
2484 KNOTE(&tp->t_wkq.ki_note, 0);
2485 lwkt_reltoken(&tty_token);
2489 * Look up a code for a specified speed in a conversion table;
2490 * used by drivers to map software speed values to hardware parameters.
2494 ttspeedtab(int speed, struct speedtab *table)
2497 for ( ; table->sp_speed != -1; table++)
2498 if (table->sp_speed == speed)
2499 return (table->sp_code);
2504 * Set input and output watermarks and buffer sizes. For input, the
2505 * high watermark is about one second's worth of input above empty, the
2506 * low watermark is slightly below high water, and the buffer size is a
2507 * driver-dependent amount above high water. For output, the watermarks
2508 * are near the ends of the buffer, with about 1 second's worth of input
2509 * between them. All this only applies to the standard line discipline.
2512 ttsetwater(struct tty *tp)
2514 int cps, ttmaxhiwat, x;
2516 lwkt_gettoken(&tty_token);
2518 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2519 switch (tp->t_ispeedwat) {
2521 cps = tp->t_ispeed / 10;
2525 * This case is for old drivers that don't know about
2526 * t_ispeedwat. Arrange for them to get the old buffer
2527 * sizes and watermarks.
2529 cps = TTYHOG - 2 * 256;
2530 tp->t_ififosize = 2 * 2048;
2533 cps = tp->t_ispeedwat / 10;
2537 tp->t_ilowat = 7 * cps / 8;
2538 x = cps + tp->t_ififosize;
2539 clist_alloc_cblocks(&tp->t_rawq, x, x);
2542 switch (tp->t_ospeedwat) {
2544 cps = tp->t_ospeed / 10;
2545 ttmaxhiwat = 2 * TTMAXHIWAT;
2548 cps = tp->t_ospeed / 10;
2549 ttmaxhiwat = TTMAXHIWAT;
2552 cps = tp->t_ospeedwat / 10;
2553 ttmaxhiwat = 8 * TTMAXHIWAT;
2556 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2557 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2559 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2560 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2561 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2563 clist_alloc_cblocks(&tp->t_outq, x, x);
2565 lwkt_reltoken(&tty_token);
2569 * Report on state of foreground process group.
2572 ttyinfo(struct tty *tp)
2575 struct proc *p, *pick;
2585 if (ttycheckoutq(tp,0) == 0)
2588 lwkt_gettoken(&tty_token);
2589 lwkt_gettoken(&proc_token);
2591 * We always print the load average, then figure out what else to
2592 * print based on the state of the current process group.
2594 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2595 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2597 if (tp->t_session == NULL) {
2598 ttyprintf(tp, "not a controlling terminal\n");
2601 if ((pgrp = tp->t_pgrp) == NULL) {
2602 ttyprintf(tp, "no foreground process group\n");
2607 * Pick an interesting process. Note that certain elements,
2608 * in particular the wmesg, require a critical section for
2609 * safe access (YYY and we are still not MP safe).
2611 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2614 lwkt_gettoken(&pgrp->pg_token);
2617 for (p = LIST_FIRST(&pgrp->pg_members);
2619 p = LIST_NEXT(p, p_pglist)) {
2620 if (proc_compare(pick, p))
2624 ttyprintf(tp, "empty foreground process group\n");
2629 * Pick an interesting LWP (XXX)
2632 lp = FIRST_LWP_IN_PROC(pick);
2635 ttyprintf(tp, "foreground process without lwp\n");
2640 * Figure out what wait/process-state message, and command
2644 * XXX lwp This is a horrible mixture. We need to rework this
2645 * as soon as lwps have their own runnable status.
2648 if (pick->p_flags & P_WEXIT)
2650 else if (lp->lwp_stat == LSRUN)
2652 else if (pick->p_stat == SIDL)
2654 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2655 str = lp->lwp_wmesg;
2659 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2660 pick->p_comm, pick->p_pid, str);
2663 * Calculate cpu usage, percent cpu, and cmsz. Note that
2664 * 'pick' becomes invalid the moment we exit the critical
2667 if (lp->lwp_thread && (pick->p_flags & P_SWAPPEDOUT) == 0)
2668 calcru_proc(pick, &ru);
2670 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2674 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) {
2676 } else if ((vm = pick->p_vmspace) == NULL) {
2680 vmsz = pgtok(vmspace_resident_count(vm));
2688 ttyprintf(tp, " %s ",
2690 ttyprintf(tp, "%ld.%02ldu ",
2691 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2692 ttyprintf(tp, "%ld.%02lds ",
2693 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2694 ttyprintf(tp, "%d%% %ldk\n",
2695 pctcpu / 100, vmsz);
2698 lwkt_reltoken(&pgrp->pg_token);
2701 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2702 lwkt_reltoken(&proc_token);
2703 lwkt_reltoken(&tty_token);
2707 * Returns 1 if p2 is "better" than p1
2709 * The algorithm for picking the "interesting" process is thus:
2711 * 1) Only foreground processes are eligible - implied.
2712 * 2) Runnable processes are favored over anything else. The runner
2713 * with the highest cpu utilization is picked (p_cpticks). Ties are
2714 * broken by picking the highest pid.
2715 * 3) The sleeper with the shortest sleep time is next. With ties,
2716 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2717 * 4) Further ties are broken by picking the highest pid.
2719 * NOTE: must be called with proc_token held.
2721 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2722 #define TESTAB(a, b) ((a)<<1 | (b))
2728 proc_compare(struct proc *p1, struct proc *p2)
2730 struct lwp *lp1, *lp2;
2733 ASSERT_LWKT_TOKEN_HELD(&proc_token);
2737 if (lwkt_trytoken(&p1->p_token) == 0)
2739 if (lwkt_trytoken(&p2->p_token) == 0) {
2740 lwkt_reltoken(&p1->p_token);
2747 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2755 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2761 /* XXX choose the best lwp? */
2762 lp1 = FIRST_LWP_IN_PROC(p1);
2763 lp2 = FIRST_LWP_IN_PROC(p2);
2766 * Favor one with LWPs verses one that has none (is exiting).
2778 * see if at least one of them is runnable
2780 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2789 * tie - favor one with highest recent cpu utilization
2791 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2793 else if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2796 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */
2803 * Pick the one with the smallest sleep time
2805 if (lp2->lwp_slptime > lp1->lwp_slptime) {
2809 if (lp1->lwp_slptime > lp2->lwp_slptime) {
2815 * Favor one sleeping in a non-interruptible sleep
2817 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0)
2820 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0)
2823 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2827 lwkt_reltoken(&p2->p_token);
2828 lwkt_reltoken(&p1->p_token);
2833 * Output char to tty; console putchar style.
2836 tputchar(int c, struct tty *tp)
2839 lwkt_gettoken(&tty_token);
2840 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2841 lwkt_reltoken(&tty_token);
2846 (void)ttyoutput('\r', tp);
2847 (void)ttyoutput(c, tp);
2849 lwkt_reltoken(&tty_token);
2855 * Sleep on chan, returning ERESTART if tty changed while we napped and
2856 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2857 * the tty is revoked, restarting a pending call will redo validation done
2858 * at the start of the call.
2861 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2867 error = tsleep(chan, slpflags, wmesg, timo);
2870 return (tp->t_gen == gen ? 0 : ERESTART);
2876 * We bump the gen to force any ttysleep()'s to return with ERESTART
2877 * and flush the tty. The related fp's should already have been
2878 * replaced so the tty will close when the last references on the
2879 * original fp's go away.
2882 ttyrevoke(struct dev_revoke_args *ap)
2886 lwkt_gettoken(&tty_token);
2887 tp = ap->a_head.a_dev->si_tty;
2889 ttyflush(tp, FREAD | FWRITE);
2890 wakeup(TSA_CARR_ON(tp));
2893 lwkt_reltoken(&tty_token);
2898 * Allocate a tty struct. Clists in the struct will be allocated by
2902 ttymalloc(struct tty *tp)
2908 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2914 ttyunregister(struct tty *tp)
2916 lwkt_gettoken(&tty_token);
2917 KKASSERT(ISSET(tp->t_state, TS_REGISTERED));
2918 CLR(tp->t_state, TS_REGISTERED);
2919 TAILQ_REMOVE(&tty_list, tp, t_list);
2920 lwkt_reltoken(&tty_token);
2924 ttyregister(struct tty *tp)
2926 lwkt_gettoken(&tty_token);
2927 KKASSERT(!ISSET(tp->t_state, TS_REGISTERED));
2928 SET(tp->t_state, TS_REGISTERED);
2929 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2930 lwkt_reltoken(&tty_token);
2934 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2941 bzero(&marker, sizeof(marker));
2942 marker.t_state = TS_MARKER;
2945 lwkt_gettoken(&tty_token);
2947 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2948 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2949 TAILQ_REMOVE(&tty_list, &marker, t_list);
2950 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2951 if (tp->t_state & TS_MARKER)
2955 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev);
2956 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2960 TAILQ_REMOVE(&tty_list, &marker, t_list);
2961 lwkt_reltoken(&tty_token);
2965 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2966 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2969 nottystop(struct tty *tp, int rw)
2975 ttyread(struct dev_read_args *ap)
2980 tp = ap->a_head.a_dev->si_tty;
2983 lwkt_gettoken(&tty_token);
2984 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2985 lwkt_reltoken(&tty_token);
2991 ttywrite(struct dev_write_args *ap)
2996 tp = ap->a_head.a_dev->si_tty;
2999 lwkt_gettoken(&tty_token);
3000 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
3001 lwkt_reltoken(&tty_token);