4 * Copyright (c) 1982, 1986, 1990, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by the University of
23 * California, Berkeley and its contributors.
24 * 4. Neither the name of the University nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 * @(#)tty.c 8.8 (Berkeley) 1/21/94
41 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
46 * Almost all functions in this file are acquiring the tty token due to their
47 * access and modifications of the 'tp' (struct tty) objects.
52 * o Fix races for sending the start char in ttyflush().
53 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
54 * With luck, there will be MIN chars before select() returns().
55 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
56 * o Don't allow input in TS_ZOMBIE case. It would be visible through
58 * o Do the new sio locking stuff here and use it to avoid special
61 * o Move EXTPROC and/or PENDIN to t_state?
62 * o Wrap most of ttioctl in spltty/splx.
63 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
64 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
65 * o Don't allow certain termios flags to affect disciplines other
66 * than TTYDISC. Cancel their effects before switch disciplines
67 * and ignore them if they are set while we are in another
69 * o Now that historical speed conversions are handled here, don't
71 * o Check for TS_CARR_ON being set while everything is closed and not
72 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
73 * so it would live until the next open even if carrier drops.
74 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
75 * only when _all_ openers leave open().
78 #include "opt_compat.h"
79 #include "opt_uconsole.h"
81 #include <sys/param.h>
82 #include <sys/systm.h>
83 #include <sys/filio.h>
84 #if defined(COMPAT_43)
85 #include <sys/ioctl_compat.h>
91 #include <sys/clist.h>
93 #include <sys/fcntl.h>
95 #include <sys/dkstat.h>
96 #include <sys/kernel.h>
97 #include <sys/vnode.h>
98 #include <sys/signalvar.h>
99 #include <sys/signal2.h>
100 #include <sys/resourcevar.h>
101 #include <sys/malloc.h>
102 #include <sys/filedesc.h>
103 #include <sys/sysctl.h>
104 #include <sys/thread2.h>
107 #include <sys/lock.h>
109 #include <vm/vm_map.h>
110 #include <vm/vm_extern.h>
112 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
114 static int proc_compare (struct proc *p1, struct proc *p2);
115 static int ttnread (struct tty *tp);
116 static void ttyecho (int c, struct tty *tp);
117 static int ttyoutput (int c, struct tty *tp);
118 static void ttypend (struct tty *tp);
119 static void ttyretype (struct tty *tp);
120 static void ttyrub (int c, struct tty *tp);
121 static void ttyrubo (struct tty *tp, int cnt);
122 static void ttyunblock (struct tty *tp);
123 static int ttywflush (struct tty *tp);
124 static int filt_ttyread (struct knote *kn, long hint);
125 static void filt_ttyrdetach (struct knote *kn);
126 static int filt_ttywrite (struct knote *kn, long hint);
127 static void filt_ttywdetach (struct knote *kn);
130 * Table with character classes and parity. The 8th bit indicates parity,
131 * the 7th bit indicates the character is an alphameric or underscore (for
132 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
133 * are 0 then the character needs no special processing on output; classes
134 * other than 0 might be translated or (not currently) require delays.
136 #define E 0x00 /* Even parity. */
137 #define O 0x80 /* Odd parity. */
138 #define PARITY(c) (char_type[c] & O)
140 #define ALPHA 0x40 /* Alpha or underscore. */
141 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
143 #define CCLASSMASK 0x3f
144 #define CCLASS(c) (char_type[c] & CCLASSMASK)
149 #define NA ORDINARY | ALPHA
155 static u_char const char_type[] = {
156 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
157 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
158 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
159 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
160 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
161 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
162 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
163 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
164 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
165 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
166 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
167 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
168 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
169 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
170 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
171 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
173 * Meta chars; should be settable per character set;
174 * for now, treat them all as normal characters.
176 NA, NA, NA, NA, NA, NA, NA, NA,
177 NA, NA, NA, NA, NA, NA, NA, NA,
178 NA, NA, NA, NA, NA, NA, NA, NA,
179 NA, NA, NA, NA, NA, NA, NA, NA,
180 NA, NA, NA, NA, NA, NA, NA, NA,
181 NA, NA, NA, NA, NA, NA, NA, NA,
182 NA, NA, NA, NA, NA, NA, NA, NA,
183 NA, NA, NA, NA, NA, NA, NA, NA,
184 NA, NA, NA, NA, NA, NA, NA, NA,
185 NA, NA, NA, NA, NA, NA, NA, NA,
186 NA, NA, NA, NA, NA, NA, NA, NA,
187 NA, NA, NA, NA, NA, NA, NA, NA,
188 NA, NA, NA, NA, NA, NA, NA, NA,
189 NA, NA, NA, NA, NA, NA, NA, NA,
190 NA, NA, NA, NA, NA, NA, NA, NA,
191 NA, NA, NA, NA, NA, NA, NA, NA,
202 /* Macros to clear/set/test flags. */
203 #define SET(t, f) (t) |= (f)
204 #define CLR(t, f) (t) &= ~(f)
205 #define ISSET(t, f) ((t) & (f))
207 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
208 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
211 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
212 "LU", "TTY input statistic");
214 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
215 "LU", "TTY output statistic");
219 * list of struct tty where pstat(8) can pick it up with sysctl
221 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
224 * Initial open of tty, or (re)entry to standard tty line discipline.
227 ttyopen(cdev_t device, struct tty *tp)
230 lwkt_gettoken(&tty_token);
232 if (!ISSET(tp->t_state, TS_ISOPEN)) {
233 SET(tp->t_state, TS_ISOPEN);
234 if (ISSET(tp->t_cflag, CLOCAL)) {
235 SET(tp->t_state, TS_CONNECTED);
237 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
240 lwkt_reltoken(&tty_token);
246 * Handle close() on a tty line: flush and set to initial state,
247 * bumping generation number so that pending read/write calls
248 * can detect recycling of the tty.
250 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
251 * and l_close() should have flushed, but we repeat the spltty() and
252 * the flush in case there are buggy callers.
255 ttyclose(struct tty *tp)
258 lwkt_gettoken(&tty_token);
259 funsetown(&tp->t_sigio);
263 ttyflush(tp, FREAD | FWRITE);
264 clist_free_cblocks(&tp->t_canq);
265 clist_free_cblocks(&tp->t_outq);
266 clist_free_cblocks(&tp->t_rawq);
269 tp->t_line = TTYDISC;
271 tp->t_state &= TS_REGISTERED; /* clear all bits except */
272 lwkt_reltoken(&tty_token);
278 * Disassociate the tty from its session. Traditionally this has only been
279 * a half-close, meaning that the session was still allowed to point at the
280 * tty (resulting in the tty in the ps command showing something like 'p0-'),
281 * even though the tty is no longer pointing at the session.
283 * The half close seems to be useful only for 'ps' output but there is as
284 * yet no reason to remove the feature. The full-close code is currently
285 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
288 ttyclearsession(struct tty *tp)
293 lwkt_gettoken(&tty_token);
301 if ((sp = tp->t_session) != NULL) {
302 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);
314 lwkt_reltoken(&tty_token);
318 * Release the tty vnode association for a session. This is the
319 * 'other half' of the close. Because multiple opens of /dev/tty
320 * only generate a single open to the actual tty, the file modes
321 * are locked to FREAD|FWRITE.
323 * If dorevoke is non-zero, the session is also revoked. We have to
324 * close the vnode if VCTTYISOPEN is set.
327 ttyclosesession(struct session *sp, int dorevoke)
331 lwkt_gettoken(&tty_token);
334 * There may not be a controlling terminal or it may have been closed
337 if ((vp = sp->s_ttyvp) == NULL) {
338 lwkt_reltoken(&tty_token);
343 * We need a lock if we have to close or revoke.
345 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
347 if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY)) {
353 * Retry if the vnode was ripped out from under us
355 if (vp != sp->s_ttyvp) {
362 * Close and revoke as needed
365 if (vp->v_flag & VCTTYISOPEN) {
366 vclrflags(vp, VCTTYISOPEN);
367 VOP_CLOSE(vp, FREAD|FWRITE);
371 vrevoke(vp, proc0.p_ucred);
377 lwkt_reltoken(&tty_token);
380 #define FLUSHQ(q) { \
382 ndflush(q, (q)->c_cc); \
385 /* Is 'c' a line delimiter ("break" character)? */
386 #define TTBREAKC(c, lflag) \
387 ((c) == '\n' || (((c) == cc[VEOF] || \
388 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
389 (c) != _POSIX_VDISABLE))
392 * Process input of a single character received on a tty.
395 ttyinput(int c, struct tty *tp)
397 tcflag_t iflag, lflag;
401 lwkt_gettoken(&tty_token);
403 * If input is pending take it first.
406 if (ISSET(lflag, PENDIN))
411 if (ISSET(lflag, ICANON))
418 * Block further input iff:
419 * current input > threshold AND input is available to user program
420 * AND input flow control is enabled and not yet invoked.
421 * The 3 is slop for PARMRK.
424 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
425 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
426 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
427 !ISSET(tp->t_state, TS_TBLOCK))
430 /* Handle exceptional conditions (break, parity, framing). */
432 err = (ISSET(c, TTY_ERRORMASK));
434 CLR(c, TTY_ERRORMASK);
435 if (ISSET(err, TTY_BI)) {
436 if (ISSET(iflag, IGNBRK)) {
437 lwkt_reltoken(&tty_token);
440 if (ISSET(iflag, BRKINT)) {
441 ttyflush(tp, FREAD | FWRITE);
442 pgsignal(tp->t_pgrp, SIGINT, 1);
445 if (ISSET(iflag, PARMRK))
447 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
448 || ISSET(err, TTY_FE)) {
449 if (ISSET(iflag, IGNPAR)) {
450 lwkt_reltoken(&tty_token);
453 else if (ISSET(iflag, PARMRK)) {
455 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
458 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
459 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
460 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
467 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
469 if (!ISSET(lflag, EXTPROC)) {
471 * Check for literal nexting very first
473 if (ISSET(tp->t_state, TS_LNCH)) {
475 CLR(tp->t_state, TS_LNCH);
478 * Scan for special characters. This code
479 * is really just a big case statement with
480 * non-constant cases. The bottom of the
481 * case statement is labeled ``endcase'', so goto
482 * it after a case match, or similar.
486 * Control chars which aren't controlled
487 * by ICANON, ISIG, or IXON.
489 if (ISSET(lflag, IEXTEN)) {
490 if (CCEQ(cc[VLNEXT], c)) {
491 if (ISSET(lflag, ECHO)) {
492 if (ISSET(lflag, ECHOE)) {
493 (void)ttyoutput('^', tp);
494 (void)ttyoutput('\b', tp);
498 SET(tp->t_state, TS_LNCH);
501 if (CCEQ(cc[VDISCARD], c)) {
502 if (ISSET(lflag, FLUSHO))
503 CLR(tp->t_lflag, FLUSHO);
505 ttyflush(tp, FWRITE);
507 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
509 SET(tp->t_lflag, FLUSHO);
517 if (ISSET(lflag, ISIG)) {
518 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
519 if (!ISSET(lflag, NOFLSH))
520 ttyflush(tp, FREAD | FWRITE);
523 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
526 if (CCEQ(cc[VSUSP], c)) {
527 if (!ISSET(lflag, NOFLSH))
530 pgsignal(tp->t_pgrp, SIGTSTP, 1);
535 * Handle start/stop characters.
537 if (ISSET(iflag, IXON)) {
538 if (CCEQ(cc[VSTOP], c)) {
539 if (!ISSET(tp->t_state, TS_TTSTOP)) {
540 SET(tp->t_state, TS_TTSTOP);
541 (*tp->t_stop)(tp, 0);
542 lwkt_reltoken(&tty_token);
545 if (!CCEQ(cc[VSTART], c)) {
546 lwkt_reltoken(&tty_token);
550 * if VSTART == VSTOP then toggle
554 if (CCEQ(cc[VSTART], c))
558 * IGNCR, ICRNL, & INLCR
561 if (ISSET(iflag, IGNCR)) {
562 lwkt_reltoken(&tty_token);
565 else if (ISSET(iflag, ICRNL))
567 } else if (c == '\n' && ISSET(iflag, INLCR))
570 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
572 * From here on down canonical mode character
573 * processing takes place.
576 * erase or erase2 (^H / ^?)
578 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
580 ttyrub(clist_unputc(&tp->t_rawq), tp);
586 if (CCEQ(cc[VKILL], c)) {
587 if (ISSET(lflag, ECHOKE) &&
588 tp->t_rawq.c_cc == tp->t_rocount &&
589 !ISSET(lflag, ECHOPRT))
590 while (tp->t_rawq.c_cc)
591 ttyrub(clist_unputc(&tp->t_rawq), tp);
594 if (ISSET(lflag, ECHOK) ||
595 ISSET(lflag, ECHOKE))
600 CLR(tp->t_state, TS_LOCAL);
606 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
612 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
617 * erase last char of word and remember the
618 * next chars type (for ALTWERASE)
621 c = clist_unputc(&tp->t_rawq);
624 if (c == ' ' || c == '\t') {
625 clist_putc(c, &tp->t_rawq);
634 c = clist_unputc(&tp->t_rawq);
637 } while (c != ' ' && c != '\t' &&
638 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
639 clist_putc(c, &tp->t_rawq);
645 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
650 * ^T - kernel info and generate SIGINFO
652 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
653 if (ISSET(lflag, ISIG))
654 pgsignal(tp->t_pgrp, SIGINFO, 1);
655 if (!ISSET(lflag, NOKERNINFO))
659 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
660 if (ISSET(lflag, ISIG))
661 pgsignal(tp->t_pgrp, SIGCKPT, 1);
666 * Check for input buffer overflow
668 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
670 if (ISSET(iflag, IMAXBEL)) {
671 if (tp->t_outq.c_cc < tp->t_ohiwat)
672 (void)ttyoutput(CTRL('g'), tp);
677 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
678 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
679 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
682 * Put data char in q for user and
683 * wakeup on seeing a line delimiter.
685 if (clist_putc(c, &tp->t_rawq) >= 0) {
686 if (!ISSET(lflag, ICANON)) {
691 if (TTBREAKC(c, lflag)) {
693 catq(&tp->t_rawq, &tp->t_canq);
695 } else if (tp->t_rocount++ == 0)
696 tp->t_rocol = tp->t_column;
697 if (ISSET(tp->t_state, TS_ERASE)) {
699 * end of prterase \.../
701 CLR(tp->t_state, TS_ERASE);
702 (void)ttyoutput('/', tp);
706 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
708 * Place the cursor over the '^' of the ^D.
710 i = imin(2, tp->t_column - i);
712 (void)ttyoutput('\b', tp);
719 * IXANY means allow any character to restart output.
721 if (ISSET(tp->t_state, TS_TTSTOP) &&
722 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
723 lwkt_reltoken(&tty_token);
727 CLR(tp->t_lflag, FLUSHO);
728 CLR(tp->t_state, TS_TTSTOP);
730 lwkt_reltoken(&tty_token);
731 return (ttstart(tp));
735 * Output a single character on a tty, doing output processing
736 * as needed (expanding tabs, newline processing, etc.).
737 * Returns < 0 if succeeds, otherwise returns char to resend.
741 ttyoutput(int c, struct tty *tp)
746 lwkt_gettoken(&tty_token);
748 if (!ISSET(oflag, OPOST)) {
749 if (ISSET(tp->t_lflag, FLUSHO)) {
750 lwkt_reltoken(&tty_token);
753 if (clist_putc(c, &tp->t_outq)) {
754 lwkt_reltoken(&tty_token);
759 lwkt_reltoken(&tty_token);
763 * Do tab expansion if OXTABS is set. Special case if we external
764 * processing, we don't do the tab expansion because we'll probably
765 * get it wrong. If tab expansion needs to be done, let it happen
768 CLR(c, ~TTY_CHARMASK);
770 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
771 c = 8 - (tp->t_column & 7);
772 if (!ISSET(tp->t_lflag, FLUSHO)) {
773 crit_enter(); /* Don't interrupt tabs. */
774 c -= b_to_q(" ", c, &tp->t_outq);
780 lwkt_reltoken(&tty_token);
781 return (c ? -1 : '\t');
783 if (c == CEOT && ISSET(oflag, ONOEOT)) {
784 lwkt_reltoken(&tty_token);
789 * Newline translation: if ONLCR is set,
790 * translate newline into "\r\n".
792 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
795 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
796 lwkt_reltoken(&tty_token);
800 /* If OCRNL is set, translate "\r" into "\n". */
801 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
803 /* If ONOCR is set, don't transmit CRs when on column 0. */
804 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
805 lwkt_reltoken(&tty_token);
811 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
812 lwkt_reltoken(&tty_token);
825 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
835 col = (col + 8) & ~7;
839 lwkt_reltoken(&tty_token);
844 * Ioctls for all tty devices. Called after line-discipline specific ioctl
845 * has been called to do discipline-specific functions and/or reject any
846 * of these ioctl commands.
850 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
852 struct thread *td = curthread;
853 struct lwp *lp = td->td_lwp;
854 struct proc *p = td->td_proc;
860 lwkt_gettoken(&tty_token);
861 lwkt_gettoken(&proc_token);
862 lwkt_gettoken(&p->p_token);
864 /* If the ioctl involves modification, hang if in the background. */
888 #if defined(COMPAT_43)
898 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) &&
899 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
900 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
901 if (p->p_pgrp->pg_jobc == 0) {
902 lwkt_reltoken(&p->p_token);
903 lwkt_reltoken(&proc_token);
904 lwkt_reltoken(&tty_token);
907 pgsignal(p->p_pgrp, SIGTTOU, 1);
908 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
911 lwkt_reltoken(&p->p_token);
912 lwkt_reltoken(&proc_token);
913 lwkt_reltoken(&tty_token);
920 switch (cmd) { /* Process the ioctl. */
921 case FIOASYNC: /* set/clear async i/o */
924 SET(tp->t_state, TS_ASYNC);
926 CLR(tp->t_state, TS_ASYNC);
929 case FIONREAD: /* get # bytes to read */
931 *(int *)data = ttnread(tp);
937 * Policy -- Don't allow FIOSETOWN on someone else's
940 if (tp->t_session != NULL && !isctty(p, tp)) {
941 lwkt_reltoken(&p->p_token);
942 lwkt_reltoken(&proc_token);
943 lwkt_reltoken(&tty_token);
947 error = fsetown(*(int *)data, &tp->t_sigio);
949 lwkt_reltoken(&p->p_token);
950 lwkt_reltoken(&proc_token);
951 lwkt_reltoken(&tty_token);
956 if (tp->t_session != NULL && !isctty(p, tp)) {
957 lwkt_reltoken(&p->p_token);
958 lwkt_reltoken(&proc_token);
959 lwkt_reltoken(&tty_token);
962 *(int *)data = fgetown(&tp->t_sigio);
965 case TIOCEXCL: /* set exclusive use of tty */
967 SET(tp->t_state, TS_XCLUDE);
970 case TIOCFLUSH: { /* flush buffers */
971 int flags = *(int *)data;
974 flags = FREAD | FWRITE;
976 flags &= FREAD | FWRITE;
980 case TIOCCONS: /* become virtual console */
982 if (constty && constty != tp &&
983 ISSET(constty->t_state, TS_CONNECTED)) {
984 lwkt_reltoken(&p->p_token);
985 lwkt_reltoken(&proc_token);
986 lwkt_reltoken(&tty_token);
990 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
991 lwkt_reltoken(&p->p_token);
992 lwkt_reltoken(&proc_token);
993 lwkt_reltoken(&tty_token);
998 } else if (tp == constty)
1001 case TIOCDRAIN: /* wait till output drained */
1002 error = ttywait(tp);
1004 lwkt_reltoken(&p->p_token);
1005 lwkt_reltoken(&proc_token);
1006 lwkt_reltoken(&tty_token);
1010 case TIOCGETA: { /* get termios struct */
1011 struct termios *t = (struct termios *)data;
1013 bcopy(&tp->t_termios, t, sizeof(struct termios));
1016 case TIOCGETD: /* get line discipline */
1017 *(int *)data = tp->t_line;
1019 case TIOCGWINSZ: /* get window size */
1020 *(struct winsize *)data = tp->t_winsize;
1022 case TIOCGPGRP: /* get pgrp of tty */
1023 if (!isctty(p, tp)) {
1024 lwkt_reltoken(&p->p_token);
1025 lwkt_reltoken(&proc_token);
1026 lwkt_reltoken(&tty_token);
1029 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1031 case TIOCGSID: /* get sid of tty */
1032 if (!isctty(p, tp)) {
1033 lwkt_reltoken(&p->p_token);
1034 lwkt_reltoken(&proc_token);
1035 lwkt_reltoken(&tty_token);
1038 *(int *)data = tp->t_session->s_sid;
1041 case TIOCHPCL: /* hang up on last close */
1043 SET(tp->t_cflag, HUPCL);
1047 case TIOCNXCL: /* reset exclusive use of tty */
1049 CLR(tp->t_state, TS_XCLUDE);
1052 case TIOCOUTQ: /* output queue size */
1053 *(int *)data = tp->t_outq.c_cc;
1055 case TIOCSETA: /* set termios struct */
1056 case TIOCSETAW: /* drain output, set */
1057 case TIOCSETAF: { /* drn out, fls in, set */
1058 struct termios *t = (struct termios *)data;
1060 if (t->c_ispeed == 0)
1061 t->c_ispeed = t->c_ospeed;
1062 if (t->c_ispeed == 0)
1063 t->c_ispeed = tp->t_ospeed;
1064 if (t->c_ispeed == 0) {
1065 lwkt_reltoken(&p->p_token);
1066 lwkt_reltoken(&proc_token);
1067 lwkt_reltoken(&tty_token);
1071 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1072 error = ttywait(tp);
1075 lwkt_reltoken(&p->p_token);
1076 lwkt_reltoken(&proc_token);
1077 lwkt_reltoken(&tty_token);
1080 if (cmd == TIOCSETAF)
1081 ttyflush(tp, FREAD);
1083 if (!ISSET(t->c_cflag, CIGNORE)) {
1085 * Set device hardware.
1087 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1089 lwkt_reltoken(&p->p_token);
1090 lwkt_reltoken(&proc_token);
1091 lwkt_reltoken(&tty_token);
1094 if (ISSET(t->c_cflag, CLOCAL) &&
1095 !ISSET(tp->t_cflag, CLOCAL)) {
1097 * XXX disconnections would be too hard to
1098 * get rid of without this kludge. The only
1099 * way to get rid of controlling terminals
1100 * is to exit from the session leader.
1102 CLR(tp->t_state, TS_ZOMBIE);
1104 wakeup(TSA_CARR_ON(tp));
1108 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1109 ISSET(t->c_cflag, CLOCAL)) &&
1110 !ISSET(tp->t_state, TS_ZOMBIE))
1111 SET(tp->t_state, TS_CONNECTED);
1113 CLR(tp->t_state, TS_CONNECTED);
1114 tp->t_cflag = t->c_cflag;
1115 tp->t_ispeed = t->c_ispeed;
1116 if (t->c_ospeed != 0)
1117 tp->t_ospeed = t->c_ospeed;
1120 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1122 if (ISSET(t->c_lflag, ICANON))
1123 SET(tp->t_lflag, PENDIN);
1126 * XXX we really shouldn't allow toggling
1127 * ICANON while we're in a non-termios line
1128 * discipline. Now we have to worry about
1129 * panicing for a null queue.
1131 if (tp->t_canq.c_cbreserved > 0 &&
1132 tp->t_rawq.c_cbreserved > 0) {
1133 catq(&tp->t_rawq, &tp->t_canq);
1135 * XXX the queue limits may be
1136 * different, so the old queue
1137 * swapping method no longer works.
1139 catq(&tp->t_canq, &tp->t_rawq);
1141 CLR(tp->t_lflag, PENDIN);
1145 tp->t_iflag = t->c_iflag;
1146 tp->t_oflag = t->c_oflag;
1148 * Make the EXTPROC bit read only.
1150 if (ISSET(tp->t_lflag, EXTPROC))
1151 SET(t->c_lflag, EXTPROC);
1153 CLR(t->c_lflag, EXTPROC);
1154 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1155 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1156 t->c_cc[VTIME] != tp->t_cc[VTIME])
1158 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1162 case TIOCSETD: { /* set line discipline */
1163 int t = *(int *)data;
1164 cdev_t device = tp->t_dev;
1166 if ((u_int)t >= nlinesw) {
1167 lwkt_reltoken(&p->p_token);
1168 lwkt_reltoken(&proc_token);
1169 lwkt_reltoken(&tty_token);
1172 if (t != tp->t_line) {
1174 (*linesw[tp->t_line].l_close)(tp, flag);
1175 error = (*linesw[t].l_open)(device, tp);
1177 (void)(*linesw[tp->t_line].l_open)(device, tp);
1179 lwkt_reltoken(&p->p_token);
1180 lwkt_reltoken(&proc_token);
1181 lwkt_reltoken(&tty_token);
1189 case TIOCSTART: /* start output, like ^Q */
1191 if (ISSET(tp->t_state, TS_TTSTOP) ||
1192 ISSET(tp->t_lflag, FLUSHO)) {
1193 CLR(tp->t_lflag, FLUSHO);
1194 CLR(tp->t_state, TS_TTSTOP);
1199 case TIOCSTI: /* simulate terminal input */
1200 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1201 lwkt_reltoken(&p->p_token);
1202 lwkt_reltoken(&proc_token);
1203 lwkt_reltoken(&tty_token);
1206 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1207 lwkt_reltoken(&p->p_token);
1208 lwkt_reltoken(&proc_token);
1209 lwkt_reltoken(&tty_token);
1213 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1216 case TIOCSTOP: /* stop output, like ^S */
1218 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1219 SET(tp->t_state, TS_TTSTOP);
1220 (*tp->t_stop)(tp, 0);
1224 case TIOCSCTTY: /* become controlling tty */
1225 /* Session ctty vnode pointer set in vnode layer. */
1226 if (!SESS_LEADER(p) ||
1227 ((p->p_session->s_ttyvp || tp->t_session) &&
1228 (tp->t_session != p->p_session))) {
1229 lwkt_reltoken(&p->p_token);
1230 lwkt_reltoken(&proc_token);
1231 lwkt_reltoken(&tty_token);
1235 tp->t_session = p->p_session;
1238 tp->t_pgrp = p->p_pgrp;
1239 otp = p->p_session->s_ttyp;
1240 p->p_session->s_ttyp = tp;
1241 p->p_flags |= P_CONTROLT;
1249 case TIOCSPGRP: { /* set pgrp of tty */
1250 pid_t pgid = *(int *)data;
1252 if (!isctty(p, tp)) {
1253 lwkt_reltoken(&p->p_token);
1254 lwkt_reltoken(&proc_token);
1255 lwkt_reltoken(&tty_token);
1258 else if (pgid < 1 || pgid > PID_MAX) {
1259 lwkt_reltoken(&p->p_token);
1260 lwkt_reltoken(&proc_token);
1261 lwkt_reltoken(&tty_token);
1264 struct pgrp *pgrp = pgfind(pgid);
1265 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1268 lwkt_reltoken(&p->p_token);
1269 lwkt_reltoken(&proc_token);
1270 lwkt_reltoken(&tty_token);
1282 case TIOCSTAT: /* simulate control-T */
1287 case TIOCSWINSZ: /* set window size */
1288 if (bcmp((caddr_t)&tp->t_winsize, data,
1289 sizeof (struct winsize))) {
1290 tp->t_winsize = *(struct winsize *)data;
1291 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1294 case TIOCSDRAINWAIT:
1295 error = priv_check(td, PRIV_ROOT);
1297 lwkt_reltoken(&p->p_token);
1298 lwkt_reltoken(&proc_token);
1299 lwkt_reltoken(&tty_token);
1302 tp->t_timeout = *(int *)data * hz;
1303 wakeup(TSA_OCOMPLETE(tp));
1304 wakeup(TSA_OLOWAT(tp));
1306 case TIOCGDRAINWAIT:
1307 *(int *)data = tp->t_timeout / hz;
1310 lwkt_reltoken(&p->p_token);
1311 lwkt_reltoken(&proc_token);
1312 lwkt_reltoken(&tty_token);
1313 #if defined(COMPAT_43)
1314 return (ttcompat(tp, cmd, data, flag));
1319 lwkt_reltoken(&p->p_token);
1320 lwkt_reltoken(&proc_token);
1321 lwkt_reltoken(&tty_token);
1325 static struct filterops ttyread_filtops =
1326 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread };
1327 static struct filterops ttywrite_filtops =
1328 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite };
1331 ttykqfilter(struct dev_kqfilter_args *ap)
1333 cdev_t dev = ap->a_head.a_dev;
1334 struct knote *kn = ap->a_kn;
1335 struct tty *tp = dev->si_tty;
1336 struct klist *klist;
1340 lwkt_gettoken(&tty_token);
1341 switch (kn->kn_filter) {
1343 klist = &tp->t_rkq.ki_note;
1344 kn->kn_fop = &ttyread_filtops;
1347 klist = &tp->t_wkq.ki_note;
1348 kn->kn_fop = &ttywrite_filtops;
1351 ap->a_result = EOPNOTSUPP;
1352 lwkt_reltoken(&tty_token);
1355 lwkt_reltoken(&tty_token);
1356 kn->kn_hook = (caddr_t)dev;
1357 knote_insert(klist, kn);
1363 filt_ttyrdetach(struct knote *kn)
1365 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1367 lwkt_gettoken(&tty_token);
1368 knote_remove(&tp->t_rkq.ki_note, kn);
1369 lwkt_reltoken(&tty_token);
1373 filt_ttyread(struct knote *kn, long hint)
1375 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1377 lwkt_gettoken(&tty_token);
1378 kn->kn_data = ttnread(tp);
1379 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1380 kn->kn_flags |= (EV_EOF | EV_NODATA);
1381 lwkt_reltoken(&tty_token);
1384 lwkt_reltoken(&tty_token);
1385 return (kn->kn_data > 0);
1389 filt_ttywdetach(struct knote *kn)
1391 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1393 lwkt_gettoken(&tty_token);
1394 knote_remove(&tp->t_wkq.ki_note, kn);
1395 lwkt_reltoken(&tty_token);
1399 filt_ttywrite(struct knote *kn, long hint)
1401 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1404 lwkt_gettoken(&tty_token);
1405 kn->kn_data = tp->t_outq.c_cc;
1406 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1407 lwkt_reltoken(&tty_token);
1410 ret = (kn->kn_data <= tp->t_olowat &&
1411 ISSET(tp->t_state, TS_CONNECTED));
1412 lwkt_reltoken(&tty_token);
1417 * Must be called while in a critical section.
1418 * NOTE: tty_token must be held.
1421 ttnread(struct tty *tp)
1425 ASSERT_LWKT_TOKEN_HELD(&tty_token);
1426 if (ISSET(tp->t_lflag, PENDIN))
1428 nread = tp->t_canq.c_cc;
1429 if (!ISSET(tp->t_lflag, ICANON)) {
1430 nread += tp->t_rawq.c_cc;
1431 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1438 * Wait for output to drain.
1441 ttywait(struct tty *tp)
1447 lwkt_gettoken(&tty_token);
1448 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1449 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1451 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1452 ISSET(tp->t_state, TS_CONNECTED)) {
1453 SET(tp->t_state, TS_SO_OCOMPLETE);
1454 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1458 if (error == EWOULDBLOCK)
1465 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1467 lwkt_reltoken(&tty_token);
1473 * Flush if successfully wait.
1476 ttywflush(struct tty *tp)
1480 if ((error = ttywait(tp)) == 0)
1481 ttyflush(tp, FREAD);
1486 * Flush tty read and/or write queues, notifying anyone waiting.
1489 ttyflush(struct tty *tp, int rw)
1492 lwkt_gettoken(&tty_token);
1497 FLUSHQ(&tp->t_outq);
1498 CLR(tp->t_state, TS_TTSTOP);
1500 (*tp->t_stop)(tp, rw);
1502 FLUSHQ(&tp->t_canq);
1503 FLUSHQ(&tp->t_rawq);
1504 CLR(tp->t_lflag, PENDIN);
1507 CLR(tp->t_state, TS_LOCAL);
1509 if (ISSET(tp->t_state, TS_TBLOCK)) {
1511 FLUSHQ(&tp->t_outq);
1515 * Don't let leave any state that might clobber the
1516 * next line discipline (although we should do more
1517 * to send the START char). Not clearing the state
1518 * may have caused the "putc to a clist with no
1519 * reserved cblocks" panic/kprintf.
1521 CLR(tp->t_state, TS_TBLOCK);
1523 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1524 if (ISSET(tp->t_iflag, IXOFF)) {
1526 * XXX wait a bit in the hope that the stop
1527 * character (if any) will go out. Waiting
1528 * isn't good since it allows races. This
1529 * will be fixed when the stop character is
1530 * put in a special queue. Don't bother with
1531 * the checks in ttywait() since the timeout
1534 SET(tp->t_state, TS_SO_OCOMPLETE);
1535 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1538 * Don't try sending the stop character again.
1540 CLR(tp->t_state, TS_TBLOCK);
1547 FLUSHQ(&tp->t_outq);
1550 lwkt_reltoken(&tty_token);
1555 * Copy in the default termios characters.
1558 termioschars(struct termios *t)
1560 lwkt_gettoken(&tty_token);
1561 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1562 lwkt_reltoken(&tty_token);
1569 ttychars(struct tty *tp)
1571 lwkt_gettoken(&tty_token);
1572 termioschars(&tp->t_termios);
1573 lwkt_reltoken(&tty_token);
1577 * Handle input high water. Send stop character for the IXOFF case. Turn
1578 * on our input flow control bit and propagate the changes to the driver.
1579 * XXX the stop character should be put in a special high priority queue.
1582 ttyblock(struct tty *tp)
1584 lwkt_gettoken(&tty_token);
1585 SET(tp->t_state, TS_TBLOCK);
1586 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1587 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1588 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1590 lwkt_reltoken(&tty_token);
1594 * Handle input low water. Send start character for the IXOFF case. Turn
1595 * off our input flow control bit and propagate the changes to the driver.
1596 * XXX the start character should be put in a special high priority queue.
1599 ttyunblock(struct tty *tp)
1601 lwkt_gettoken(&tty_token);
1602 CLR(tp->t_state, TS_TBLOCK);
1603 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1604 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1605 SET(tp->t_state, TS_TBLOCK); /* try again later */
1607 lwkt_reltoken(&tty_token);
1611 /* Not used by any current (i386) drivers. */
1613 * Restart after an inter-char delay.
1616 ttrstrt(void *tp_arg)
1620 KASSERT(tp_arg != NULL, ("ttrstrt"));
1624 lwkt_gettoken(&tty_token);
1625 CLR(tp->t_state, TS_TIMEOUT);
1627 lwkt_reltoken(&tty_token);
1633 ttstart(struct tty *tp)
1635 lwkt_gettoken(&tty_token);
1636 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1638 lwkt_reltoken(&tty_token);
1643 * "close" a line discipline
1646 ttylclose(struct tty *tp, int flag)
1648 lwkt_gettoken(&tty_token);
1649 if (flag & FNONBLOCK || ttywflush(tp))
1650 ttyflush(tp, FREAD | FWRITE);
1651 lwkt_reltoken(&tty_token);
1656 ttyhold(struct tty *tp)
1662 ttyunhold(struct tty *tp)
1671 * Handle modem control transition on a tty.
1672 * Flag indicates new state of carrier.
1673 * Returns 0 if the line should be turned off, otherwise 1.
1676 ttymodem(struct tty *tp, int flag)
1678 lwkt_gettoken(&tty_token);
1679 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1681 * MDMBUF: do flow control according to carrier flag
1682 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1683 * works if IXON and IXANY are clear.
1686 CLR(tp->t_state, TS_CAR_OFLOW);
1687 CLR(tp->t_state, TS_TTSTOP);
1689 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1690 SET(tp->t_state, TS_CAR_OFLOW);
1691 SET(tp->t_state, TS_TTSTOP);
1692 (*tp->t_stop)(tp, 0);
1694 } else if (flag == 0) {
1698 CLR(tp->t_state, TS_CARR_ON);
1699 if (ISSET(tp->t_state, TS_ISOPEN) &&
1700 !ISSET(tp->t_cflag, CLOCAL)) {
1701 SET(tp->t_state, TS_ZOMBIE);
1702 CLR(tp->t_state, TS_CONNECTED);
1703 if (tp->t_session && tp->t_session->s_leader)
1704 ksignal(tp->t_session->s_leader, SIGHUP);
1705 ttyflush(tp, FREAD | FWRITE);
1706 lwkt_reltoken(&tty_token);
1713 SET(tp->t_state, TS_CARR_ON);
1714 if (!ISSET(tp->t_state, TS_ZOMBIE))
1715 SET(tp->t_state, TS_CONNECTED);
1716 wakeup(TSA_CARR_ON(tp));
1720 lwkt_reltoken(&tty_token);
1725 * Reinput pending characters after state switch
1726 * call from a critical section.
1729 ttypend(struct tty *tp)
1734 lwkt_gettoken(&tty_token);
1735 CLR(tp->t_lflag, PENDIN);
1736 SET(tp->t_state, TS_TYPEN);
1738 * XXX this assumes too much about clist internals. It may even
1739 * fail if the cblock slush pool is empty. We can't allocate more
1740 * cblocks here because we are called from an interrupt handler
1741 * and clist_alloc_cblocks() can wait.
1744 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1745 tp->t_rawq.c_cbmax = tq.c_cbmax;
1746 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1747 while ((c = clist_getc(&tq)) >= 0)
1749 CLR(tp->t_state, TS_TYPEN);
1750 lwkt_reltoken(&tty_token);
1754 * Process a read call on a tty device.
1757 ttread(struct tty *tp, struct uio *uio, int flag)
1762 cc_t *cc = tp->t_cc;
1765 int first, error = 0;
1766 int has_stime = 0, last_cc = 0;
1767 long slp = 0; /* XXX this should be renamed `timo'. */
1768 struct timeval stime;
1770 lp = curthread->td_lwp;
1771 stime.tv_sec = 0; /* fix compiler warnings */
1774 lwkt_gettoken(&tty_token);
1777 lflag = tp->t_lflag;
1779 * take pending input first
1781 if (ISSET(lflag, PENDIN)) {
1783 splz(); /* reduce latency */
1784 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1788 * Hang process if it's in the background.
1790 lwkt_gettoken(&proc_token);
1791 if ((pp = curproc) && isbackground(pp, tp)) {
1793 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1794 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1795 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1796 lwkt_reltoken(&proc_token);
1797 lwkt_reltoken(&tty_token);
1800 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1801 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1803 lwkt_reltoken(&proc_token);
1804 lwkt_reltoken(&tty_token);
1807 lwkt_reltoken(&proc_token);
1810 lwkt_reltoken(&proc_token);
1812 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1814 lwkt_reltoken(&tty_token);
1815 return (0); /* EOF */
1819 * If canonical, use the canonical queue,
1820 * else use the raw queue.
1822 * (should get rid of clists...)
1824 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1826 if (flag & IO_NDELAY) {
1829 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1831 lwkt_reltoken(&tty_token);
1835 lwkt_reltoken(&tty_token);
1836 return (EWOULDBLOCK);
1838 if (!ISSET(lflag, ICANON)) {
1841 struct timeval timecopy;
1844 * Check each of the four combinations.
1845 * (m > 0 && t == 0) is the normal read case.
1846 * It should be fairly efficient, so we check that and its
1847 * companion case (m == 0 && t == 0) first.
1848 * For the other two cases, we compute the target sleep time
1857 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1859 lwkt_reltoken(&tty_token);
1862 t *= 100000; /* time in us */
1863 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1864 ((t1).tv_usec - (t2).tv_usec))
1870 getmicrotime(&timecopy);
1871 if (has_stime == 0) {
1872 /* first character, start timer */
1876 } else if (qp->c_cc > last_cc) {
1877 /* got a character, restart timer */
1881 /* nothing, check expiration */
1882 slp = t - diff(timecopy, stime);
1887 } else { /* m == 0 */
1890 getmicrotime(&timecopy);
1891 if (has_stime == 0) {
1896 slp = t - diff(timecopy, stime);
1898 /* Timed out, but 0 is enough input. */
1900 lwkt_reltoken(&tty_token);
1907 * Rounding down may make us wake up just short
1908 * of the target, so we round up.
1909 * The formula is ceiling(slp * hz/1000000).
1910 * 32-bit arithmetic is enough for hz < 169.
1911 * XXX see tvtohz() for how to avoid overflow if hz
1912 * is large (divide by `tick' and/or arrange to
1913 * use tvtohz() if hz is large).
1915 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1918 if (qp->c_cc <= 0) {
1921 * There is no input, or not enough input and we can block.
1923 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1924 ISSET(tp->t_state, TS_CONNECTED) ?
1925 "ttyin" : "ttyhup", (int)slp);
1927 if (error == EWOULDBLOCK)
1930 lwkt_reltoken(&tty_token);
1934 * XXX what happens if another process eats some input
1935 * while we are asleep (not just here)? It would be
1936 * safest to detect changes and reset our state variables
1937 * (has_stime and last_cc).
1945 * Input present, check for input mapping and processing.
1948 if (ISSET(lflag, ICANON | ISIG))
1954 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1955 icc = q_to_b(qp, ibuf, icc);
1961 error = uiomove(ibuf, (size_t)icc, uio);
1963 * XXX if there was an error then we should ungetc() the
1964 * unmoved chars and reduce icc here.
1968 if (uio->uio_resid == 0)
1982 * delayed suspend (^Y)
1984 if (CCEQ(cc[VDSUSP], c) &&
1985 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1986 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1988 error = ttysleep(tp, &lbolt, PCATCH,
1997 * Interpret EOF only in canonical mode.
1999 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
2002 * Give user character.
2004 error = ureadc(c, uio);
2006 /* XXX should ungetc(c, qp). */
2008 if (uio->uio_resid == 0)
2011 * In canonical mode check for a "break character"
2012 * marking the end of a "line of input".
2014 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
2021 * Look to unblock input now that (presumably)
2022 * the input queue has gone down.
2025 if (ISSET(tp->t_state, TS_TBLOCK) &&
2026 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
2030 lwkt_reltoken(&tty_token);
2035 * Check the output queue on tp for space for a kernel message (from uprintf
2036 * or tprintf). Allow some space over the normal hiwater mark so we don't
2037 * lose messages due to normal flow control, but don't let the tty run amok.
2038 * Sleeps here are not interruptible, but we return prematurely if new signals
2042 ttycheckoutq(struct tty *tp, int wait)
2044 struct lwp *lp = curthread->td_lwp;
2046 sigset_t oldset, newset;
2048 lwkt_gettoken(&tty_token);
2049 hiwat = tp->t_ohiwat;
2050 SIGEMPTYSET(oldset);
2051 SIGEMPTYSET(newset);
2054 oldset = lwp_sigpend(lp);
2055 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
2056 while (tp->t_outq.c_cc > hiwat) {
2058 if (tp->t_outq.c_cc <= hiwat)
2061 newset = lwp_sigpend(lp);
2062 if (!wait || SIGSETNEQ(oldset, newset)) {
2064 lwkt_reltoken(&tty_token);
2067 SET(tp->t_state, TS_SO_OLOWAT);
2068 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
2072 lwkt_reltoken(&tty_token);
2077 * Process a write call on a tty device.
2080 ttwrite(struct tty *tp, struct uio *uio, int flag)
2086 int i, hiwat, error;
2091 lwkt_gettoken(&tty_token);
2092 lp = curthread->td_lwp;
2093 hiwat = tp->t_ohiwat;
2094 cnt = uio->uio_resid;
2099 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2101 if (uio->uio_resid == cnt)
2105 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2106 if (flag & IO_NDELAY) {
2108 error = EWOULDBLOCK;
2111 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2120 * Hang the process if it's in the background.
2122 lwkt_gettoken(&proc_token);
2123 if ((pp = curproc) && isbackground(pp, tp) &&
2124 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) &&
2125 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2126 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2127 if (pp->p_pgrp->pg_jobc == 0) {
2129 lwkt_reltoken(&proc_token);
2132 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2133 lwkt_reltoken(&proc_token);
2134 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2139 lwkt_reltoken(&proc_token);
2141 * Process the user's data in at most OBUFSIZ chunks. Perform any
2142 * output translation. Keep track of high water mark, sleep on
2143 * overflow awaiting device aid in acquiring new space.
2145 while (uio->uio_resid > 0 || cc > 0) {
2146 if (ISSET(tp->t_lflag, FLUSHO)) {
2148 lwkt_reltoken(&tty_token);
2151 if (tp->t_outq.c_cc > hiwat)
2154 * Grab a hunk of data from the user, unless we have some
2155 * leftover from last time.
2158 cc = szmin(uio->uio_resid, OBUFSIZ);
2160 error = uiomove(cp, (size_t)cc, uio);
2167 * If nothing fancy need be done, grab those characters we
2168 * can handle without any of ttyoutput's processing and
2169 * just transfer them to the output q. For those chars
2170 * which require special processing (as indicated by the
2171 * bits in char_type), call ttyoutput. After processing
2172 * a hunk of data, look for FLUSHO so ^O's will take effect
2176 if (!ISSET(tp->t_oflag, OPOST))
2179 ce = cc - scanc((u_int)cc, (u_char *)cp,
2180 char_type, CCLASSMASK);
2182 * If ce is zero, then we're processing
2183 * a special character through ttyoutput.
2187 if (ttyoutput(*cp, tp) >= 0) {
2188 /* No Clists, wait a bit. */
2190 if (flag & IO_NDELAY) {
2191 error = EWOULDBLOCK;
2194 error = ttysleep(tp, &lbolt,
2203 if (ISSET(tp->t_lflag, FLUSHO) ||
2204 tp->t_outq.c_cc > hiwat)
2210 * A bunch of normal characters have been found.
2211 * Transfer them en masse to the output queue and
2212 * continue processing at the top of the loop.
2213 * If there are any further characters in this
2214 * <= OBUFSIZ chunk, the first should be a character
2215 * requiring special handling by ttyoutput.
2218 i = b_to_q(cp, ce, &tp->t_outq);
2221 cp += ce, cc -= ce, tk_nout += ce;
2224 /* No Clists, wait a bit. */
2226 if (flag & IO_NDELAY) {
2227 error = EWOULDBLOCK;
2230 error = ttysleep(tp, &lbolt, PCATCH,
2236 if (ISSET(tp->t_lflag, FLUSHO) ||
2237 tp->t_outq.c_cc > hiwat)
2244 * If cc is nonzero, we leave the uio structure inconsistent, as the
2245 * offset and iov pointers have moved forward, but it doesn't matter
2246 * (the call will either return short or restart with a new uio).
2248 uio->uio_resid += cc;
2249 lwkt_reltoken(&tty_token);
2256 * This can only occur if FLUSHO is set in t_lflag,
2257 * or if ttstart/oproc is synchronous (or very fast).
2259 if (tp->t_outq.c_cc <= hiwat) {
2263 if (flag & IO_NDELAY) {
2265 uio->uio_resid += cc;
2266 lwkt_reltoken(&tty_token);
2267 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2269 SET(tp->t_state, TS_SO_OLOWAT);
2270 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2272 if (error == EWOULDBLOCK)
2280 * Rubout one character from the rawq of tp
2281 * as cleanly as possible.
2282 * NOTE: Must be called with tty_token held
2285 ttyrub(int c, struct tty *tp)
2291 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2292 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2294 CLR(tp->t_lflag, FLUSHO);
2295 if (ISSET(tp->t_lflag, ECHOE)) {
2296 if (tp->t_rocount == 0) {
2298 * Screwed by ttwrite; retype
2303 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2306 CLR(c, ~TTY_CHARMASK);
2307 switch (CCLASS(c)) {
2316 if (ISSET(tp->t_lflag, ECHOCTL))
2320 if (tp->t_rocount < tp->t_rawq.c_cc) {
2325 savecol = tp->t_column;
2326 SET(tp->t_state, TS_CNTTB);
2327 SET(tp->t_lflag, FLUSHO);
2328 tp->t_column = tp->t_rocol;
2329 cp = tp->t_rawq.c_cf;
2331 tabc = *cp; /* XXX FIX NEXTC */
2332 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2334 CLR(tp->t_lflag, FLUSHO);
2335 CLR(tp->t_state, TS_CNTTB);
2338 /* savecol will now be length of the tab. */
2339 savecol -= tp->t_column;
2340 tp->t_column += savecol;
2342 savecol = 8; /* overflow screw */
2343 while (--savecol >= 0)
2344 (void)ttyoutput('\b', tp);
2347 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2348 (void)kprintf(PANICSTR, c, CCLASS(c));
2350 panic(PANICSTR, c, CCLASS(c));
2354 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2355 if (!ISSET(tp->t_state, TS_ERASE)) {
2356 SET(tp->t_state, TS_ERASE);
2357 (void)ttyoutput('\\', tp);
2361 ttyecho(tp->t_cc[VERASE], tp);
2363 * This code may be executed not only when an ERASE key
2364 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2365 * So, I didn't think it was worthwhile to pass the extra
2366 * information (which would need an extra parameter,
2367 * changing every call) needed to distinguish the ERASE2
2368 * case from the ERASE.
2375 * Back over cnt characters, erasing them.
2376 * NOTE: Must be called with tty_token held
2379 ttyrubo(struct tty *tp, int cnt)
2381 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2383 (void)ttyoutput('\b', tp);
2384 (void)ttyoutput(' ', tp);
2385 (void)ttyoutput('\b', tp);
2391 * Reprint the rawq line. Note, it is assumed that c_cc has already
2393 * NOTE: Must be called with tty_token held
2396 ttyretype(struct tty *tp)
2401 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2402 /* Echo the reprint character. */
2403 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2404 ttyecho(tp->t_cc[VREPRINT], tp);
2406 (void)ttyoutput('\n', tp);
2410 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2411 * BIT OF FIRST CHAR.
2414 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2415 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2417 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2418 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2420 CLR(tp->t_state, TS_ERASE);
2423 tp->t_rocount = tp->t_rawq.c_cc;
2428 * Echo a typed character to the terminal.
2429 * NOTE: Must be called with tty_token held
2432 ttyecho(int c, struct tty *tp)
2434 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2436 if (!ISSET(tp->t_state, TS_CNTTB))
2437 CLR(tp->t_lflag, FLUSHO);
2438 if ((!ISSET(tp->t_lflag, ECHO) &&
2439 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2440 ISSET(tp->t_lflag, EXTPROC))
2442 if (ISSET(tp->t_lflag, ECHOCTL) &&
2443 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2444 ISSET(c, TTY_CHARMASK) == 0177)) {
2445 (void)ttyoutput('^', tp);
2446 CLR(c, ~TTY_CHARMASK);
2452 (void)ttyoutput(c, tp);
2456 * Wake up any readers on a tty.
2459 ttwakeup(struct tty *tp)
2461 lwkt_gettoken(&tty_token);
2462 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2463 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2464 wakeup(TSA_HUP_OR_INPUT(tp));
2465 KNOTE(&tp->t_rkq.ki_note, 0);
2466 lwkt_reltoken(&tty_token);
2470 * Wake up any writers on a tty.
2473 ttwwakeup(struct tty *tp)
2475 lwkt_gettoken(&tty_token);
2476 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2477 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2478 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2479 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2480 CLR(tp->t_state, TS_SO_OCOMPLETE);
2481 wakeup(TSA_OCOMPLETE(tp));
2483 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2484 tp->t_outq.c_cc <= tp->t_olowat) {
2485 CLR(tp->t_state, TS_SO_OLOWAT);
2486 wakeup(TSA_OLOWAT(tp));
2488 KNOTE(&tp->t_wkq.ki_note, 0);
2489 lwkt_reltoken(&tty_token);
2493 * Look up a code for a specified speed in a conversion table;
2494 * used by drivers to map software speed values to hardware parameters.
2498 ttspeedtab(int speed, struct speedtab *table)
2501 for ( ; table->sp_speed != -1; table++)
2502 if (table->sp_speed == speed)
2503 return (table->sp_code);
2508 * Set input and output watermarks and buffer sizes. For input, the
2509 * high watermark is about one second's worth of input above empty, the
2510 * low watermark is slightly below high water, and the buffer size is a
2511 * driver-dependent amount above high water. For output, the watermarks
2512 * are near the ends of the buffer, with about 1 second's worth of input
2513 * between them. All this only applies to the standard line discipline.
2516 ttsetwater(struct tty *tp)
2518 int cps, ttmaxhiwat, x;
2520 lwkt_gettoken(&tty_token);
2522 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2523 switch (tp->t_ispeedwat) {
2525 cps = tp->t_ispeed / 10;
2529 * This case is for old drivers that don't know about
2530 * t_ispeedwat. Arrange for them to get the old buffer
2531 * sizes and watermarks.
2533 cps = TTYHOG - 2 * 256;
2534 tp->t_ififosize = 2 * 2048;
2537 cps = tp->t_ispeedwat / 10;
2541 tp->t_ilowat = 7 * cps / 8;
2542 x = cps + tp->t_ififosize;
2543 clist_alloc_cblocks(&tp->t_rawq, x, x);
2546 switch (tp->t_ospeedwat) {
2548 cps = tp->t_ospeed / 10;
2549 ttmaxhiwat = 2 * TTMAXHIWAT;
2552 cps = tp->t_ospeed / 10;
2553 ttmaxhiwat = TTMAXHIWAT;
2556 cps = tp->t_ospeedwat / 10;
2557 ttmaxhiwat = 8 * TTMAXHIWAT;
2560 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2561 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2563 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2564 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2565 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2567 clist_alloc_cblocks(&tp->t_outq, x, x);
2569 lwkt_reltoken(&tty_token);
2573 * Report on state of foreground process group.
2576 ttyinfo(struct tty *tp)
2579 struct proc *p, *pick;
2589 if (ttycheckoutq(tp,0) == 0)
2592 lwkt_gettoken(&tty_token);
2593 lwkt_gettoken(&proc_token);
2595 * We always print the load average, then figure out what else to
2596 * print based on the state of the current process group.
2598 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2599 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2601 if (tp->t_session == NULL) {
2602 ttyprintf(tp, "not a controlling terminal\n");
2605 if ((pgrp = tp->t_pgrp) == NULL) {
2606 ttyprintf(tp, "no foreground process group\n");
2611 * Pick an interesting process. Note that certain elements,
2612 * in particular the wmesg, require a critical section for
2613 * safe access (YYY and we are still not MP safe).
2615 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2618 lwkt_gettoken(&pgrp->pg_token);
2621 for (p = LIST_FIRST(&pgrp->pg_members);
2623 p = LIST_NEXT(p, p_pglist)) {
2624 if (proc_compare(pick, p))
2628 ttyprintf(tp, "empty foreground process group\n");
2633 * Pick an interesting LWP (XXX)
2636 lp = FIRST_LWP_IN_PROC(pick);
2639 ttyprintf(tp, "foreground process without lwp\n");
2644 * Figure out what wait/process-state message, and command
2648 * XXX lwp This is a horrible mixture. We need to rework this
2649 * as soon as lwps have their own runnable status.
2652 if (pick->p_flags & P_WEXIT)
2654 else if (lp->lwp_stat == LSRUN)
2656 else if (pick->p_stat == SIDL)
2658 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2659 str = lp->lwp_wmesg;
2663 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2664 pick->p_comm, pick->p_pid, str);
2667 * Calculate cpu usage, percent cpu, and cmsz. Note that
2668 * 'pick' becomes invalid the moment we exit the critical
2671 if (lp->lwp_thread && (pick->p_flags & P_SWAPPEDOUT) == 0)
2672 calcru_proc(pick, &ru);
2674 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2678 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) {
2680 } else if ((vm = pick->p_vmspace) == NULL) {
2684 vmsz = pgtok(vmspace_resident_count(vm));
2692 ttyprintf(tp, " %s ",
2694 ttyprintf(tp, "%ld.%02ldu ",
2695 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2696 ttyprintf(tp, "%ld.%02lds ",
2697 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2698 ttyprintf(tp, "%d%% %ldk\n",
2699 pctcpu / 100, vmsz);
2702 lwkt_reltoken(&pgrp->pg_token);
2705 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2706 lwkt_reltoken(&proc_token);
2707 lwkt_reltoken(&tty_token);
2711 * Returns 1 if p2 is "better" than p1
2713 * The algorithm for picking the "interesting" process is thus:
2715 * 1) Only foreground processes are eligible - implied.
2716 * 2) Runnable processes are favored over anything else. The runner
2717 * with the highest cpu utilization is picked (p_cpticks). Ties are
2718 * broken by picking the highest pid.
2719 * 3) The sleeper with the shortest sleep time is next. With ties,
2720 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2721 * 4) Further ties are broken by picking the highest pid.
2723 * NOTE: must be called with proc_token held.
2725 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2726 #define TESTAB(a, b) ((a)<<1 | (b))
2732 proc_compare(struct proc *p1, struct proc *p2)
2734 struct lwp *lp1, *lp2;
2737 ASSERT_LWKT_TOKEN_HELD(&proc_token);
2741 if (lwkt_trytoken(&p1->p_token) == 0)
2743 if (lwkt_trytoken(&p2->p_token) == 0) {
2744 lwkt_reltoken(&p1->p_token);
2751 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2759 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2765 /* XXX choose the best lwp? */
2766 lp1 = FIRST_LWP_IN_PROC(p1);
2767 lp2 = FIRST_LWP_IN_PROC(p2);
2770 * Favor one with LWPs verses one that has none (is exiting).
2782 * see if at least one of them is runnable
2784 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2793 * tie - favor one with highest recent cpu utilization
2795 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2797 else if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2800 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */
2807 * Pick the one with the smallest sleep time
2809 if (lp2->lwp_slptime > lp1->lwp_slptime) {
2813 if (lp1->lwp_slptime > lp2->lwp_slptime) {
2819 * Favor one sleeping in a non-interruptible sleep
2821 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0)
2824 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0)
2827 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2831 lwkt_reltoken(&p2->p_token);
2832 lwkt_reltoken(&p1->p_token);
2837 * Output char to tty; console putchar style.
2840 tputchar(int c, struct tty *tp)
2843 lwkt_gettoken(&tty_token);
2844 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2845 lwkt_reltoken(&tty_token);
2850 (void)ttyoutput('\r', tp);
2851 (void)ttyoutput(c, tp);
2853 lwkt_reltoken(&tty_token);
2859 * Sleep on chan, returning ERESTART if tty changed while we napped and
2860 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2861 * the tty is revoked, restarting a pending call will redo validation done
2862 * at the start of the call.
2865 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2871 error = tsleep(chan, slpflags, wmesg, timo);
2874 return (tp->t_gen == gen ? 0 : ERESTART);
2880 * We bump the gen to force any ttysleep()'s to return with ERESTART
2881 * and flush the tty. The related fp's should already have been
2882 * replaced so the tty will close when the last references on the
2883 * original fp's go away.
2886 ttyrevoke(struct dev_revoke_args *ap)
2890 lwkt_gettoken(&tty_token);
2891 tp = ap->a_head.a_dev->si_tty;
2893 ttyflush(tp, FREAD | FWRITE);
2894 wakeup(TSA_CARR_ON(tp));
2897 lwkt_reltoken(&tty_token);
2902 * Allocate a tty struct. Clists in the struct will be allocated by
2906 ttymalloc(struct tty *tp)
2912 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2918 ttyunregister(struct tty *tp)
2920 lwkt_gettoken(&tty_token);
2921 KKASSERT(ISSET(tp->t_state, TS_REGISTERED));
2922 CLR(tp->t_state, TS_REGISTERED);
2923 TAILQ_REMOVE(&tty_list, tp, t_list);
2924 lwkt_reltoken(&tty_token);
2928 ttyregister(struct tty *tp)
2930 lwkt_gettoken(&tty_token);
2931 KKASSERT(!ISSET(tp->t_state, TS_REGISTERED));
2932 SET(tp->t_state, TS_REGISTERED);
2933 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2934 lwkt_reltoken(&tty_token);
2938 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2945 bzero(&marker, sizeof(marker));
2946 marker.t_state = TS_MARKER;
2949 lwkt_gettoken(&tty_token);
2951 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2952 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2953 TAILQ_REMOVE(&tty_list, &marker, t_list);
2954 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2955 if (tp->t_state & TS_MARKER)
2959 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev);
2960 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2964 TAILQ_REMOVE(&tty_list, &marker, t_list);
2965 lwkt_reltoken(&tty_token);
2969 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2970 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2973 nottystop(struct tty *tp, int rw)
2979 ttyread(struct dev_read_args *ap)
2984 tp = ap->a_head.a_dev->si_tty;
2987 lwkt_gettoken(&tty_token);
2988 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2989 lwkt_reltoken(&tty_token);
2995 ttywrite(struct dev_write_args *ap)
3000 tp = ap->a_head.a_dev->si_tty;
3003 lwkt_gettoken(&tty_token);
3004 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
3005 lwkt_reltoken(&tty_token);