2 * Copyright (c) 1982, 1986, 1990, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * @(#)tty.c 8.8 (Berkeley) 1/21/94
39 * $FreeBSD: src/sys/kern/tty.c,v 1.129.2.5 2002/03/11 01:32:31 dd Exp $
40 * $DragonFly: src/sys/kern/tty.c,v 1.41 2007/02/25 23:17:12 corecode Exp $
45 * o Fix races for sending the start char in ttyflush().
46 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
47 * With luck, there will be MIN chars before select() returns().
48 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
49 * o Don't allow input in TS_ZOMBIE case. It would be visible through
51 * o Do the new sio locking stuff here and use it to avoid special
54 * o Move EXTPROC and/or PENDIN to t_state?
55 * o Wrap most of ttioctl in spltty/splx.
56 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
57 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
58 * o Don't allow certain termios flags to affect disciplines other
59 * than TTYDISC. Cancel their effects before switch disciplines
60 * and ignore them if they are set while we are in another
62 * o Now that historical speed conversions are handled here, don't
64 * o Check for TS_CARR_ON being set while everything is closed and not
65 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
66 * so it would live until the next open even if carrier drops.
67 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
68 * only when _all_ openers leave open().
71 #include "opt_compat.h"
72 #include "opt_uconsole.h"
74 #include <sys/param.h>
75 #include <sys/systm.h>
76 #include <sys/filio.h>
77 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
78 #include <sys/ioctl_compat.h>
83 #include <sys/clist.h>
85 #include <sys/fcntl.h>
87 #include <sys/dkstat.h>
89 #include <sys/kernel.h>
90 #include <sys/vnode.h>
91 #include <sys/signalvar.h>
92 #include <sys/signal2.h>
93 #include <sys/resourcevar.h>
94 #include <sys/malloc.h>
95 #include <sys/filedesc.h>
96 #include <sys/sysctl.h>
97 #include <sys/thread2.h>
100 #include <sys/lock.h>
102 #include <vm/vm_map.h>
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 SLIST_HEAD(, tty
) tty_list
;
216 * Initial open of tty, or (re)entry to standard tty line discipline.
219 ttyopen(cdev_t device
, struct tty
*tp
)
223 if (!ISSET(tp
->t_state
, TS_ISOPEN
)) {
224 SET(tp
->t_state
, TS_ISOPEN
);
225 if (ISSET(tp
->t_cflag
, CLOCAL
))
226 SET(tp
->t_state
, TS_CONNECTED
);
227 bzero(&tp
->t_winsize
, sizeof(tp
->t_winsize
));
235 * Handle close() on a tty line: flush and set to initial state,
236 * bumping generation number so that pending read/write calls
237 * can detect recycling of the tty.
239 * XXX our caller should have done `spltty(); l_close(); ttyclose();'
240 * and l_close() should have flushed, but we repeat the spltty() and
241 * the flush in case there are buggy callers.
244 ttyclose(struct tty
*tp
)
246 funsetown(tp
->t_sigio
);
251 ttyflush(tp
, FREAD
| FWRITE
);
252 clist_free_cblocks(&tp
->t_canq
);
253 clist_free_cblocks(&tp
->t_outq
);
254 clist_free_cblocks(&tp
->t_rawq
);
257 tp
->t_line
= TTYDISC
;
265 * Disassociate the tty from its session. Traditionally this has only been
266 * a half-close, meaning that the session was still allowed to point at the
267 * tty (resulting in the tty in the ps command showing something like 'p0-'),
268 * even though the tty is no longer pointing at the session.
270 * The half close seems to be useful only for 'ps' output but there is as
271 * yet no reason to remove the feature. The full-close code is currently
272 * #if 0'd out. See also sess_rele() in kern/kern_proc.c.
275 ttyclearsession(struct tty
*tp
)
280 if ((sp
= tp
->t_session
) != NULL
) {
281 tp
->t_session
= NULL
;
282 #ifdef TTY_DO_FULL_CLOSE
283 /* FULL CLOSE (not yet) */
284 if (sp
->s_ttyp
== tp
) {
287 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
288 "%p/%p\n", sp
->s_ttyp
, tp
);
295 * Terminate the tty vnode association for a session. This is the
296 * 'other half' of the close. Because multiple opens of /dev/tty
297 * only generate a single open to the actual tty, the file modes
298 * are locked to FREAD|FWRITE.
301 ttyclosesession(struct session
*sp
, int dorele
)
305 if ((vp
= sp
->s_ttyvp
) == NULL
)
308 if (vp
->v_flag
& VCTTYISOPEN
) {
309 if (vn_lock(vp
, LK_EXCLUSIVE
|LK_RETRY
) == 0) {
310 vclrflags(vp
, VCTTYISOPEN
);
311 VOP_CLOSE(vp
, FREAD
|FWRITE
);
320 #define FLUSHQ(q) { \
322 ndflush(q, (q)->c_cc); \
325 /* Is 'c' a line delimiter ("break" character)? */
326 #define TTBREAKC(c, lflag) \
327 ((c) == '\n' || (((c) == cc[VEOF] || \
328 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
329 (c) != _POSIX_VDISABLE))
332 * Process input of a single character received on a tty.
335 ttyinput(int c
, struct tty
*tp
)
337 tcflag_t iflag
, lflag
;
342 * If input is pending take it first.
345 if (ISSET(lflag
, PENDIN
))
350 if (ISSET(lflag
, ICANON
))
357 * Block further input iff:
358 * current input > threshold AND input is available to user program
359 * AND input flow control is enabled and not yet invoked.
360 * The 3 is slop for PARMRK.
363 if (tp
->t_rawq
.c_cc
+ tp
->t_canq
.c_cc
> tp
->t_ihiwat
- 3 &&
364 (!ISSET(lflag
, ICANON
) || tp
->t_canq
.c_cc
!= 0) &&
365 (ISSET(tp
->t_cflag
, CRTS_IFLOW
) || ISSET(iflag
, IXOFF
)) &&
366 !ISSET(tp
->t_state
, TS_TBLOCK
))
369 /* Handle exceptional conditions (break, parity, framing). */
371 err
= (ISSET(c
, TTY_ERRORMASK
));
373 CLR(c
, TTY_ERRORMASK
);
374 if (ISSET(err
, TTY_BI
)) {
375 if (ISSET(iflag
, IGNBRK
))
377 if (ISSET(iflag
, BRKINT
)) {
378 ttyflush(tp
, FREAD
| FWRITE
);
379 pgsignal(tp
->t_pgrp
, SIGINT
, 1);
382 if (ISSET(iflag
, PARMRK
))
384 } else if ((ISSET(err
, TTY_PE
) && ISSET(iflag
, INPCK
))
385 || ISSET(err
, TTY_FE
)) {
386 if (ISSET(iflag
, IGNPAR
))
388 else if (ISSET(iflag
, PARMRK
)) {
390 if (tp
->t_rawq
.c_cc
+ tp
->t_canq
.c_cc
>
393 clist_putc(0377 | TTY_QUOTE
, &tp
->t_rawq
);
394 clist_putc(0 | TTY_QUOTE
, &tp
->t_rawq
);
395 clist_putc(c
| TTY_QUOTE
, &tp
->t_rawq
);
402 if (!ISSET(tp
->t_state
, TS_TYPEN
) && ISSET(iflag
, ISTRIP
))
404 if (!ISSET(lflag
, EXTPROC
)) {
406 * Check for literal nexting very first
408 if (ISSET(tp
->t_state
, TS_LNCH
)) {
410 CLR(tp
->t_state
, TS_LNCH
);
413 * Scan for special characters. This code
414 * is really just a big case statement with
415 * non-constant cases. The bottom of the
416 * case statement is labeled ``endcase'', so goto
417 * it after a case match, or similar.
421 * Control chars which aren't controlled
422 * by ICANON, ISIG, or IXON.
424 if (ISSET(lflag
, IEXTEN
)) {
425 if (CCEQ(cc
[VLNEXT
], c
)) {
426 if (ISSET(lflag
, ECHO
)) {
427 if (ISSET(lflag
, ECHOE
)) {
428 (void)ttyoutput('^', tp
);
429 (void)ttyoutput('\b', tp
);
433 SET(tp
->t_state
, TS_LNCH
);
436 if (CCEQ(cc
[VDISCARD
], c
)) {
437 if (ISSET(lflag
, FLUSHO
))
438 CLR(tp
->t_lflag
, FLUSHO
);
440 ttyflush(tp
, FWRITE
);
442 if (tp
->t_rawq
.c_cc
+ tp
->t_canq
.c_cc
)
444 SET(tp
->t_lflag
, FLUSHO
);
452 if (ISSET(lflag
, ISIG
)) {
453 if (CCEQ(cc
[VINTR
], c
) || CCEQ(cc
[VQUIT
], c
)) {
454 if (!ISSET(lflag
, NOFLSH
))
455 ttyflush(tp
, FREAD
| FWRITE
);
458 CCEQ(cc
[VINTR
], c
) ? SIGINT
: SIGQUIT
, 1);
461 if (CCEQ(cc
[VSUSP
], c
)) {
462 if (!ISSET(lflag
, NOFLSH
))
465 pgsignal(tp
->t_pgrp
, SIGTSTP
, 1);
470 * Handle start/stop characters.
472 if (ISSET(iflag
, IXON
)) {
473 if (CCEQ(cc
[VSTOP
], c
)) {
474 if (!ISSET(tp
->t_state
, TS_TTSTOP
)) {
475 SET(tp
->t_state
, TS_TTSTOP
);
476 (*tp
->t_stop
)(tp
, 0);
479 if (!CCEQ(cc
[VSTART
], c
))
482 * if VSTART == VSTOP then toggle
486 if (CCEQ(cc
[VSTART
], c
))
490 * IGNCR, ICRNL, & INLCR
493 if (ISSET(iflag
, IGNCR
))
495 else if (ISSET(iflag
, ICRNL
))
497 } else if (c
== '\n' && ISSET(iflag
, INLCR
))
500 if (!ISSET(tp
->t_lflag
, EXTPROC
) && ISSET(lflag
, ICANON
)) {
502 * From here on down canonical mode character
503 * processing takes place.
506 * erase or erase2 (^H / ^?)
508 if (CCEQ(cc
[VERASE
], c
) || CCEQ(cc
[VERASE2
], c
) ) {
510 ttyrub(clist_unputc(&tp
->t_rawq
), tp
);
516 if (CCEQ(cc
[VKILL
], c
)) {
517 if (ISSET(lflag
, ECHOKE
) &&
518 tp
->t_rawq
.c_cc
== tp
->t_rocount
&&
519 !ISSET(lflag
, ECHOPRT
))
520 while (tp
->t_rawq
.c_cc
)
521 ttyrub(clist_unputc(&tp
->t_rawq
), tp
);
524 if (ISSET(lflag
, ECHOK
) ||
525 ISSET(lflag
, ECHOKE
))
530 CLR(tp
->t_state
, TS_LOCAL
);
536 if (CCEQ(cc
[VWERASE
], c
) && ISSET(lflag
, IEXTEN
)) {
542 while ((c
= clist_unputc(&tp
->t_rawq
)) == ' ' || c
== '\t')
547 * erase last char of word and remember the
548 * next chars type (for ALTWERASE)
551 c
= clist_unputc(&tp
->t_rawq
);
554 if (c
== ' ' || c
== '\t') {
555 clist_putc(c
, &tp
->t_rawq
);
564 c
= clist_unputc(&tp
->t_rawq
);
567 } while (c
!= ' ' && c
!= '\t' &&
568 (!ISSET(lflag
, ALTWERASE
) || ISALPHA(c
) == ctype
));
569 clist_putc(c
, &tp
->t_rawq
);
575 if (CCEQ(cc
[VREPRINT
], c
) && ISSET(lflag
, IEXTEN
)) {
580 * ^T - kernel info and generate SIGINFO
582 if (CCEQ(cc
[VSTATUS
], c
) && ISSET(lflag
, IEXTEN
)) {
583 if (ISSET(lflag
, ISIG
))
584 pgsignal(tp
->t_pgrp
, SIGINFO
, 1);
585 if (!ISSET(lflag
, NOKERNINFO
))
589 if (CCEQ(cc
[VCHECKPT
], c
) && ISSET(lflag
, IEXTEN
)) {
590 if (ISSET(lflag
, ISIG
))
591 pgsignal(tp
->t_pgrp
, SIGCKPT
, 1);
596 * Check for input buffer overflow
598 if (tp
->t_rawq
.c_cc
+ tp
->t_canq
.c_cc
>= MAX_INPUT
) {
600 if (ISSET(iflag
, IMAXBEL
)) {
601 if (tp
->t_outq
.c_cc
< tp
->t_ohiwat
)
602 (void)ttyoutput(CTRL('g'), tp
);
607 if ( c
== 0377 && ISSET(iflag
, PARMRK
) && !ISSET(iflag
, ISTRIP
)
608 && ISSET(iflag
, IGNBRK
|IGNPAR
) != (IGNBRK
|IGNPAR
))
609 clist_putc(0377 | TTY_QUOTE
, &tp
->t_rawq
);
612 * Put data char in q for user and
613 * wakeup on seeing a line delimiter.
615 if (clist_putc(c
, &tp
->t_rawq
) >= 0) {
616 if (!ISSET(lflag
, ICANON
)) {
621 if (TTBREAKC(c
, lflag
)) {
623 catq(&tp
->t_rawq
, &tp
->t_canq
);
625 } else if (tp
->t_rocount
++ == 0)
626 tp
->t_rocol
= tp
->t_column
;
627 if (ISSET(tp
->t_state
, TS_ERASE
)) {
629 * end of prterase \.../
631 CLR(tp
->t_state
, TS_ERASE
);
632 (void)ttyoutput('/', tp
);
636 if (CCEQ(cc
[VEOF
], c
) && ISSET(lflag
, ECHO
)) {
638 * Place the cursor over the '^' of the ^D.
640 i
= imin(2, tp
->t_column
- i
);
642 (void)ttyoutput('\b', tp
);
649 * IXANY means allow any character to restart output.
651 if (ISSET(tp
->t_state
, TS_TTSTOP
) &&
652 !ISSET(iflag
, IXANY
) && cc
[VSTART
] != cc
[VSTOP
])
655 CLR(tp
->t_lflag
, FLUSHO
);
656 CLR(tp
->t_state
, TS_TTSTOP
);
658 return (ttstart(tp
));
662 * Output a single character on a tty, doing output processing
663 * as needed (expanding tabs, newline processing, etc.).
664 * Returns < 0 if succeeds, otherwise returns char to resend.
668 ttyoutput(int c
, struct tty
*tp
)
674 if (!ISSET(oflag
, OPOST
)) {
675 if (ISSET(tp
->t_lflag
, FLUSHO
))
677 if (clist_putc(c
, &tp
->t_outq
))
684 * Do tab expansion if OXTABS is set. Special case if we external
685 * processing, we don't do the tab expansion because we'll probably
686 * get it wrong. If tab expansion needs to be done, let it happen
689 CLR(c
, ~TTY_CHARMASK
);
691 ISSET(oflag
, OXTABS
) && !ISSET(tp
->t_lflag
, EXTPROC
)) {
692 c
= 8 - (tp
->t_column
& 7);
693 if (!ISSET(tp
->t_lflag
, FLUSHO
)) {
694 crit_enter(); /* Don't interrupt tabs. */
695 c
-= b_to_q(" ", c
, &tp
->t_outq
);
701 return (c
? -1 : '\t');
703 if (c
== CEOT
&& ISSET(oflag
, ONOEOT
))
707 * Newline translation: if ONLCR is set,
708 * translate newline into "\r\n".
710 if (c
== '\n' && ISSET(tp
->t_oflag
, ONLCR
)) {
713 if (!ISSET(tp
->t_lflag
, FLUSHO
) && clist_putc('\r', &tp
->t_outq
))
716 /* If OCRNL is set, translate "\r" into "\n". */
717 else if (c
== '\r' && ISSET(tp
->t_oflag
, OCRNL
))
719 /* If ONOCR is set, don't transmit CRs when on column 0. */
720 else if (c
== '\r' && ISSET(tp
->t_oflag
, ONOCR
) && tp
->t_column
== 0)
725 if (!ISSET(tp
->t_lflag
, FLUSHO
) && clist_putc(c
, &tp
->t_outq
))
737 if (ISSET(tp
->t_oflag
, ONLCR
| ONLRET
))
747 col
= (col
+ 8) & ~7;
755 * Ioctls for all tty devices. Called after line-discipline specific ioctl
756 * has been called to do discipline-specific functions and/or reject any
757 * of these ioctl commands.
761 ttioctl(struct tty
*tp
, u_long cmd
, void *data
, int flag
)
763 struct thread
*td
= curthread
;
764 struct lwp
*lp
= td
->td_lwp
;
765 struct proc
*p
= td
->td_proc
;
770 /* If the ioctl involves modification, hang if in the background. */
794 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
804 while (isbackground(p
, tp
) && !(p
->p_flag
& P_PPWAIT
) &&
805 !SIGISMEMBER(p
->p_sigignore
, SIGTTOU
) &&
806 !SIGISMEMBER(lp
->lwp_sigmask
, SIGTTOU
)) {
807 if (p
->p_pgrp
->pg_jobc
== 0)
809 pgsignal(p
->p_pgrp
, SIGTTOU
, 1);
810 error
= ttysleep(tp
, &lbolt
, PCATCH
, "ttybg1",
818 switch (cmd
) { /* Process the ioctl. */
819 case FIOASYNC
: /* set/clear async i/o */
822 SET(tp
->t_state
, TS_ASYNC
);
824 CLR(tp
->t_state
, TS_ASYNC
);
827 case FIONREAD
: /* get # bytes to read */
829 *(int *)data
= ttnread(tp
);
835 * Policy -- Don't allow FIOSETOWN on someone else's
838 if (tp
->t_session
!= NULL
&& !isctty(p
, tp
))
841 error
= fsetown(*(int *)data
, &tp
->t_sigio
);
846 if (tp
->t_session
!= NULL
&& !isctty(p
, tp
))
848 *(int *)data
= fgetown(tp
->t_sigio
);
851 case TIOCEXCL
: /* set exclusive use of tty */
853 SET(tp
->t_state
, TS_XCLUDE
);
856 case TIOCFLUSH
: { /* flush buffers */
857 int flags
= *(int *)data
;
860 flags
= FREAD
| FWRITE
;
862 flags
&= FREAD
| FWRITE
;
866 case TIOCCONS
: /* become virtual console */
868 if (constty
&& constty
!= tp
&&
869 ISSET(constty
->t_state
, TS_CONNECTED
))
872 if ((error
= suser(td
)) != 0)
876 } else if (tp
== constty
)
879 case TIOCDRAIN
: /* wait till output drained */
884 case TIOCGETA
: { /* get termios struct */
885 struct termios
*t
= (struct termios
*)data
;
887 bcopy(&tp
->t_termios
, t
, sizeof(struct termios
));
890 case TIOCGETD
: /* get line discipline */
891 *(int *)data
= tp
->t_line
;
893 case TIOCGWINSZ
: /* get window size */
894 *(struct winsize
*)data
= tp
->t_winsize
;
896 case TIOCGPGRP
: /* get pgrp of tty */
899 *(int *)data
= tp
->t_pgrp
? tp
->t_pgrp
->pg_id
: NO_PID
;
902 case TIOCHPCL
: /* hang up on last close */
904 SET(tp
->t_cflag
, HUPCL
);
908 case TIOCNXCL
: /* reset exclusive use of tty */
910 CLR(tp
->t_state
, TS_XCLUDE
);
913 case TIOCOUTQ
: /* output queue size */
914 *(int *)data
= tp
->t_outq
.c_cc
;
916 case TIOCSETA
: /* set termios struct */
917 case TIOCSETAW
: /* drain output, set */
918 case TIOCSETAF
: { /* drn out, fls in, set */
919 struct termios
*t
= (struct termios
*)data
;
921 if (t
->c_ispeed
== 0)
922 t
->c_ispeed
= t
->c_ospeed
;
923 if (t
->c_ispeed
== 0)
924 t
->c_ispeed
= tp
->t_ospeed
;
925 if (t
->c_ispeed
== 0)
928 if (cmd
== TIOCSETAW
|| cmd
== TIOCSETAF
) {
934 if (cmd
== TIOCSETAF
)
937 if (!ISSET(t
->c_cflag
, CIGNORE
)) {
939 * Set device hardware.
941 if (tp
->t_param
&& (error
= (*tp
->t_param
)(tp
, t
))) {
945 if (ISSET(t
->c_cflag
, CLOCAL
) &&
946 !ISSET(tp
->t_cflag
, CLOCAL
)) {
948 * XXX disconnections would be too hard to
949 * get rid of without this kludge. The only
950 * way to get rid of controlling terminals
951 * is to exit from the session leader.
953 CLR(tp
->t_state
, TS_ZOMBIE
);
955 wakeup(TSA_CARR_ON(tp
));
959 if ((ISSET(tp
->t_state
, TS_CARR_ON
) ||
960 ISSET(t
->c_cflag
, CLOCAL
)) &&
961 !ISSET(tp
->t_state
, TS_ZOMBIE
))
962 SET(tp
->t_state
, TS_CONNECTED
);
964 CLR(tp
->t_state
, TS_CONNECTED
);
965 tp
->t_cflag
= t
->c_cflag
;
966 tp
->t_ispeed
= t
->c_ispeed
;
967 if (t
->c_ospeed
!= 0)
968 tp
->t_ospeed
= t
->c_ospeed
;
971 if (ISSET(t
->c_lflag
, ICANON
) != ISSET(tp
->t_lflag
, ICANON
) &&
973 if (ISSET(t
->c_lflag
, ICANON
))
974 SET(tp
->t_lflag
, PENDIN
);
977 * XXX we really shouldn't allow toggling
978 * ICANON while we're in a non-termios line
979 * discipline. Now we have to worry about
980 * panicing for a null queue.
982 if (tp
->t_canq
.c_cbreserved
> 0 &&
983 tp
->t_rawq
.c_cbreserved
> 0) {
984 catq(&tp
->t_rawq
, &tp
->t_canq
);
986 * XXX the queue limits may be
987 * different, so the old queue
988 * swapping method no longer works.
990 catq(&tp
->t_canq
, &tp
->t_rawq
);
992 CLR(tp
->t_lflag
, PENDIN
);
996 tp
->t_iflag
= t
->c_iflag
;
997 tp
->t_oflag
= t
->c_oflag
;
999 * Make the EXTPROC bit read only.
1001 if (ISSET(tp
->t_lflag
, EXTPROC
))
1002 SET(t
->c_lflag
, EXTPROC
);
1004 CLR(t
->c_lflag
, EXTPROC
);
1005 tp
->t_lflag
= t
->c_lflag
| ISSET(tp
->t_lflag
, PENDIN
);
1006 if (t
->c_cc
[VMIN
] != tp
->t_cc
[VMIN
] ||
1007 t
->c_cc
[VTIME
] != tp
->t_cc
[VTIME
])
1009 bcopy(t
->c_cc
, tp
->t_cc
, sizeof(t
->c_cc
));
1013 case TIOCSETD
: { /* set line discipline */
1014 int t
= *(int *)data
;
1015 cdev_t device
= tp
->t_dev
;
1017 if ((u_int
)t
>= nlinesw
)
1019 if (t
!= tp
->t_line
) {
1021 (*linesw
[tp
->t_line
].l_close
)(tp
, flag
);
1022 error
= (*linesw
[t
].l_open
)(device
, tp
);
1024 (void)(*linesw
[tp
->t_line
].l_open
)(device
, tp
);
1033 case TIOCSTART
: /* start output, like ^Q */
1035 if (ISSET(tp
->t_state
, TS_TTSTOP
) ||
1036 ISSET(tp
->t_lflag
, FLUSHO
)) {
1037 CLR(tp
->t_lflag
, FLUSHO
);
1038 CLR(tp
->t_state
, TS_TTSTOP
);
1043 case TIOCSTI
: /* simulate terminal input */
1044 if ((flag
& FREAD
) == 0 && suser(td
))
1046 if (!isctty(p
, tp
) && suser(td
))
1049 (*linesw
[tp
->t_line
].l_rint
)(*(u_char
*)data
, tp
);
1052 case TIOCSTOP
: /* stop output, like ^S */
1054 if (!ISSET(tp
->t_state
, TS_TTSTOP
)) {
1055 SET(tp
->t_state
, TS_TTSTOP
);
1056 (*tp
->t_stop
)(tp
, 0);
1060 case TIOCSCTTY
: /* become controlling tty */
1061 /* Session ctty vnode pointer set in vnode layer. */
1062 if (!SESS_LEADER(p
) ||
1063 ((p
->p_session
->s_ttyvp
|| tp
->t_session
) &&
1064 (tp
->t_session
!= p
->p_session
)))
1066 tp
->t_session
= p
->p_session
;
1067 tp
->t_pgrp
= p
->p_pgrp
;
1068 p
->p_session
->s_ttyp
= tp
;
1069 p
->p_flag
|= P_CONTROLT
;
1071 case TIOCSPGRP
: { /* set pgrp of tty */
1072 struct pgrp
*pgrp
= pgfind(*(int *)data
);
1076 else if (pgrp
== NULL
|| pgrp
->pg_session
!= p
->p_session
)
1081 case TIOCSTAT
: /* simulate control-T */
1086 case TIOCSWINSZ
: /* set window size */
1087 if (bcmp((caddr_t
)&tp
->t_winsize
, data
,
1088 sizeof (struct winsize
))) {
1089 tp
->t_winsize
= *(struct winsize
*)data
;
1090 pgsignal(tp
->t_pgrp
, SIGWINCH
, 1);
1093 case TIOCSDRAINWAIT
:
1097 tp
->t_timeout
= *(int *)data
* hz
;
1098 wakeup(TSA_OCOMPLETE(tp
));
1099 wakeup(TSA_OLOWAT(tp
));
1101 case TIOCGDRAINWAIT
:
1102 *(int *)data
= tp
->t_timeout
/ hz
;
1105 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1106 return (ttcompat(tp
, cmd
, data
, flag
));
1115 ttypoll(struct dev_poll_args
*ap
)
1117 cdev_t dev
= ap
->a_head
.a_dev
;
1118 int events
= ap
->a_events
;
1123 /* XXX used to return ENXIO, but that means true! */
1125 ap
->a_events
= (events
& (POLLIN
| POLLOUT
| POLLRDNORM
|
1126 POLLWRNORM
)) | POLLHUP
;
1131 if (events
& (POLLIN
| POLLRDNORM
)) {
1132 if (ttnread(tp
) > 0 || ISSET(tp
->t_state
, TS_ZOMBIE
))
1133 revents
|= events
& (POLLIN
| POLLRDNORM
);
1135 selrecord(curthread
, &tp
->t_rsel
);
1137 if (events
& (POLLOUT
| POLLWRNORM
)) {
1138 if ((tp
->t_outq
.c_cc
<= tp
->t_olowat
&&
1139 ISSET(tp
->t_state
, TS_CONNECTED
))
1140 || ISSET(tp
->t_state
, TS_ZOMBIE
))
1141 revents
|= events
& (POLLOUT
| POLLWRNORM
);
1143 selrecord(curthread
, &tp
->t_wsel
);
1146 ap
->a_events
= revents
;
1150 static struct filterops ttyread_filtops
=
1151 { 1, NULL
, filt_ttyrdetach
, filt_ttyread
};
1152 static struct filterops ttywrite_filtops
=
1153 { 1, NULL
, filt_ttywdetach
, filt_ttywrite
};
1156 ttykqfilter(struct dev_kqfilter_args
*ap
)
1158 cdev_t dev
= ap
->a_head
.a_dev
;
1159 struct knote
*kn
= ap
->a_kn
;
1160 struct tty
*tp
= dev
->si_tty
;
1161 struct klist
*klist
;
1164 switch (kn
->kn_filter
) {
1166 klist
= &tp
->t_rsel
.si_note
;
1167 kn
->kn_fop
= &ttyread_filtops
;
1170 klist
= &tp
->t_wsel
.si_note
;
1171 kn
->kn_fop
= &ttywrite_filtops
;
1178 kn
->kn_hook
= (caddr_t
)dev
;
1181 SLIST_INSERT_HEAD(klist
, kn
, kn_selnext
);
1188 filt_ttyrdetach(struct knote
*kn
)
1190 struct tty
*tp
= ((cdev_t
)kn
->kn_hook
)->si_tty
;
1193 SLIST_REMOVE(&tp
->t_rsel
.si_note
, kn
, knote
, kn_selnext
);
1198 filt_ttyread(struct knote
*kn
, long hint
)
1200 struct tty
*tp
= ((cdev_t
)kn
->kn_hook
)->si_tty
;
1202 kn
->kn_data
= ttnread(tp
);
1203 if (ISSET(tp
->t_state
, TS_ZOMBIE
)) {
1204 kn
->kn_flags
|= EV_EOF
;
1207 return (kn
->kn_data
> 0);
1211 filt_ttywdetach(struct knote
*kn
)
1213 struct tty
*tp
= ((cdev_t
)kn
->kn_hook
)->si_tty
;
1216 SLIST_REMOVE(&tp
->t_wsel
.si_note
, kn
, knote
, kn_selnext
);
1221 filt_ttywrite(struct knote
*kn
, long hint
)
1223 struct tty
*tp
= ((cdev_t
)kn
->kn_hook
)->si_tty
;
1225 kn
->kn_data
= tp
->t_outq
.c_cc
;
1226 if (ISSET(tp
->t_state
, TS_ZOMBIE
))
1228 return (kn
->kn_data
<= tp
->t_olowat
&&
1229 ISSET(tp
->t_state
, TS_CONNECTED
));
1233 * Must be called while in a critical section.
1236 ttnread(struct tty
*tp
)
1240 if (ISSET(tp
->t_lflag
, PENDIN
))
1242 nread
= tp
->t_canq
.c_cc
;
1243 if (!ISSET(tp
->t_lflag
, ICANON
)) {
1244 nread
+= tp
->t_rawq
.c_cc
;
1245 if (nread
< tp
->t_cc
[VMIN
] && tp
->t_cc
[VTIME
] == 0)
1252 * Wait for output to drain.
1255 ttywait(struct tty
*tp
)
1261 while ((tp
->t_outq
.c_cc
|| ISSET(tp
->t_state
, TS_BUSY
)) &&
1262 ISSET(tp
->t_state
, TS_CONNECTED
) && tp
->t_oproc
) {
1264 if ((tp
->t_outq
.c_cc
|| ISSET(tp
->t_state
, TS_BUSY
)) &&
1265 ISSET(tp
->t_state
, TS_CONNECTED
)) {
1266 SET(tp
->t_state
, TS_SO_OCOMPLETE
);
1267 error
= ttysleep(tp
, TSA_OCOMPLETE(tp
),
1271 if (error
== EWOULDBLOCK
)
1278 if (!error
&& (tp
->t_outq
.c_cc
|| ISSET(tp
->t_state
, TS_BUSY
)))
1285 * Flush if successfully wait.
1288 ttywflush(struct tty
*tp
)
1292 if ((error
= ttywait(tp
)) == 0)
1293 ttyflush(tp
, FREAD
);
1298 * Flush tty read and/or write queues, notifying anyone waiting.
1301 ttyflush(struct tty
*tp
, int rw
)
1308 FLUSHQ(&tp
->t_outq
);
1309 CLR(tp
->t_state
, TS_TTSTOP
);
1311 (*tp
->t_stop
)(tp
, rw
);
1313 FLUSHQ(&tp
->t_canq
);
1314 FLUSHQ(&tp
->t_rawq
);
1315 CLR(tp
->t_lflag
, PENDIN
);
1318 CLR(tp
->t_state
, TS_LOCAL
);
1320 if (ISSET(tp
->t_state
, TS_TBLOCK
)) {
1322 FLUSHQ(&tp
->t_outq
);
1326 * Don't let leave any state that might clobber the
1327 * next line discipline (although we should do more
1328 * to send the START char). Not clearing the state
1329 * may have caused the "putc to a clist with no
1330 * reserved cblocks" panic/kprintf.
1332 CLR(tp
->t_state
, TS_TBLOCK
);
1334 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1335 if (ISSET(tp
->t_iflag
, IXOFF
)) {
1337 * XXX wait a bit in the hope that the stop
1338 * character (if any) will go out. Waiting
1339 * isn't good since it allows races. This
1340 * will be fixed when the stop character is
1341 * put in a special queue. Don't bother with
1342 * the checks in ttywait() since the timeout
1345 SET(tp
->t_state
, TS_SO_OCOMPLETE
);
1346 ttysleep(tp
, TSA_OCOMPLETE(tp
), 0,
1349 * Don't try sending the stop character again.
1351 CLR(tp
->t_state
, TS_TBLOCK
);
1358 FLUSHQ(&tp
->t_outq
);
1365 * Copy in the default termios characters.
1368 termioschars(struct termios
*t
)
1371 bcopy(ttydefchars
, t
->c_cc
, sizeof t
->c_cc
);
1378 ttychars(struct tty
*tp
)
1381 termioschars(&tp
->t_termios
);
1385 * Handle input high water. Send stop character for the IXOFF case. Turn
1386 * on our input flow control bit and propagate the changes to the driver.
1387 * XXX the stop character should be put in a special high priority queue.
1390 ttyblock(struct tty
*tp
)
1393 SET(tp
->t_state
, TS_TBLOCK
);
1394 if (ISSET(tp
->t_iflag
, IXOFF
) && tp
->t_cc
[VSTOP
] != _POSIX_VDISABLE
&&
1395 clist_putc(tp
->t_cc
[VSTOP
], &tp
->t_outq
) != 0)
1396 CLR(tp
->t_state
, TS_TBLOCK
); /* try again later */
1401 * Handle input low water. Send start character for the IXOFF case. Turn
1402 * off our input flow control bit and propagate the changes to the driver.
1403 * XXX the start character should be put in a special high priority queue.
1406 ttyunblock(struct tty
*tp
)
1409 CLR(tp
->t_state
, TS_TBLOCK
);
1410 if (ISSET(tp
->t_iflag
, IXOFF
) && tp
->t_cc
[VSTART
] != _POSIX_VDISABLE
&&
1411 clist_putc(tp
->t_cc
[VSTART
], &tp
->t_outq
) != 0)
1412 SET(tp
->t_state
, TS_TBLOCK
); /* try again later */
1417 /* Not used by any current (i386) drivers. */
1419 * Restart after an inter-char delay.
1422 ttrstrt(void *tp_arg
)
1426 KASSERT(tp_arg
!= NULL
, ("ttrstrt"));
1430 CLR(tp
->t_state
, TS_TIMEOUT
);
1437 ttstart(struct tty
*tp
)
1440 if (tp
->t_oproc
!= NULL
) /* XXX: Kludge for pty. */
1446 * "close" a line discipline
1449 ttylclose(struct tty
*tp
, int flag
)
1452 if (flag
& FNONBLOCK
|| ttywflush(tp
))
1453 ttyflush(tp
, FREAD
| FWRITE
);
1458 * Handle modem control transition on a tty.
1459 * Flag indicates new state of carrier.
1460 * Returns 0 if the line should be turned off, otherwise 1.
1463 ttymodem(struct tty
*tp
, int flag
)
1466 if (ISSET(tp
->t_state
, TS_CARR_ON
) && ISSET(tp
->t_cflag
, MDMBUF
)) {
1468 * MDMBUF: do flow control according to carrier flag
1469 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1470 * works if IXON and IXANY are clear.
1473 CLR(tp
->t_state
, TS_CAR_OFLOW
);
1474 CLR(tp
->t_state
, TS_TTSTOP
);
1476 } else if (!ISSET(tp
->t_state
, TS_CAR_OFLOW
)) {
1477 SET(tp
->t_state
, TS_CAR_OFLOW
);
1478 SET(tp
->t_state
, TS_TTSTOP
);
1479 (*tp
->t_stop
)(tp
, 0);
1481 } else if (flag
== 0) {
1485 CLR(tp
->t_state
, TS_CARR_ON
);
1486 if (ISSET(tp
->t_state
, TS_ISOPEN
) &&
1487 !ISSET(tp
->t_cflag
, CLOCAL
)) {
1488 SET(tp
->t_state
, TS_ZOMBIE
);
1489 CLR(tp
->t_state
, TS_CONNECTED
);
1490 if (tp
->t_session
&& tp
->t_session
->s_leader
)
1491 ksignal(tp
->t_session
->s_leader
, SIGHUP
);
1492 ttyflush(tp
, FREAD
| FWRITE
);
1499 SET(tp
->t_state
, TS_CARR_ON
);
1500 if (!ISSET(tp
->t_state
, TS_ZOMBIE
))
1501 SET(tp
->t_state
, TS_CONNECTED
);
1502 wakeup(TSA_CARR_ON(tp
));
1510 * Reinput pending characters after state switch
1511 * call from a critical section.
1514 ttypend(struct tty
*tp
)
1519 CLR(tp
->t_lflag
, PENDIN
);
1520 SET(tp
->t_state
, TS_TYPEN
);
1522 * XXX this assumes too much about clist internals. It may even
1523 * fail if the cblock slush pool is empty. We can't allocate more
1524 * cblocks here because we are called from an interrupt handler
1525 * and clist_alloc_cblocks() can wait.
1528 bzero(&tp
->t_rawq
, sizeof tp
->t_rawq
);
1529 tp
->t_rawq
.c_cbmax
= tq
.c_cbmax
;
1530 tp
->t_rawq
.c_cbreserved
= tq
.c_cbreserved
;
1531 while ((c
= clist_getc(&tq
)) >= 0)
1533 CLR(tp
->t_state
, TS_TYPEN
);
1537 * Process a read call on a tty device.
1540 ttread(struct tty
*tp
, struct uio
*uio
, int flag
)
1545 cc_t
*cc
= tp
->t_cc
;
1548 int first
, error
= 0;
1549 int has_stime
= 0, last_cc
= 0;
1550 long slp
= 0; /* XXX this should be renamed `timo'. */
1551 struct timeval stime
;
1553 lp
= curthread
->td_lwp
;
1557 lflag
= tp
->t_lflag
;
1559 * take pending input first
1561 if (ISSET(lflag
, PENDIN
)) {
1563 splz(); /* reduce latency */
1564 lflag
= tp
->t_lflag
; /* XXX ttypend() clobbers it */
1568 * Hang process if it's in the background.
1570 if ((pp
= curproc
) && isbackground(pp
, tp
)) {
1572 if (SIGISMEMBER(pp
->p_sigignore
, SIGTTIN
) ||
1573 SIGISMEMBER(lp
->lwp_sigmask
, SIGTTIN
) ||
1574 (pp
->p_flag
& P_PPWAIT
) || pp
->p_pgrp
->pg_jobc
== 0)
1576 pgsignal(pp
->p_pgrp
, SIGTTIN
, 1);
1577 error
= ttysleep(tp
, &lbolt
, PCATCH
, "ttybg2", 0);
1583 if (ISSET(tp
->t_state
, TS_ZOMBIE
)) {
1585 return (0); /* EOF */
1589 * If canonical, use the canonical queue,
1590 * else use the raw queue.
1592 * (should get rid of clists...)
1594 qp
= ISSET(lflag
, ICANON
) ? &tp
->t_canq
: &tp
->t_rawq
;
1596 if (flag
& IO_NDELAY
) {
1599 if (!ISSET(lflag
, ICANON
) && cc
[VMIN
] == 0) {
1604 return (EWOULDBLOCK
);
1606 if (!ISSET(lflag
, ICANON
)) {
1609 struct timeval timecopy
;
1612 * Check each of the four combinations.
1613 * (m > 0 && t == 0) is the normal read case.
1614 * It should be fairly efficient, so we check that and its
1615 * companion case (m == 0 && t == 0) first.
1616 * For the other two cases, we compute the target sleep time
1625 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1629 t
*= 100000; /* time in us */
1630 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1631 ((t1).tv_usec - (t2).tv_usec))
1637 getmicrotime(&timecopy
);
1639 /* first character, start timer */
1643 } else if (qp
->c_cc
> last_cc
) {
1644 /* got a character, restart timer */
1648 /* nothing, check expiration */
1649 slp
= t
- diff(timecopy
, stime
);
1654 } else { /* m == 0 */
1657 getmicrotime(&timecopy
);
1663 slp
= t
- diff(timecopy
, stime
);
1665 /* Timed out, but 0 is enough input. */
1673 * Rounding down may make us wake up just short
1674 * of the target, so we round up.
1675 * The formula is ceiling(slp * hz/1000000).
1676 * 32-bit arithmetic is enough for hz < 169.
1677 * XXX see tvtohz() for how to avoid overflow if hz
1678 * is large (divide by `tick' and/or arrange to
1679 * use tvtohz() if hz is large).
1681 slp
= (long) (((u_long
)slp
* hz
) + 999999) / 1000000;
1684 if (qp
->c_cc
<= 0) {
1687 * There is no input, or not enough input and we can block.
1689 error
= ttysleep(tp
, TSA_HUP_OR_INPUT(tp
), PCATCH
,
1690 ISSET(tp
->t_state
, TS_CONNECTED
) ?
1691 "ttyin" : "ttyhup", (int)slp
);
1693 if (error
== EWOULDBLOCK
)
1698 * XXX what happens if another process eats some input
1699 * while we are asleep (not just here)? It would be
1700 * safest to detect changes and reset our state variables
1701 * (has_stime and last_cc).
1709 * Input present, check for input mapping and processing.
1712 if (ISSET(lflag
, ICANON
| ISIG
))
1718 icc
= imin(uio
->uio_resid
, IBUFSIZ
);
1719 icc
= q_to_b(qp
, ibuf
, icc
);
1725 error
= uiomove(ibuf
, icc
, uio
);
1727 * XXX if there was an error then we should ungetc() the
1728 * unmoved chars and reduce icc here.
1732 if (uio
->uio_resid
== 0)
1746 * delayed suspend (^Y)
1748 if (CCEQ(cc
[VDSUSP
], c
) &&
1749 ISSET(lflag
, IEXTEN
| ISIG
) == (IEXTEN
| ISIG
)) {
1750 pgsignal(tp
->t_pgrp
, SIGTSTP
, 1);
1752 error
= ttysleep(tp
, &lbolt
, PCATCH
,
1761 * Interpret EOF only in canonical mode.
1763 if (CCEQ(cc
[VEOF
], c
) && ISSET(lflag
, ICANON
))
1766 * Give user character.
1768 error
= ureadc(c
, uio
);
1770 /* XXX should ungetc(c, qp). */
1772 if (uio
->uio_resid
== 0)
1775 * In canonical mode check for a "break character"
1776 * marking the end of a "line of input".
1778 if (ISSET(lflag
, ICANON
) && TTBREAKC(c
, lflag
))
1785 * Look to unblock input now that (presumably)
1786 * the input queue has gone down.
1789 if (ISSET(tp
->t_state
, TS_TBLOCK
) &&
1790 tp
->t_rawq
.c_cc
+ tp
->t_canq
.c_cc
<= tp
->t_ilowat
)
1798 * Check the output queue on tp for space for a kernel message (from uprintf
1799 * or tprintf). Allow some space over the normal hiwater mark so we don't
1800 * lose messages due to normal flow control, but don't let the tty run amok.
1801 * Sleeps here are not interruptible, but we return prematurely if new signals
1805 ttycheckoutq(struct tty
*tp
, int wait
)
1807 struct lwp
*lp
= curthread
->td_lwp
;
1809 sigset_t oldset
, newset
;
1811 hiwat
= tp
->t_ohiwat
;
1812 SIGEMPTYSET(oldset
);
1813 SIGEMPTYSET(newset
);
1816 oldset
= lwp_sigpend(lp
);
1817 if (tp
->t_outq
.c_cc
> hiwat
+ OBUFSIZ
+ 100) {
1818 while (tp
->t_outq
.c_cc
> hiwat
) {
1820 if (tp
->t_outq
.c_cc
<= hiwat
)
1823 newset
= lwp_sigpend(lp
);
1824 if (!wait
|| SIGSETNEQ(oldset
, newset
)) {
1828 SET(tp
->t_state
, TS_SO_OLOWAT
);
1829 tsleep(TSA_OLOWAT(tp
), 0, "ttoutq", hz
);
1837 * Process a write call on a tty device.
1840 ttwrite(struct tty
*tp
, struct uio
*uio
, int flag
)
1846 int i
, hiwat
, cnt
, error
;
1849 lp
= curthread
->td_lwp
;
1850 hiwat
= tp
->t_ohiwat
;
1851 cnt
= uio
->uio_resid
;
1856 if (ISSET(tp
->t_state
, TS_ZOMBIE
)) {
1858 if (uio
->uio_resid
== cnt
)
1862 if (!ISSET(tp
->t_state
, TS_CONNECTED
)) {
1863 if (flag
& IO_NDELAY
) {
1865 error
= EWOULDBLOCK
;
1868 error
= ttysleep(tp
, TSA_CARR_ON(tp
), PCATCH
, "ttydcd", 0);
1877 * Hang the process if it's in the background.
1879 if ((pp
= curproc
) && isbackground(pp
, tp
) &&
1880 ISSET(tp
->t_lflag
, TOSTOP
) && !(pp
->p_flag
& P_PPWAIT
) &&
1881 !SIGISMEMBER(pp
->p_sigignore
, SIGTTOU
) &&
1882 !SIGISMEMBER(lp
->lwp_sigmask
, SIGTTOU
)) {
1883 if (pp
->p_pgrp
->pg_jobc
== 0) {
1887 pgsignal(pp
->p_pgrp
, SIGTTOU
, 1);
1888 error
= ttysleep(tp
, &lbolt
, PCATCH
, "ttybg4", 0);
1894 * Process the user's data in at most OBUFSIZ chunks. Perform any
1895 * output translation. Keep track of high water mark, sleep on
1896 * overflow awaiting device aid in acquiring new space.
1898 while (uio
->uio_resid
> 0 || cc
> 0) {
1899 if (ISSET(tp
->t_lflag
, FLUSHO
)) {
1903 if (tp
->t_outq
.c_cc
> hiwat
)
1906 * Grab a hunk of data from the user, unless we have some
1907 * leftover from last time.
1910 cc
= imin(uio
->uio_resid
, OBUFSIZ
);
1912 error
= uiomove(cp
, cc
, uio
);
1919 * If nothing fancy need be done, grab those characters we
1920 * can handle without any of ttyoutput's processing and
1921 * just transfer them to the output q. For those chars
1922 * which require special processing (as indicated by the
1923 * bits in char_type), call ttyoutput. After processing
1924 * a hunk of data, look for FLUSHO so ^O's will take effect
1928 if (!ISSET(tp
->t_oflag
, OPOST
))
1931 ce
= cc
- scanc((u_int
)cc
, (u_char
*)cp
,
1932 char_type
, CCLASSMASK
);
1934 * If ce is zero, then we're processing
1935 * a special character through ttyoutput.
1939 if (ttyoutput(*cp
, tp
) >= 0) {
1940 /* No Clists, wait a bit. */
1942 if (flag
& IO_NDELAY
) {
1943 error
= EWOULDBLOCK
;
1946 error
= ttysleep(tp
, &lbolt
,
1955 if (ISSET(tp
->t_lflag
, FLUSHO
) ||
1956 tp
->t_outq
.c_cc
> hiwat
)
1962 * A bunch of normal characters have been found.
1963 * Transfer them en masse to the output queue and
1964 * continue processing at the top of the loop.
1965 * If there are any further characters in this
1966 * <= OBUFSIZ chunk, the first should be a character
1967 * requiring special handling by ttyoutput.
1970 i
= b_to_q(cp
, ce
, &tp
->t_outq
);
1973 cp
+= ce
, cc
-= ce
, tk_nout
+= ce
;
1976 /* No Clists, wait a bit. */
1978 if (flag
& IO_NDELAY
) {
1979 error
= EWOULDBLOCK
;
1982 error
= ttysleep(tp
, &lbolt
, PCATCH
,
1988 if (ISSET(tp
->t_lflag
, FLUSHO
) ||
1989 tp
->t_outq
.c_cc
> hiwat
)
1996 * If cc is nonzero, we leave the uio structure inconsistent, as the
1997 * offset and iov pointers have moved forward, but it doesn't matter
1998 * (the call will either return short or restart with a new uio).
2000 uio
->uio_resid
+= cc
;
2007 * This can only occur if FLUSHO is set in t_lflag,
2008 * or if ttstart/oproc is synchronous (or very fast).
2010 if (tp
->t_outq
.c_cc
<= hiwat
) {
2014 if (flag
& IO_NDELAY
) {
2016 uio
->uio_resid
+= cc
;
2017 return (uio
->uio_resid
== cnt
? EWOULDBLOCK
: 0);
2019 SET(tp
->t_state
, TS_SO_OLOWAT
);
2020 error
= ttysleep(tp
, TSA_OLOWAT(tp
), PCATCH
, "ttywri", tp
->t_timeout
);
2022 if (error
== EWOULDBLOCK
)
2030 * Rubout one character from the rawq of tp
2031 * as cleanly as possible.
2034 ttyrub(int c
, struct tty
*tp
)
2040 if (!ISSET(tp
->t_lflag
, ECHO
) || ISSET(tp
->t_lflag
, EXTPROC
))
2042 CLR(tp
->t_lflag
, FLUSHO
);
2043 if (ISSET(tp
->t_lflag
, ECHOE
)) {
2044 if (tp
->t_rocount
== 0) {
2046 * Screwed by ttwrite; retype
2051 if (c
== ('\t' | TTY_QUOTE
) || c
== ('\n' | TTY_QUOTE
))
2054 CLR(c
, ~TTY_CHARMASK
);
2055 switch (CCLASS(c
)) {
2064 if (ISSET(tp
->t_lflag
, ECHOCTL
))
2068 if (tp
->t_rocount
< tp
->t_rawq
.c_cc
) {
2073 savecol
= tp
->t_column
;
2074 SET(tp
->t_state
, TS_CNTTB
);
2075 SET(tp
->t_lflag
, FLUSHO
);
2076 tp
->t_column
= tp
->t_rocol
;
2077 cp
= tp
->t_rawq
.c_cf
;
2079 tabc
= *cp
; /* XXX FIX NEXTC */
2080 for (; cp
; cp
= nextc(&tp
->t_rawq
, cp
, &tabc
))
2082 CLR(tp
->t_lflag
, FLUSHO
);
2083 CLR(tp
->t_state
, TS_CNTTB
);
2086 /* savecol will now be length of the tab. */
2087 savecol
-= tp
->t_column
;
2088 tp
->t_column
+= savecol
;
2090 savecol
= 8; /* overflow screw */
2091 while (--savecol
>= 0)
2092 (void)ttyoutput('\b', tp
);
2095 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2096 (void)kprintf(PANICSTR
, c
, CCLASS(c
));
2098 panic(PANICSTR
, c
, CCLASS(c
));
2102 } else if (ISSET(tp
->t_lflag
, ECHOPRT
)) {
2103 if (!ISSET(tp
->t_state
, TS_ERASE
)) {
2104 SET(tp
->t_state
, TS_ERASE
);
2105 (void)ttyoutput('\\', tp
);
2109 ttyecho(tp
->t_cc
[VERASE
], tp
);
2111 * This code may be executed not only when an ERASE key
2112 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2113 * So, I didn't think it was worthwhile to pass the extra
2114 * information (which would need an extra parameter,
2115 * changing every call) needed to distinguish the ERASE2
2116 * case from the ERASE.
2123 * Back over cnt characters, erasing them.
2126 ttyrubo(struct tty
*tp
, int cnt
)
2130 (void)ttyoutput('\b', tp
);
2131 (void)ttyoutput(' ', tp
);
2132 (void)ttyoutput('\b', tp
);
2138 * Reprint the rawq line. Note, it is assumed that c_cc has already
2142 ttyretype(struct tty
*tp
)
2147 /* Echo the reprint character. */
2148 if (tp
->t_cc
[VREPRINT
] != _POSIX_VDISABLE
)
2149 ttyecho(tp
->t_cc
[VREPRINT
], tp
);
2151 (void)ttyoutput('\n', tp
);
2155 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2156 * BIT OF FIRST CHAR.
2159 for (cp
= tp
->t_canq
.c_cf
, c
= (cp
!= NULL
? *cp
: 0);
2160 cp
!= NULL
; cp
= nextc(&tp
->t_canq
, cp
, &c
))
2162 for (cp
= tp
->t_rawq
.c_cf
, c
= (cp
!= NULL
? *cp
: 0);
2163 cp
!= NULL
; cp
= nextc(&tp
->t_rawq
, cp
, &c
))
2165 CLR(tp
->t_state
, TS_ERASE
);
2168 tp
->t_rocount
= tp
->t_rawq
.c_cc
;
2173 * Echo a typed character to the terminal.
2176 ttyecho(int c
, struct tty
*tp
)
2179 if (!ISSET(tp
->t_state
, TS_CNTTB
))
2180 CLR(tp
->t_lflag
, FLUSHO
);
2181 if ((!ISSET(tp
->t_lflag
, ECHO
) &&
2182 (c
!= '\n' || !ISSET(tp
->t_lflag
, ECHONL
))) ||
2183 ISSET(tp
->t_lflag
, EXTPROC
))
2185 if (ISSET(tp
->t_lflag
, ECHOCTL
) &&
2186 ((ISSET(c
, TTY_CHARMASK
) <= 037 && c
!= '\t' && c
!= '\n') ||
2187 ISSET(c
, TTY_CHARMASK
) == 0177)) {
2188 (void)ttyoutput('^', tp
);
2189 CLR(c
, ~TTY_CHARMASK
);
2195 (void)ttyoutput(c
, tp
);
2199 * Wake up any readers on a tty.
2202 ttwakeup(struct tty
*tp
)
2205 if (tp
->t_rsel
.si_pid
!= 0)
2206 selwakeup(&tp
->t_rsel
);
2207 if (ISSET(tp
->t_state
, TS_ASYNC
) && tp
->t_sigio
!= NULL
)
2208 pgsigio(tp
->t_sigio
, SIGIO
, (tp
->t_session
!= NULL
));
2209 wakeup(TSA_HUP_OR_INPUT(tp
));
2210 KNOTE(&tp
->t_rsel
.si_note
, 0);
2214 * Wake up any writers on a tty.
2217 ttwwakeup(struct tty
*tp
)
2220 if (tp
->t_wsel
.si_pid
!= 0 && tp
->t_outq
.c_cc
<= tp
->t_olowat
)
2221 selwakeup(&tp
->t_wsel
);
2222 if (ISSET(tp
->t_state
, TS_ASYNC
) && tp
->t_sigio
!= NULL
)
2223 pgsigio(tp
->t_sigio
, SIGIO
, (tp
->t_session
!= NULL
));
2224 if (ISSET(tp
->t_state
, TS_BUSY
| TS_SO_OCOMPLETE
) ==
2225 TS_SO_OCOMPLETE
&& tp
->t_outq
.c_cc
== 0) {
2226 CLR(tp
->t_state
, TS_SO_OCOMPLETE
);
2227 wakeup(TSA_OCOMPLETE(tp
));
2229 if (ISSET(tp
->t_state
, TS_SO_OLOWAT
) &&
2230 tp
->t_outq
.c_cc
<= tp
->t_olowat
) {
2231 CLR(tp
->t_state
, TS_SO_OLOWAT
);
2232 wakeup(TSA_OLOWAT(tp
));
2234 KNOTE(&tp
->t_wsel
.si_note
, 0);
2238 * Look up a code for a specified speed in a conversion table;
2239 * used by drivers to map software speed values to hardware parameters.
2242 ttspeedtab(int speed
, struct speedtab
*table
)
2245 for ( ; table
->sp_speed
!= -1; table
++)
2246 if (table
->sp_speed
== speed
)
2247 return (table
->sp_code
);
2252 * Set input and output watermarks and buffer sizes. For input, the
2253 * high watermark is about one second's worth of input above empty, the
2254 * low watermark is slightly below high water, and the buffer size is a
2255 * driver-dependent amount above high water. For output, the watermarks
2256 * are near the ends of the buffer, with about 1 second's worth of input
2257 * between them. All this only applies to the standard line discipline.
2260 ttsetwater(struct tty
*tp
)
2262 int cps
, ttmaxhiwat
, x
;
2265 clist_alloc_cblocks(&tp
->t_canq
, TTYHOG
, 512);
2266 switch (tp
->t_ispeedwat
) {
2268 cps
= tp
->t_ispeed
/ 10;
2272 * This case is for old drivers that don't know about
2273 * t_ispeedwat. Arrange for them to get the old buffer
2274 * sizes and watermarks.
2276 cps
= TTYHOG
- 2 * 256;
2277 tp
->t_ififosize
= 2 * 256;
2280 cps
= tp
->t_ispeedwat
/ 10;
2284 tp
->t_ilowat
= 7 * cps
/ 8;
2285 x
= cps
+ tp
->t_ififosize
;
2286 clist_alloc_cblocks(&tp
->t_rawq
, x
, x
);
2289 switch (tp
->t_ospeedwat
) {
2291 cps
= tp
->t_ospeed
/ 10;
2292 ttmaxhiwat
= 2 * TTMAXHIWAT
;
2295 cps
= tp
->t_ospeed
/ 10;
2296 ttmaxhiwat
= TTMAXHIWAT
;
2299 cps
= tp
->t_ospeedwat
/ 10;
2300 ttmaxhiwat
= 8 * TTMAXHIWAT
;
2303 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2304 tp
->t_olowat
= x
= CLAMP(cps
/ 2, TTMAXLOWAT
, TTMINLOWAT
);
2306 x
= CLAMP(x
, ttmaxhiwat
, TTMINHIWAT
); /* XXX clamps are too magic */
2307 tp
->t_ohiwat
= roundup(x
, CBSIZE
); /* XXX for compat */
2308 x
= imax(tp
->t_ohiwat
, TTMAXHIWAT
); /* XXX for compat/safety */
2310 clist_alloc_cblocks(&tp
->t_outq
, x
, x
);
2315 * Report on state of foreground process group.
2318 ttyinfo(struct tty
*tp
)
2320 struct proc
*p
, *pick
;
2325 if (ttycheckoutq(tp
,0) == 0)
2329 * We always print the load average, then figure out what else to
2330 * print based on the state of the current process group.
2332 tmp
= (averunnable
.ldavg
[0] * 100 + FSCALE
/ 2) >> FSHIFT
;
2333 ttyprintf(tp
, "load: %d.%02d ", tmp
/ 100, tmp
% 100);
2335 if (tp
->t_session
== NULL
) {
2336 ttyprintf(tp
, "not a controlling terminal\n");
2337 } else if (tp
->t_pgrp
== NULL
) {
2338 ttyprintf(tp
, "no foreground process group\n");
2339 } else if ((p
= LIST_FIRST(&tp
->t_pgrp
->pg_members
)) == 0) {
2340 ttyprintf(tp
, "empty foreground process group\n");
2343 * Pick an interesting process. Note that certain elements,
2344 * in particular the wmesg, require a critical section for
2345 * safe access (YYY and we are still not MP safe).
2347 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2357 /* XXX lwp should compare lwps */
2359 for (pick
= NULL
; p
!= 0; p
= LIST_NEXT(p
, p_pglist
)) {
2360 if (proc_compare(pick
, p
))
2365 lp
= FIRST_LWP_IN_PROC(pick
);
2367 ttyprintf(tp
, "foreground process without lwp\n");
2373 * Figure out what wait/process-state message, and command
2377 * XXX lwp This is a horrible mixture. We need to rework this
2378 * as soon as lwps have their own runnable status.
2380 if (pick
->p_flag
& P_WEXIT
)
2382 else if (lp
->lwp_stat
== LSRUN
)
2384 else if (pick
->p_stat
== SIDL
)
2386 else if (lp
->lwp_wmesg
) /* lwp_thread must not be NULL */
2387 str
= lp
->lwp_wmesg
;
2391 ksnprintf(buf
, sizeof(buf
), "cmd: %s %d [%s]",
2392 pick
->p_comm
, pick
->p_pid
, str
);
2395 * Calculate cpu usage, percent cpu, and cmsz. Note that
2396 * 'pick' becomes invalid the moment we exit the critical
2399 if (lp
->lwp_thread
&& (pick
->p_flag
& P_SWAPPEDOUT
) == 0) {
2400 calcru_proc(pick
, &ru
);
2406 pctcpu
= (lp
->lwp_pctcpu
* 10000 + FSCALE
/ 2) >> FSHIFT
;
2408 if (pick
->p_stat
== SIDL
|| pick
->p_stat
== SZOMB
)
2411 vmsz
= pgtok(vmspace_resident_count(pick
->p_vmspace
));
2418 ttyprintf(tp
, " %s ", buf
);
2419 ttyprintf(tp
, "%ld.%02ldu ",
2420 ru
.ru_utime
.tv_sec
, ru
.ru_utime
.tv_usec
/ 10000);
2421 ttyprintf(tp
, "%ld.%02lds ",
2422 ru
.ru_stime
.tv_sec
, ru
.ru_stime
.tv_usec
/ 10000);
2423 ttyprintf(tp
, "%d%% %ldk\n", pctcpu
/ 100, vmsz
);
2425 tp
->t_rocount
= 0; /* so pending input will be retyped if BS */
2429 * Returns 1 if p2 is "better" than p1
2431 * The algorithm for picking the "interesting" process is thus:
2433 * 1) Only foreground processes are eligible - implied.
2434 * 2) Runnable processes are favored over anything else. The runner
2435 * with the highest cpu utilization is picked (p_cpticks). Ties are
2436 * broken by picking the highest pid.
2437 * 3) The sleeper with the shortest sleep time is next. With ties,
2438 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2439 * 4) Further ties are broken by picking the highest pid.
2441 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2442 #define TESTAB(a, b) ((a)<<1 | (b))
2448 proc_compare(struct proc
*p1
, struct proc
*p2
)
2450 struct lwp
*lp1
, *lp2
;
2455 lp1
= FIRST_LWP_IN_PROC(p1
);
2456 lp2
= FIRST_LWP_IN_PROC(p2
);
2459 * see if at least one of them is runnable
2461 switch (TESTAB(ISRUN(lp1
), ISRUN(lp2
))) {
2468 * tie - favor one with highest recent cpu utilization
2470 if (lp2
->lwp_cpticks
> lp1
->lwp_cpticks
)
2472 if (lp1
->lwp_cpticks
> lp2
->lwp_cpticks
)
2474 return (p2
->p_pid
> p1
->p_pid
); /* tie - return highest pid */
2479 switch (TESTAB(p1
->p_stat
== SZOMB
, p2
->p_stat
== SZOMB
)) {
2485 return (p2
->p_pid
> p1
->p_pid
); /* tie - return highest pid */
2488 * pick the one with the smallest sleep time
2490 if (lp2
->lwp_slptime
> lp1
->lwp_slptime
)
2492 if (lp1
->lwp_slptime
> lp2
->lwp_slptime
)
2495 * favor one sleeping in a non-interruptible sleep
2497 if (lp1
->lwp_flag
& LWP_SINTR
&& (lp2
->lwp_flag
& LWP_SINTR
) == 0)
2499 if (lp2
->lwp_flag
& LWP_SINTR
&& (lp1
->lwp_flag
& LWP_SINTR
) == 0)
2501 return (p2
->p_pid
> p1
->p_pid
); /* tie - return highest pid */
2505 * Output char to tty; console putchar style.
2508 tputchar(int c
, struct tty
*tp
)
2511 if (!ISSET(tp
->t_state
, TS_CONNECTED
)) {
2516 (void)ttyoutput('\r', tp
);
2517 (void)ttyoutput(c
, tp
);
2524 * Sleep on chan, returning ERESTART if tty changed while we napped and
2525 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2526 * the tty is revoked, restarting a pending call will redo validation done
2527 * at the start of the call.
2530 ttysleep(struct tty
*tp
, void *chan
, int slpflags
, char *wmesg
, int timo
)
2536 error
= tsleep(chan
, slpflags
, wmesg
, timo
);
2539 return (tp
->t_gen
== gen
? 0 : ERESTART
);
2543 * Allocate a tty struct. Clists in the struct will be allocated by
2547 ttymalloc(struct tty
*tp
)
2552 tp
= kmalloc(sizeof *tp
, M_TTYS
, M_WAITOK
|M_ZERO
);
2559 * Free a tty struct. Clists in the struct should have been freed by
2562 * XXX not yet usable: since we support a half-closed state and do not
2563 * ref count the tty reference from the session, it is possible for a
2564 * session to hold a ref on the tty. See TTY_DO_FULL_CLOSE.
2567 ttyfree(struct tty
*tp
)
2574 ttyregister(struct tty
*tp
)
2576 SLIST_INSERT_HEAD(&tty_list
, tp
, t_list
);
2580 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS
)
2584 SLIST_FOREACH(tp
, &tty_list
, t_list
) {
2587 t
.t_dev
= (cdev_t
)dev2udev(t
.t_dev
);
2588 error
= SYSCTL_OUT(req
, (caddr_t
)&t
, sizeof(t
));
2595 SYSCTL_PROC(_kern
, OID_AUTO
, ttys
, CTLTYPE_OPAQUE
|CTLFLAG_RD
,
2596 0, 0, sysctl_kern_ttys
, "S,tty", "All struct ttys");
2599 nottystop(struct tty
*tp
, int rw
)
2606 ttyread(struct dev_read_args
*ap
)
2610 tp
= ap
->a_head
.a_dev
->si_tty
;
2613 return ((*linesw
[tp
->t_line
].l_read
)(tp
, ap
->a_uio
, ap
->a_ioflag
));
2617 ttywrite(struct dev_write_args
*ap
)
2621 tp
= ap
->a_head
.a_dev
->si_tty
;
2624 return ((*linesw
[tp
->t_line
].l_write
)(tp
, ap
->a_uio
, ap
->a_ioflag
));