FreeBSD/Linux Kernel Cross Reference
sys/kern/tty.c
1 /*-
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.
9 *
10 * Copyright (c) 2002 Networks Associates Technologies, Inc.
11 * All rights reserved.
12 *
13 * Portions of this software were developed for the FreeBSD Project by
14 * ThinkSec AS and NAI Labs, the Security Research Division of Network
15 * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
16 * ("CBOSS"), as part of the DARPA CHATS research program.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 4. Neither the name of the University nor the names of its contributors
27 * may be used to endorse or promote products derived from this software
28 * without specific prior written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
31 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
34 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 * SUCH DAMAGE.
41 *
42 * @(#)tty.c 8.8 (Berkeley) 1/21/94
43 */
44
45 /*-
46 * TODO:
47 * o Fix races for sending the start char in ttyflush().
48 * o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
49 * With luck, there will be MIN chars before select() returns().
50 * o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
51 * o Don't allow input in TS_ZOMBIE case. It would be visible through
52 * FIONREAD.
53 * o Do the new sio locking stuff here and use it to avoid special
54 * case for EXTPROC?
55 * o Lock PENDIN too?
56 * o Move EXTPROC and/or PENDIN to t_state?
57 * o Wrap most of ttioctl in spltty/splx.
58 * o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
59 * o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
60 * o Don't allow certain termios flags to affect disciplines other
61 * than TTYDISC. Cancel their effects before switch disciplines
62 * and ignore them if they are set while we are in another
63 * discipline.
64 * o Now that historical speed conversions are handled here, don't
65 * do them in drivers.
66 * o Check for TS_CARR_ON being set while everything is closed and not
67 * waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
68 * so it would live until the next open even if carrier drops.
69 * o Restore TS_WOPEN since it is useful in pstat. It must be cleared
70 * only when _all_ openers leave open().
71 */
72
73 #include <sys/cdefs.h>
74 __FBSDID("$FreeBSD: src/sys/kern/tty.c,v 1.228.2.5 2005/05/07 17:47:39 scottl Exp $");
75
76 #include "opt_compat.h"
77 #include "opt_tty.h"
78
79 #include <sys/param.h>
80 #include <sys/systm.h>
81 #include <sys/filio.h>
82 #include <sys/lock.h>
83 #include <sys/mutex.h>
84 #include <sys/namei.h>
85 #include <sys/sx.h>
86 #ifndef BURN_BRIDGES
87 #if defined(COMPAT_43)
88 #include <sys/ioctl_compat.h>
89 #endif
90 #endif
91 #include <sys/proc.h>
92 #define TTYDEFCHARS
93 #include <sys/tty.h>
94 #undef TTYDEFCHARS
95 #include <sys/fcntl.h>
96 #include <sys/conf.h>
97 #include <sys/poll.h>
98 #include <sys/kernel.h>
99 #include <sys/vnode.h>
100 #include <sys/serial.h>
101 #include <sys/signalvar.h>
102 #include <sys/resourcevar.h>
103 #include <sys/malloc.h>
104 #include <sys/filedesc.h>
105 #include <sys/sched.h>
106 #include <sys/sysctl.h>
107
108 #include <vm/vm.h>
109 #include <vm/pmap.h>
110 #include <vm/vm_map.h>
111
112 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
113
114 long tk_cancc;
115 long tk_nin;
116 long tk_nout;
117 long tk_rawcc;
118
119 static int proc_compare(struct proc *p1, struct proc *p2);
120 static int ttnread(struct tty *tp);
121 static void ttyecho(int c, struct tty *tp);
122 static int ttyoutput(int c, struct tty *tp);
123 static void ttypend(struct tty *tp);
124 static void ttyretype(struct tty *tp);
125 static void ttyrub(int c, struct tty *tp);
126 static void ttyrubo(struct tty *tp, int cnt);
127 static void ttyunblock(struct tty *tp);
128 static int ttywflush(struct tty *tp);
129 static int filt_ttyread(struct knote *kn, long hint);
130 static void filt_ttyrdetach(struct knote *kn);
131 static int filt_ttywrite(struct knote *kn, long hint);
132 static void filt_ttywdetach(struct knote *kn);
133
134 /*
135 * Table with character classes and parity. The 8th bit indicates parity,
136 * the 7th bit indicates the character is an alphameric or underscore (for
137 * ALTWERASE), and the low 6 bits indicate delay type. If the low 6 bits
138 * are 0 then the character needs no special processing on output; classes
139 * other than 0 might be translated or (not currently) require delays.
140 */
141 #define E 0x00 /* Even parity. */
142 #define O 0x80 /* Odd parity. */
143 #define PARITY(c) (char_type[c] & O)
144
145 #define ALPHA 0x40 /* Alpha or underscore. */
146 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
147
148 #define CCLASSMASK 0x3f
149 #define CCLASS(c) (char_type[c] & CCLASSMASK)
150
151 #define BS BACKSPACE
152 #define CC CONTROL
153 #define CR RETURN
154 #define NA ORDINARY | ALPHA
155 #define NL NEWLINE
156 #define NO ORDINARY
157 #define TB TAB
158 #define VT VTAB
159
160 static u_char const char_type[] = {
161 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
162 O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
163 O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
164 E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
165 O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
166 E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
167 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
168 O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
169 O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
170 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
171 E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
172 O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
173 E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
174 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
175 O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
176 E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
177 /*
178 * Meta chars; should be settable per character set;
179 * for now, treat them all as normal characters.
180 */
181 NA, NA, NA, NA, NA, NA, NA, NA,
182 NA, NA, NA, NA, NA, NA, NA, NA,
183 NA, NA, NA, NA, NA, NA, NA, NA,
184 NA, NA, NA, NA, NA, NA, NA, NA,
185 NA, NA, NA, NA, NA, NA, NA, NA,
186 NA, NA, NA, NA, NA, NA, NA, NA,
187 NA, NA, NA, NA, NA, NA, NA, NA,
188 NA, NA, NA, NA, NA, NA, NA, NA,
189 NA, NA, NA, NA, NA, NA, NA, NA,
190 NA, NA, NA, NA, NA, NA, NA, NA,
191 NA, NA, NA, NA, NA, NA, NA, NA,
192 NA, NA, NA, NA, NA, NA, NA, NA,
193 NA, NA, NA, NA, NA, NA, NA, NA,
194 NA, NA, NA, NA, NA, NA, NA, NA,
195 NA, NA, NA, NA, NA, NA, NA, NA,
196 NA, NA, NA, NA, NA, NA, NA, NA,
197 };
198 #undef BS
199 #undef CC
200 #undef CR
201 #undef NA
202 #undef NL
203 #undef NO
204 #undef TB
205 #undef VT
206
207 /* Macros to clear/set/test flags. */
208 #define SET(t, f) (t) |= (f)
209 #define CLR(t, f) (t) &= ~(f)
210 #define ISSET(t, f) ((t) & (f))
211
212 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
213 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
214
215 /*
216 * list of struct tty where pstat(8) can pick it up with sysctl
217 *
218 * The lock order is to grab the list mutex before the tty mutex.
219 * Together with additions going on the tail of the list, this allows
220 * the sysctl to avoid doing retries.
221 */
222 static TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
223 static struct mtx tty_list_mutex;
224
225 static int drainwait = 5*60;
226 SYSCTL_INT(_kern, OID_AUTO, drainwait, CTLFLAG_RW, &drainwait,
227 0, "Output drain timeout in seconds");
228
229 /*
230 * Initial open of tty, or (re)entry to standard tty line discipline.
231 */
232 int
233 tty_open(struct cdev *device, struct tty *tp)
234 {
235 int s;
236
237 s = spltty();
238 tp->t_dev = device;
239 tp->t_hotchar = 0;
240 if (!ISSET(tp->t_state, TS_ISOPEN)) {
241 ttyref(tp);
242 SET(tp->t_state, TS_ISOPEN);
243 if (ISSET(tp->t_cflag, CLOCAL))
244 SET(tp->t_state, TS_CONNECTED);
245 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
246 }
247 /* XXX don't hang forever on output */
248 if (tp->t_timeout < 0)
249 tp->t_timeout = drainwait*hz;
250 ttsetwater(tp);
251 splx(s);
252 return (0);
253 }
254
255 /*
256 * Handle close() on a tty line: flush and set to initial state,
257 * bumping generation number so that pending read/write calls
258 * can detect recycling of the tty.
259 * XXX our caller should have done `spltty(); l_close(); tty_close();'
260 * and l_close() should have flushed, but we repeat the spltty() and
261 * the flush in case there are buggy callers.
262 */
263 int
264 tty_close(struct tty *tp)
265 {
266 int s;
267
268 funsetown(&tp->t_sigio);
269 s = spltty();
270 if (constty == tp)
271 constty_clear();
272
273 ttyflush(tp, FREAD | FWRITE);
274 clist_free_cblocks(&tp->t_canq);
275 clist_free_cblocks(&tp->t_outq);
276 clist_free_cblocks(&tp->t_rawq);
277
278 tp->t_gen++;
279 tp->t_line = TTYDISC;
280 tp->t_hotchar = 0;
281 tp->t_pgrp = NULL;
282 tp->t_session = NULL;
283 tp->t_state = 0;
284 knlist_clear(&tp->t_rsel.si_note, 0);
285 knlist_clear(&tp->t_wsel.si_note, 0);
286 ttyrel(tp);
287 splx(s);
288 return (0);
289 }
290
291 #define FLUSHQ(q) { \
292 if ((q)->c_cc) \
293 ndflush(q, (q)->c_cc); \
294 }
295
296 /* Is 'c' a line delimiter ("break" character)? */
297 #define TTBREAKC(c, lflag) \
298 ((c) == '\n' || (((c) == cc[VEOF] || \
299 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
300 (c) != _POSIX_VDISABLE))
301
302 /*
303 * Process input of a single character received on a tty.
304 */
305 int
306 ttyinput(int c, struct tty *tp)
307 {
308 tcflag_t iflag, lflag;
309 cc_t *cc;
310 int i, err;
311
312 /*
313 * If input is pending take it first.
314 */
315 lflag = tp->t_lflag;
316 if (ISSET(lflag, PENDIN))
317 ttypend(tp);
318 /*
319 * Gather stats.
320 */
321 if (ISSET(lflag, ICANON)) {
322 ++tk_cancc;
323 ++tp->t_cancc;
324 } else {
325 ++tk_rawcc;
326 ++tp->t_rawcc;
327 }
328 ++tk_nin;
329
330 /*
331 * Block further input iff:
332 * current input > threshold AND input is available to user program
333 * AND input flow control is enabled and not yet invoked.
334 * The 3 is slop for PARMRK.
335 */
336 iflag = tp->t_iflag;
337 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
338 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
339 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
340 !ISSET(tp->t_state, TS_TBLOCK))
341 ttyblock(tp);
342
343 /* Handle exceptional conditions (break, parity, framing). */
344 cc = tp->t_cc;
345 err = (ISSET(c, TTY_ERRORMASK));
346 if (err) {
347 CLR(c, TTY_ERRORMASK);
348 if (ISSET(err, TTY_BI)) {
349 if (ISSET(iflag, IGNBRK))
350 return (0);
351 if (ISSET(iflag, BRKINT)) {
352 ttyflush(tp, FREAD | FWRITE);
353 if (tp->t_pgrp != NULL) {
354 PGRP_LOCK(tp->t_pgrp);
355 pgsignal(tp->t_pgrp, SIGINT, 1);
356 PGRP_UNLOCK(tp->t_pgrp);
357 }
358 goto endcase;
359 }
360 if (ISSET(iflag, PARMRK))
361 goto parmrk;
362 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
363 || ISSET(err, TTY_FE)) {
364 if (ISSET(iflag, IGNPAR))
365 return (0);
366 else if (ISSET(iflag, PARMRK)) {
367 parmrk:
368 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
369 MAX_INPUT - 3)
370 goto input_overflow;
371 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
372 (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
373 (void)putc(c | TTY_QUOTE, &tp->t_rawq);
374 goto endcase;
375 } else
376 c = 0;
377 }
378 }
379
380 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
381 CLR(c, 0x80);
382 if (!ISSET(lflag, EXTPROC)) {
383 /*
384 * Check for literal nexting very first
385 */
386 if (ISSET(tp->t_state, TS_LNCH)) {
387 SET(c, TTY_QUOTE);
388 CLR(tp->t_state, TS_LNCH);
389 }
390 /*
391 * Scan for special characters. This code
392 * is really just a big case statement with
393 * non-constant cases. The bottom of the
394 * case statement is labeled ``endcase'', so goto
395 * it after a case match, or similar.
396 */
397
398 /*
399 * Control chars which aren't controlled
400 * by ICANON, ISIG, or IXON.
401 */
402 if (ISSET(lflag, IEXTEN)) {
403 if (CCEQ(cc[VLNEXT], c)) {
404 if (ISSET(lflag, ECHO)) {
405 if (ISSET(lflag, ECHOE)) {
406 (void)ttyoutput('^', tp);
407 (void)ttyoutput('\b', tp);
408 } else
409 ttyecho(c, tp);
410 }
411 SET(tp->t_state, TS_LNCH);
412 goto endcase;
413 }
414 if (CCEQ(cc[VDISCARD], c)) {
415 if (ISSET(lflag, FLUSHO))
416 CLR(tp->t_lflag, FLUSHO);
417 else {
418 ttyflush(tp, FWRITE);
419 ttyecho(c, tp);
420 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
421 ttyretype(tp);
422 SET(tp->t_lflag, FLUSHO);
423 }
424 goto startoutput;
425 }
426 }
427 /*
428 * Signals.
429 */
430 if (ISSET(lflag, ISIG)) {
431 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
432 if (!ISSET(lflag, NOFLSH))
433 ttyflush(tp, FREAD | FWRITE);
434 ttyecho(c, tp);
435 if (tp->t_pgrp != NULL) {
436 PGRP_LOCK(tp->t_pgrp);
437 pgsignal(tp->t_pgrp,
438 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
439 PGRP_UNLOCK(tp->t_pgrp);
440 }
441 goto endcase;
442 }
443 if (CCEQ(cc[VSUSP], c)) {
444 if (!ISSET(lflag, NOFLSH))
445 ttyflush(tp, FREAD);
446 ttyecho(c, tp);
447 if (tp->t_pgrp != NULL) {
448 PGRP_LOCK(tp->t_pgrp);
449 pgsignal(tp->t_pgrp, SIGTSTP, 1);
450 PGRP_UNLOCK(tp->t_pgrp);
451 }
452 goto endcase;
453 }
454 }
455 /*
456 * Handle start/stop characters.
457 */
458 if (ISSET(iflag, IXON)) {
459 if (CCEQ(cc[VSTOP], c)) {
460 if (!ISSET(tp->t_state, TS_TTSTOP)) {
461 SET(tp->t_state, TS_TTSTOP);
462 (*tp->t_stop)(tp, 0);
463 return (0);
464 }
465 if (!CCEQ(cc[VSTART], c))
466 return (0);
467 /*
468 * if VSTART == VSTOP then toggle
469 */
470 goto endcase;
471 }
472 if (CCEQ(cc[VSTART], c))
473 goto restartoutput;
474 }
475 /*
476 * IGNCR, ICRNL, & INLCR
477 */
478 if (c == '\r') {
479 if (ISSET(iflag, IGNCR))
480 return (0);
481 else if (ISSET(iflag, ICRNL))
482 c = '\n';
483 } else if (c == '\n' && ISSET(iflag, INLCR))
484 c = '\r';
485 }
486 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
487 /*
488 * From here on down canonical mode character
489 * processing takes place.
490 */
491 /*
492 * erase or erase2 (^H / ^?)
493 */
494 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
495 if (tp->t_rawq.c_cc)
496 ttyrub(unputc(&tp->t_rawq), tp);
497 goto endcase;
498 }
499 /*
500 * kill (^U)
501 */
502 if (CCEQ(cc[VKILL], c)) {
503 if (ISSET(lflag, ECHOKE) &&
504 tp->t_rawq.c_cc == tp->t_rocount &&
505 !ISSET(lflag, ECHOPRT))
506 while (tp->t_rawq.c_cc)
507 ttyrub(unputc(&tp->t_rawq), tp);
508 else {
509 ttyecho(c, tp);
510 if (ISSET(lflag, ECHOK) ||
511 ISSET(lflag, ECHOKE))
512 ttyecho('\n', tp);
513 FLUSHQ(&tp->t_rawq);
514 tp->t_rocount = 0;
515 }
516 CLR(tp->t_state, TS_LOCAL);
517 goto endcase;
518 }
519 /*
520 * word erase (^W)
521 */
522 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
523 int ctype;
524
525 /*
526 * erase whitespace
527 */
528 while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
529 ttyrub(c, tp);
530 if (c == -1)
531 goto endcase;
532 /*
533 * erase last char of word and remember the
534 * next chars type (for ALTWERASE)
535 */
536 ttyrub(c, tp);
537 c = unputc(&tp->t_rawq);
538 if (c == -1)
539 goto endcase;
540 if (c == ' ' || c == '\t') {
541 (void)putc(c, &tp->t_rawq);
542 goto endcase;
543 }
544 ctype = ISALPHA(c);
545 /*
546 * erase rest of word
547 */
548 do {
549 ttyrub(c, tp);
550 c = unputc(&tp->t_rawq);
551 if (c == -1)
552 goto endcase;
553 } while (c != ' ' && c != '\t' &&
554 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
555 (void)putc(c, &tp->t_rawq);
556 goto endcase;
557 }
558 /*
559 * reprint line (^R)
560 */
561 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
562 ttyretype(tp);
563 goto endcase;
564 }
565 /*
566 * ^T - kernel info and generate SIGINFO
567 */
568 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
569 if (ISSET(lflag, ISIG) && tp->t_pgrp != NULL) {
570 PGRP_LOCK(tp->t_pgrp);
571 pgsignal(tp->t_pgrp, SIGINFO, 1);
572 PGRP_UNLOCK(tp->t_pgrp);
573 }
574 if (!ISSET(lflag, NOKERNINFO))
575 ttyinfo(tp);
576 goto endcase;
577 }
578 }
579 /*
580 * Check for input buffer overflow
581 */
582 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
583 input_overflow:
584 if (ISSET(iflag, IMAXBEL)) {
585 if (tp->t_outq.c_cc < tp->t_ohiwat)
586 (void)ttyoutput(CTRL('g'), tp);
587 }
588 goto endcase;
589 }
590
591 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
592 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
593 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
594
595 /*
596 * Put data char in q for user and
597 * wakeup on seeing a line delimiter.
598 */
599 if (putc(c, &tp->t_rawq) >= 0) {
600 if (!ISSET(lflag, ICANON)) {
601 ttwakeup(tp);
602 ttyecho(c, tp);
603 goto endcase;
604 }
605 if (TTBREAKC(c, lflag)) {
606 tp->t_rocount = 0;
607 catq(&tp->t_rawq, &tp->t_canq);
608 ttwakeup(tp);
609 } else if (tp->t_rocount++ == 0)
610 tp->t_rocol = tp->t_column;
611 if (ISSET(tp->t_state, TS_ERASE)) {
612 /*
613 * end of prterase \.../
614 */
615 CLR(tp->t_state, TS_ERASE);
616 (void)ttyoutput('/', tp);
617 }
618 i = tp->t_column;
619 ttyecho(c, tp);
620 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
621 /*
622 * Place the cursor over the '^' of the ^D.
623 */
624 i = imin(2, tp->t_column - i);
625 while (i > 0) {
626 (void)ttyoutput('\b', tp);
627 i--;
628 }
629 }
630 }
631 endcase:
632 /*
633 * IXANY means allow any character to restart output.
634 */
635 if (ISSET(tp->t_state, TS_TTSTOP) &&
636 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
637 return (0);
638 restartoutput:
639 CLR(tp->t_lflag, FLUSHO);
640 CLR(tp->t_state, TS_TTSTOP);
641 startoutput:
642 return (ttstart(tp));
643 }
644
645 /*
646 * Output a single character on a tty, doing output processing
647 * as needed (expanding tabs, newline processing, etc.).
648 * Returns < 0 if succeeds, otherwise returns char to resend.
649 * Must be recursive.
650 */
651 static int
652 ttyoutput(int c, struct tty *tp)
653 {
654 tcflag_t oflag;
655 int col, s;
656
657 oflag = tp->t_oflag;
658 if (!ISSET(oflag, OPOST)) {
659 if (ISSET(tp->t_lflag, FLUSHO))
660 return (-1);
661 if (putc(c, &tp->t_outq))
662 return (c);
663 tk_nout++;
664 tp->t_outcc++;
665 return (-1);
666 }
667 /*
668 * Do tab expansion if OXTABS is set. Special case if we external
669 * processing, we don't do the tab expansion because we'll probably
670 * get it wrong. If tab expansion needs to be done, let it happen
671 * externally.
672 */
673 CLR(c, ~TTY_CHARMASK);
674 if (c == '\t' &&
675 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
676 c = 8 - (tp->t_column & 7);
677 if (!ISSET(tp->t_lflag, FLUSHO)) {
678 s = spltty(); /* Don't interrupt tabs. */
679 c -= b_to_q(" ", c, &tp->t_outq);
680 tk_nout += c;
681 tp->t_outcc += c;
682 splx(s);
683 }
684 tp->t_column += c;
685 return (c ? -1 : '\t');
686 }
687 if (c == CEOT && ISSET(oflag, ONOEOT))
688 return (-1);
689
690 /*
691 * Newline translation: if ONLCR is set,
692 * translate newline into "\r\n".
693 */
694 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
695 tk_nout++;
696 tp->t_outcc++;
697 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
698 return (c);
699 }
700 /* If OCRNL is set, translate "\r" into "\n". */
701 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
702 c = '\n';
703 /* If ONOCR is set, don't transmit CRs when on column 0. */
704 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
705 return (-1);
706
707 tk_nout++;
708 tp->t_outcc++;
709 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
710 return (c);
711
712 col = tp->t_column;
713 switch (CCLASS(c)) {
714 case BACKSPACE:
715 if (col > 0)
716 --col;
717 break;
718 case CONTROL:
719 break;
720 case NEWLINE:
721 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
722 col = 0;
723 break;
724 case RETURN:
725 col = 0;
726 break;
727 case ORDINARY:
728 ++col;
729 break;
730 case TAB:
731 col = (col + 8) & ~7;
732 break;
733 }
734 tp->t_column = col;
735 return (-1);
736 }
737
738 /*
739 * Ioctls for all tty devices. Called after line-discipline specific ioctl
740 * has been called to do discipline-specific functions and/or reject any
741 * of these ioctl commands.
742 */
743 /* ARGSUSED */
744 int
745 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
746 {
747 struct proc *p;
748 struct thread *td;
749 struct pgrp *pgrp;
750 int s, error, bits, sig, sig2;
751
752 td = curthread; /* XXX */
753 p = td->td_proc;
754
755 /* If the ioctl involves modification, hang if in the background. */
756 switch (cmd) {
757 case TIOCCBRK:
758 case TIOCCONS:
759 case TIOCDRAIN:
760 case TIOCEXCL:
761 case TIOCFLUSH:
762 #ifdef TIOCHPCL
763 case TIOCHPCL:
764 #endif
765 case TIOCNXCL:
766 case TIOCSBRK:
767 case TIOCSCTTY:
768 case TIOCSDRAINWAIT:
769 case TIOCSETA:
770 case TIOCSETAF:
771 case TIOCSETAW:
772 case TIOCSETD:
773 case TIOCSPGRP:
774 case TIOCSTART:
775 case TIOCSTAT:
776 case TIOCSTI:
777 case TIOCSTOP:
778 case TIOCSWINSZ:
779 #ifndef BURN_BRIDGES
780 #if defined(COMPAT_43)
781 case TIOCLBIC:
782 case TIOCLBIS:
783 case TIOCLSET:
784 case TIOCSETC:
785 case OTIOCSETD:
786 case TIOCSETN:
787 case TIOCSETP:
788 case TIOCSLTC:
789 #endif
790 #endif
791 sx_slock(&proctree_lock);
792 PROC_LOCK(p);
793 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
794 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
795 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
796 pgrp = p->p_pgrp;
797 PROC_UNLOCK(p);
798 if (pgrp->pg_jobc == 0) {
799 sx_sunlock(&proctree_lock);
800 return (EIO);
801 }
802 PGRP_LOCK(pgrp);
803 sx_sunlock(&proctree_lock);
804 pgsignal(pgrp, SIGTTOU, 1);
805 PGRP_UNLOCK(pgrp);
806 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
807 0);
808 if (error)
809 return (error);
810 sx_slock(&proctree_lock);
811 PROC_LOCK(p);
812 }
813 PROC_UNLOCK(p);
814 sx_sunlock(&proctree_lock);
815 break;
816 }
817
818 if (tp->t_break != NULL) {
819 switch (cmd) {
820 case TIOCSBRK:
821 tp->t_break(tp, 1);
822 return (0);
823 case TIOCCBRK:
824 tp->t_break(tp, 0);
825 return (0);
826 default:
827 break;
828 }
829 }
830
831 if (tp->t_modem != NULL) {
832 switch (cmd) {
833 case TIOCSDTR:
834 tp->t_modem(tp, SER_DTR, 0);
835 return (0);
836 case TIOCCDTR:
837 tp->t_modem(tp, 0, SER_DTR);
838 return (0);
839 case TIOCMSET:
840 bits = *(int *)data;
841 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
842 sig2 = ((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1;
843 tp->t_modem(tp, sig, sig2);
844 return (0);
845 case TIOCMBIS:
846 bits = *(int *)data;
847 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
848 tp->t_modem(tp, sig, 0);
849 return (0);
850 case TIOCMBIC:
851 bits = *(int *)data;
852 sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
853 tp->t_modem(tp, 0, sig);
854 return (0);
855 case TIOCMGET:
856 sig = tp->t_modem(tp, 0, 0);
857 /* See <sys/serial.h. for the "<< 1" stuff */
858 bits = TIOCM_LE + (sig << 1);
859 *(int *)data = bits;
860 return (0);
861 default:
862 break;
863 }
864 }
865
866 switch (cmd) { /* Process the ioctl. */
867 case FIOASYNC: /* set/clear async i/o */
868 s = spltty();
869 if (*(int *)data)
870 SET(tp->t_state, TS_ASYNC);
871 else
872 CLR(tp->t_state, TS_ASYNC);
873 splx(s);
874 break;
875 case FIONBIO: /* set/clear non-blocking i/o */
876 break; /* XXX: delete. */
877 case FIONREAD: /* get # bytes to read */
878 s = spltty();
879 *(int *)data = ttnread(tp);
880 splx(s);
881 break;
882
883 case FIOSETOWN:
884 /*
885 * Policy -- Don't allow FIOSETOWN on someone else's
886 * controlling tty
887 */
888 if (tp->t_session != NULL && !isctty(p, tp))
889 return (ENOTTY);
890
891 error = fsetown(*(int *)data, &tp->t_sigio);
892 if (error)
893 return (error);
894 break;
895 case FIOGETOWN:
896 if (tp->t_session != NULL && !isctty(p, tp))
897 return (ENOTTY);
898 *(int *)data = fgetown(&tp->t_sigio);
899 break;
900
901 case TIOCEXCL: /* set exclusive use of tty */
902 s = spltty();
903 SET(tp->t_state, TS_XCLUDE);
904 splx(s);
905 break;
906 case TIOCFLUSH: { /* flush buffers */
907 int flags = *(int *)data;
908
909 if (flags == 0)
910 flags = FREAD | FWRITE;
911 else
912 flags &= FREAD | FWRITE;
913 ttyflush(tp, flags);
914 break;
915 }
916 case TIOCCONS: /* become virtual console */
917 if (*(int *)data) {
918 struct nameidata nid;
919
920 if (constty && constty != tp &&
921 ISSET(constty->t_state, TS_CONNECTED))
922 return (EBUSY);
923
924 /* Ensure user can open the real console. */
925 NDINIT(&nid, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE,
926 "/dev/console", td);
927 if ((error = namei(&nid)) != 0)
928 return (error);
929 NDFREE(&nid, NDF_ONLY_PNBUF);
930 error = VOP_ACCESS(nid.ni_vp, VREAD, td->td_ucred, td);
931 vput(nid.ni_vp);
932 if (error)
933 return (error);
934
935 constty_set(tp);
936 } else if (tp == constty)
937 constty_clear();
938 break;
939 case TIOCDRAIN: /* wait till output drained */
940 error = ttywait(tp);
941 if (error)
942 return (error);
943 break;
944 case TIOCGETA: { /* get termios struct */
945 struct termios *t = (struct termios *)data;
946
947 bcopy(&tp->t_termios, t, sizeof(struct termios));
948 break;
949 }
950 case TIOCGETD: /* get line discipline */
951 *(int *)data = tp->t_line;
952 break;
953 case TIOCGWINSZ: /* get window size */
954 *(struct winsize *)data = tp->t_winsize;
955 break;
956 case TIOCGPGRP: /* get pgrp of tty */
957 if (!isctty(p, tp))
958 return (ENOTTY);
959 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
960 break;
961 #ifdef TIOCHPCL
962 case TIOCHPCL: /* hang up on last close */
963 s = spltty();
964 SET(tp->t_cflag, HUPCL);
965 splx(s);
966 break;
967 #endif
968 case TIOCMGDTRWAIT:
969 *(int *)data = tp->t_dtr_wait * 100 / hz;
970 break;
971 case TIOCMSDTRWAIT:
972 /* must be root since the wait applies to following logins */
973 error = suser(td);
974 if (error)
975 return (error);
976 tp->t_dtr_wait = *(int *)data * hz / 100;
977 break;
978 case TIOCNXCL: /* reset exclusive use of tty */
979 s = spltty();
980 CLR(tp->t_state, TS_XCLUDE);
981 splx(s);
982 break;
983 case TIOCOUTQ: /* output queue size */
984 *(int *)data = tp->t_outq.c_cc;
985 break;
986 case TIOCSETA: /* set termios struct */
987 case TIOCSETAW: /* drain output, set */
988 case TIOCSETAF: { /* drn out, fls in, set */
989 struct termios *t = (struct termios *)data;
990
991 if (t->c_ispeed == 0)
992 t->c_ispeed = t->c_ospeed;
993 if (t->c_ispeed == 0)
994 t->c_ispeed = tp->t_ospeed;
995 if (t->c_ispeed == 0)
996 return (EINVAL);
997 s = spltty();
998 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
999 error = ttywait(tp);
1000 if (error) {
1001 splx(s);
1002 return (error);
1003 }
1004 if (cmd == TIOCSETAF)
1005 ttyflush(tp, FREAD);
1006 }
1007 if (!ISSET(t->c_cflag, CIGNORE)) {
1008 /*
1009 * Set device hardware.
1010 */
1011 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1012 splx(s);
1013 return (error);
1014 }
1015 if (ISSET(t->c_cflag, CLOCAL) &&
1016 !ISSET(tp->t_cflag, CLOCAL)) {
1017 /*
1018 * XXX disconnections would be too hard to
1019 * get rid of without this kludge. The only
1020 * way to get rid of controlling terminals
1021 * is to exit from the session leader.
1022 */
1023 CLR(tp->t_state, TS_ZOMBIE);
1024
1025 wakeup(TSA_CARR_ON(tp));
1026 ttwakeup(tp);
1027 ttwwakeup(tp);
1028 }
1029 if ((ISSET(tp->t_state, TS_CARR_ON) ||
1030 ISSET(t->c_cflag, CLOCAL)) &&
1031 !ISSET(tp->t_state, TS_ZOMBIE))
1032 SET(tp->t_state, TS_CONNECTED);
1033 else
1034 CLR(tp->t_state, TS_CONNECTED);
1035 tp->t_cflag = t->c_cflag;
1036 tp->t_ispeed = t->c_ispeed;
1037 if (t->c_ospeed != 0)
1038 tp->t_ospeed = t->c_ospeed;
1039 ttsetwater(tp);
1040 }
1041 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1042 cmd != TIOCSETAF) {
1043 if (ISSET(t->c_lflag, ICANON))
1044 SET(tp->t_lflag, PENDIN);
1045 else {
1046 /*
1047 * XXX we really shouldn't allow toggling
1048 * ICANON while we're in a non-termios line
1049 * discipline. Now we have to worry about
1050 * panicing for a null queue.
1051 */
1052 if (tp->t_canq.c_cbreserved > 0 &&
1053 tp->t_rawq.c_cbreserved > 0) {
1054 catq(&tp->t_rawq, &tp->t_canq);
1055 /*
1056 * XXX the queue limits may be
1057 * different, so the old queue
1058 * swapping method no longer works.
1059 */
1060 catq(&tp->t_canq, &tp->t_rawq);
1061 }
1062 CLR(tp->t_lflag, PENDIN);
1063 }
1064 ttwakeup(tp);
1065 }
1066 tp->t_iflag = t->c_iflag;
1067 tp->t_oflag = t->c_oflag;
1068 /*
1069 * Make the EXTPROC bit read only.
1070 */
1071 if (ISSET(tp->t_lflag, EXTPROC))
1072 SET(t->c_lflag, EXTPROC);
1073 else
1074 CLR(t->c_lflag, EXTPROC);
1075 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1076 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1077 t->c_cc[VTIME] != tp->t_cc[VTIME])
1078 ttwakeup(tp);
1079 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1080 splx(s);
1081 break;
1082 }
1083 case TIOCSETD: { /* set line discipline */
1084 int t = *(int *)data;
1085 struct cdev *device = tp->t_dev;
1086
1087 if ((u_int)t >= nlinesw)
1088 return (ENXIO);
1089 if (t == tp->t_line)
1090 return (0);
1091 s = spltty();
1092 ttyld_close(tp, flag);
1093 tp->t_line = t;
1094 error = ttyld_open(tp, device);
1095 if (error) {
1096 /*
1097 * If we fail to switch line discipline we cannot
1098 * fall back to the previous, because we can not
1099 * trust that ldisc to open successfully either.
1100 * Fall back to the default ldisc which we know
1101 * will allways succeed.
1102 */
1103 tp->t_line = TTYDISC;
1104 (void)ttyld_open(tp, device);
1105 }
1106 splx(s);
1107 return (error);
1108 break;
1109 }
1110 case TIOCSTART: /* start output, like ^Q */
1111 s = spltty();
1112 if (ISSET(tp->t_state, TS_TTSTOP) ||
1113 ISSET(tp->t_lflag, FLUSHO)) {
1114 CLR(tp->t_lflag, FLUSHO);
1115 CLR(tp->t_state, TS_TTSTOP);
1116 ttstart(tp);
1117 }
1118 splx(s);
1119 break;
1120 case TIOCSTI: /* simulate terminal input */
1121 if ((flag & FREAD) == 0 && suser(td))
1122 return (EPERM);
1123 if (!isctty(p, tp) && suser(td))
1124 return (EACCES);
1125 s = spltty();
1126 ttyld_rint(tp, *(u_char *)data);
1127 splx(s);
1128 break;
1129 case TIOCSTOP: /* stop output, like ^S */
1130 s = spltty();
1131 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1132 SET(tp->t_state, TS_TTSTOP);
1133 (*tp->t_stop)(tp, 0);
1134 }
1135 splx(s);
1136 break;
1137 case TIOCSCTTY: /* become controlling tty */
1138 /* Session ctty vnode pointer set in vnode layer. */
1139 sx_slock(&proctree_lock);
1140 if (!SESS_LEADER(p) ||
1141 ((p->p_session->s_ttyvp || tp->t_session) &&
1142 (tp->t_session != p->p_session))) {
1143 sx_sunlock(&proctree_lock);
1144 return (EPERM);
1145 }
1146 tp->t_session = p->p_session;
1147 tp->t_pgrp = p->p_pgrp;
1148 SESS_LOCK(p->p_session);
1149 ttyref(tp); /* ttyrel(): kern_proc.c:pgdelete() */
1150 p->p_session->s_ttyp = tp;
1151 SESS_UNLOCK(p->p_session);
1152 PROC_LOCK(p);
1153 p->p_flag |= P_CONTROLT;
1154 PROC_UNLOCK(p);
1155 sx_sunlock(&proctree_lock);
1156 break;
1157 case TIOCSPGRP: { /* set pgrp of tty */
1158 sx_slock(&proctree_lock);
1159 pgrp = pgfind(*(int *)data);
1160 if (!isctty(p, tp)) {
1161 if (pgrp != NULL)
1162 PGRP_UNLOCK(pgrp);
1163 sx_sunlock(&proctree_lock);
1164 return (ENOTTY);
1165 }
1166 if (pgrp == NULL) {
1167 sx_sunlock(&proctree_lock);
1168 return (EPERM);
1169 }
1170 PGRP_UNLOCK(pgrp);
1171 if (pgrp->pg_session != p->p_session) {
1172 sx_sunlock(&proctree_lock);
1173 return (EPERM);
1174 }
1175 sx_sunlock(&proctree_lock);
1176 tp->t_pgrp = pgrp;
1177 break;
1178 }
1179 case TIOCSTAT: /* simulate control-T */
1180 s = spltty();
1181 ttyinfo(tp);
1182 splx(s);
1183 break;
1184 case TIOCSWINSZ: /* set window size */
1185 if (bcmp((caddr_t)&tp->t_winsize, data,
1186 sizeof (struct winsize))) {
1187 tp->t_winsize = *(struct winsize *)data;
1188 if (tp->t_pgrp != NULL) {
1189 PGRP_LOCK(tp->t_pgrp);
1190 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1191 PGRP_UNLOCK(tp->t_pgrp);
1192 }
1193 }
1194 break;
1195 case TIOCSDRAINWAIT:
1196 error = suser(td);
1197 if (error)
1198 return (error);
1199 tp->t_timeout = *(int *)data * hz;
1200 wakeup(TSA_OCOMPLETE(tp));
1201 wakeup(TSA_OLOWAT(tp));
1202 break;
1203 case TIOCGDRAINWAIT:
1204 *(int *)data = tp->t_timeout / hz;
1205 break;
1206 default:
1207 #if defined(COMPAT_43)
1208 #ifndef BURN_BRIDGES
1209 return (ttcompat(tp, cmd, data, flag));
1210 #else
1211 return (ENOIOCTL);
1212 #endif
1213 #else
1214 return (ENOIOCTL);
1215 #endif
1216 }
1217 return (0);
1218 }
1219
1220 int
1221 ttypoll(struct cdev *dev, int events, struct thread *td)
1222 {
1223 int s;
1224 int revents = 0;
1225 struct tty *tp;
1226
1227 KASSERT(devsw(dev)->d_flags & D_TTY,
1228 ("ttypoll() called on non D_TTY device (%s)", devtoname(dev)));
1229 tp = dev->si_tty;
1230 KASSERT(tp != NULL,
1231 ("ttypoll(): no tty pointer on device (%s)", devtoname(dev)));
1232 if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
1233 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
1234 | POLLHUP);
1235
1236 s = spltty();
1237 if (events & (POLLIN | POLLRDNORM)) {
1238 if (ISSET(tp->t_state, TS_ZOMBIE))
1239 revents |= (events & (POLLIN | POLLRDNORM)) |
1240 POLLHUP;
1241 else if (ttnread(tp) > 0)
1242 revents |= events & (POLLIN | POLLRDNORM);
1243 else
1244 selrecord(td, &tp->t_rsel);
1245 }
1246 if (events & POLLOUT) {
1247 if (ISSET(tp->t_state, TS_ZOMBIE))
1248 revents |= POLLHUP;
1249 else if (tp->t_outq.c_cc <= tp->t_olowat &&
1250 ISSET(tp->t_state, TS_CONNECTED))
1251 revents |= events & POLLOUT;
1252 else
1253 selrecord(td, &tp->t_wsel);
1254 }
1255 splx(s);
1256 return (revents);
1257 }
1258
1259 static struct filterops ttyread_filtops =
1260 { 1, NULL, filt_ttyrdetach, filt_ttyread };
1261 static struct filterops ttywrite_filtops =
1262 { 1, NULL, filt_ttywdetach, filt_ttywrite };
1263
1264 int
1265 ttykqfilter(struct cdev *dev, struct knote *kn)
1266 {
1267 struct tty *tp;
1268 struct knlist *klist;
1269 int s;
1270
1271 KASSERT(devsw(dev)->d_flags & D_TTY,
1272 ("ttykqfilter() called on non D_TTY device (%s)", devtoname(dev)));
1273 tp = dev->si_tty;
1274 KASSERT(tp != NULL,
1275 ("ttykqfilter(): no tty pointer on device (%s)", devtoname(dev)));
1276 switch (kn->kn_filter) {
1277 case EVFILT_READ:
1278 klist = &tp->t_rsel.si_note;
1279 kn->kn_fop = &ttyread_filtops;
1280 break;
1281 case EVFILT_WRITE:
1282 klist = &tp->t_wsel.si_note;
1283 kn->kn_fop = &ttywrite_filtops;
1284 break;
1285 default:
1286 return (EINVAL);
1287 }
1288
1289 kn->kn_hook = (caddr_t)dev;
1290
1291 s = spltty();
1292 knlist_add(klist, kn, 0);
1293 splx(s);
1294
1295 return (0);
1296 }
1297
1298 static void
1299 filt_ttyrdetach(struct knote *kn)
1300 {
1301 struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1302 int s = spltty();
1303
1304 knlist_remove(&tp->t_rsel.si_note, kn, 0);
1305 splx(s);
1306 }
1307
1308 static int
1309 filt_ttyread(struct knote *kn, long hint)
1310 {
1311 struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1312
1313 kn->kn_data = ttnread(tp);
1314 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1315 kn->kn_flags |= EV_EOF;
1316 return (1);
1317 }
1318 return (kn->kn_data > 0);
1319 }
1320
1321 static void
1322 filt_ttywdetach(struct knote *kn)
1323 {
1324 struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1325 int s = spltty();
1326
1327 knlist_remove(&tp->t_wsel.si_note, kn, 0);
1328 splx(s);
1329 }
1330
1331 static int
1332 filt_ttywrite(struct knote *kn, long hint)
1333 {
1334 struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1335
1336 kn->kn_data = tp->t_outq.c_cc;
1337 if (ISSET(tp->t_state, TS_ZOMBIE))
1338 return (1);
1339 return (kn->kn_data <= tp->t_olowat &&
1340 ISSET(tp->t_state, TS_CONNECTED));
1341 }
1342
1343 /*
1344 * Must be called at spltty().
1345 */
1346 static int
1347 ttnread(struct tty *tp)
1348 {
1349 int nread;
1350
1351 if (ISSET(tp->t_lflag, PENDIN))
1352 ttypend(tp);
1353 nread = tp->t_canq.c_cc;
1354 if (!ISSET(tp->t_lflag, ICANON)) {
1355 nread += tp->t_rawq.c_cc;
1356 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1357 nread = 0;
1358 }
1359 return (nread);
1360 }
1361
1362 /*
1363 * Wait for output to drain.
1364 */
1365 int
1366 ttywait(struct tty *tp)
1367 {
1368 int error, s;
1369
1370 error = 0;
1371 s = spltty();
1372 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1373 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1374 (*tp->t_oproc)(tp);
1375 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1376 ISSET(tp->t_state, TS_CONNECTED)) {
1377 SET(tp->t_state, TS_SO_OCOMPLETE);
1378 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1379 TTOPRI | PCATCH, "ttywai",
1380 tp->t_timeout);
1381 if (error) {
1382 if (error == EWOULDBLOCK)
1383 error = EIO;
1384 break;
1385 }
1386 } else
1387 break;
1388 }
1389 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1390 error = EIO;
1391 splx(s);
1392 return (error);
1393 }
1394
1395 /*
1396 * Flush if successfully wait.
1397 */
1398 static int
1399 ttywflush(struct tty *tp)
1400 {
1401 int error;
1402
1403 if ((error = ttywait(tp)) == 0)
1404 ttyflush(tp, FREAD);
1405 return (error);
1406 }
1407
1408 /*
1409 * Flush tty read and/or write queues, notifying anyone waiting.
1410 */
1411 void
1412 ttyflush(struct tty *tp, int rw)
1413 {
1414 int s;
1415
1416 s = spltty();
1417 #if 0
1418 again:
1419 #endif
1420 if (rw & FWRITE) {
1421 FLUSHQ(&tp->t_outq);
1422 CLR(tp->t_state, TS_TTSTOP);
1423 }
1424 (*tp->t_stop)(tp, rw);
1425 if (rw & FREAD) {
1426 FLUSHQ(&tp->t_canq);
1427 FLUSHQ(&tp->t_rawq);
1428 CLR(tp->t_lflag, PENDIN);
1429 tp->t_rocount = 0;
1430 tp->t_rocol = 0;
1431 CLR(tp->t_state, TS_LOCAL);
1432 ttwakeup(tp);
1433 if (ISSET(tp->t_state, TS_TBLOCK)) {
1434 if (rw & FWRITE)
1435 FLUSHQ(&tp->t_outq);
1436 ttyunblock(tp);
1437
1438 /*
1439 * Don't let leave any state that might clobber the
1440 * next line discipline (although we should do more
1441 * to send the START char). Not clearing the state
1442 * may have caused the "putc to a clist with no
1443 * reserved cblocks" panic/printf.
1444 */
1445 CLR(tp->t_state, TS_TBLOCK);
1446
1447 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1448 if (ISSET(tp->t_iflag, IXOFF)) {
1449 /*
1450 * XXX wait a bit in the hope that the stop
1451 * character (if any) will go out. Waiting
1452 * isn't good since it allows races. This
1453 * will be fixed when the stop character is
1454 * put in a special queue. Don't bother with
1455 * the checks in ttywait() since the timeout
1456 * will save us.
1457 */
1458 SET(tp->t_state, TS_SO_OCOMPLETE);
1459 ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
1460 "ttyfls", hz / 10);
1461 /*
1462 * Don't try sending the stop character again.
1463 */
1464 CLR(tp->t_state, TS_TBLOCK);
1465 goto again;
1466 }
1467 #endif
1468 }
1469 }
1470 if (rw & FWRITE) {
1471 FLUSHQ(&tp->t_outq);
1472 ttwwakeup(tp);
1473 }
1474 splx(s);
1475 }
1476
1477 /*
1478 * Copy in the default termios characters.
1479 */
1480 void
1481 termioschars(struct termios *t)
1482 {
1483
1484 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1485 }
1486
1487 /*
1488 * Old interface.
1489 */
1490 void
1491 ttychars(struct tty *tp)
1492 {
1493
1494 termioschars(&tp->t_termios);
1495 }
1496
1497 /*
1498 * Handle input high water. Send stop character for the IXOFF case. Turn
1499 * on our input flow control bit and propagate the changes to the driver.
1500 * XXX the stop character should be put in a special high priority queue.
1501 */
1502 void
1503 ttyblock(struct tty *tp)
1504 {
1505
1506 SET(tp->t_state, TS_TBLOCK);
1507 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1508 putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1509 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1510 ttstart(tp);
1511 }
1512
1513 /*
1514 * Handle input low water. Send start character for the IXOFF case. Turn
1515 * off our input flow control bit and propagate the changes to the driver.
1516 * XXX the start character should be put in a special high priority queue.
1517 */
1518 static void
1519 ttyunblock(struct tty *tp)
1520 {
1521
1522 CLR(tp->t_state, TS_TBLOCK);
1523 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1524 putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1525 SET(tp->t_state, TS_TBLOCK); /* try again later */
1526 ttstart(tp);
1527 }
1528
1529 #ifdef notyet
1530 /* Not used by any current (i386) drivers. */
1531 /*
1532 * Restart after an inter-char delay.
1533 */
1534 void
1535 ttrstrt(void *tp_arg)
1536 {
1537 struct tty *tp;
1538 int s;
1539
1540 KASSERT(tp_arg != NULL, ("ttrstrt"));
1541
1542 tp = tp_arg;
1543 s = spltty();
1544
1545 CLR(tp->t_state, TS_TIMEOUT);
1546 ttstart(tp);
1547
1548 splx(s);
1549 }
1550 #endif
1551
1552 int
1553 ttstart(struct tty *tp)
1554 {
1555
1556 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1557 (*tp->t_oproc)(tp);
1558 return (0);
1559 }
1560
1561 /*
1562 * "close" a line discipline
1563 */
1564 int
1565 ttylclose(struct tty *tp, int flag)
1566 {
1567
1568 if (flag & FNONBLOCK || ttywflush(tp))
1569 ttyflush(tp, FREAD | FWRITE);
1570 return (0);
1571 }
1572
1573 /*
1574 * Handle modem control transition on a tty.
1575 * Flag indicates new state of carrier.
1576 * Returns 0 if the line should be turned off, otherwise 1.
1577 */
1578 int
1579 ttymodem(struct tty *tp, int flag)
1580 {
1581
1582 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1583 /*
1584 * MDMBUF: do flow control according to carrier flag
1585 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1586 * works if IXON and IXANY are clear.
1587 */
1588 if (flag) {
1589 CLR(tp->t_state, TS_CAR_OFLOW);
1590 CLR(tp->t_state, TS_TTSTOP);
1591 ttstart(tp);
1592 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1593 SET(tp->t_state, TS_CAR_OFLOW);
1594 SET(tp->t_state, TS_TTSTOP);
1595 (*tp->t_stop)(tp, 0);
1596 }
1597 } else if (flag == 0) {
1598 /*
1599 * Lost carrier.
1600 */
1601 CLR(tp->t_state, TS_CARR_ON);
1602 if (ISSET(tp->t_state, TS_ISOPEN) &&
1603 !ISSET(tp->t_cflag, CLOCAL)) {
1604 SET(tp->t_state, TS_ZOMBIE);
1605 CLR(tp->t_state, TS_CONNECTED);
1606 if (tp->t_session) {
1607 sx_slock(&proctree_lock);
1608 if (tp->t_session->s_leader) {
1609 struct proc *p;
1610
1611 p = tp->t_session->s_leader;
1612 PROC_LOCK(p);
1613 psignal(p, SIGHUP);
1614 PROC_UNLOCK(p);
1615 }
1616 sx_sunlock(&proctree_lock);
1617 }
1618 ttyflush(tp, FREAD | FWRITE);
1619 return (0);
1620 }
1621 } else {
1622 /*
1623 * Carrier now on.
1624 */
1625 SET(tp->t_state, TS_CARR_ON);
1626 if (!ISSET(tp->t_state, TS_ZOMBIE))
1627 SET(tp->t_state, TS_CONNECTED);
1628 wakeup(TSA_CARR_ON(tp));
1629 ttwakeup(tp);
1630 ttwwakeup(tp);
1631 }
1632 return (1);
1633 }
1634
1635 /*
1636 * Reinput pending characters after state switch
1637 * call at spltty().
1638 */
1639 static void
1640 ttypend(struct tty *tp)
1641 {
1642 struct clist tq;
1643 int c;
1644
1645 CLR(tp->t_lflag, PENDIN);
1646 SET(tp->t_state, TS_TYPEN);
1647 /*
1648 * XXX this assumes too much about clist internals. It may even
1649 * fail if the cblock slush pool is empty. We can't allocate more
1650 * cblocks here because we are called from an interrupt handler
1651 * and clist_alloc_cblocks() can wait.
1652 */
1653 tq = tp->t_rawq;
1654 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1655 tp->t_rawq.c_cbmax = tq.c_cbmax;
1656 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1657 while ((c = getc(&tq)) >= 0)
1658 ttyinput(c, tp);
1659 CLR(tp->t_state, TS_TYPEN);
1660 }
1661
1662 /*
1663 * Process a read call on a tty device.
1664 */
1665 int
1666 ttread(struct tty *tp, struct uio *uio, int flag)
1667 {
1668 struct clist *qp;
1669 int c;
1670 tcflag_t lflag;
1671 cc_t *cc = tp->t_cc;
1672 struct thread *td;
1673 struct proc *p;
1674 int s, first, error = 0;
1675 int has_stime = 0, last_cc = 0;
1676 long slp = 0; /* XXX this should be renamed `timo'. */
1677 struct timeval stime;
1678 struct pgrp *pg;
1679
1680 td = curthread;
1681 p = td->td_proc;
1682 loop:
1683 s = spltty();
1684 lflag = tp->t_lflag;
1685 /*
1686 * take pending input first
1687 */
1688 if (ISSET(lflag, PENDIN)) {
1689 ttypend(tp);
1690 splx(s); /* reduce latency */
1691 s = spltty();
1692 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1693 }
1694
1695 /*
1696 * Hang process if it's in the background.
1697 */
1698 if (isbackground(p, tp)) {
1699 splx(s);
1700 sx_slock(&proctree_lock);
1701 PROC_LOCK(p);
1702 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) ||
1703 SIGISMEMBER(td->td_sigmask, SIGTTIN) ||
1704 (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) {
1705 PROC_UNLOCK(p);
1706 sx_sunlock(&proctree_lock);
1707 return (EIO);
1708 }
1709 pg = p->p_pgrp;
1710 PROC_UNLOCK(p);
1711 PGRP_LOCK(pg);
1712 sx_sunlock(&proctree_lock);
1713 pgsignal(pg, SIGTTIN, 1);
1714 PGRP_UNLOCK(pg);
1715 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
1716 if (error)
1717 return (error);
1718 goto loop;
1719 }
1720
1721 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1722 splx(s);
1723 return (0); /* EOF */
1724 }
1725
1726 /*
1727 * If canonical, use the canonical queue,
1728 * else use the raw queue.
1729 *
1730 * (should get rid of clists...)
1731 */
1732 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1733
1734 if (flag & IO_NDELAY) {
1735 if (qp->c_cc > 0)
1736 goto read;
1737 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1738 splx(s);
1739 return (0);
1740 }
1741 splx(s);
1742 return (EWOULDBLOCK);
1743 }
1744 if (!ISSET(lflag, ICANON)) {
1745 int m = cc[VMIN];
1746 long t = cc[VTIME];
1747 struct timeval timecopy;
1748
1749 /*
1750 * Check each of the four combinations.
1751 * (m > 0 && t == 0) is the normal read case.
1752 * It should be fairly efficient, so we check that and its
1753 * companion case (m == 0 && t == 0) first.
1754 * For the other two cases, we compute the target sleep time
1755 * into slp.
1756 */
1757 if (t == 0) {
1758 if (qp->c_cc < m)
1759 goto sleep;
1760 if (qp->c_cc > 0)
1761 goto read;
1762
1763 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1764 splx(s);
1765 return (0);
1766 }
1767 t *= 100000; /* time in us */
1768 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1769 ((t1).tv_usec - (t2).tv_usec))
1770 if (m > 0) {
1771 if (qp->c_cc <= 0)
1772 goto sleep;
1773 if (qp->c_cc >= m)
1774 goto read;
1775 getmicrotime(&timecopy);
1776 if (!has_stime) {
1777 /* first character, start timer */
1778 has_stime = 1;
1779 stime = timecopy;
1780 slp = t;
1781 } else if (qp->c_cc > last_cc) {
1782 /* got a character, restart timer */
1783 stime = timecopy;
1784 slp = t;
1785 } else {
1786 /* nothing, check expiration */
1787 slp = t - diff(timecopy, stime);
1788 if (slp <= 0)
1789 goto read;
1790 }
1791 last_cc = qp->c_cc;
1792 } else { /* m == 0 */
1793 if (qp->c_cc > 0)
1794 goto read;
1795 getmicrotime(&timecopy);
1796 if (!has_stime) {
1797 has_stime = 1;
1798 stime = timecopy;
1799 slp = t;
1800 } else {
1801 slp = t - diff(timecopy, stime);
1802 if (slp <= 0) {
1803 /* Timed out, but 0 is enough input. */
1804 splx(s);
1805 return (0);
1806 }
1807 }
1808 }
1809 #undef diff
1810 /*
1811 * Rounding down may make us wake up just short
1812 * of the target, so we round up.
1813 * The formula is ceiling(slp * hz/1000000).
1814 * 32-bit arithmetic is enough for hz < 169.
1815 * XXX see tvtohz() for how to avoid overflow if hz
1816 * is large (divide by `tick' and/or arrange to
1817 * use tvtohz() if hz is large).
1818 */
1819 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1820 goto sleep;
1821 }
1822 if (qp->c_cc <= 0) {
1823 sleep:
1824 /*
1825 * There is no input, or not enough input and we can block.
1826 */
1827 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
1828 ISSET(tp->t_state, TS_CONNECTED) ?
1829 "ttyin" : "ttyhup", (int)slp);
1830 splx(s);
1831 if (error == EWOULDBLOCK)
1832 error = 0;
1833 else if (error)
1834 return (error);
1835 /*
1836 * XXX what happens if another process eats some input
1837 * while we are asleep (not just here)? It would be
1838 * safest to detect changes and reset our state variables
1839 * (has_stime and last_cc).
1840 */
1841 slp = 0;
1842 goto loop;
1843 }
1844 read:
1845 splx(s);
1846 /*
1847 * Input present, check for input mapping and processing.
1848 */
1849 first = 1;
1850 if (ISSET(lflag, ICANON | ISIG))
1851 goto slowcase;
1852 for (;;) {
1853 char ibuf[IBUFSIZ];
1854 int icc;
1855
1856 icc = imin(uio->uio_resid, IBUFSIZ);
1857 icc = q_to_b(qp, ibuf, icc);
1858 if (icc <= 0) {
1859 if (first)
1860 goto loop;
1861 break;
1862 }
1863 error = uiomove(ibuf, icc, uio);
1864 /*
1865 * XXX if there was an error then we should ungetc() the
1866 * unmoved chars and reduce icc here.
1867 */
1868 if (error)
1869 break;
1870 if (uio->uio_resid == 0)
1871 break;
1872 first = 0;
1873 }
1874 goto out;
1875 slowcase:
1876 for (;;) {
1877 c = getc(qp);
1878 if (c < 0) {
1879 if (first)
1880 goto loop;
1881 break;
1882 }
1883 /*
1884 * delayed suspend (^Y)
1885 */
1886 if (CCEQ(cc[VDSUSP], c) &&
1887 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1888 if (tp->t_pgrp != NULL) {
1889 PGRP_LOCK(tp->t_pgrp);
1890 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1891 PGRP_UNLOCK(tp->t_pgrp);
1892 }
1893 if (first) {
1894 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
1895 "ttybg3", 0);
1896 if (error)
1897 break;
1898 goto loop;
1899 }
1900 break;
1901 }
1902 /*
1903 * Interpret EOF only in canonical mode.
1904 */
1905 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1906 break;
1907 /*
1908 * Give user character.
1909 */
1910 error = ureadc(c, uio);
1911 if (error)
1912 /* XXX should ungetc(c, qp). */
1913 break;
1914 if (uio->uio_resid == 0)
1915 break;
1916 /*
1917 * In canonical mode check for a "break character"
1918 * marking the end of a "line of input".
1919 */
1920 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1921 break;
1922 first = 0;
1923 }
1924
1925 out:
1926 /*
1927 * Look to unblock input now that (presumably)
1928 * the input queue has gone down.
1929 */
1930 s = spltty();
1931 if (ISSET(tp->t_state, TS_TBLOCK) &&
1932 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1933 ttyunblock(tp);
1934 splx(s);
1935
1936 return (error);
1937 }
1938
1939 /*
1940 * Check the output queue on tp for space for a kernel message (from uprintf
1941 * or tprintf). Allow some space over the normal hiwater mark so we don't
1942 * lose messages due to normal flow control, but don't let the tty run amok.
1943 * Sleeps here are not interruptible, but we return prematurely if new signals
1944 * arrive.
1945 */
1946 int
1947 ttycheckoutq(struct tty *tp, int wait)
1948 {
1949 int hiwat, s;
1950 sigset_t oldmask;
1951 struct thread *td;
1952 struct proc *p;
1953
1954 td = curthread;
1955 p = td->td_proc;
1956 hiwat = tp->t_ohiwat;
1957 SIGEMPTYSET(oldmask);
1958 s = spltty();
1959 if (wait) {
1960 PROC_LOCK(p);
1961 oldmask = td->td_siglist;
1962 PROC_UNLOCK(p);
1963 }
1964 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
1965 while (tp->t_outq.c_cc > hiwat) {
1966 ttstart(tp);
1967 if (tp->t_outq.c_cc <= hiwat)
1968 break;
1969 if (!wait) {
1970 splx(s);
1971 return (0);
1972 }
1973 PROC_LOCK(p);
1974 if (!SIGSETEQ(td->td_siglist, oldmask)) {
1975 PROC_UNLOCK(p);
1976 splx(s);
1977 return (0);
1978 }
1979 PROC_UNLOCK(p);
1980 SET(tp->t_state, TS_SO_OLOWAT);
1981 tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
1982 }
1983 splx(s);
1984 return (1);
1985 }
1986
1987 /*
1988 * Process a write call on a tty device.
1989 */
1990 int
1991 ttwrite(struct tty *tp, struct uio *uio, int flag)
1992 {
1993 char *cp = NULL;
1994 int cc, ce;
1995 struct thread *td;
1996 struct proc *p;
1997 int i, hiwat, cnt, error, s;
1998 char obuf[OBUFSIZ];
1999
2000 hiwat = tp->t_ohiwat;
2001 cnt = uio->uio_resid;
2002 error = 0;
2003 cc = 0;
2004 td = curthread;
2005 p = td->td_proc;
2006 loop:
2007 s = spltty();
2008 if (ISSET(tp->t_state, TS_ZOMBIE)) {
2009 splx(s);
2010 if (uio->uio_resid == cnt)
2011 error = EIO;
2012 goto out;
2013 }
2014 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2015 if (flag & IO_NDELAY) {
2016 splx(s);
2017 error = EWOULDBLOCK;
2018 goto out;
2019 }
2020 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
2021 "ttydcd", 0);
2022 splx(s);
2023 if (error)
2024 goto out;
2025 goto loop;
2026 }
2027 splx(s);
2028 /*
2029 * Hang the process if it's in the background.
2030 */
2031 sx_slock(&proctree_lock);
2032 PROC_LOCK(p);
2033 if (isbackground(p, tp) &&
2034 ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
2035 !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
2036 !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
2037 if (p->p_pgrp->pg_jobc == 0) {
2038 PROC_UNLOCK(p);
2039 sx_sunlock(&proctree_lock);
2040 error = EIO;
2041 goto out;
2042 }
2043 PROC_UNLOCK(p);
2044 PGRP_LOCK(p->p_pgrp);
2045 sx_sunlock(&proctree_lock);
2046 pgsignal(p->p_pgrp, SIGTTOU, 1);
2047 PGRP_UNLOCK(p->p_pgrp);
2048 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
2049 if (error)
2050 goto out;
2051 goto loop;
2052 } else {
2053 PROC_UNLOCK(p);
2054 sx_sunlock(&proctree_lock);
2055 }
2056 /*
2057 * Process the user's data in at most OBUFSIZ chunks. Perform any
2058 * output translation. Keep track of high water mark, sleep on
2059 * overflow awaiting device aid in acquiring new space.
2060 */
2061 while (uio->uio_resid > 0 || cc > 0) {
2062 if (ISSET(tp->t_lflag, FLUSHO)) {
2063 uio->uio_resid = 0;
2064 return (0);
2065 }
2066 if (tp->t_outq.c_cc > hiwat)
2067 goto ovhiwat;
2068 /*
2069 * Grab a hunk of data from the user, unless we have some
2070 * leftover from last time.
2071 */
2072 if (cc == 0) {
2073 cc = imin(uio->uio_resid, OBUFSIZ);
2074 cp = obuf;
2075 error = uiomove(cp, cc, uio);
2076 if (error) {
2077 cc = 0;
2078 break;
2079 }
2080 }
2081 /*
2082 * If nothing fancy need be done, grab those characters we
2083 * can handle without any of ttyoutput's processing and
2084 * just transfer them to the output q. For those chars
2085 * which require special processing (as indicated by the
2086 * bits in char_type), call ttyoutput. After processing
2087 * a hunk of data, look for FLUSHO so ^O's will take effect
2088 * immediately.
2089 */
2090 while (cc > 0) {
2091 if (!ISSET(tp->t_oflag, OPOST))
2092 ce = cc;
2093 else {
2094 ce = cc - scanc((u_int)cc, (u_char *)cp,
2095 char_type, CCLASSMASK);
2096 /*
2097 * If ce is zero, then we're processing
2098 * a special character through ttyoutput.
2099 */
2100 if (ce == 0) {
2101 tp->t_rocount = 0;
2102 if (ttyoutput(*cp, tp) >= 0) {
2103 /* No Clists, wait a bit. */
2104 ttstart(tp);
2105 if (flag & IO_NDELAY) {
2106 error = EWOULDBLOCK;
2107 goto out;
2108 }
2109 error = ttysleep(tp, &lbolt,
2110 TTOPRI|PCATCH,
2111 "ttybf1", 0);
2112 if (error)
2113 goto out;
2114 goto loop;
2115 }
2116 cp++;
2117 cc--;
2118 if (ISSET(tp->t_lflag, FLUSHO) ||
2119 tp->t_outq.c_cc > hiwat)
2120 goto ovhiwat;
2121 continue;
2122 }
2123 }
2124 /*
2125 * A bunch of normal characters have been found.
2126 * Transfer them en masse to the output queue and
2127 * continue processing at the top of the loop.
2128 * If there are any further characters in this
2129 * <= OBUFSIZ chunk, the first should be a character
2130 * requiring special handling by ttyoutput.
2131 */
2132 tp->t_rocount = 0;
2133 i = b_to_q(cp, ce, &tp->t_outq);
2134 ce -= i;
2135 tp->t_column += ce;
2136 cp += ce, cc -= ce, tk_nout += ce;
2137 tp->t_outcc += ce;
2138 if (i > 0) {
2139 /* No Clists, wait a bit. */
2140 ttstart(tp);
2141 if (flag & IO_NDELAY) {
2142 error = EWOULDBLOCK;
2143 goto out;
2144 }
2145 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
2146 "ttybf2", 0);
2147 if (error)
2148 goto out;
2149 goto loop;
2150 }
2151 if (ISSET(tp->t_lflag, FLUSHO) ||
2152 tp->t_outq.c_cc > hiwat)
2153 break;
2154 }
2155 ttstart(tp);
2156 }
2157 out:
2158 /*
2159 * If cc is nonzero, we leave the uio structure inconsistent, as the
2160 * offset and iov pointers have moved forward, but it doesn't matter
2161 * (the call will either return short or restart with a new uio).
2162 */
2163 uio->uio_resid += cc;
2164 return (error);
2165
2166 ovhiwat:
2167 ttstart(tp);
2168 s = spltty();
2169 /*
2170 * This can only occur if FLUSHO is set in t_lflag,
2171 * or if ttstart/oproc is synchronous (or very fast).
2172 */
2173 if (tp->t_outq.c_cc <= hiwat) {
2174 splx(s);
2175 goto loop;
2176 }
2177 if (flag & IO_NDELAY) {
2178 splx(s);
2179 uio->uio_resid += cc;
2180 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2181 }
2182 SET(tp->t_state, TS_SO_OLOWAT);
2183 error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
2184 tp->t_timeout);
2185 splx(s);
2186 if (error == EWOULDBLOCK)
2187 error = EIO;
2188 if (error)
2189 goto out;
2190 goto loop;
2191 }
2192
2193 /*
2194 * Rubout one character from the rawq of tp
2195 * as cleanly as possible.
2196 */
2197 static void
2198 ttyrub(int c, struct tty *tp)
2199 {
2200 char *cp;
2201 int savecol;
2202 int tabc, s;
2203
2204 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2205 return;
2206 CLR(tp->t_lflag, FLUSHO);
2207 if (ISSET(tp->t_lflag, ECHOE)) {
2208 if (tp->t_rocount == 0) {
2209 /*
2210 * Screwed by ttwrite; retype
2211 */
2212 ttyretype(tp);
2213 return;
2214 }
2215 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2216 ttyrubo(tp, 2);
2217 else {
2218 CLR(c, ~TTY_CHARMASK);
2219 switch (CCLASS(c)) {
2220 case ORDINARY:
2221 ttyrubo(tp, 1);
2222 break;
2223 case BACKSPACE:
2224 case CONTROL:
2225 case NEWLINE:
2226 case RETURN:
2227 case VTAB:
2228 if (ISSET(tp->t_lflag, ECHOCTL))
2229 ttyrubo(tp, 2);
2230 break;
2231 case TAB:
2232 if (tp->t_rocount < tp->t_rawq.c_cc) {
2233 ttyretype(tp);
2234 return;
2235 }
2236 s = spltty();
2237 savecol = tp->t_column;
2238 SET(tp->t_state, TS_CNTTB);
2239 SET(tp->t_lflag, FLUSHO);
2240 tp->t_column = tp->t_rocol;
2241 cp = tp->t_rawq.c_cf;
2242 if (cp)
2243 tabc = *cp; /* XXX FIX NEXTC */
2244 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2245 ttyecho(tabc, tp);
2246 CLR(tp->t_lflag, FLUSHO);
2247 CLR(tp->t_state, TS_CNTTB);
2248 splx(s);
2249
2250 /* savecol will now be length of the tab. */
2251 savecol -= tp->t_column;
2252 tp->t_column += savecol;
2253 if (savecol > 8)
2254 savecol = 8; /* overflow screw */
2255 while (--savecol >= 0)
2256 (void)ttyoutput('\b', tp);
2257 break;
2258 default: /* XXX */
2259 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2260 (void)printf(PANICSTR, c, CCLASS(c));
2261 #ifdef notdef
2262 panic(PANICSTR, c, CCLASS(c));
2263 #endif
2264 }
2265 }
2266 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2267 if (!ISSET(tp->t_state, TS_ERASE)) {
2268 SET(tp->t_state, TS_ERASE);
2269 (void)ttyoutput('\\', tp);
2270 }
2271 ttyecho(c, tp);
2272 } else {
2273 ttyecho(tp->t_cc[VERASE], tp);
2274 /*
2275 * This code may be executed not only when an ERASE key
2276 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2277 * So, I didn't think it was worthwhile to pass the extra
2278 * information (which would need an extra parameter,
2279 * changing every call) needed to distinguish the ERASE2
2280 * case from the ERASE.
2281 */
2282 }
2283 --tp->t_rocount;
2284 }
2285
2286 /*
2287 * Back over cnt characters, erasing them.
2288 */
2289 static void
2290 ttyrubo(struct tty *tp, int cnt)
2291 {
2292
2293 while (cnt-- > 0) {
2294 (void)ttyoutput('\b', tp);
2295 (void)ttyoutput(' ', tp);
2296 (void)ttyoutput('\b', tp);
2297 }
2298 }
2299
2300 /*
2301 * ttyretype --
2302 * Reprint the rawq line. Note, it is assumed that c_cc has already
2303 * been checked.
2304 */
2305 static void
2306 ttyretype(struct tty *tp)
2307 {
2308 char *cp;
2309 int s, c;
2310
2311 /* Echo the reprint character. */
2312 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2313 ttyecho(tp->t_cc[VREPRINT], tp);
2314
2315 (void)ttyoutput('\n', tp);
2316
2317 /*
2318 * XXX
2319 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2320 * BIT OF FIRST CHAR.
2321 */
2322 s = spltty();
2323 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2324 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2325 ttyecho(c, tp);
2326 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2327 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2328 ttyecho(c, tp);
2329 CLR(tp->t_state, TS_ERASE);
2330 splx(s);
2331
2332 tp->t_rocount = tp->t_rawq.c_cc;
2333 tp->t_rocol = 0;
2334 }
2335
2336 /*
2337 * Echo a typed character to the terminal.
2338 */
2339 static void
2340 ttyecho(int c, struct tty *tp)
2341 {
2342
2343 if (!ISSET(tp->t_state, TS_CNTTB))
2344 CLR(tp->t_lflag, FLUSHO);
2345 if ((!ISSET(tp->t_lflag, ECHO) &&
2346 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2347 ISSET(tp->t_lflag, EXTPROC))
2348 return;
2349 if (ISSET(tp->t_lflag, ECHOCTL) &&
2350 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2351 ISSET(c, TTY_CHARMASK) == 0177)) {
2352 (void)ttyoutput('^', tp);
2353 CLR(c, ~TTY_CHARMASK);
2354 if (c == 0177)
2355 c = '?';
2356 else
2357 c += 'A' - 1;
2358 }
2359 (void)ttyoutput(c, tp);
2360 }
2361
2362 /*
2363 * Wake up any readers on a tty.
2364 */
2365 void
2366 ttwakeup(struct tty *tp)
2367 {
2368
2369 if (SEL_WAITING(&tp->t_rsel))
2370 selwakeuppri(&tp->t_rsel, TTIPRI);
2371 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2372 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2373 wakeup(TSA_HUP_OR_INPUT(tp));
2374 KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0);
2375 }
2376
2377 /*
2378 * Wake up any writers on a tty.
2379 */
2380 void
2381 ttwwakeup(struct tty *tp)
2382 {
2383
2384 if (SEL_WAITING(&tp->t_wsel) && tp->t_outq.c_cc <= tp->t_olowat)
2385 selwakeuppri(&tp->t_wsel, TTOPRI);
2386 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2387 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2388 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2389 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2390 CLR(tp->t_state, TS_SO_OCOMPLETE);
2391 wakeup(TSA_OCOMPLETE(tp));
2392 }
2393 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2394 tp->t_outq.c_cc <= tp->t_olowat) {
2395 CLR(tp->t_state, TS_SO_OLOWAT);
2396 wakeup(TSA_OLOWAT(tp));
2397 }
2398 KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0);
2399 }
2400
2401 /*
2402 * Look up a code for a specified speed in a conversion table;
2403 * used by drivers to map software speed values to hardware parameters.
2404 */
2405 int
2406 ttspeedtab(int speed, struct speedtab *table)
2407 {
2408
2409 for ( ; table->sp_speed != -1; table++)
2410 if (table->sp_speed == speed)
2411 return (table->sp_code);
2412 return (-1);
2413 }
2414
2415 /*
2416 * Set input and output watermarks and buffer sizes. For input, the
2417 * high watermark is about one second's worth of input above empty, the
2418 * low watermark is slightly below high water, and the buffer size is a
2419 * driver-dependent amount above high water. For output, the watermarks
2420 * are near the ends of the buffer, with about 1 second's worth of input
2421 * between them. All this only applies to the standard line discipline.
2422 */
2423 void
2424 ttsetwater(struct tty *tp)
2425 {
2426 int cps, ttmaxhiwat, x;
2427
2428 /* Input. */
2429 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2430 switch (tp->t_ispeedwat) {
2431 case (speed_t)-1:
2432 cps = tp->t_ispeed / 10;
2433 break;
2434 case 0:
2435 /*
2436 * This case is for old drivers that don't know about
2437 * t_ispeedwat. Arrange for them to get the old buffer
2438 * sizes and watermarks.
2439 */
2440 cps = TTYHOG - 2 * 256;
2441 tp->t_ififosize = 2 * 256;
2442 break;
2443 default:
2444 cps = tp->t_ispeedwat / 10;
2445 break;
2446 }
2447 tp->t_ihiwat = cps;
2448 tp->t_ilowat = 7 * cps / 8;
2449 x = cps + tp->t_ififosize;
2450 clist_alloc_cblocks(&tp->t_rawq, x, x);
2451
2452 /* Output. */
2453 switch (tp->t_ospeedwat) {
2454 case (speed_t)-1:
2455 cps = tp->t_ospeed / 10;
2456 ttmaxhiwat = 2 * TTMAXHIWAT;
2457 break;
2458 case 0:
2459 cps = tp->t_ospeed / 10;
2460 ttmaxhiwat = TTMAXHIWAT;
2461 break;
2462 default:
2463 cps = tp->t_ospeedwat / 10;
2464 ttmaxhiwat = 8 * TTMAXHIWAT;
2465 break;
2466 }
2467 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2468 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2469 x += cps;
2470 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2471 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2472 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2473 x += OBUFSIZ + 100;
2474 clist_alloc_cblocks(&tp->t_outq, x, x);
2475 #undef CLAMP
2476 }
2477
2478 /*
2479 * Report on state of foreground process group.
2480 */
2481 void
2482 ttyinfo(struct tty *tp)
2483 {
2484 struct timeval utime, stime;
2485 struct proc *p, *pick;
2486 struct thread *td;
2487 const char *stateprefix, *state;
2488 long rss;
2489 int load, pctcpu;
2490
2491 if (ttycheckoutq(tp,0) == 0)
2492 return;
2493
2494 /* Print load average. */
2495 load = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2496 ttyprintf(tp, "load: %d.%02d ", load / 100, load % 100);
2497
2498 /*
2499 * On return following a ttyprintf(), we set tp->t_rocount to 0 so
2500 * that pending input will be retyped on BS.
2501 */
2502 if (tp->t_session == NULL) {
2503 ttyprintf(tp, "not a controlling terminal\n");
2504 tp->t_rocount = 0;
2505 return;
2506 }
2507 if (tp->t_pgrp == NULL) {
2508 ttyprintf(tp, "no foreground process group\n");
2509 tp->t_rocount = 0;
2510 return;
2511 }
2512 PGRP_LOCK(tp->t_pgrp);
2513 if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
2514 PGRP_UNLOCK(tp->t_pgrp);
2515 ttyprintf(tp, "empty foreground process group\n");
2516 tp->t_rocount = 0;
2517 return;
2518 }
2519
2520 /*
2521 * Pick the most interesting process and copy some of its
2522 * state for printing later. sched_lock must be held for
2523 * most parts of this. Holding it throughout is simplest
2524 * and prevents even unimportant inconsistencies in the
2525 * copy of the state, but may increase interrupt latency
2526 * too much.
2527 */
2528 mtx_lock_spin(&sched_lock);
2529 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist))
2530 if (proc_compare(pick, p))
2531 pick = p;
2532 PGRP_UNLOCK(tp->t_pgrp);
2533
2534 td = FIRST_THREAD_IN_PROC(pick); /* XXXKSE */
2535 #if 0
2536 KASSERT(td != NULL, ("ttyinfo: no thread"));
2537 #else
2538 if (td == NULL) {
2539 mtx_unlock_spin(&sched_lock);
2540 ttyprintf(tp, "foreground process without thread\n");
2541 tp->t_rocount = 0;
2542 return;
2543 }
2544 #endif
2545 stateprefix = "";
2546 if (TD_IS_RUNNING(td))
2547 state = "running";
2548 else if (TD_ON_RUNQ(td) || TD_CAN_RUN(td))
2549 state = "runnable";
2550 else if (TD_IS_SLEEPING(td)) {
2551 /* XXX: If we're sleeping, are we ever not in a queue? */
2552 if (TD_ON_SLEEPQ(td))
2553 state = td->td_wmesg;
2554 else
2555 state = "sleeping without queue";
2556 } else if (TD_ON_LOCK(td)) {
2557 state = td->td_lockname;
2558 stateprefix = "*";
2559 } else if (TD_IS_SUSPENDED(td))
2560 state = "suspended";
2561 else if (TD_AWAITING_INTR(td))
2562 state = "intrwait";
2563 else
2564 state = "unknown";
2565 calcru(pick, &utime, &stime, NULL);
2566 pctcpu = (sched_pctcpu(td) * 10000 + FSCALE / 2) >> FSHIFT;
2567 if (pick->p_state == PRS_NEW || pick->p_state == PRS_ZOMBIE)
2568 rss = 0;
2569 else
2570 rss = pgtok(vmspace_resident_count(pick->p_vmspace));
2571 mtx_unlock_spin(&sched_lock);
2572
2573 /* Print command, pid, state, utime, stime, %cpu, and rss. */
2574 ttyprintf(tp,
2575 " cmd: %s %d [%s%s] %ld.%02ldu %ld.%02lds %d%% %ldk\n",
2576 pick->p_comm, pick->p_pid, stateprefix, state,
2577 (long)utime.tv_sec, utime.tv_usec / 10000,
2578 (long)stime.tv_sec, stime.tv_usec / 10000,
2579 pctcpu / 100, rss);
2580 tp->t_rocount = 0;
2581 }
2582
2583 /*
2584 * Returns 1 if p2 is "better" than p1
2585 *
2586 * The algorithm for picking the "interesting" process is thus:
2587 *
2588 * 1) Only foreground processes are eligible - implied.
2589 * 2) Runnable processes are favored over anything else. The runner
2590 * with the highest cpu utilization is picked (p_estcpu). Ties are
2591 * broken by picking the highest pid.
2592 * 3) The sleeper with the shortest sleep time is next. With ties,
2593 * we pick out just "short-term" sleepers (P_SINTR == 0).
2594 * 4) Further ties are broken by picking the highest pid.
2595 */
2596 #define ISRUN(p, val) \
2597 do { \
2598 struct thread *td; \
2599 val = 0; \
2600 FOREACH_THREAD_IN_PROC(p, td) { \
2601 if (TD_ON_RUNQ(td) || \
2602 TD_IS_RUNNING(td)) { \
2603 val = 1; \
2604 break; \
2605 } \
2606 } \
2607 } while (0)
2608
2609 #define TESTAB(a, b) ((a)<<1 | (b))
2610 #define ONLYA 2
2611 #define ONLYB 1
2612 #define BOTH 3
2613
2614 static int
2615 proc_compare(struct proc *p1, struct proc *p2)
2616 {
2617
2618 int esta, estb;
2619 struct ksegrp *kg;
2620 mtx_assert(&sched_lock, MA_OWNED);
2621 if (p1 == NULL)
2622 return (1);
2623
2624 ISRUN(p1, esta);
2625 ISRUN(p2, estb);
2626
2627 /*
2628 * see if at least one of them is runnable
2629 */
2630 switch (TESTAB(esta, estb)) {
2631 case ONLYA:
2632 return (0);
2633 case ONLYB:
2634 return (1);
2635 case BOTH:
2636 /*
2637 * tie - favor one with highest recent cpu utilization
2638 */
2639 esta = estb = 0;
2640 FOREACH_KSEGRP_IN_PROC(p1,kg) {
2641 esta += kg->kg_estcpu;
2642 }
2643 FOREACH_KSEGRP_IN_PROC(p2,kg) {
2644 estb += kg->kg_estcpu;
2645 }
2646 if (estb > esta)
2647 return (1);
2648 if (esta > estb)
2649 return (0);
2650 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2651 }
2652 /*
2653 * weed out zombies
2654 */
2655 switch (TESTAB(p1->p_state == PRS_ZOMBIE, p2->p_state == PRS_ZOMBIE)) {
2656 case ONLYA:
2657 return (1);
2658 case ONLYB:
2659 return (0);
2660 case BOTH:
2661 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2662 }
2663
2664 #if 0 /* XXXKSE */
2665 /*
2666 * pick the one with the smallest sleep time
2667 */
2668 if (p2->p_slptime > p1->p_slptime)
2669 return (0);
2670 if (p1->p_slptime > p2->p_slptime)
2671 return (1);
2672 /*
2673 * favor one sleeping in a non-interruptible sleep
2674 */
2675 if (p1->p_sflag & PS_SINTR && (p2->p_sflag & PS_SINTR) == 0)
2676 return (1);
2677 if (p2->p_sflag & PS_SINTR && (p1->p_sflag & PS_SINTR) == 0)
2678 return (0);
2679 #endif
2680 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2681 }
2682
2683 /*
2684 * Output char to tty; console putchar style.
2685 */
2686 int
2687 tputchar(int c, struct tty *tp)
2688 {
2689 int s;
2690
2691 s = spltty();
2692 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2693 splx(s);
2694 return (-1);
2695 }
2696 if (c == '\n')
2697 (void)ttyoutput('\r', tp);
2698 (void)ttyoutput(c, tp);
2699 ttstart(tp);
2700 splx(s);
2701 return (0);
2702 }
2703
2704 /*
2705 * Sleep on chan, returning ERESTART if tty changed while we napped and
2706 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2707 * the tty is revoked, restarting a pending call will redo validation done
2708 * at the start of the call.
2709 */
2710 int
2711 ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo)
2712 {
2713 int error;
2714 int gen;
2715
2716 gen = tp->t_gen;
2717 error = tsleep(chan, pri, wmesg, timo);
2718 if (error)
2719 return (error);
2720 return (tp->t_gen == gen ? 0 : ERESTART);
2721 }
2722
2723 /*
2724 * Gain a reference to a TTY
2725 */
2726 int
2727 ttyref(struct tty *tp)
2728 {
2729 int i;
2730
2731 mtx_lock(&tp->t_mtx);
2732 KASSERT(tp->t_refcnt > 0,
2733 ("ttyref(): tty refcnt is %d (%s)",
2734 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2735 i = ++tp->t_refcnt;
2736 mtx_unlock(&tp->t_mtx);
2737 return (i);
2738 }
2739
2740 /*
2741 * Drop a reference to a TTY.
2742 * When reference count drops to zero, we free it.
2743 */
2744 int
2745 ttyrel(struct tty *tp)
2746 {
2747 int i;
2748
2749 mtx_lock(&tty_list_mutex);
2750 mtx_lock(&tp->t_mtx);
2751 KASSERT(tp->t_refcnt > 0,
2752 ("ttyrel(): tty refcnt is %d (%s)",
2753 tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2754 i = --tp->t_refcnt;
2755 if (i != 0) {
2756 mtx_unlock(&tp->t_mtx);
2757 mtx_unlock(&tty_list_mutex);
2758 return (i);
2759 }
2760 TAILQ_REMOVE(&tty_list, tp, t_list);
2761 mtx_unlock(&tp->t_mtx);
2762 mtx_unlock(&tty_list_mutex);
2763 knlist_destroy(&tp->t_rsel.si_note);
2764 knlist_destroy(&tp->t_wsel.si_note);
2765 mtx_destroy(&tp->t_mtx);
2766 free(tp, M_TTYS);
2767 return (i);
2768 }
2769
2770 /*
2771 * Allocate a tty struct. Clists in the struct will be allocated by
2772 * tty_open().
2773 */
2774 struct tty *
2775 ttymalloc(struct tty *tp)
2776 {
2777 static int once;
2778
2779 if (!once) {
2780 mtx_init(&tty_list_mutex, "ttylist", NULL, MTX_DEF);
2781 once++;
2782 }
2783
2784 if (tp) {
2785 /*
2786 * XXX: Either this argument should go away, or we should
2787 * XXX: require it and do a ttyrel(tp) here and allocate
2788 * XXX: a new tty. For now do nothing.
2789 */
2790 return(tp);
2791 }
2792 tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO);
2793 tp->t_timeout = -1;
2794 tp->t_dtr_wait = 3 * hz;
2795 mtx_init(&tp->t_mtx, "tty", NULL, MTX_DEF);
2796 tp->t_refcnt = 1;
2797 mtx_lock(&tty_list_mutex);
2798 TAILQ_INSERT_TAIL(&tty_list, tp, t_list);
2799 mtx_unlock(&tty_list_mutex);
2800 knlist_init(&tp->t_rsel.si_note, &tp->t_mtx);
2801 knlist_init(&tp->t_wsel.si_note, &tp->t_mtx);
2802 return (tp);
2803 }
2804
2805 static int
2806 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2807 {
2808 struct tty *tp, *tp2;
2809 struct xtty xt;
2810 int error;
2811
2812 error = 0;
2813 mtx_lock(&tty_list_mutex);
2814 tp = TAILQ_FIRST(&tty_list);
2815 if (tp != NULL)
2816 ttyref(tp);
2817 mtx_unlock(&tty_list_mutex);
2818 while (tp != NULL) {
2819 bzero(&xt, sizeof xt);
2820 xt.xt_size = sizeof xt;
2821 #define XT_COPY(field) xt.xt_##field = tp->t_##field
2822 xt.xt_rawcc = tp->t_rawq.c_cc;
2823 xt.xt_cancc = tp->t_canq.c_cc;
2824 xt.xt_outcc = tp->t_outq.c_cc;
2825 XT_COPY(line);
2826 if (tp->t_dev != NULL)
2827 xt.xt_dev = dev2udev(tp->t_dev);
2828 XT_COPY(state);
2829 XT_COPY(flags);
2830 XT_COPY(timeout);
2831 if (tp->t_pgrp != NULL)
2832 xt.xt_pgid = tp->t_pgrp->pg_id;
2833 if (tp->t_session != NULL)
2834 xt.xt_sid = tp->t_session->s_sid;
2835 XT_COPY(termios);
2836 XT_COPY(winsize);
2837 XT_COPY(column);
2838 XT_COPY(rocount);
2839 XT_COPY(rocol);
2840 XT_COPY(ififosize);
2841 XT_COPY(ihiwat);
2842 XT_COPY(ilowat);
2843 XT_COPY(ispeedwat);
2844 XT_COPY(ohiwat);
2845 XT_COPY(olowat);
2846 XT_COPY(ospeedwat);
2847 #undef XT_COPY
2848 error = SYSCTL_OUT(req, &xt, sizeof xt);
2849 if (error != 0) {
2850 ttyrel(tp);
2851 return (error);
2852 }
2853 mtx_lock(&tty_list_mutex);
2854 tp2 = TAILQ_NEXT(tp, t_list);
2855 if (tp2 != NULL)
2856 ttyref(tp2);
2857 mtx_unlock(&tty_list_mutex);
2858 ttyrel(tp);
2859 tp = tp2;
2860 }
2861 return (0);
2862 }
2863
2864 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2865 0, 0, sysctl_kern_ttys, "S,xtty", "All ttys");
2866 SYSCTL_LONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD,
2867 &tk_nin, 0, "Total TTY in characters");
2868 SYSCTL_LONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD,
2869 &tk_nout, 0, "Total TTY out characters");
2870
2871 void
2872 nottystop(struct tty *tp, int rw)
2873 {
2874
2875 return;
2876 }
2877
2878 int
2879 ttyread(struct cdev *dev, struct uio *uio, int flag)
2880 {
2881 struct tty *tp;
2882
2883 KASSERT(devsw(dev)->d_flags & D_TTY,
2884 ("ttyread() called on non D_TTY device (%s)", devtoname(dev)));
2885 tp = dev->si_tty;
2886 KASSERT(tp != NULL,
2887 ("ttyread(): no tty pointer on device (%s)", devtoname(dev)));
2888 if (tp == NULL)
2889 return (ENODEV);
2890 return (ttyld_read(tp, uio, flag));
2891 }
2892
2893 int
2894 ttywrite(struct cdev *dev, struct uio *uio, int flag)
2895 {
2896 struct tty *tp;
2897
2898 KASSERT(devsw(dev)->d_flags & D_TTY,
2899 ("ttywrite() called on non D_TTY device (%s)", devtoname(dev)));
2900 tp = dev->si_tty;
2901 KASSERT(tp != NULL,
2902 ("ttywrite(): no tty pointer on device (%s)", devtoname(dev)));
2903 if (tp == NULL)
2904 return (ENODEV);
2905 return (ttyld_write(tp, uio, flag));
2906 }
2907
2908 int
2909 ttyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
2910 {
2911 struct tty *tp;
2912 int error;
2913
2914 tp = dev->si_tty;
2915 error = ttyld_ioctl(tp, cmd, data, flag, td);
2916 if (error == ENOIOCTL)
2917 error = ttioctl(tp, cmd, data, flag);
2918 ttyldoptim(tp);
2919 if (error != ENOIOCTL)
2920 return (error);
2921 return (ENOTTY);
2922 }
2923
2924 void
2925 ttyldoptim(struct tty *tp)
2926 {
2927 struct termios *t;
2928
2929 t = &tp->t_termios;
2930 if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))
2931 && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK))
2932 && (!(t->c_iflag & PARMRK)
2933 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))
2934 && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))
2935 && linesw[tp->t_line]->l_rint == ttyinput)
2936 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2937 else
2938 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2939 }
2940
2941 static void
2942 ttydtrwaitwakeup(void *arg)
2943 {
2944 struct tty *tp;
2945
2946 tp = arg;
2947 tp->t_state &= ~TS_DTR_WAIT;
2948 wakeup(&tp->t_dtr_wait);
2949 }
2950
2951
2952 void
2953 ttydtrwaitstart(struct tty *tp)
2954 {
2955
2956 if (tp->t_dtr_wait == 0)
2957 return;
2958 if (tp->t_state & TS_DTR_WAIT)
2959 return;
2960 timeout(ttydtrwaitwakeup, tp, tp->t_dtr_wait);
2961 tp->t_state |= TS_DTR_WAIT;
2962 }
2963
2964 int
2965 ttydtrwaitsleep(struct tty *tp)
2966 {
2967 int error;
2968
2969 error = 0;
2970 while (error == 0) {
2971 if (tp->t_state & TS_GONE)
2972 error = ENXIO;
2973 else if (!(tp->t_state & TS_DTR_WAIT))
2974 break;
2975 else
2976 error = tsleep(&tp->t_dtr_wait, TTIPRI | PCATCH,
2977 "dtrwait", 0);
2978 }
2979 return (error);
2980 }
2981
2982 /*
2983 * This function is called when the hardware disappears. We set a flag
2984 * and wake up stuff so all sleeping threads will notice.
2985 */
2986 void
2987 ttygone(struct tty *tp)
2988 {
2989
2990 tp->t_state |= TS_GONE;
2991 wakeup(&tp->t_dtr_wait);
2992 }
2993
2994 /*
2995 * Record the relationship between the serial ports notion of modem control
2996 * signals and the one used in certain ioctls in a way the compiler can enforce
2997 * XXX: We should define TIOCM_* in terms of SER_ if we can limit the
2998 * XXX: consequences of the #include work that would take.
2999 */
3000 CTASSERT(SER_DTR == TIOCM_DTR / 2);
3001 CTASSERT(SER_RTS == TIOCM_RTS / 2);
3002 CTASSERT(SER_STX == TIOCM_ST / 2);
3003 CTASSERT(SER_SRX == TIOCM_SR / 2);
3004 CTASSERT(SER_CTS == TIOCM_CTS / 2);
3005 CTASSERT(SER_DCD == TIOCM_DCD / 2);
3006 CTASSERT(SER_RI == TIOCM_RI / 2);
3007 CTASSERT(SER_DSR == TIOCM_DSR / 2);
3008
Cache object: 363fbfc72adb4ced1a13609caa9c1d59
|