4 * Copyright (c) 1982, 1986, 1990, 1991, 1993
5 * The Regents of the University of California. All rights reserved.
6 * (c) UNIX System Laboratories, Inc.
7 * All or some portions of this file are derived from material licensed
8 * to the University of California by American Telephone and Telegraph
9 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 * the permission of UNIX System Laboratories, Inc.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * @(#)tty.c 8.8 (Berkeley) 1/21/94
37 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
42 * Almost all functions in this file are acquiring the tty token due to their
43 * access and modifications of the 'tp' (struct tty) objects.
48 * o Fix races for sending the start char in ttyflush().
49 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
50 * With luck, there will be MIN chars before select() returns().
51 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
52 * o Don't allow input in TS_ZOMBIE case. It would be visible through
54 * o Do the new sio locking stuff here and use it to avoid special
57 * o Move EXTPROC and/or PENDIN to t_state?
58 * o Wrap most of ttioctl in spltty/splx.
59 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
60 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
61 * o Don't allow certain termios flags to affect disciplines other
62 * than TTYDISC. Cancel their effects before switch disciplines
63 * and ignore them if they are set while we are in another
65 * o Now that historical speed conversions are handled here, don't
67 * o Check for TS_CARR_ON being set while everything is closed and not
68 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
69 * so it would live until the next open even if carrier drops.
70 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
71 * only when _all_ openers leave open().
74 #include "opt_uconsole.h"
76 #include <sys/param.h>
77 #include <sys/systm.h>
78 #include <sys/filio.h>
83 #include <sys/clist.h>
85 #include <sys/fcntl.h>
87 #include <sys/dkstat.h>
88 #include <sys/kernel.h>
89 #include <sys/vnode.h>
90 #include <sys/signalvar.h>
91 #include <sys/signal2.h>
92 #include <sys/resourcevar.h>
93 #include <sys/malloc.h>
94 #include <sys/filedesc.h>
95 #include <sys/sysctl.h>
96 #include <sys/thread2.h>
101 #include <vm/vm_map.h>
102 #include <vm/vm_extern.h>
104 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
106 static int proc_compare (struct proc *p1, struct proc *p2);
107 static int ttnread (struct tty *tp);
108 static void ttyecho (int c, struct tty *tp);
109 static int ttyoutput (int c, struct tty *tp);
110 static void ttypend (struct tty *tp);
111 static void ttyretype (struct tty *tp);
112 static void ttyrub (int c, struct tty *tp);
113 static void ttyrubo (struct tty *tp, int cnt);
114 static void ttyunblock (struct tty *tp);
115 static int ttywflush (struct tty *tp);
116 static int filt_ttyread (struct knote *kn, long hint);
117 static void filt_ttyrdetach (struct knote *kn);
118 static int filt_ttywrite (struct knote *kn, long hint);
119 static void filt_ttywdetach (struct knote *kn);
122 * Table with character classes and parity. The 8th bit indicates parity,
123 * the 7th bit indicates the character is an alphameric or underscore (for
124 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
125 * are 0 then the character needs no special processing on output; classes
126 * other than 0 might be translated or (not currently) require delays.
128 #define E 0x00 /* Even parity. */
129 #define O 0x80 /* Odd parity. */
130 #define PARITY(c) (char_type[c] & O)
132 #define ALPHA 0x40 /* Alpha or underscore. */
133 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
135 #define CCLASSMASK 0x3f
136 #define CCLASS(c) (char_type[c] & CCLASSMASK)
141 #define NA ORDINARY | ALPHA
147 static u_char const char_type[] = {
148 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
149 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
150 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
151 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
152 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
153 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
154 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
155 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
156 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
157 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
158 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
159 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
160 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
161 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
162 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
163 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
165 * Meta chars; should be settable per character set;
166 * for now, treat them all as normal characters.
168 NA, NA, NA, NA, NA, NA, NA, NA,
169 NA, NA, NA, NA, NA, NA, NA, NA,
170 NA, NA, NA, NA, NA, NA, NA, NA,
171 NA, NA, NA, NA, NA, NA, NA, NA,
172 NA, NA, NA, NA, NA, NA, NA, NA,
173 NA, NA, NA, NA, NA, NA, NA, NA,
174 NA, NA, NA, NA, NA, NA, NA, NA,
175 NA, NA, NA, NA, NA, NA, NA, NA,
176 NA, NA, NA, NA, NA, NA, NA, NA,
177 NA, NA, NA, NA, NA, NA, NA, NA,
178 NA, NA, NA, NA, NA, NA, NA, NA,
179 NA, NA, NA, NA, NA, NA, NA, NA,
180 NA, NA, NA, NA, NA, NA, NA, NA,
181 NA, NA, NA, NA, NA, NA, NA, NA,
182 NA, NA, NA, NA, NA, NA, NA, NA,
183 NA, NA, NA, NA, NA, NA, NA, NA,
194 /* Macros to clear/set/test flags. */
195 #define SET(t, f) (t) |= (f)
196 #define CLR(t, f) (t) &= ~(f)
197 #define ISSET(t, f) ((t) & (f))
199 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
200 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
203 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
204 "LU", "TTY input statistic");
206 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
207 "LU", "TTY output statistic");
211 * list of struct tty where pstat(8) can pick it up with sysctl
213 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
216 * Initial open of tty, or (re)entry to standard tty line discipline.
219 ttyopen(cdev_t device, struct tty *tp)
222 lwkt_gettoken(&tty_token);
224 if (!ISSET(tp->t_state, TS_ISOPEN)) {
225 SET(tp->t_state, TS_ISOPEN);
226 if (ISSET(tp->t_cflag, CLOCAL)) {
227 SET(tp->t_state, TS_CONNECTED);
229 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
232 lwkt_reltoken(&tty_token);
238 * Handle close() on a tty line: flush and set to initial state,
239 * bumping generation number so that pending read/write calls
240 * can detect recycling of the tty.
242 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
243 * and l_close() should have flushed, but we repeat the spltty() and
244 * the flush in case there are buggy callers.
247 ttyclose(struct tty *tp)
250 lwkt_gettoken(&tty_token);
251 funsetown(&tp->t_sigio);
255 ttyflush(tp, FREAD | FWRITE);
256 clist_free_cblocks(&tp->t_canq);
257 clist_free_cblocks(&tp->t_outq);
258 clist_free_cblocks(&tp->t_rawq);
261 tp->t_line = TTYDISC;
263 tp->t_state &= TS_REGISTERED; /* clear all bits except */
264 lwkt_reltoken(&tty_token);
270 * Disassociate the tty from its session. Traditionally this has only been
271 * a half-close, meaning that the session was still allowed to point at the
272 * tty (resulting in the tty in the ps command showing something like 'p0-'),
273 * even though the tty is no longer pointing at the session.
275 * The half close seems to be useful only for 'ps' output but there is as
276 * yet no reason to remove the feature. The full-close code is currently
277 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
280 ttyclearsession(struct tty *tp)
285 lwkt_gettoken(&tty_token);
293 if ((sp = tp->t_session) != NULL) {
294 tp->t_session = NULL;
295 #ifdef TTY_DO_FULL_CLOSE
296 /* FULL CLOSE (not yet) */
297 if (sp->s_ttyp == tp) {
301 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
302 "%p/%p\n", sp->s_ttyp, tp);
306 lwkt_reltoken(&tty_token);
310 * Release the tty vnode association for a session. This is the
311 * 'other half' of the close. Because multiple opens of /dev/tty
312 * only generate a single open to the actual tty, the file modes
313 * are locked to FREAD|FWRITE.
315 * If dorevoke is non-zero, the session is also revoked. We have to
316 * close the vnode if VCTTYISOPEN is set.
319 ttyclosesession(struct session *sp, int dorevoke)
323 lwkt_gettoken(&tty_token);
326 * There may not be a controlling terminal or it may have been closed
329 if ((vp = sp->s_ttyvp) == NULL) {
330 lwkt_reltoken(&tty_token);
335 * We need a lock if we have to close or revoke.
337 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
339 if (vn_lock(vp, LK_EXCLUSIVE | LK_RETRY | LK_FAILRECLAIM)) {
345 * Retry if the vnode was ripped out from under us
347 if (vp != sp->s_ttyvp) {
354 * Close and revoke as needed
357 if (vp->v_flag & VCTTYISOPEN) {
358 vclrflags(vp, VCTTYISOPEN);
359 VOP_CLOSE(vp, FREAD|FWRITE, NULL);
363 vrevoke(vp, proc0.p_ucred);
369 lwkt_reltoken(&tty_token);
372 #define FLUSHQ(q) { \
374 ndflush(q, (q)->c_cc); \
377 /* Is 'c' a line delimiter ("break" character)? */
378 #define TTBREAKC(c, lflag) \
379 ((c) == '\n' || (((c) == cc[VEOF] || \
380 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
381 (c) != _POSIX_VDISABLE))
384 * Process input of a single character received on a tty.
387 ttyinput(int c, struct tty *tp)
389 tcflag_t iflag, lflag;
393 lwkt_gettoken(&tty_token);
395 * If input is pending take it first.
398 if (ISSET(lflag, PENDIN))
403 if (ISSET(lflag, ICANON))
410 * Block further input iff:
411 * current input > threshold AND input is available to user program
412 * AND input flow control is enabled and not yet invoked.
413 * The 3 is slop for PARMRK.
416 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
417 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
418 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
419 !ISSET(tp->t_state, TS_TBLOCK))
422 /* Handle exceptional conditions (break, parity, framing). */
424 err = (ISSET(c, TTY_ERRORMASK));
426 CLR(c, TTY_ERRORMASK);
427 if (ISSET(err, TTY_BI)) {
428 if (ISSET(iflag, IGNBRK)) {
429 lwkt_reltoken(&tty_token);
432 if (ISSET(iflag, BRKINT)) {
433 ttyflush(tp, FREAD | FWRITE);
434 pgsignal(tp->t_pgrp, SIGINT, 1);
437 if (ISSET(iflag, PARMRK))
439 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
440 || ISSET(err, TTY_FE)) {
441 if (ISSET(iflag, IGNPAR)) {
442 lwkt_reltoken(&tty_token);
445 else if (ISSET(iflag, PARMRK)) {
447 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
450 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
451 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
452 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
459 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
461 if (!ISSET(lflag, EXTPROC)) {
463 * Check for literal nexting very first
465 if (ISSET(tp->t_state, TS_LNCH)) {
467 CLR(tp->t_state, TS_LNCH);
470 * Scan for special characters. This code
471 * is really just a big case statement with
472 * non-constant cases. The bottom of the
473 * case statement is labeled ``endcase'', so goto
474 * it after a case match, or similar.
478 * Control chars which aren't controlled
479 * by ICANON, ISIG, or IXON.
481 if (ISSET(lflag, IEXTEN)) {
482 if (CCEQ(cc[VLNEXT], c)) {
483 if (ISSET(lflag, ECHO)) {
484 if (ISSET(lflag, ECHOE)) {
485 (void)ttyoutput('^', tp);
486 (void)ttyoutput('\b', tp);
490 SET(tp->t_state, TS_LNCH);
493 if (CCEQ(cc[VDISCARD], c)) {
494 if (ISSET(lflag, FLUSHO))
495 CLR(tp->t_lflag, FLUSHO);
497 ttyflush(tp, FWRITE);
499 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
501 SET(tp->t_lflag, FLUSHO);
509 if (ISSET(lflag, ISIG)) {
510 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
511 if (!ISSET(lflag, NOFLSH))
512 ttyflush(tp, FREAD | FWRITE);
515 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
518 if (CCEQ(cc[VSUSP], c)) {
519 if (!ISSET(lflag, NOFLSH))
522 pgsignal(tp->t_pgrp, SIGTSTP, 1);
527 * Handle start/stop characters.
529 if (ISSET(iflag, IXON)) {
530 if (CCEQ(cc[VSTOP], c)) {
531 if (!ISSET(tp->t_state, TS_TTSTOP)) {
532 SET(tp->t_state, TS_TTSTOP);
533 (*tp->t_stop)(tp, 0);
534 lwkt_reltoken(&tty_token);
537 if (!CCEQ(cc[VSTART], c)) {
538 lwkt_reltoken(&tty_token);
542 * if VSTART == VSTOP then toggle
546 if (CCEQ(cc[VSTART], c))
550 * IGNCR, ICRNL, & INLCR
553 if (ISSET(iflag, IGNCR)) {
554 lwkt_reltoken(&tty_token);
557 else if (ISSET(iflag, ICRNL))
559 } else if (c == '\n' && ISSET(iflag, INLCR))
562 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
564 * From here on down canonical mode character
565 * processing takes place.
568 * erase or erase2 (^H / ^?)
570 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
572 ttyrub(clist_unputc(&tp->t_rawq), tp);
578 if (CCEQ(cc[VKILL], c)) {
579 if (ISSET(lflag, ECHOKE) &&
580 tp->t_rawq.c_cc == tp->t_rocount &&
581 !ISSET(lflag, ECHOPRT))
582 while (tp->t_rawq.c_cc)
583 ttyrub(clist_unputc(&tp->t_rawq), tp);
586 if (ISSET(lflag, ECHOK) ||
587 ISSET(lflag, ECHOKE))
592 CLR(tp->t_state, TS_LOCAL);
598 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
604 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
609 * erase last char of word and remember the
610 * next chars type (for ALTWERASE)
613 c = clist_unputc(&tp->t_rawq);
616 if (c == ' ' || c == '\t') {
617 clist_putc(c, &tp->t_rawq);
626 c = clist_unputc(&tp->t_rawq);
629 } while (c != ' ' && c != '\t' &&
630 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
631 clist_putc(c, &tp->t_rawq);
637 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
642 * ^T - kernel info and generate SIGINFO
644 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
645 if (ISSET(lflag, ISIG))
646 pgsignal(tp->t_pgrp, SIGINFO, 1);
647 if (!ISSET(lflag, NOKERNINFO))
651 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
652 if (ISSET(lflag, ISIG))
653 pgsignal(tp->t_pgrp, SIGCKPT, 1);
658 * Check for input buffer overflow
660 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
662 if (ISSET(iflag, IMAXBEL)) {
663 if (tp->t_outq.c_cc < tp->t_ohiwat)
664 (void)ttyoutput(CTRL('g'), tp);
669 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
670 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
671 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
674 * Put data char in q for user and
675 * wakeup on seeing a line delimiter.
677 if (clist_putc(c, &tp->t_rawq) >= 0) {
678 if (!ISSET(lflag, ICANON)) {
683 if (TTBREAKC(c, lflag)) {
685 catq(&tp->t_rawq, &tp->t_canq);
687 } else if (tp->t_rocount++ == 0)
688 tp->t_rocol = tp->t_column;
689 if (ISSET(tp->t_state, TS_ERASE)) {
691 * end of prterase \.../
693 CLR(tp->t_state, TS_ERASE);
694 (void)ttyoutput('/', tp);
698 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
700 * Place the cursor over the '^' of the ^D.
702 i = imin(2, tp->t_column - i);
704 (void)ttyoutput('\b', tp);
711 * IXANY means allow any character to restart output.
713 if (ISSET(tp->t_state, TS_TTSTOP) &&
714 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
715 lwkt_reltoken(&tty_token);
719 CLR(tp->t_lflag, FLUSHO);
720 CLR(tp->t_state, TS_TTSTOP);
722 lwkt_reltoken(&tty_token);
723 return (ttstart(tp));
727 * Output a single character on a tty, doing output processing
728 * as needed (expanding tabs, newline processing, etc.).
729 * Returns < 0 if succeeds, otherwise returns char to resend.
733 ttyoutput(int c, struct tty *tp)
738 lwkt_gettoken(&tty_token);
740 if (!ISSET(oflag, OPOST)) {
741 if (ISSET(tp->t_lflag, FLUSHO)) {
742 lwkt_reltoken(&tty_token);
745 if (clist_putc(c, &tp->t_outq)) {
746 lwkt_reltoken(&tty_token);
751 lwkt_reltoken(&tty_token);
755 * Do tab expansion if OXTABS is set. Special case if we external
756 * processing, we don't do the tab expansion because we'll probably
757 * get it wrong. If tab expansion needs to be done, let it happen
760 CLR(c, ~TTY_CHARMASK);
762 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
763 c = 8 - (tp->t_column & 7);
764 if (!ISSET(tp->t_lflag, FLUSHO)) {
765 crit_enter(); /* Don't interrupt tabs. */
766 c -= b_to_q(" ", c, &tp->t_outq);
772 lwkt_reltoken(&tty_token);
773 return (c ? -1 : '\t');
775 if (c == CEOT && ISSET(oflag, ONOEOT)) {
776 lwkt_reltoken(&tty_token);
781 * Newline translation: if ONLCR is set,
782 * translate newline into "\r\n".
784 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
787 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq)) {
788 lwkt_reltoken(&tty_token);
792 /* If OCRNL is set, translate "\r" into "\n". */
793 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
795 /* If ONOCR is set, don't transmit CRs when on column 0. */
796 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0) {
797 lwkt_reltoken(&tty_token);
803 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq)) {
804 lwkt_reltoken(&tty_token);
817 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
827 col = (col + 8) & ~7;
831 lwkt_reltoken(&tty_token);
836 * Ioctls for all tty devices. Called after line-discipline specific ioctl
837 * has been called to do discipline-specific functions and/or reject any
838 * of these ioctl commands.
842 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
844 struct thread *td = curthread;
845 struct lwp *lp = td->td_lwp;
846 struct proc *p = td->td_proc;
852 lwkt_gettoken(&tty_token);
853 lwkt_gettoken(&p->p_token);
855 /* If the ioctl involves modification, hang if in the background. */
879 while (isbackground(p, tp) && !(p->p_flags & P_PPWAIT) &&
880 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
881 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
882 if (p->p_pgrp->pg_jobc == 0) {
883 lwkt_reltoken(&p->p_token);
884 lwkt_reltoken(&tty_token);
887 pgsignal(p->p_pgrp, SIGTTOU, 1);
888 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
891 lwkt_reltoken(&p->p_token);
892 lwkt_reltoken(&tty_token);
899 switch (cmd) { /* Process the ioctl. */
900 case FIOASYNC: /* set/clear async i/o */
903 SET(tp->t_state, TS_ASYNC);
905 CLR(tp->t_state, TS_ASYNC);
908 case FIONREAD: /* get # bytes to read */
910 *(int *)data = ttnread(tp);
916 * Policy -- Don't allow FIOSETOWN on someone else's
919 if (tp->t_session != NULL && !isctty(p, tp)) {
920 lwkt_reltoken(&p->p_token);
921 lwkt_reltoken(&tty_token);
925 error = fsetown(*(int *)data, &tp->t_sigio);
927 lwkt_reltoken(&p->p_token);
928 lwkt_reltoken(&tty_token);
933 if (tp->t_session != NULL && !isctty(p, tp)) {
934 lwkt_reltoken(&p->p_token);
935 lwkt_reltoken(&tty_token);
938 *(int *)data = fgetown(&tp->t_sigio);
941 case TIOCEXCL: /* set exclusive use of tty */
943 SET(tp->t_state, TS_XCLUDE);
946 case TIOCFLUSH: { /* flush buffers */
947 int flags = *(int *)data;
950 flags = FREAD | FWRITE;
952 flags &= FREAD | FWRITE;
956 case TIOCCONS: /* become virtual console */
958 if (constty && constty != tp &&
959 ISSET(constty->t_state, TS_CONNECTED)) {
960 lwkt_reltoken(&p->p_token);
961 lwkt_reltoken(&tty_token);
965 if ((error = priv_check(td, PRIV_ROOT)) != 0) {
966 lwkt_reltoken(&p->p_token);
967 lwkt_reltoken(&tty_token);
972 } else if (tp == constty)
975 case TIOCDRAIN: /* wait till output drained */
978 lwkt_reltoken(&p->p_token);
979 lwkt_reltoken(&tty_token);
983 case TIOCGETA: { /* get termios struct */
984 struct termios *t = (struct termios *)data;
986 bcopy(&tp->t_termios, t, sizeof(struct termios));
989 case TIOCGETD: /* get line discipline */
990 *(int *)data = tp->t_line;
992 case TIOCGWINSZ: /* get window size */
993 *(struct winsize *)data = tp->t_winsize;
995 case TIOCGPGRP: /* get pgrp of tty */
996 if (!isctty(p, tp)) {
997 lwkt_reltoken(&p->p_token);
998 lwkt_reltoken(&tty_token);
1001 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1003 case TIOCGSID: /* get sid of tty */
1004 if (!isctty(p, tp)) {
1005 lwkt_reltoken(&p->p_token);
1006 lwkt_reltoken(&tty_token);
1009 *(int *)data = tp->t_session->s_sid;
1012 case TIOCHPCL: /* hang up on last close */
1014 SET(tp->t_cflag, HUPCL);
1018 case TIOCNXCL: /* reset exclusive use of tty */
1020 CLR(tp->t_state, TS_XCLUDE);
1023 case TIOCOUTQ: /* output queue size */
1024 *(int *)data = tp->t_outq.c_cc;
1026 case TIOCSETA: /* set termios struct */
1027 case TIOCSETAW: /* drain output, set */
1028 case TIOCSETAF: { /* drn out, fls in, set */
1029 struct termios *t = (struct termios *)data;
1031 if (t->c_ispeed == 0)
1032 t->c_ispeed = t->c_ospeed;
1033 if (t->c_ispeed == 0)
1034 t->c_ispeed = tp->t_ospeed;
1035 if (t->c_ispeed == 0) {
1036 lwkt_reltoken(&p->p_token);
1037 lwkt_reltoken(&tty_token);
1041 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1042 error = ttywait(tp);
1045 lwkt_reltoken(&p->p_token);
1046 lwkt_reltoken(&tty_token);
1049 if (cmd == TIOCSETAF)
1050 ttyflush(tp, FREAD);
1052 if (!ISSET(t->c_cflag, CIGNORE)) {
1054 * Set device hardware.
1056 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1058 lwkt_reltoken(&p->p_token);
1059 lwkt_reltoken(&tty_token);
1062 if (ISSET(t->c_cflag, CLOCAL) &&
1063 !ISSET(tp->t_cflag, CLOCAL)) {
1065 * XXX disconnections would be too hard to
1066 * get rid of without this kludge. The only
1067 * way to get rid of controlling terminals
1068 * is to exit from the session leader.
1070 CLR(tp->t_state, TS_ZOMBIE);
1072 wakeup(TSA_CARR_ON(tp));
1076 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1077 ISSET(t->c_cflag, CLOCAL)) &&
1078 !ISSET(tp->t_state, TS_ZOMBIE))
1079 SET(tp->t_state, TS_CONNECTED);
1081 CLR(tp->t_state, TS_CONNECTED);
1082 tp->t_cflag = t->c_cflag;
1083 tp->t_ispeed = t->c_ispeed;
1084 if (t->c_ospeed != 0)
1085 tp->t_ospeed = t->c_ospeed;
1088 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1090 if (ISSET(t->c_lflag, ICANON))
1091 SET(tp->t_lflag, PENDIN);
1094 * XXX we really shouldn't allow toggling
1095 * ICANON while we're in a non-termios line
1096 * discipline. Now we have to worry about
1097 * panicing for a null queue.
1099 if (tp->t_canq.c_cbreserved > 0 &&
1100 tp->t_rawq.c_cbreserved > 0) {
1101 catq(&tp->t_rawq, &tp->t_canq);
1103 * XXX the queue limits may be
1104 * different, so the old queue
1105 * swapping method no longer works.
1107 catq(&tp->t_canq, &tp->t_rawq);
1109 CLR(tp->t_lflag, PENDIN);
1113 tp->t_iflag = t->c_iflag;
1114 tp->t_oflag = t->c_oflag;
1116 * Make the EXTPROC bit read only.
1118 if (ISSET(tp->t_lflag, EXTPROC))
1119 SET(t->c_lflag, EXTPROC);
1121 CLR(t->c_lflag, EXTPROC);
1122 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1123 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1124 t->c_cc[VTIME] != tp->t_cc[VTIME])
1126 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1130 case TIOCSETD: { /* set line discipline */
1131 int t = *(int *)data;
1132 cdev_t device = tp->t_dev;
1134 if ((u_int)t >= nlinesw) {
1135 lwkt_reltoken(&p->p_token);
1136 lwkt_reltoken(&tty_token);
1139 if (t != tp->t_line) {
1141 (*linesw[tp->t_line].l_close)(tp, flag);
1142 error = (*linesw[t].l_open)(device, tp);
1144 (void)(*linesw[tp->t_line].l_open)(device, tp);
1146 lwkt_reltoken(&p->p_token);
1147 lwkt_reltoken(&tty_token);
1155 case TIOCSTART: /* start output, like ^Q */
1157 if (ISSET(tp->t_state, TS_TTSTOP) ||
1158 ISSET(tp->t_lflag, FLUSHO)) {
1159 CLR(tp->t_lflag, FLUSHO);
1160 CLR(tp->t_state, TS_TTSTOP);
1165 case TIOCSTI: /* simulate terminal input */
1166 if ((flag & FREAD) == 0 && priv_check(td, PRIV_ROOT)) {
1167 lwkt_reltoken(&p->p_token);
1168 lwkt_reltoken(&tty_token);
1171 if (!isctty(p, tp) && priv_check(td, PRIV_ROOT)) {
1172 lwkt_reltoken(&p->p_token);
1173 lwkt_reltoken(&tty_token);
1177 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1180 case TIOCSTOP: /* stop output, like ^S */
1182 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1183 SET(tp->t_state, TS_TTSTOP);
1184 (*tp->t_stop)(tp, 0);
1188 case TIOCSCTTY: /* become controlling tty */
1189 /* Session ctty vnode pointer set in vnode layer. */
1190 if (!SESS_LEADER(p) ||
1191 ((p->p_session->s_ttyvp || tp->t_session) &&
1192 (tp->t_session != p->p_session))) {
1193 lwkt_reltoken(&p->p_token);
1194 lwkt_reltoken(&tty_token);
1198 tp->t_session = p->p_session;
1201 tp->t_pgrp = p->p_pgrp;
1202 otp = p->p_session->s_ttyp;
1203 p->p_session->s_ttyp = tp;
1204 p->p_flags |= P_CONTROLT;
1212 case TIOCSPGRP: { /* set pgrp of tty */
1213 pid_t pgid = *(int *)data;
1215 if (!isctty(p, tp)) {
1216 lwkt_reltoken(&p->p_token);
1217 lwkt_reltoken(&tty_token);
1220 else if (pgid < 1 || pgid > PID_MAX) {
1221 lwkt_reltoken(&p->p_token);
1222 lwkt_reltoken(&tty_token);
1225 struct pgrp *pgrp = pgfind(pgid);
1226 if (pgrp == NULL || pgrp->pg_session != p->p_session) {
1229 lwkt_reltoken(&p->p_token);
1230 lwkt_reltoken(&tty_token);
1242 case TIOCSTAT: /* simulate control-T */
1247 case TIOCSWINSZ: /* set window size */
1248 if (bcmp((caddr_t)&tp->t_winsize, data,
1249 sizeof (struct winsize))) {
1250 tp->t_winsize = *(struct winsize *)data;
1251 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1254 case TIOCSDRAINWAIT:
1255 error = priv_check(td, PRIV_ROOT);
1257 lwkt_reltoken(&p->p_token);
1258 lwkt_reltoken(&tty_token);
1261 tp->t_timeout = *(int *)data * hz;
1262 wakeup(TSA_OCOMPLETE(tp));
1263 wakeup(TSA_OLOWAT(tp));
1265 case TIOCGDRAINWAIT:
1266 *(int *)data = tp->t_timeout / hz;
1269 lwkt_reltoken(&p->p_token);
1270 lwkt_reltoken(&tty_token);
1273 lwkt_reltoken(&p->p_token);
1274 lwkt_reltoken(&tty_token);
1278 static struct filterops ttyread_filtops =
1279 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttyrdetach, filt_ttyread };
1280 static struct filterops ttywrite_filtops =
1281 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_ttywdetach, filt_ttywrite };
1284 ttykqfilter(struct dev_kqfilter_args *ap)
1286 cdev_t dev = ap->a_head.a_dev;
1287 struct knote *kn = ap->a_kn;
1288 struct tty *tp = dev->si_tty;
1289 struct klist *klist;
1293 lwkt_gettoken(&tty_token);
1294 switch (kn->kn_filter) {
1296 klist = &tp->t_rkq.ki_note;
1297 kn->kn_fop = &ttyread_filtops;
1300 klist = &tp->t_wkq.ki_note;
1301 kn->kn_fop = &ttywrite_filtops;
1304 ap->a_result = EOPNOTSUPP;
1305 lwkt_reltoken(&tty_token);
1308 lwkt_reltoken(&tty_token);
1309 kn->kn_hook = (caddr_t)dev;
1310 knote_insert(klist, kn);
1316 filt_ttyrdetach(struct knote *kn)
1318 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1320 lwkt_gettoken(&tty_token);
1321 knote_remove(&tp->t_rkq.ki_note, kn);
1322 lwkt_reltoken(&tty_token);
1326 filt_ttyread(struct knote *kn, long hint)
1328 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1330 lwkt_gettoken(&tty_token);
1331 kn->kn_data = ttnread(tp);
1332 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1333 kn->kn_flags |= (EV_EOF | EV_NODATA);
1334 lwkt_reltoken(&tty_token);
1337 lwkt_reltoken(&tty_token);
1338 return (kn->kn_data > 0);
1342 filt_ttywdetach(struct knote *kn)
1344 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1346 lwkt_gettoken(&tty_token);
1347 knote_remove(&tp->t_wkq.ki_note, kn);
1348 lwkt_reltoken(&tty_token);
1352 filt_ttywrite(struct knote *kn, long hint)
1354 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1357 lwkt_gettoken(&tty_token);
1358 kn->kn_data = tp->t_outq.c_cc;
1359 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1360 lwkt_reltoken(&tty_token);
1363 ret = (kn->kn_data <= tp->t_olowat &&
1364 ISSET(tp->t_state, TS_CONNECTED));
1365 lwkt_reltoken(&tty_token);
1370 * Must be called while in a critical section.
1371 * NOTE: tty_token must be held.
1374 ttnread(struct tty *tp)
1378 ASSERT_LWKT_TOKEN_HELD(&tty_token);
1379 if (ISSET(tp->t_lflag, PENDIN))
1381 nread = tp->t_canq.c_cc;
1382 if (!ISSET(tp->t_lflag, ICANON)) {
1383 nread += tp->t_rawq.c_cc;
1384 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1391 * Wait for output to drain.
1394 ttywait(struct tty *tp)
1400 lwkt_gettoken(&tty_token);
1401 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1402 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1404 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1405 ISSET(tp->t_state, TS_CONNECTED)) {
1406 SET(tp->t_state, TS_SO_OCOMPLETE);
1407 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1411 if (error == EWOULDBLOCK)
1418 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1420 lwkt_reltoken(&tty_token);
1426 * Flush if successfully wait.
1429 ttywflush(struct tty *tp)
1433 if ((error = ttywait(tp)) == 0)
1434 ttyflush(tp, FREAD);
1439 * Flush tty read and/or write queues, notifying anyone waiting.
1442 ttyflush(struct tty *tp, int rw)
1445 lwkt_gettoken(&tty_token);
1450 FLUSHQ(&tp->t_outq);
1451 CLR(tp->t_state, TS_TTSTOP);
1453 (*tp->t_stop)(tp, rw);
1455 FLUSHQ(&tp->t_canq);
1456 FLUSHQ(&tp->t_rawq);
1457 CLR(tp->t_lflag, PENDIN);
1460 CLR(tp->t_state, TS_LOCAL);
1462 if (ISSET(tp->t_state, TS_TBLOCK)) {
1464 FLUSHQ(&tp->t_outq);
1468 * Don't let leave any state that might clobber the
1469 * next line discipline (although we should do more
1470 * to send the START char). Not clearing the state
1471 * may have caused the "putc to a clist with no
1472 * reserved cblocks" panic/kprintf.
1474 CLR(tp->t_state, TS_TBLOCK);
1476 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1477 if (ISSET(tp->t_iflag, IXOFF)) {
1479 * XXX wait a bit in the hope that the stop
1480 * character (if any) will go out. Waiting
1481 * isn't good since it allows races. This
1482 * will be fixed when the stop character is
1483 * put in a special queue. Don't bother with
1484 * the checks in ttywait() since the timeout
1487 SET(tp->t_state, TS_SO_OCOMPLETE);
1488 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1491 * Don't try sending the stop character again.
1493 CLR(tp->t_state, TS_TBLOCK);
1500 FLUSHQ(&tp->t_outq);
1503 lwkt_reltoken(&tty_token);
1508 * Copy in the default termios characters.
1511 termioschars(struct termios *t)
1513 lwkt_gettoken(&tty_token);
1514 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1515 lwkt_reltoken(&tty_token);
1522 ttychars(struct tty *tp)
1524 lwkt_gettoken(&tty_token);
1525 termioschars(&tp->t_termios);
1526 lwkt_reltoken(&tty_token);
1530 * Handle input high water. Send stop character for the IXOFF case. Turn
1531 * on our input flow control bit and propagate the changes to the driver.
1532 * XXX the stop character should be put in a special high priority queue.
1535 ttyblock(struct tty *tp)
1537 lwkt_gettoken(&tty_token);
1538 SET(tp->t_state, TS_TBLOCK);
1539 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1540 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1541 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1543 lwkt_reltoken(&tty_token);
1547 * Handle input low water. Send start character for the IXOFF case. Turn
1548 * off our input flow control bit and propagate the changes to the driver.
1549 * XXX the start character should be put in a special high priority queue.
1552 ttyunblock(struct tty *tp)
1554 lwkt_gettoken(&tty_token);
1555 CLR(tp->t_state, TS_TBLOCK);
1556 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1557 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1558 SET(tp->t_state, TS_TBLOCK); /* try again later */
1560 lwkt_reltoken(&tty_token);
1564 /* Not used by any current (i386) drivers. */
1566 * Restart after an inter-char delay.
1569 ttrstrt(void *tp_arg)
1573 KASSERT(tp_arg != NULL, ("ttrstrt"));
1577 lwkt_gettoken(&tty_token);
1578 CLR(tp->t_state, TS_TIMEOUT);
1580 lwkt_reltoken(&tty_token);
1586 ttstart(struct tty *tp)
1588 lwkt_gettoken(&tty_token);
1589 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1591 lwkt_reltoken(&tty_token);
1596 * "close" a line discipline
1599 ttylclose(struct tty *tp, int flag)
1601 lwkt_gettoken(&tty_token);
1602 if (flag & FNONBLOCK || ttywflush(tp))
1603 ttyflush(tp, FREAD | FWRITE);
1604 lwkt_reltoken(&tty_token);
1609 ttyhold(struct tty *tp)
1615 ttyunhold(struct tty *tp)
1624 * Handle modem control transition on a tty.
1625 * Flag indicates new state of carrier.
1626 * Returns 0 if the line should be turned off, otherwise 1.
1629 ttymodem(struct tty *tp, int flag)
1631 lwkt_gettoken(&tty_token);
1632 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1634 * MDMBUF: do flow control according to carrier flag
1635 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1636 * works if IXON and IXANY are clear.
1639 CLR(tp->t_state, TS_CAR_OFLOW);
1640 CLR(tp->t_state, TS_TTSTOP);
1642 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1643 SET(tp->t_state, TS_CAR_OFLOW);
1644 SET(tp->t_state, TS_TTSTOP);
1645 (*tp->t_stop)(tp, 0);
1647 } else if (flag == 0) {
1651 CLR(tp->t_state, TS_CARR_ON);
1652 if (ISSET(tp->t_state, TS_ISOPEN) &&
1653 !ISSET(tp->t_cflag, CLOCAL)) {
1654 SET(tp->t_state, TS_ZOMBIE);
1655 CLR(tp->t_state, TS_CONNECTED);
1656 if (tp->t_session && tp->t_session->s_leader)
1657 ksignal(tp->t_session->s_leader, SIGHUP);
1658 ttyflush(tp, FREAD | FWRITE);
1659 lwkt_reltoken(&tty_token);
1666 SET(tp->t_state, TS_CARR_ON);
1667 if (!ISSET(tp->t_state, TS_ZOMBIE))
1668 SET(tp->t_state, TS_CONNECTED);
1669 wakeup(TSA_CARR_ON(tp));
1673 lwkt_reltoken(&tty_token);
1678 * Reinput pending characters after state switch
1679 * call from a critical section.
1682 ttypend(struct tty *tp)
1687 lwkt_gettoken(&tty_token);
1688 CLR(tp->t_lflag, PENDIN);
1689 SET(tp->t_state, TS_TYPEN);
1691 * XXX this assumes too much about clist internals. It may even
1692 * fail if the cblock slush pool is empty. We can't allocate more
1693 * cblocks here because we are called from an interrupt handler
1694 * and clist_alloc_cblocks() can wait.
1697 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1698 tp->t_rawq.c_cbmax = tq.c_cbmax;
1699 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1700 while ((c = clist_getc(&tq)) >= 0)
1702 CLR(tp->t_state, TS_TYPEN);
1703 lwkt_reltoken(&tty_token);
1707 * Process a read call on a tty device.
1710 ttread(struct tty *tp, struct uio *uio, int flag)
1715 cc_t *cc = tp->t_cc;
1718 int first, error = 0;
1719 int has_stime = 0, last_cc = 0;
1720 long slp = 0; /* XXX this should be renamed `timo'. */
1721 struct timeval stime;
1723 lp = curthread->td_lwp;
1724 stime.tv_sec = 0; /* fix compiler warnings */
1727 lwkt_gettoken(&tty_token);
1730 lflag = tp->t_lflag;
1732 * take pending input first
1734 if (ISSET(lflag, PENDIN)) {
1736 splz(); /* reduce latency */
1737 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1741 * Hang process if it's in the background.
1743 if ((pp = curproc) != NULL)
1744 lwkt_gettoken(&pp->p_token);
1745 if (pp && isbackground(pp, tp)) {
1747 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1748 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1749 (pp->p_flags & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0) {
1750 lwkt_reltoken(&pp->p_token);
1751 lwkt_reltoken(&tty_token);
1754 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1755 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1757 lwkt_reltoken(&pp->p_token);
1758 lwkt_reltoken(&tty_token);
1761 lwkt_reltoken(&pp->p_token);
1765 lwkt_reltoken(&pp->p_token);
1767 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1769 lwkt_reltoken(&tty_token);
1770 return (0); /* EOF */
1774 * If canonical, use the canonical queue,
1775 * else use the raw queue.
1777 * (should get rid of clists...)
1779 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1781 if (flag & IO_NDELAY) {
1784 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1786 lwkt_reltoken(&tty_token);
1790 lwkt_reltoken(&tty_token);
1791 return (EWOULDBLOCK);
1793 if (!ISSET(lflag, ICANON)) {
1796 struct timeval timecopy;
1799 * Check each of the four combinations.
1800 * (m > 0 && t == 0) is the normal read case.
1801 * It should be fairly efficient, so we check that and its
1802 * companion case (m == 0 && t == 0) first.
1803 * For the other two cases, we compute the target sleep time
1812 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1814 lwkt_reltoken(&tty_token);
1817 t *= 100000; /* time in us */
1818 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1819 ((t1).tv_usec - (t2).tv_usec))
1825 getmicrotime(&timecopy);
1826 if (has_stime == 0) {
1827 /* first character, start timer */
1831 } else if (qp->c_cc > last_cc) {
1832 /* got a character, restart timer */
1836 /* nothing, check expiration */
1837 slp = t - diff(timecopy, stime);
1842 } else { /* m == 0 */
1845 getmicrotime(&timecopy);
1846 if (has_stime == 0) {
1851 slp = t - diff(timecopy, stime);
1853 /* Timed out, but 0 is enough input. */
1855 lwkt_reltoken(&tty_token);
1862 * Rounding down may make us wake up just short
1863 * of the target, so we round up.
1864 * The formula is ceiling(slp * hz/1000000).
1865 * 32-bit arithmetic is enough for hz < 169.
1866 * XXX see tvtohz() for how to avoid overflow if hz
1867 * is large (divide by `tick' and/or arrange to
1868 * use tvtohz() if hz is large).
1870 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1873 if (qp->c_cc <= 0) {
1876 * There is no input, or not enough input and we can block.
1878 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1879 ISSET(tp->t_state, TS_CONNECTED) ?
1880 "ttyin" : "ttyhup", (int)slp);
1882 if (error == EWOULDBLOCK)
1885 lwkt_reltoken(&tty_token);
1889 * XXX what happens if another process eats some input
1890 * while we are asleep (not just here)? It would be
1891 * safest to detect changes and reset our state variables
1892 * (has_stime and last_cc).
1900 * Input present, check for input mapping and processing.
1903 if (ISSET(lflag, ICANON | ISIG))
1909 icc = (int)szmin(uio->uio_resid, IBUFSIZ);
1910 icc = q_to_b(qp, ibuf, icc);
1916 error = uiomove(ibuf, (size_t)icc, uio);
1918 * XXX if there was an error then we should ungetc() the
1919 * unmoved chars and reduce icc here.
1923 if (uio->uio_resid == 0)
1937 * delayed suspend (^Y)
1939 if (CCEQ(cc[VDSUSP], c) &&
1940 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1941 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1943 error = ttysleep(tp, &lbolt, PCATCH,
1952 * Interpret EOF only in canonical mode.
1954 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1957 * Give user character.
1959 error = ureadc(c, uio);
1961 /* XXX should ungetc(c, qp). */
1963 if (uio->uio_resid == 0)
1966 * In canonical mode check for a "break character"
1967 * marking the end of a "line of input".
1969 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1976 * Look to unblock input now that (presumably)
1977 * the input queue has gone down.
1980 if (ISSET(tp->t_state, TS_TBLOCK) &&
1981 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1985 lwkt_reltoken(&tty_token);
1990 * Check the output queue on tp for space for a kernel message (from uprintf
1991 * or tprintf). Allow some space over the normal hiwater mark so we don't
1992 * lose messages due to normal flow control, but don't let the tty run amok.
1993 * Sleeps here are not interruptible, but we return prematurely if new signals
1997 ttycheckoutq(struct tty *tp, int wait)
1999 struct lwp *lp = curthread->td_lwp;
2001 sigset_t oldset, newset;
2003 lwkt_gettoken(&tty_token);
2004 hiwat = tp->t_ohiwat;
2005 SIGEMPTYSET(oldset);
2006 SIGEMPTYSET(newset);
2009 oldset = lwp_sigpend(lp);
2010 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
2011 while (tp->t_outq.c_cc > hiwat) {
2013 if (tp->t_outq.c_cc <= hiwat)
2016 newset = lwp_sigpend(lp);
2017 if (!wait || SIGSETNEQ(oldset, newset)) {
2019 lwkt_reltoken(&tty_token);
2022 SET(tp->t_state, TS_SO_OLOWAT);
2023 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
2027 lwkt_reltoken(&tty_token);
2032 * Process a write call on a tty device.
2035 ttwrite(struct tty *tp, struct uio *uio, int flag)
2041 int i, hiwat, error;
2046 lwkt_gettoken(&tty_token);
2047 lp = curthread->td_lwp;
2048 hiwat = tp->t_ohiwat;
2049 cnt = uio->uio_resid;
2054 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2056 if (uio->uio_resid == cnt)
2060 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2061 if (flag & IO_NDELAY) {
2063 error = EWOULDBLOCK;
2066 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
2075 * Hang the process if it's in the background.
2077 if ((pp = curproc) != NULL)
2078 lwkt_gettoken(&pp->p_token);
2079 if (pp && isbackground(pp, tp) &&
2080 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flags & P_PPWAIT) &&
2081 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
2082 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
2083 if (pp->p_pgrp->pg_jobc == 0) {
2085 lwkt_reltoken(&pp->p_token);
2088 pgsignal(pp->p_pgrp, SIGTTOU, 1);
2089 lwkt_reltoken(&pp->p_token);
2090 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
2096 lwkt_reltoken(&pp->p_token);
2098 * Process the user's data in at most OBUFSIZ chunks. Perform any
2099 * output translation. Keep track of high water mark, sleep on
2100 * overflow awaiting device aid in acquiring new space.
2102 while (uio->uio_resid > 0 || cc > 0) {
2103 if (ISSET(tp->t_lflag, FLUSHO)) {
2105 lwkt_reltoken(&tty_token);
2108 if (tp->t_outq.c_cc > hiwat)
2111 * Grab a hunk of data from the user, unless we have some
2112 * leftover from last time.
2115 cc = szmin(uio->uio_resid, OBUFSIZ);
2117 error = uiomove(cp, (size_t)cc, uio);
2124 * If nothing fancy need be done, grab those characters we
2125 * can handle without any of ttyoutput's processing and
2126 * just transfer them to the output q. For those chars
2127 * which require special processing (as indicated by the
2128 * bits in char_type), call ttyoutput. After processing
2129 * a hunk of data, look for FLUSHO so ^O's will take effect
2133 if (!ISSET(tp->t_oflag, OPOST))
2136 ce = cc - scanc((u_int)cc, (u_char *)cp,
2137 char_type, CCLASSMASK);
2139 * If ce is zero, then we're processing
2140 * a special character through ttyoutput.
2144 if (ttyoutput(*cp, tp) >= 0) {
2145 /* No Clists, wait a bit. */
2147 if (flag & IO_NDELAY) {
2148 error = EWOULDBLOCK;
2151 error = ttysleep(tp, &lbolt,
2160 if (ISSET(tp->t_lflag, FLUSHO) ||
2161 tp->t_outq.c_cc > hiwat)
2167 * A bunch of normal characters have been found.
2168 * Transfer them en masse to the output queue and
2169 * continue processing at the top of the loop.
2170 * If there are any further characters in this
2171 * <= OBUFSIZ chunk, the first should be a character
2172 * requiring special handling by ttyoutput.
2175 i = b_to_q(cp, ce, &tp->t_outq);
2178 cp += ce, cc -= ce, tk_nout += ce;
2181 /* No Clists, wait a bit. */
2183 if (flag & IO_NDELAY) {
2184 error = EWOULDBLOCK;
2187 error = ttysleep(tp, &lbolt, PCATCH,
2193 if (ISSET(tp->t_lflag, FLUSHO) ||
2194 tp->t_outq.c_cc > hiwat)
2201 * If cc is nonzero, we leave the uio structure inconsistent, as the
2202 * offset and iov pointers have moved forward, but it doesn't matter
2203 * (the call will either return short or restart with a new uio).
2205 uio->uio_resid += cc;
2206 lwkt_reltoken(&tty_token);
2213 * This can only occur if FLUSHO is set in t_lflag,
2214 * or if ttstart/oproc is synchronous (or very fast).
2216 if (tp->t_outq.c_cc <= hiwat) {
2220 if (flag & IO_NDELAY) {
2222 uio->uio_resid += cc;
2223 lwkt_reltoken(&tty_token);
2224 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2226 SET(tp->t_state, TS_SO_OLOWAT);
2227 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2229 if (error == EWOULDBLOCK)
2237 * Rubout one character from the rawq of tp
2238 * as cleanly as possible.
2239 * NOTE: Must be called with tty_token held
2242 ttyrub(int c, struct tty *tp)
2248 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2249 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2251 CLR(tp->t_lflag, FLUSHO);
2252 if (ISSET(tp->t_lflag, ECHOE)) {
2253 if (tp->t_rocount == 0) {
2255 * Screwed by ttwrite; retype
2260 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2263 CLR(c, ~TTY_CHARMASK);
2264 switch (CCLASS(c)) {
2273 if (ISSET(tp->t_lflag, ECHOCTL))
2277 if (tp->t_rocount < tp->t_rawq.c_cc) {
2282 savecol = tp->t_column;
2283 SET(tp->t_state, TS_CNTTB);
2284 SET(tp->t_lflag, FLUSHO);
2285 tp->t_column = tp->t_rocol;
2286 cp = tp->t_rawq.c_cf;
2288 tabc = *cp; /* XXX FIX NEXTC */
2289 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2291 CLR(tp->t_lflag, FLUSHO);
2292 CLR(tp->t_state, TS_CNTTB);
2295 /* savecol will now be length of the tab. */
2296 savecol -= tp->t_column;
2297 tp->t_column += savecol;
2299 savecol = 8; /* overflow screw */
2300 while (--savecol >= 0)
2301 (void)ttyoutput('\b', tp);
2304 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2305 (void)kprintf(PANICSTR, c, CCLASS(c));
2307 panic(PANICSTR, c, CCLASS(c));
2311 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2312 if (!ISSET(tp->t_state, TS_ERASE)) {
2313 SET(tp->t_state, TS_ERASE);
2314 (void)ttyoutput('\\', tp);
2318 ttyecho(tp->t_cc[VERASE], tp);
2320 * This code may be executed not only when an ERASE key
2321 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2322 * So, I didn't think it was worthwhile to pass the extra
2323 * information (which would need an extra parameter,
2324 * changing every call) needed to distinguish the ERASE2
2325 * case from the ERASE.
2332 * Back over cnt characters, erasing them.
2333 * NOTE: Must be called with tty_token held
2336 ttyrubo(struct tty *tp, int cnt)
2338 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2340 (void)ttyoutput('\b', tp);
2341 (void)ttyoutput(' ', tp);
2342 (void)ttyoutput('\b', tp);
2348 * Reprint the rawq line. Note, it is assumed that c_cc has already
2350 * NOTE: Must be called with tty_token held
2353 ttyretype(struct tty *tp)
2358 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2359 /* Echo the reprint character. */
2360 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2361 ttyecho(tp->t_cc[VREPRINT], tp);
2363 (void)ttyoutput('\n', tp);
2367 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2368 * BIT OF FIRST CHAR.
2371 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2372 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2374 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2375 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2377 CLR(tp->t_state, TS_ERASE);
2380 tp->t_rocount = tp->t_rawq.c_cc;
2385 * Echo a typed character to the terminal.
2386 * NOTE: Must be called with tty_token held
2389 ttyecho(int c, struct tty *tp)
2391 ASSERT_LWKT_TOKEN_HELD(&tty_token);
2393 if (!ISSET(tp->t_state, TS_CNTTB))
2394 CLR(tp->t_lflag, FLUSHO);
2395 if ((!ISSET(tp->t_lflag, ECHO) &&
2396 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2397 ISSET(tp->t_lflag, EXTPROC))
2399 if (ISSET(tp->t_lflag, ECHOCTL) &&
2400 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2401 ISSET(c, TTY_CHARMASK) == 0177)) {
2402 (void)ttyoutput('^', tp);
2403 CLR(c, ~TTY_CHARMASK);
2409 (void)ttyoutput(c, tp);
2413 * Wake up any readers on a tty.
2416 ttwakeup(struct tty *tp)
2418 lwkt_gettoken(&tty_token);
2419 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2420 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2421 wakeup(TSA_HUP_OR_INPUT(tp));
2422 KNOTE(&tp->t_rkq.ki_note, 0);
2423 lwkt_reltoken(&tty_token);
2427 * Wake up any writers on a tty.
2430 ttwwakeup(struct tty *tp)
2432 lwkt_gettoken(&tty_token);
2433 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2434 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2435 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2436 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2437 CLR(tp->t_state, TS_SO_OCOMPLETE);
2438 wakeup(TSA_OCOMPLETE(tp));
2440 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2441 tp->t_outq.c_cc <= tp->t_olowat) {
2442 CLR(tp->t_state, TS_SO_OLOWAT);
2443 wakeup(TSA_OLOWAT(tp));
2445 KNOTE(&tp->t_wkq.ki_note, 0);
2446 lwkt_reltoken(&tty_token);
2450 * Look up a code for a specified speed in a conversion table;
2451 * used by drivers to map software speed values to hardware parameters.
2455 ttspeedtab(int speed, struct speedtab *table)
2458 for ( ; table->sp_speed != -1; table++)
2459 if (table->sp_speed == speed)
2460 return (table->sp_code);
2465 * Set input and output watermarks and buffer sizes. For input, the
2466 * high watermark is about one second's worth of input above empty, the
2467 * low watermark is slightly below high water, and the buffer size is a
2468 * driver-dependent amount above high water. For output, the watermarks
2469 * are near the ends of the buffer, with about 1 second's worth of input
2470 * between them. All this only applies to the standard line discipline.
2473 ttsetwater(struct tty *tp)
2475 int cps, ttmaxhiwat, x;
2477 lwkt_gettoken(&tty_token);
2479 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2480 switch (tp->t_ispeedwat) {
2482 cps = tp->t_ispeed / 10;
2486 * This case is for old drivers that don't know about
2487 * t_ispeedwat. Arrange for them to get the old buffer
2488 * sizes and watermarks.
2490 cps = TTYHOG - 2 * 256;
2491 tp->t_ififosize = 2 * 2048;
2494 cps = tp->t_ispeedwat / 10;
2498 tp->t_ilowat = 7 * cps / 8;
2499 x = cps + tp->t_ififosize;
2500 clist_alloc_cblocks(&tp->t_rawq, x, x);
2503 switch (tp->t_ospeedwat) {
2505 cps = tp->t_ospeed / 10;
2506 ttmaxhiwat = 2 * TTMAXHIWAT;
2509 cps = tp->t_ospeed / 10;
2510 ttmaxhiwat = TTMAXHIWAT;
2513 cps = tp->t_ospeedwat / 10;
2514 ttmaxhiwat = 8 * TTMAXHIWAT;
2517 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2518 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2520 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2521 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2522 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2524 clist_alloc_cblocks(&tp->t_outq, x, x);
2526 lwkt_reltoken(&tty_token);
2530 * Report on state of foreground process group.
2533 ttyinfo(struct tty *tp)
2536 struct proc *p, *pick;
2546 if (ttycheckoutq(tp,0) == 0)
2549 lwkt_gettoken(&tty_token);
2552 * We always print the load average, then figure out what else to
2553 * print based on the state of the current process group.
2555 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2556 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2558 if (tp->t_session == NULL) {
2559 ttyprintf(tp, "not a controlling terminal\n");
2562 if ((pgrp = tp->t_pgrp) == NULL) {
2563 ttyprintf(tp, "no foreground process group\n");
2568 * Pick an interesting process. Note that certain elements,
2569 * in particular the wmesg, require a critical section for
2570 * safe access (YYY and we are still not MP safe).
2572 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2575 lwkt_gettoken(&pgrp->pg_token);
2578 for (p = LIST_FIRST(&pgrp->pg_members);
2580 p = LIST_NEXT(p, p_pglist)) {
2582 if (proc_compare(pick, p)) {
2591 ttyprintf(tp, "empty foreground process group\n");
2596 * Pick an interesting LWP (XXX)
2600 lp = FIRST_LWP_IN_PROC(pick);
2603 ttyprintf(tp, "foreground process without lwp\n");
2608 * Figure out what wait/process-state message, and command
2612 * XXX lwp This is a horrible mixture. We need to rework this
2613 * as soon as lwps have their own runnable status.
2616 if (pick->p_flags & P_WEXIT)
2618 else if (lp->lwp_stat == LSRUN)
2620 else if (pick->p_stat == SIDL)
2622 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2623 str = lp->lwp_wmesg;
2627 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2628 pick->p_comm, pick->p_pid, str);
2631 * Calculate cpu usage, percent cpu, and cmsz. Note that
2632 * 'pick' becomes invalid the moment we exit the critical
2635 if (lp->lwp_thread && (pick->p_flags & P_SWAPPEDOUT) == 0)
2636 calcru_proc(pick, &ru);
2638 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2643 * NOTE: vmspace should be protected from destruction by the
2644 * combination of pg_token and the fact that we are not
2645 * flagged as a zombie.
2647 if (pick->p_stat == SIDL || pick->p_stat == SZOMB) {
2649 } else if ((vm = pick->p_vmspace) == NULL) {
2653 vmsz = pgtok(vmspace_resident_count(vm));
2661 ttyprintf(tp, " %s ",
2663 ttyprintf(tp, "%ld.%02ldu ",
2664 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2665 ttyprintf(tp, "%ld.%02lds ",
2666 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2667 ttyprintf(tp, "%d%% %ldk\n",
2668 pctcpu / 100, vmsz);
2671 lwkt_reltoken(&pgrp->pg_token);
2674 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2675 lwkt_reltoken(&tty_token);
2679 * Returns 1 if p2 is "better" than p1
2681 * The algorithm for picking the "interesting" process is thus:
2683 * 1) Only foreground processes are eligible - implied.
2684 * 2) Runnable processes are favored over anything else. The runner
2685 * with the highest cpu utilization is picked (p_cpticks). Ties are
2686 * broken by picking the highest pid.
2687 * 3) The sleeper with the shortest sleep time is next. With ties,
2688 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2689 * 4) Further ties are broken by picking the highest pid.
2691 * NOTE: must be called with p1 and p2 held.
2693 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2694 #define TESTAB(a, b) ((a)<<1 | (b))
2700 proc_compare(struct proc *p1, struct proc *p2)
2702 struct lwp *lp1, *lp2;
2707 if (lwkt_trytoken(&p1->p_token) == 0)
2709 if (lwkt_trytoken(&p2->p_token) == 0) {
2710 lwkt_reltoken(&p1->p_token);
2717 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2725 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2731 /* XXX choose the best lwp? */
2732 lp1 = FIRST_LWP_IN_PROC(p1);
2733 lp2 = FIRST_LWP_IN_PROC(p2);
2736 * Favor one with LWPs verses one that has none (is exiting).
2748 * see if at least one of them is runnable
2750 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2759 * tie - favor one with highest recent cpu utilization
2761 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2763 else if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2766 res = (p2->p_pid > p1->p_pid); /* tie - ret highest */
2773 * Pick the one with the smallest sleep time
2775 if (lp2->lwp_slptime > lp1->lwp_slptime) {
2779 if (lp1->lwp_slptime > lp2->lwp_slptime) {
2785 * Favor one sleeping in a non-interruptible sleep
2787 if ((lp1->lwp_flags & LWP_SINTR) && (lp2->lwp_flags & LWP_SINTR) == 0)
2790 if ((lp2->lwp_flags & LWP_SINTR) && (lp1->lwp_flags & LWP_SINTR) == 0)
2793 res = (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2797 lwkt_reltoken(&p2->p_token);
2798 lwkt_reltoken(&p1->p_token);
2803 * Output char to tty; console putchar style.
2806 tputchar(int c, struct tty *tp)
2809 lwkt_gettoken(&tty_token);
2810 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2811 lwkt_reltoken(&tty_token);
2816 (void)ttyoutput('\r', tp);
2817 (void)ttyoutput(c, tp);
2819 lwkt_reltoken(&tty_token);
2825 * Sleep on chan, returning ERESTART if tty changed while we napped and
2826 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2827 * the tty is revoked, restarting a pending call will redo validation done
2828 * at the start of the call.
2831 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2837 error = tsleep(chan, slpflags, wmesg, timo);
2840 return (tp->t_gen == gen ? 0 : ERESTART);
2846 * We bump the gen to force any ttysleep()'s to return with ERESTART
2847 * and flush the tty. The related fp's should already have been
2848 * replaced so the tty will close when the last references on the
2849 * original fp's go away.
2852 ttyrevoke(struct dev_revoke_args *ap)
2856 lwkt_gettoken(&tty_token);
2857 tp = ap->a_head.a_dev->si_tty;
2859 ttyflush(tp, FREAD | FWRITE);
2860 wakeup(TSA_CARR_ON(tp));
2863 lwkt_reltoken(&tty_token);
2868 * Allocate a tty struct. Clists in the struct will be allocated by
2872 ttymalloc(struct tty *tp)
2878 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2884 ttyunregister(struct tty *tp)
2886 lwkt_gettoken(&tty_token);
2887 KKASSERT(ISSET(tp->t_state, TS_REGISTERED));
2888 CLR(tp->t_state, TS_REGISTERED);
2889 TAILQ_REMOVE(&tty_list, tp, t_list);
2890 lwkt_reltoken(&tty_token);
2894 ttyregister(struct tty *tp)
2896 lwkt_gettoken(&tty_token);
2897 KKASSERT(!ISSET(tp->t_state, TS_REGISTERED));
2898 SET(tp->t_state, TS_REGISTERED);
2899 TAILQ_INSERT_HEAD(&tty_list, tp, t_list);
2900 lwkt_reltoken(&tty_token);
2904 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2911 bzero(&marker, sizeof(marker));
2912 marker.t_state = TS_MARKER;
2915 lwkt_gettoken(&tty_token);
2917 TAILQ_INSERT_HEAD(&tty_list, &marker, t_list);
2918 while ((tp = TAILQ_NEXT(&marker, t_list)) != NULL) {
2919 TAILQ_REMOVE(&tty_list, &marker, t_list);
2920 TAILQ_INSERT_AFTER(&tty_list, tp, &marker, t_list);
2921 if (tp->t_state & TS_MARKER)
2925 t.t_dev = (cdev_t)(uintptr_t)dev2udev(t.t_dev);
2926 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2930 TAILQ_REMOVE(&tty_list, &marker, t_list);
2931 lwkt_reltoken(&tty_token);
2935 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2936 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2939 nottystop(struct tty *tp, int rw)
2945 ttyread(struct dev_read_args *ap)
2950 tp = ap->a_head.a_dev->si_tty;
2953 lwkt_gettoken(&tty_token);
2954 ret = ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2955 lwkt_reltoken(&tty_token);
2961 ttywrite(struct dev_write_args *ap)
2966 tp = ap->a_head.a_dev->si_tty;
2969 lwkt_gettoken(&tty_token);
2970 ret = ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2971 lwkt_reltoken(&tty_token);