?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HAMMER 60I/Many: Mirroring
[dragonfly.git] / sys / kern / tty.c
blob162780bd138276e3730d67ee7eca8864f02ef7c8
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 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
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.
25 *
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
36 * SUCH DAMAGE.
37 *
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.44 2008/01/15 14:19:11 hasso Exp $
41 */
42
43 /*-
44 * TODO:
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
50 * FIONREAD.
51 * o Do the new sio locking stuff here and use it to avoid special
52 * case for EXTPROC?
53 * o Lock PENDIN too?
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
61 * discipline.
62 * o Now that historical speed conversions are handled here, don't
63 * do them in drivers.
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().
69 */
70
71 #include "opt_compat.h"
72 #include "opt_uconsole.h"
73
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>
79 #endif
80 #include <sys/proc.h>
81 #define TTYDEFCHARS
82 #include <sys/tty.h>
83 #include <sys/clist.h>
84 #undef TTYDEFCHARS
85 #include <sys/fcntl.h>
86 #include <sys/conf.h>
87 #include <sys/dkstat.h>
88 #include <sys/poll.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>
98
99 #include <vm/vm.h>
100 #include <sys/lock.h>
101 #include <vm/pmap.h>
102 #include <vm/vm_map.h>
103
104 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
105
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);
120
121 /*
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.
127 */
128 #define E 0x00 /* Even parity. */
129 #define O 0x80 /* Odd parity. */
130 #define PARITY(c) (char_type[c] & O)
131
132 #define ALPHA 0x40 /* Alpha or underscore. */
133 #define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
134
135 #define CCLASSMASK 0x3f
136 #define CCLASS(c) (char_type[c] & CCLASSMASK)
137
138 #define BS BACKSPACE
139 #define CC CONTROL
140 #define CR RETURN
141 #define NA ORDINARY | ALPHA
142 #define NL NEWLINE
143 #define NO ORDINARY
144 #define TB TAB
145 #define VT VTAB
146
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 */
164 /*
165 * Meta chars; should be settable per character set;
166 * for now, treat them all as normal characters.
167 */
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,
184 };
185 #undef BS
186 #undef CC
187 #undef CR
188 #undef NA
189 #undef NL
190 #undef NO
191 #undef TB
192 #undef VT
193
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))
198
199 #undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
200 #define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
201
202 uint64_t tk_nin;
203 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nin, CTLFLAG_RD, &tk_nin, sizeof(tk_nin),
204 "LU", "TTY input statistic");
205 uint64_t tk_nout;
206 SYSCTL_OPAQUE(_kern, OID_AUTO, tk_nout, CTLFLAG_RD, &tk_nout, sizeof(tk_nout),
207 "LU", "TTY output statistic");
208 uint64_t tk_rawcc;
209
210 /*
211 * list of struct tty where pstat(8) can pick it up with sysctl
212 */
213 static SLIST_HEAD(, tty) tty_list;
214
215 /*
216 * Initial open of tty, or (re)entry to standard tty line discipline.
217 */
218 int
219 ttyopen(cdev_t device, struct tty *tp)
220 {
221 crit_enter();
222 tp->t_dev = device;
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));
228 }
229 ttsetwater(tp);
230 crit_exit();
231 return (0);
232 }
233
234 /*
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.
238 *
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.
242 */
243 int
244 ttyclose(struct tty *tp)
245 {
246 funsetown(tp->t_sigio);
247 crit_enter();
248 if (constty == tp)
249 constty = NULL;
250
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);
255
256 tp->t_gen++;
257 tp->t_line = TTYDISC;
258 ttyclearsession(tp);
259 tp->t_state = 0;
260 crit_exit();
261 return (0);
262 }
263
264 /*
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.
269 *
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.
273 */
274 void
275 ttyclearsession(struct tty *tp)
276 {
277 struct session *sp;
278
279 tp->t_pgrp = NULL;
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) {
285 sp->s_ttyp = NULL;
286 } else {
287 kprintf("ttyclearsession: warning: sp->s_ttyp != tp "
288 "%p/%p\n", sp->s_ttyp, tp);
289 }
290 #endif
291 }
292 }
293
294 /*
295 * Release 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.
299 *
300 * If dorevoke is non-zero, the session is also revoked. We have to
301 * close the vnode if VCTTYISOPEN is set.
302 */
303 void
304 ttyclosesession(struct session *sp, int dorevoke)
305 {
306 struct vnode *vp;
307
308 retry:
309 /*
310 * There may not be a controlling terminal or it may have been closed
311 * out from under us.
312 */
313 if ((vp = sp->s_ttyvp) == NULL)
314 return;
315
316 /*
317 * We need a lock if we have to close or revoke.
318 */
319 if ((vp->v_flag & VCTTYISOPEN) || dorevoke) {
320 vhold(vp);
321 if (vn_lock(vp, LK_EXCLUSIVE|LK_RETRY)) {
322 vdrop(vp);
323 goto retry;
324 }
325
326 /*
327 * Retry if the vnode was ripped out from under us
328 */
329 if (vp != sp->s_ttyvp) {
330 vn_unlock(vp);
331 vdrop(vp);
332 goto retry;
333 }
334
335 /*
336 * Close and revoke as needed
337 */
338 sp->s_ttyvp = NULL;
339 if (vp->v_flag & VCTTYISOPEN) {
340 vclrflags(vp, VCTTYISOPEN);
341 VOP_CLOSE(vp, FREAD|FWRITE);
342 }
343 if (dorevoke)
344 VOP_REVOKE(vp, REVOKEALL);
345 vn_unlock(vp);
346 vdrop(vp);
347 } else {
348 sp->s_ttyvp = NULL;
349 }
350 vrele(vp);
351 }
352
353 #define FLUSHQ(q) { \
354 if ((q)->c_cc) \
355 ndflush(q, (q)->c_cc); \
356 }
357
358 /* Is 'c' a line delimiter ("break" character)? */
359 #define TTBREAKC(c, lflag) \
360 ((c) == '\n' || (((c) == cc[VEOF] || \
361 (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
362 (c) != _POSIX_VDISABLE))
363
364 /*
365 * Process input of a single character received on a tty.
366 */
367 int
368 ttyinput(int c, struct tty *tp)
369 {
370 tcflag_t iflag, lflag;
371 cc_t *cc;
372 int i, err;
373
374 /*
375 * If input is pending take it first.
376 */
377 lflag = tp->t_lflag;
378 if (ISSET(lflag, PENDIN))
379 ttypend(tp);
380 /*
381 * Gather stats.
382 */
383 if (ISSET(lflag, ICANON))
384 ++tp->t_cancc;
385 else
386 ++tp->t_rawcc;
387 ++tk_nin;
388
389 /*
390 * Block further input iff:
391 * current input > threshold AND input is available to user program
392 * AND input flow control is enabled and not yet invoked.
393 * The 3 is slop for PARMRK.
394 */
395 iflag = tp->t_iflag;
396 if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
397 (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
398 (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
399 !ISSET(tp->t_state, TS_TBLOCK))
400 ttyblock(tp);
401
402 /* Handle exceptional conditions (break, parity, framing). */
403 cc = tp->t_cc;
404 err = (ISSET(c, TTY_ERRORMASK));
405 if (err) {
406 CLR(c, TTY_ERRORMASK);
407 if (ISSET(err, TTY_BI)) {
408 if (ISSET(iflag, IGNBRK))
409 return (0);
410 if (ISSET(iflag, BRKINT)) {
411 ttyflush(tp, FREAD | FWRITE);
412 pgsignal(tp->t_pgrp, SIGINT, 1);
413 goto endcase;
414 }
415 if (ISSET(iflag, PARMRK))
416 goto parmrk;
417 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
418 || ISSET(err, TTY_FE)) {
419 if (ISSET(iflag, IGNPAR))
420 return (0);
421 else if (ISSET(iflag, PARMRK)) {
422 parmrk:
423 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
424 MAX_INPUT - 3)
425 goto input_overflow;
426 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
427 clist_putc(0 | TTY_QUOTE, &tp->t_rawq);
428 clist_putc(c | TTY_QUOTE, &tp->t_rawq);
429 goto endcase;
430 } else
431 c = 0;
432 }
433 }
434
435 if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
436 CLR(c, 0x80);
437 if (!ISSET(lflag, EXTPROC)) {
438 /*
439 * Check for literal nexting very first
440 */
441 if (ISSET(tp->t_state, TS_LNCH)) {
442 SET(c, TTY_QUOTE);
443 CLR(tp->t_state, TS_LNCH);
444 }
445 /*
446 * Scan for special characters. This code
447 * is really just a big case statement with
448 * non-constant cases. The bottom of the
449 * case statement is labeled ``endcase'', so goto
450 * it after a case match, or similar.
451 */
452
453 /*
454 * Control chars which aren't controlled
455 * by ICANON, ISIG, or IXON.
456 */
457 if (ISSET(lflag, IEXTEN)) {
458 if (CCEQ(cc[VLNEXT], c)) {
459 if (ISSET(lflag, ECHO)) {
460 if (ISSET(lflag, ECHOE)) {
461 (void)ttyoutput('^', tp);
462 (void)ttyoutput('\b', tp);
463 } else
464 ttyecho(c, tp);
465 }
466 SET(tp->t_state, TS_LNCH);
467 goto endcase;
468 }
469 if (CCEQ(cc[VDISCARD], c)) {
470 if (ISSET(lflag, FLUSHO))
471 CLR(tp->t_lflag, FLUSHO);
472 else {
473 ttyflush(tp, FWRITE);
474 ttyecho(c, tp);
475 if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
476 ttyretype(tp);
477 SET(tp->t_lflag, FLUSHO);
478 }
479 goto startoutput;
480 }
481 }
482 /*
483 * Signals.
484 */
485 if (ISSET(lflag, ISIG)) {
486 if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
487 if (!ISSET(lflag, NOFLSH))
488 ttyflush(tp, FREAD | FWRITE);
489 ttyecho(c, tp);
490 pgsignal(tp->t_pgrp,
491 CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
492 goto endcase;
493 }
494 if (CCEQ(cc[VSUSP], c)) {
495 if (!ISSET(lflag, NOFLSH))
496 ttyflush(tp, FREAD);
497 ttyecho(c, tp);
498 pgsignal(tp->t_pgrp, SIGTSTP, 1);
499 goto endcase;
500 }
501 }
502 /*
503 * Handle start/stop characters.
504 */
505 if (ISSET(iflag, IXON)) {
506 if (CCEQ(cc[VSTOP], c)) {
507 if (!ISSET(tp->t_state, TS_TTSTOP)) {
508 SET(tp->t_state, TS_TTSTOP);
509 (*tp->t_stop)(tp, 0);
510 return (0);
511 }
512 if (!CCEQ(cc[VSTART], c))
513 return (0);
514 /*
515 * if VSTART == VSTOP then toggle
516 */
517 goto endcase;
518 }
519 if (CCEQ(cc[VSTART], c))
520 goto restartoutput;
521 }
522 /*
523 * IGNCR, ICRNL, & INLCR
524 */
525 if (c == '\r') {
526 if (ISSET(iflag, IGNCR))
527 return (0);
528 else if (ISSET(iflag, ICRNL))
529 c = '\n';
530 } else if (c == '\n' && ISSET(iflag, INLCR))
531 c = '\r';
532 }
533 if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
534 /*
535 * From here on down canonical mode character
536 * processing takes place.
537 */
538 /*
539 * erase or erase2 (^H / ^?)
540 */
541 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
542 if (tp->t_rawq.c_cc)
543 ttyrub(clist_unputc(&tp->t_rawq), tp);
544 goto endcase;
545 }
546 /*
547 * kill (^U)
548 */
549 if (CCEQ(cc[VKILL], c)) {
550 if (ISSET(lflag, ECHOKE) &&
551 tp->t_rawq.c_cc == tp->t_rocount &&
552 !ISSET(lflag, ECHOPRT))
553 while (tp->t_rawq.c_cc)
554 ttyrub(clist_unputc(&tp->t_rawq), tp);
555 else {
556 ttyecho(c, tp);
557 if (ISSET(lflag, ECHOK) ||
558 ISSET(lflag, ECHOKE))
559 ttyecho('\n', tp);
560 FLUSHQ(&tp->t_rawq);
561 tp->t_rocount = 0;
562 }
563 CLR(tp->t_state, TS_LOCAL);
564 goto endcase;
565 }
566 /*
567 * word erase (^W)
568 */
569 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
570 int ctype;
571
572 /*
573 * erase whitespace
574 */
575 while ((c = clist_unputc(&tp->t_rawq)) == ' ' || c == '\t')
576 ttyrub(c, tp);
577 if (c == -1)
578 goto endcase;
579 /*
580 * erase last char of word and remember the
581 * next chars type (for ALTWERASE)
582 */
583 ttyrub(c, tp);
584 c = clist_unputc(&tp->t_rawq);
585 if (c == -1)
586 goto endcase;
587 if (c == ' ' || c == '\t') {
588 clist_putc(c, &tp->t_rawq);
589 goto endcase;
590 }
591 ctype = ISALPHA(c);
592 /*
593 * erase rest of word
594 */
595 do {
596 ttyrub(c, tp);
597 c = clist_unputc(&tp->t_rawq);
598 if (c == -1)
599 goto endcase;
600 } while (c != ' ' && c != '\t' &&
601 (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
602 clist_putc(c, &tp->t_rawq);
603 goto endcase;
604 }
605 /*
606 * reprint line (^R)
607 */
608 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
609 ttyretype(tp);
610 goto endcase;
611 }
612 /*
613 * ^T - kernel info and generate SIGINFO
614 */
615 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
616 if (ISSET(lflag, ISIG))
617 pgsignal(tp->t_pgrp, SIGINFO, 1);
618 if (!ISSET(lflag, NOKERNINFO))
619 ttyinfo(tp);
620 goto endcase;
621 }
622 if (CCEQ(cc[VCHECKPT], c) && ISSET(lflag, IEXTEN)) {
623 if (ISSET(lflag, ISIG))
624 pgsignal(tp->t_pgrp, SIGCKPT, 1);
625 goto endcase;
626 }
627 }
628 /*
629 * Check for input buffer overflow
630 */
631 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
632 input_overflow:
633 if (ISSET(iflag, IMAXBEL)) {
634 if (tp->t_outq.c_cc < tp->t_ohiwat)
635 (void)ttyoutput(CTRL('g'), tp);
636 }
637 goto endcase;
638 }
639
640 if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
641 && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
642 clist_putc(0377 | TTY_QUOTE, &tp->t_rawq);
643
644 /*
645 * Put data char in q for user and
646 * wakeup on seeing a line delimiter.
647 */
648 if (clist_putc(c, &tp->t_rawq) >= 0) {
649 if (!ISSET(lflag, ICANON)) {
650 ttwakeup(tp);
651 ttyecho(c, tp);
652 goto endcase;
653 }
654 if (TTBREAKC(c, lflag)) {
655 tp->t_rocount = 0;
656 catq(&tp->t_rawq, &tp->t_canq);
657 ttwakeup(tp);
658 } else if (tp->t_rocount++ == 0)
659 tp->t_rocol = tp->t_column;
660 if (ISSET(tp->t_state, TS_ERASE)) {
661 /*
662 * end of prterase \.../
663 */
664 CLR(tp->t_state, TS_ERASE);
665 (void)ttyoutput('/', tp);
666 }
667 i = tp->t_column;
668 ttyecho(c, tp);
669 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
670 /*
671 * Place the cursor over the '^' of the ^D.
672 */
673 i = imin(2, tp->t_column - i);
674 while (i > 0) {
675 (void)ttyoutput('\b', tp);
676 i--;
677 }
678 }
679 }
680 endcase:
681 /*
682 * IXANY means allow any character to restart output.
683 */
684 if (ISSET(tp->t_state, TS_TTSTOP) &&
685 !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
686 return (0);
687 restartoutput:
688 CLR(tp->t_lflag, FLUSHO);
689 CLR(tp->t_state, TS_TTSTOP);
690 startoutput:
691 return (ttstart(tp));
692 }
693
694 /*
695 * Output a single character on a tty, doing output processing
696 * as needed (expanding tabs, newline processing, etc.).
697 * Returns < 0 if succeeds, otherwise returns char to resend.
698 * Must be recursive.
699 */
700 static int
701 ttyoutput(int c, struct tty *tp)
702 {
703 tcflag_t oflag;
704 int col;
705
706 oflag = tp->t_oflag;
707 if (!ISSET(oflag, OPOST)) {
708 if (ISSET(tp->t_lflag, FLUSHO))
709 return (-1);
710 if (clist_putc(c, &tp->t_outq))
711 return (c);
712 tk_nout++;
713 tp->t_outcc++;
714 return (-1);
715 }
716 /*
717 * Do tab expansion if OXTABS is set. Special case if we external
718 * processing, we don't do the tab expansion because we'll probably
719 * get it wrong. If tab expansion needs to be done, let it happen
720 * externally.
721 */
722 CLR(c, ~TTY_CHARMASK);
723 if (c == '\t' &&
724 ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
725 c = 8 - (tp->t_column & 7);
726 if (!ISSET(tp->t_lflag, FLUSHO)) {
727 crit_enter(); /* Don't interrupt tabs. */
728 c -= b_to_q(" ", c, &tp->t_outq);
729 tk_nout += c;
730 tp->t_outcc += c;
731 crit_exit();
732 }
733 tp->t_column += c;
734 return (c ? -1 : '\t');
735 }
736 if (c == CEOT && ISSET(oflag, ONOEOT))
737 return (-1);
738
739 /*
740 * Newline translation: if ONLCR is set,
741 * translate newline into "\r\n".
742 */
743 if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
744 tk_nout++;
745 tp->t_outcc++;
746 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc('\r', &tp->t_outq))
747 return (c);
748 }
749 /* If OCRNL is set, translate "\r" into "\n". */
750 else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
751 c = '\n';
752 /* If ONOCR is set, don't transmit CRs when on column 0. */
753 else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
754 return (-1);
755
756 tk_nout++;
757 tp->t_outcc++;
758 if (!ISSET(tp->t_lflag, FLUSHO) && clist_putc(c, &tp->t_outq))
759 return (c);
760
761 col = tp->t_column;
762 switch (CCLASS(c)) {
763 case BACKSPACE:
764 if (col > 0)
765 --col;
766 break;
767 case CONTROL:
768 break;
769 case NEWLINE:
770 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
771 col = 0;
772 break;
773 case RETURN:
774 col = 0;
775 break;
776 case ORDINARY:
777 ++col;
778 break;
779 case TAB:
780 col = (col + 8) & ~7;
781 break;
782 }
783 tp->t_column = col;
784 return (-1);
785 }
786
787 /*
788 * Ioctls for all tty devices. Called after line-discipline specific ioctl
789 * has been called to do discipline-specific functions and/or reject any
790 * of these ioctl commands.
791 */
792 /* ARGSUSED */
793 int
794 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
795 {
796 struct thread *td = curthread;
797 struct lwp *lp = td->td_lwp;
798 struct proc *p = td->td_proc;
799 int error;
800
801 KKASSERT(p);
802
803 /* If the ioctl involves modification, hang if in the background. */
804 switch (cmd) {
805 case TIOCCBRK:
806 case TIOCCONS:
807 case TIOCDRAIN:
808 case TIOCEXCL:
809 case TIOCFLUSH:
810 #ifdef TIOCHPCL
811 case TIOCHPCL:
812 #endif
813 case TIOCNXCL:
814 case TIOCSBRK:
815 case TIOCSCTTY:
816 case TIOCSDRAINWAIT:
817 case TIOCSETA:
818 case TIOCSETAF:
819 case TIOCSETAW:
820 case TIOCSETD:
821 case TIOCSPGRP:
822 case TIOCSTART:
823 case TIOCSTAT:
824 case TIOCSTI:
825 case TIOCSTOP:
826 case TIOCSWINSZ:
827 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
828 case TIOCLBIC:
829 case TIOCLBIS:
830 case TIOCLSET:
831 case TIOCSETC:
832 case OTIOCSETD:
833 case TIOCSETN:
834 case TIOCSETP:
835 case TIOCSLTC:
836 #endif
837 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
838 !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
839 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
840 if (p->p_pgrp->pg_jobc == 0)
841 return (EIO);
842 pgsignal(p->p_pgrp, SIGTTOU, 1);
843 error = ttysleep(tp, &lbolt, PCATCH, "ttybg1",
844 0);
845 if (error)
846 return (error);
847 }
848 break;
849 }
850
851 switch (cmd) { /* Process the ioctl. */
852 case FIOASYNC: /* set/clear async i/o */
853 crit_enter();
854 if (*(int *)data)
855 SET(tp->t_state, TS_ASYNC);
856 else
857 CLR(tp->t_state, TS_ASYNC);
858 crit_exit();
859 break;
860 case FIONREAD: /* get # bytes to read */
861 crit_enter();
862 *(int *)data = ttnread(tp);
863 crit_exit();
864 break;
865
866 case FIOSETOWN:
867 /*
868 * Policy -- Don't allow FIOSETOWN on someone else's
869 * controlling tty
870 */
871 if (tp->t_session != NULL && !isctty(p, tp))
872 return (ENOTTY);
873
874 error = fsetown(*(int *)data, &tp->t_sigio);
875 if (error)
876 return (error);
877 break;
878 case FIOGETOWN:
879 if (tp->t_session != NULL && !isctty(p, tp))
880 return (ENOTTY);
881 *(int *)data = fgetown(tp->t_sigio);
882 break;
883
884 case TIOCEXCL: /* set exclusive use of tty */
885 crit_enter();
886 SET(tp->t_state, TS_XCLUDE);
887 crit_exit();
888 break;
889 case TIOCFLUSH: { /* flush buffers */
890 int flags = *(int *)data;
891
892 if (flags == 0)
893 flags = FREAD | FWRITE;
894 else
895 flags &= FREAD | FWRITE;
896 ttyflush(tp, flags);
897 break;
898 }
899 case TIOCCONS: /* become virtual console */
900 if (*(int *)data) {
901 if (constty && constty != tp &&
902 ISSET(constty->t_state, TS_CONNECTED))
903 return (EBUSY);
904 #ifndef UCONSOLE
905 if ((error = suser(td)) != 0)
906 return (error);
907 #endif
908 constty = tp;
909 } else if (tp == constty)
910 constty = NULL;
911 break;
912 case TIOCDRAIN: /* wait till output drained */
913 error = ttywait(tp);
914 if (error)
915 return (error);
916 break;
917 case TIOCGETA: { /* get termios struct */
918 struct termios *t = (struct termios *)data;
919
920 bcopy(&tp->t_termios, t, sizeof(struct termios));
921 break;
922 }
923 case TIOCGETD: /* get line discipline */
924 *(int *)data = tp->t_line;
925 break;
926 case TIOCGWINSZ: /* get window size */
927 *(struct winsize *)data = tp->t_winsize;
928 break;
929 case TIOCGPGRP: /* get pgrp of tty */
930 if (!isctty(p, tp))
931 return (ENOTTY);
932 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
933 break;
934 #ifdef TIOCHPCL
935 case TIOCHPCL: /* hang up on last close */
936 crit_enter();
937 SET(tp->t_cflag, HUPCL);
938 crit_exit();
939 break;
940 #endif
941 case TIOCNXCL: /* reset exclusive use of tty */
942 crit_enter();
943 CLR(tp->t_state, TS_XCLUDE);
944 crit_exit();
945 break;
946 case TIOCOUTQ: /* output queue size */
947 *(int *)data = tp->t_outq.c_cc;
948 break;
949 case TIOCSETA: /* set termios struct */
950 case TIOCSETAW: /* drain output, set */
951 case TIOCSETAF: { /* drn out, fls in, set */
952 struct termios *t = (struct termios *)data;
953
954 if (t->c_ispeed == 0)
955 t->c_ispeed = t->c_ospeed;
956 if (t->c_ispeed == 0)
957 t->c_ispeed = tp->t_ospeed;
958 if (t->c_ispeed == 0)
959 return (EINVAL);
960 crit_enter();
961 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
962 error = ttywait(tp);
963 if (error) {
964 crit_exit();
965 return (error);
966 }
967 if (cmd == TIOCSETAF)
968 ttyflush(tp, FREAD);
969 }
970 if (!ISSET(t->c_cflag, CIGNORE)) {
971 /*
972 * Set device hardware.
973 */
974 if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
975 crit_exit();
976 return (error);
977 }
978 if (ISSET(t->c_cflag, CLOCAL) &&
979 !ISSET(tp->t_cflag, CLOCAL)) {
980 /*
981 * XXX disconnections would be too hard to
982 * get rid of without this kludge. The only
983 * way to get rid of controlling terminals
984 * is to exit from the session leader.
985 */
986 CLR(tp->t_state, TS_ZOMBIE);
987
988 wakeup(TSA_CARR_ON(tp));
989 ttwakeup(tp);
990 ttwwakeup(tp);
991 }
992 if ((ISSET(tp->t_state, TS_CARR_ON) ||
993 ISSET(t->c_cflag, CLOCAL)) &&
994 !ISSET(tp->t_state, TS_ZOMBIE))
995 SET(tp->t_state, TS_CONNECTED);
996 else
997 CLR(tp->t_state, TS_CONNECTED);
998 tp->t_cflag = t->c_cflag;
999 tp->t_ispeed = t->c_ispeed;
1000 if (t->c_ospeed != 0)
1001 tp->t_ospeed = t->c_ospeed;
1002 ttsetwater(tp);
1003 }
1004 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1005 cmd != TIOCSETAF) {
1006 if (ISSET(t->c_lflag, ICANON))
1007 SET(tp->t_lflag, PENDIN);
1008 else {
1009 /*
1010 * XXX we really shouldn't allow toggling
1011 * ICANON while we're in a non-termios line
1012 * discipline. Now we have to worry about
1013 * panicing for a null queue.
1014 */
1015 if (tp->t_canq.c_cbreserved > 0 &&
1016 tp->t_rawq.c_cbreserved > 0) {
1017 catq(&tp->t_rawq, &tp->t_canq);
1018 /*
1019 * XXX the queue limits may be
1020 * different, so the old queue
1021 * swapping method no longer works.
1022 */
1023 catq(&tp->t_canq, &tp->t_rawq);
1024 }
1025 CLR(tp->t_lflag, PENDIN);
1026 }
1027 ttwakeup(tp);
1028 }
1029 tp->t_iflag = t->c_iflag;
1030 tp->t_oflag = t->c_oflag;
1031 /*
1032 * Make the EXTPROC bit read only.
1033 */
1034 if (ISSET(tp->t_lflag, EXTPROC))
1035 SET(t->c_lflag, EXTPROC);
1036 else
1037 CLR(t->c_lflag, EXTPROC);
1038 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1039 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1040 t->c_cc[VTIME] != tp->t_cc[VTIME])
1041 ttwakeup(tp);
1042 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1043 crit_exit();
1044 break;
1045 }
1046 case TIOCSETD: { /* set line discipline */
1047 int t = *(int *)data;
1048 cdev_t device = tp->t_dev;
1049
1050 if ((u_int)t >= nlinesw)
1051 return (ENXIO);
1052 if (t != tp->t_line) {
1053 crit_enter();
1054 (*linesw[tp->t_line].l_close)(tp, flag);
1055 error = (*linesw[t].l_open)(device, tp);
1056 if (error) {
1057 (void)(*linesw[tp->t_line].l_open)(device, tp);
1058 crit_exit();
1059 return (error);
1060 }
1061 tp->t_line = t;
1062 crit_exit();
1063 }
1064 break;
1065 }
1066 case TIOCSTART: /* start output, like ^Q */
1067 crit_enter();
1068 if (ISSET(tp->t_state, TS_TTSTOP) ||
1069 ISSET(tp->t_lflag, FLUSHO)) {
1070 CLR(tp->t_lflag, FLUSHO);
1071 CLR(tp->t_state, TS_TTSTOP);
1072 ttstart(tp);
1073 }
1074 crit_exit();
1075 break;
1076 case TIOCSTI: /* simulate terminal input */
1077 if ((flag & FREAD) == 0 && suser(td))
1078 return (EPERM);
1079 if (!isctty(p, tp) && suser(td))
1080 return (EACCES);
1081 crit_enter();
1082 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
1083 crit_exit();
1084 break;
1085 case TIOCSTOP: /* stop output, like ^S */
1086 crit_enter();
1087 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1088 SET(tp->t_state, TS_TTSTOP);
1089 (*tp->t_stop)(tp, 0);
1090 }
1091 crit_exit();
1092 break;
1093 case TIOCSCTTY: /* become controlling tty */
1094 /* Session ctty vnode pointer set in vnode layer. */
1095 if (!SESS_LEADER(p) ||
1096 ((p->p_session->s_ttyvp || tp->t_session) &&
1097 (tp->t_session != p->p_session)))
1098 return (EPERM);
1099 tp->t_session = p->p_session;
1100 tp->t_pgrp = p->p_pgrp;
1101 p->p_session->s_ttyp = tp;
1102 p->p_flag |= P_CONTROLT;
1103 break;
1104 case TIOCSPGRP: { /* set pgrp of tty */
1105 struct pgrp *pgrp = pgfind(*(int *)data);
1106
1107 if (!isctty(p, tp))
1108 return (ENOTTY);
1109 else if (pgrp == NULL || pgrp->pg_session != p->p_session)
1110 return (EPERM);
1111 tp->t_pgrp = pgrp;
1112 break;
1113 }
1114 case TIOCSTAT: /* simulate control-T */
1115 crit_enter();
1116 ttyinfo(tp);
1117 crit_exit();
1118 break;
1119 case TIOCSWINSZ: /* set window size */
1120 if (bcmp((caddr_t)&tp->t_winsize, data,
1121 sizeof (struct winsize))) {
1122 tp->t_winsize = *(struct winsize *)data;
1123 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1124 }
1125 break;
1126 case TIOCSDRAINWAIT:
1127 error = suser(td);
1128 if (error)
1129 return (error);
1130 tp->t_timeout = *(int *)data * hz;
1131 wakeup(TSA_OCOMPLETE(tp));
1132 wakeup(TSA_OLOWAT(tp));
1133 break;
1134 case TIOCGDRAINWAIT:
1135 *(int *)data = tp->t_timeout / hz;
1136 break;
1137 default:
1138 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1139 return (ttcompat(tp, cmd, data, flag));
1140 #else
1141 return (ENOIOCTL);
1142 #endif
1143 }
1144 return (0);
1145 }
1146
1147 int
1148 ttypoll(struct dev_poll_args *ap)
1149 {
1150 cdev_t dev = ap->a_head.a_dev;
1151 int events = ap->a_events;
1152 int revents = 0;
1153 struct tty *tp;
1154
1155 tp = dev->si_tty;
1156 /* XXX used to return ENXIO, but that means true! */
1157 if (tp == NULL) {
1158 ap->a_events = (events & (POLLIN | POLLOUT | POLLRDNORM |
1159 POLLWRNORM)) | POLLHUP;
1160 return(0);
1161 }
1162
1163 crit_enter();
1164 if (events & (POLLIN | POLLRDNORM)) {
1165 if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
1166 revents |= events & (POLLIN | POLLRDNORM);
1167 else
1168 selrecord(curthread, &tp->t_rsel);
1169 }
1170 if (events & (POLLOUT | POLLWRNORM)) {
1171 if ((tp->t_outq.c_cc <= tp->t_olowat &&
1172 ISSET(tp->t_state, TS_CONNECTED))
1173 || ISSET(tp->t_state, TS_ZOMBIE))
1174 revents |= events & (POLLOUT | POLLWRNORM);
1175 else
1176 selrecord(curthread, &tp->t_wsel);
1177 }
1178 crit_exit();
1179 ap->a_events = revents;
1180 return (0);
1181 }
1182
1183 static struct filterops ttyread_filtops =
1184 { 1, NULL, filt_ttyrdetach, filt_ttyread };
1185 static struct filterops ttywrite_filtops =
1186 { 1, NULL, filt_ttywdetach, filt_ttywrite };
1187
1188 int
1189 ttykqfilter(struct dev_kqfilter_args *ap)
1190 {
1191 cdev_t dev = ap->a_head.a_dev;
1192 struct knote *kn = ap->a_kn;
1193 struct tty *tp = dev->si_tty;
1194 struct klist *klist;
1195
1196 ap->a_result = 0;
1197 switch (kn->kn_filter) {
1198 case EVFILT_READ:
1199 klist = &tp->t_rsel.si_note;
1200 kn->kn_fop = &ttyread_filtops;
1201 break;
1202 case EVFILT_WRITE:
1203 klist = &tp->t_wsel.si_note;
1204 kn->kn_fop = &ttywrite_filtops;
1205 break;
1206 default:
1207 ap->a_result = 1;
1208 return (0);
1209 }
1210
1211 kn->kn_hook = (caddr_t)dev;
1212
1213 crit_enter();
1214 SLIST_INSERT_HEAD(klist, kn, kn_selnext);
1215 crit_exit();
1216
1217 return (0);
1218 }
1219
1220 static void
1221 filt_ttyrdetach(struct knote *kn)
1222 {
1223 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1224
1225 crit_enter();
1226 SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
1227 crit_exit();
1228 }
1229
1230 static int
1231 filt_ttyread(struct knote *kn, long hint)
1232 {
1233 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1234
1235 kn->kn_data = ttnread(tp);
1236 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1237 kn->kn_flags |= EV_EOF;
1238 return (1);
1239 }
1240 return (kn->kn_data > 0);
1241 }
1242
1243 static void
1244 filt_ttywdetach(struct knote *kn)
1245 {
1246 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1247
1248 crit_enter();
1249 SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
1250 crit_exit();
1251 }
1252
1253 static int
1254 filt_ttywrite(struct knote *kn, long hint)
1255 {
1256 struct tty *tp = ((cdev_t)kn->kn_hook)->si_tty;
1257
1258 kn->kn_data = tp->t_outq.c_cc;
1259 if (ISSET(tp->t_state, TS_ZOMBIE))
1260 return (1);
1261 return (kn->kn_data <= tp->t_olowat &&
1262 ISSET(tp->t_state, TS_CONNECTED));
1263 }
1264
1265 /*
1266 * Must be called while in a critical section.
1267 */
1268 static int
1269 ttnread(struct tty *tp)
1270 {
1271 int nread;
1272
1273 if (ISSET(tp->t_lflag, PENDIN))
1274 ttypend(tp);
1275 nread = tp->t_canq.c_cc;
1276 if (!ISSET(tp->t_lflag, ICANON)) {
1277 nread += tp->t_rawq.c_cc;
1278 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1279 nread = 0;
1280 }
1281 return (nread);
1282 }
1283
1284 /*
1285 * Wait for output to drain.
1286 */
1287 int
1288 ttywait(struct tty *tp)
1289 {
1290 int error;
1291
1292 error = 0;
1293 crit_enter();
1294 while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1295 ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1296 (*tp->t_oproc)(tp);
1297 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1298 ISSET(tp->t_state, TS_CONNECTED)) {
1299 SET(tp->t_state, TS_SO_OCOMPLETE);
1300 error = ttysleep(tp, TSA_OCOMPLETE(tp),
1301 PCATCH, "ttywai",
1302 tp->t_timeout);
1303 if (error) {
1304 if (error == EWOULDBLOCK)
1305 error = EIO;
1306 break;
1307 }
1308 } else
1309 break;
1310 }
1311 if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1312 error = EIO;
1313 crit_exit();
1314 return (error);
1315 }
1316
1317 /*
1318 * Flush if successfully wait.
1319 */
1320 static int
1321 ttywflush(struct tty *tp)
1322 {
1323 int error;
1324
1325 if ((error = ttywait(tp)) == 0)
1326 ttyflush(tp, FREAD);
1327 return (error);
1328 }
1329
1330 /*
1331 * Flush tty read and/or write queues, notifying anyone waiting.
1332 */
1333 void
1334 ttyflush(struct tty *tp, int rw)
1335 {
1336 crit_enter();
1337 #if 0
1338 again:
1339 #endif
1340 if (rw & FWRITE) {
1341 FLUSHQ(&tp->t_outq);
1342 CLR(tp->t_state, TS_TTSTOP);
1343 }
1344 (*tp->t_stop)(tp, rw);
1345 if (rw & FREAD) {
1346 FLUSHQ(&tp->t_canq);
1347 FLUSHQ(&tp->t_rawq);
1348 CLR(tp->t_lflag, PENDIN);
1349 tp->t_rocount = 0;
1350 tp->t_rocol = 0;
1351 CLR(tp->t_state, TS_LOCAL);
1352 ttwakeup(tp);
1353 if (ISSET(tp->t_state, TS_TBLOCK)) {
1354 if (rw & FWRITE)
1355 FLUSHQ(&tp->t_outq);
1356 ttyunblock(tp);
1357
1358 /*
1359 * Don't let leave any state that might clobber the
1360 * next line discipline (although we should do more
1361 * to send the START char). Not clearing the state
1362 * may have caused the "putc to a clist with no
1363 * reserved cblocks" panic/kprintf.
1364 */
1365 CLR(tp->t_state, TS_TBLOCK);
1366
1367 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1368 if (ISSET(tp->t_iflag, IXOFF)) {
1369 /*
1370 * XXX wait a bit in the hope that the stop
1371 * character (if any) will go out. Waiting
1372 * isn't good since it allows races. This
1373 * will be fixed when the stop character is
1374 * put in a special queue. Don't bother with
1375 * the checks in ttywait() since the timeout
1376 * will save us.
1377 */
1378 SET(tp->t_state, TS_SO_OCOMPLETE);
1379 ttysleep(tp, TSA_OCOMPLETE(tp), 0,
1380 "ttyfls", hz / 10);
1381 /*
1382 * Don't try sending the stop character again.
1383 */
1384 CLR(tp->t_state, TS_TBLOCK);
1385 goto again;
1386 }
1387 #endif
1388 }
1389 }
1390 if (rw & FWRITE) {
1391 FLUSHQ(&tp->t_outq);
1392 ttwwakeup(tp);
1393 }
1394 crit_exit();
1395 }
1396
1397 /*
1398 * Copy in the default termios characters.
1399 */
1400 void
1401 termioschars(struct termios *t)
1402 {
1403
1404 bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1405 }
1406
1407 /*
1408 * Old interface.
1409 */
1410 void
1411 ttychars(struct tty *tp)
1412 {
1413
1414 termioschars(&tp->t_termios);
1415 }
1416
1417 /*
1418 * Handle input high water. Send stop character for the IXOFF case. Turn
1419 * on our input flow control bit and propagate the changes to the driver.
1420 * XXX the stop character should be put in a special high priority queue.
1421 */
1422 void
1423 ttyblock(struct tty *tp)
1424 {
1425
1426 SET(tp->t_state, TS_TBLOCK);
1427 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1428 clist_putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1429 CLR(tp->t_state, TS_TBLOCK); /* try again later */
1430 ttstart(tp);
1431 }
1432
1433 /*
1434 * Handle input low water. Send start character for the IXOFF case. Turn
1435 * off our input flow control bit and propagate the changes to the driver.
1436 * XXX the start character should be put in a special high priority queue.
1437 */
1438 static void
1439 ttyunblock(struct tty *tp)
1440 {
1441
1442 CLR(tp->t_state, TS_TBLOCK);
1443 if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1444 clist_putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1445 SET(tp->t_state, TS_TBLOCK); /* try again later */
1446 ttstart(tp);
1447 }
1448
1449 #ifdef notyet
1450 /* Not used by any current (i386) drivers. */
1451 /*
1452 * Restart after an inter-char delay.
1453 */
1454 void
1455 ttrstrt(void *tp_arg)
1456 {
1457 struct tty *tp;
1458
1459 KASSERT(tp_arg != NULL, ("ttrstrt"));
1460
1461 tp = tp_arg;
1462 crit_enter();
1463 CLR(tp->t_state, TS_TIMEOUT);
1464 ttstart(tp);
1465 crit_exit();
1466 }
1467 #endif
1468
1469 int
1470 ttstart(struct tty *tp)
1471 {
1472
1473 if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
1474 (*tp->t_oproc)(tp);
1475 return (0);
1476 }
1477
1478 /*
1479 * "close" a line discipline
1480 */
1481 int
1482 ttylclose(struct tty *tp, int flag)
1483 {
1484
1485 if (flag & FNONBLOCK || ttywflush(tp))
1486 ttyflush(tp, FREAD | FWRITE);
1487 return (0);
1488 }
1489
1490 /*
1491 * Handle modem control transition on a tty.
1492 * Flag indicates new state of carrier.
1493 * Returns 0 if the line should be turned off, otherwise 1.
1494 */
1495 int
1496 ttymodem(struct tty *tp, int flag)
1497 {
1498
1499 if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1500 /*
1501 * MDMBUF: do flow control according to carrier flag
1502 * XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
1503 * works if IXON and IXANY are clear.
1504 */
1505 if (flag) {
1506 CLR(tp->t_state, TS_CAR_OFLOW);
1507 CLR(tp->t_state, TS_TTSTOP);
1508 ttstart(tp);
1509 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1510 SET(tp->t_state, TS_CAR_OFLOW);
1511 SET(tp->t_state, TS_TTSTOP);
1512 (*tp->t_stop)(tp, 0);
1513 }
1514 } else if (flag == 0) {
1515 /*
1516 * Lost carrier.
1517 */
1518 CLR(tp->t_state, TS_CARR_ON);
1519 if (ISSET(tp->t_state, TS_ISOPEN) &&
1520 !ISSET(tp->t_cflag, CLOCAL)) {
1521 SET(tp->t_state, TS_ZOMBIE);
1522 CLR(tp->t_state, TS_CONNECTED);
1523 if (tp->t_session && tp->t_session->s_leader)
1524 ksignal(tp->t_session->s_leader, SIGHUP);
1525 ttyflush(tp, FREAD | FWRITE);
1526 return (0);
1527 }
1528 } else {
1529 /*
1530 * Carrier now on.
1531 */
1532 SET(tp->t_state, TS_CARR_ON);
1533 if (!ISSET(tp->t_state, TS_ZOMBIE))
1534 SET(tp->t_state, TS_CONNECTED);
1535 wakeup(TSA_CARR_ON(tp));
1536 ttwakeup(tp);
1537 ttwwakeup(tp);
1538 }
1539 return (1);
1540 }
1541
1542 /*
1543 * Reinput pending characters after state switch
1544 * call from a critical section.
1545 */
1546 static void
1547 ttypend(struct tty *tp)
1548 {
1549 struct clist tq;
1550 int c;
1551
1552 CLR(tp->t_lflag, PENDIN);
1553 SET(tp->t_state, TS_TYPEN);
1554 /*
1555 * XXX this assumes too much about clist internals. It may even
1556 * fail if the cblock slush pool is empty. We can't allocate more
1557 * cblocks here because we are called from an interrupt handler
1558 * and clist_alloc_cblocks() can wait.
1559 */
1560 tq = tp->t_rawq;
1561 bzero(&tp->t_rawq, sizeof tp->t_rawq);
1562 tp->t_rawq.c_cbmax = tq.c_cbmax;
1563 tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1564 while ((c = clist_getc(&tq)) >= 0)
1565 ttyinput(c, tp);
1566 CLR(tp->t_state, TS_TYPEN);
1567 }
1568
1569 /*
1570 * Process a read call on a tty device.
1571 */
1572 int
1573 ttread(struct tty *tp, struct uio *uio, int flag)
1574 {
1575 struct clist *qp;
1576 int c;
1577 tcflag_t lflag;
1578 cc_t *cc = tp->t_cc;
1579 struct proc *pp;
1580 struct lwp *lp;
1581 int first, error = 0;
1582 int has_stime = 0, last_cc = 0;
1583 long slp = 0; /* XXX this should be renamed `timo'. */
1584 struct timeval stime;
1585
1586 lp = curthread->td_lwp;
1587
1588 loop:
1589 crit_enter();
1590 lflag = tp->t_lflag;
1591 /*
1592 * take pending input first
1593 */
1594 if (ISSET(lflag, PENDIN)) {
1595 ttypend(tp);
1596 splz(); /* reduce latency */
1597 lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
1598 }
1599
1600 /*
1601 * Hang process if it's in the background.
1602 */
1603 if ((pp = curproc) && isbackground(pp, tp)) {
1604 crit_exit();
1605 if (SIGISMEMBER(pp->p_sigignore, SIGTTIN) ||
1606 SIGISMEMBER(lp->lwp_sigmask, SIGTTIN) ||
1607 (pp->p_flag & P_PPWAIT) || pp->p_pgrp->pg_jobc == 0)
1608 return (EIO);
1609 pgsignal(pp->p_pgrp, SIGTTIN, 1);
1610 error = ttysleep(tp, &lbolt, PCATCH, "ttybg2", 0);
1611 if (error)
1612 return (error);
1613 goto loop;
1614 }
1615
1616 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1617 crit_exit();
1618 return (0); /* EOF */
1619 }
1620
1621 /*
1622 * If canonical, use the canonical queue,
1623 * else use the raw queue.
1624 *
1625 * (should get rid of clists...)
1626 */
1627 qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1628
1629 if (flag & IO_NDELAY) {
1630 if (qp->c_cc > 0)
1631 goto read;
1632 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1633 crit_exit();
1634 return (0);
1635 }
1636 crit_exit();
1637 return (EWOULDBLOCK);
1638 }
1639 if (!ISSET(lflag, ICANON)) {
1640 int m = cc[VMIN];
1641 long t = cc[VTIME];
1642 struct timeval timecopy;
1643
1644 /*
1645 * Check each of the four combinations.
1646 * (m > 0 && t == 0) is the normal read case.
1647 * It should be fairly efficient, so we check that and its
1648 * companion case (m == 0 && t == 0) first.
1649 * For the other two cases, we compute the target sleep time
1650 * into slp.
1651 */
1652 if (t == 0) {
1653 if (qp->c_cc < m)
1654 goto sleep;
1655 if (qp->c_cc > 0)
1656 goto read;
1657
1658 /* m, t and qp->c_cc are all 0. 0 is enough input. */
1659 crit_exit();
1660 return (0);
1661 }
1662 t *= 100000; /* time in us */
1663 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1664 ((t1).tv_usec - (t2).tv_usec))
1665 if (m > 0) {
1666 if (qp->c_cc <= 0)
1667 goto sleep;
1668 if (qp->c_cc >= m)
1669 goto read;
1670 getmicrotime(&timecopy);
1671 if (!has_stime) {
1672 /* first character, start timer */
1673 has_stime = 1;
1674 stime = timecopy;
1675 slp = t;
1676 } else if (qp->c_cc > last_cc) {
1677 /* got a character, restart timer */
1678 stime = timecopy;
1679 slp = t;
1680 } else {
1681 /* nothing, check expiration */
1682 slp = t - diff(timecopy, stime);
1683 if (slp <= 0)
1684 goto read;
1685 }
1686 last_cc = qp->c_cc;
1687 } else { /* m == 0 */
1688 if (qp->c_cc > 0)
1689 goto read;
1690 getmicrotime(&timecopy);
1691 if (!has_stime) {
1692 has_stime = 1;
1693 stime = timecopy;
1694 slp = t;
1695 } else {
1696 slp = t - diff(timecopy, stime);
1697 if (slp <= 0) {
1698 /* Timed out, but 0 is enough input. */
1699 crit_exit();
1700 return (0);
1701 }
1702 }
1703 }
1704 #undef diff
1705 /*
1706 * Rounding down may make us wake up just short
1707 * of the target, so we round up.
1708 * The formula is ceiling(slp * hz/1000000).
1709 * 32-bit arithmetic is enough for hz < 169.
1710 * XXX see tvtohz() for how to avoid overflow if hz
1711 * is large (divide by `tick' and/or arrange to
1712 * use tvtohz() if hz is large).
1713 */
1714 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1715 goto sleep;
1716 }
1717 if (qp->c_cc <= 0) {
1718 sleep:
1719 /*
1720 * There is no input, or not enough input and we can block.
1721 */
1722 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), PCATCH,
1723 ISSET(tp->t_state, TS_CONNECTED) ?
1724 "ttyin" : "ttyhup", (int)slp);
1725 crit_exit();
1726 if (error == EWOULDBLOCK)
1727 error = 0;
1728 else if (error)
1729 return (error);
1730 /*
1731 * XXX what happens if another process eats some input
1732 * while we are asleep (not just here)? It would be
1733 * safest to detect changes and reset our state variables
1734 * (has_stime and last_cc).
1735 */
1736 slp = 0;
1737 goto loop;
1738 }
1739 read:
1740 crit_exit();
1741 /*
1742 * Input present, check for input mapping and processing.
1743 */
1744 first = 1;
1745 if (ISSET(lflag, ICANON | ISIG))
1746 goto slowcase;
1747 for (;;) {
1748 char ibuf[IBUFSIZ];
1749 int icc;
1750
1751 icc = imin(uio->uio_resid, IBUFSIZ);
1752 icc = q_to_b(qp, ibuf, icc);
1753 if (icc <= 0) {
1754 if (first)
1755 goto loop;
1756 break;
1757 }
1758 error = uiomove(ibuf, icc, uio);
1759 /*
1760 * XXX if there was an error then we should ungetc() the
1761 * unmoved chars and reduce icc here.
1762 */
1763 if (error)
1764 break;
1765 if (uio->uio_resid == 0)
1766 break;
1767 first = 0;
1768 }
1769 goto out;
1770 slowcase:
1771 for (;;) {
1772 c = clist_getc(qp);
1773 if (c < 0) {
1774 if (first)
1775 goto loop;
1776 break;
1777 }
1778 /*
1779 * delayed suspend (^Y)
1780 */
1781 if (CCEQ(cc[VDSUSP], c) &&
1782 ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1783 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1784 if (first) {
1785 error = ttysleep(tp, &lbolt, PCATCH,
1786 "ttybg3", 0);
1787 if (error)
1788 break;
1789 goto loop;
1790 }
1791 break;
1792 }
1793 /*
1794 * Interpret EOF only in canonical mode.
1795 */
1796 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1797 break;
1798 /*
1799 * Give user character.
1800 */
1801 error = ureadc(c, uio);
1802 if (error)
1803 /* XXX should ungetc(c, qp). */
1804 break;
1805 if (uio->uio_resid == 0)
1806 break;
1807 /*
1808 * In canonical mode check for a "break character"
1809 * marking the end of a "line of input".
1810 */
1811 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1812 break;
1813 first = 0;
1814 }
1815
1816 out:
1817 /*
1818 * Look to unblock input now that (presumably)
1819 * the input queue has gone down.
1820 */
1821 crit_enter();
1822 if (ISSET(tp->t_state, TS_TBLOCK) &&
1823 tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1824 ttyunblock(tp);
1825 crit_exit();
1826
1827 return (error);
1828 }
1829
1830 /*
1831 * Check the output queue on tp for space for a kernel message (from uprintf
1832 * or tprintf). Allow some space over the normal hiwater mark so we don't
1833 * lose messages due to normal flow control, but don't let the tty run amok.
1834 * Sleeps here are not interruptible, but we return prematurely if new signals
1835 * arrive.
1836 */
1837 int
1838 ttycheckoutq(struct tty *tp, int wait)
1839 {
1840 struct lwp *lp = curthread->td_lwp;
1841 int hiwat;
1842 sigset_t oldset, newset;
1843
1844 hiwat = tp->t_ohiwat;
1845 SIGEMPTYSET(oldset);
1846 SIGEMPTYSET(newset);
1847 crit_enter();
1848 if (wait)
1849 oldset = lwp_sigpend(lp);
1850 if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) {
1851 while (tp->t_outq.c_cc > hiwat) {
1852 ttstart(tp);
1853 if (tp->t_outq.c_cc <= hiwat)
1854 break;
1855 if (wait)
1856 newset = lwp_sigpend(lp);
1857 if (!wait || SIGSETNEQ(oldset, newset)) {
1858 crit_exit();
1859 return (0);
1860 }
1861 SET(tp->t_state, TS_SO_OLOWAT);
1862 tsleep(TSA_OLOWAT(tp), 0, "ttoutq", hz);
1863 }
1864 }
1865 crit_exit();
1866 return (1);
1867 }
1868
1869 /*
1870 * Process a write call on a tty device.
1871 */
1872 int
1873 ttwrite(struct tty *tp, struct uio *uio, int flag)
1874 {
1875 char *cp = NULL;
1876 int cc, ce;
1877 struct proc *pp;
1878 struct lwp *lp;
1879 int i, hiwat, cnt, error;
1880 char obuf[OBUFSIZ];
1881
1882 lp = curthread->td_lwp;
1883 hiwat = tp->t_ohiwat;
1884 cnt = uio->uio_resid;
1885 error = 0;
1886 cc = 0;
1887 loop:
1888 crit_enter();
1889 if (ISSET(tp->t_state, TS_ZOMBIE)) {
1890 crit_exit();
1891 if (uio->uio_resid == cnt)
1892 error = EIO;
1893 goto out;
1894 }
1895 if (!ISSET(tp->t_state, TS_CONNECTED)) {
1896 if (flag & IO_NDELAY) {
1897 crit_exit();
1898 error = EWOULDBLOCK;
1899 goto out;
1900 }
1901 error = ttysleep(tp, TSA_CARR_ON(tp), PCATCH, "ttydcd", 0);
1902 crit_exit();
1903 if (error)
1904 goto out;
1905 goto loop;
1906 }
1907 crit_exit();
1908
1909 /*
1910 * Hang the process if it's in the background.
1911 */
1912 if ((pp = curproc) && isbackground(pp, tp) &&
1913 ISSET(tp->t_lflag, TOSTOP) && !(pp->p_flag & P_PPWAIT) &&
1914 !SIGISMEMBER(pp->p_sigignore, SIGTTOU) &&
1915 !SIGISMEMBER(lp->lwp_sigmask, SIGTTOU)) {
1916 if (pp->p_pgrp->pg_jobc == 0) {
1917 error = EIO;
1918 goto out;
1919 }
1920 pgsignal(pp->p_pgrp, SIGTTOU, 1);
1921 error = ttysleep(tp, &lbolt, PCATCH, "ttybg4", 0);
1922 if (error)
1923 goto out;
1924 goto loop;
1925 }
1926 /*
1927 * Process the user's data in at most OBUFSIZ chunks. Perform any
1928 * output translation. Keep track of high water mark, sleep on
1929 * overflow awaiting device aid in acquiring new space.
1930 */
1931 while (uio->uio_resid > 0 || cc > 0) {
1932 if (ISSET(tp->t_lflag, FLUSHO)) {
1933 uio->uio_resid = 0;
1934 return (0);
1935 }
1936 if (tp->t_outq.c_cc > hiwat)
1937 goto ovhiwat;
1938 /*
1939 * Grab a hunk of data from the user, unless we have some
1940 * leftover from last time.
1941 */
1942 if (cc == 0) {
1943 cc = imin(uio->uio_resid, OBUFSIZ);
1944 cp = obuf;
1945 error = uiomove(cp, cc, uio);
1946 if (error) {
1947 cc = 0;
1948 break;
1949 }
1950 }
1951 /*
1952 * If nothing fancy need be done, grab those characters we
1953 * can handle without any of ttyoutput's processing and
1954 * just transfer them to the output q. For those chars
1955 * which require special processing (as indicated by the
1956 * bits in char_type), call ttyoutput. After processing
1957 * a hunk of data, look for FLUSHO so ^O's will take effect
1958 * immediately.
1959 */
1960 while (cc > 0) {
1961 if (!ISSET(tp->t_oflag, OPOST))
1962 ce = cc;
1963 else {
1964 ce = cc - scanc((u_int)cc, (u_char *)cp,
1965 char_type, CCLASSMASK);
1966 /*
1967 * If ce is zero, then we're processing
1968 * a special character through ttyoutput.
1969 */
1970 if (ce == 0) {
1971 tp->t_rocount = 0;
1972 if (ttyoutput(*cp, tp) >= 0) {
1973 /* No Clists, wait a bit. */
1974 ttstart(tp);
1975 if (flag & IO_NDELAY) {
1976 error = EWOULDBLOCK;
1977 goto out;
1978 }
1979 error = ttysleep(tp, &lbolt,
1980 PCATCH,
1981 "ttybf1", 0);
1982 if (error)
1983 goto out;
1984 goto loop;
1985 }
1986 cp++;
1987 cc--;
1988 if (ISSET(tp->t_lflag, FLUSHO) ||
1989 tp->t_outq.c_cc > hiwat)
1990 goto ovhiwat;
1991 continue;
1992 }
1993 }
1994 /*
1995 * A bunch of normal characters have been found.
1996 * Transfer them en masse to the output queue and
1997 * continue processing at the top of the loop.
1998 * If there are any further characters in this
1999 * <= OBUFSIZ chunk, the first should be a character
2000 * requiring special handling by ttyoutput.
2001 */
2002 tp->t_rocount = 0;
2003 i = b_to_q(cp, ce, &tp->t_outq);
2004 ce -= i;
2005 tp->t_column += ce;
2006 cp += ce, cc -= ce, tk_nout += ce;
2007 tp->t_outcc += ce;
2008 if (i > 0) {
2009 /* No Clists, wait a bit. */
2010 ttstart(tp);
2011 if (flag & IO_NDELAY) {
2012 error = EWOULDBLOCK;
2013 goto out;
2014 }
2015 error = ttysleep(tp, &lbolt, PCATCH,
2016 "ttybf2", 0);
2017 if (error)
2018 goto out;
2019 goto loop;
2020 }
2021 if (ISSET(tp->t_lflag, FLUSHO) ||
2022 tp->t_outq.c_cc > hiwat)
2023 break;
2024 }
2025 ttstart(tp);
2026 }
2027 out:
2028 /*
2029 * If cc is nonzero, we leave the uio structure inconsistent, as the
2030 * offset and iov pointers have moved forward, but it doesn't matter
2031 * (the call will either return short or restart with a new uio).
2032 */
2033 uio->uio_resid += cc;
2034 return (error);
2035
2036 ovhiwat:
2037 ttstart(tp);
2038 crit_enter();
2039 /*
2040 * This can only occur if FLUSHO is set in t_lflag,
2041 * or if ttstart/oproc is synchronous (or very fast).
2042 */
2043 if (tp->t_outq.c_cc <= hiwat) {
2044 crit_exit();
2045 goto loop;
2046 }
2047 if (flag & IO_NDELAY) {
2048 crit_exit();
2049 uio->uio_resid += cc;
2050 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2051 }
2052 SET(tp->t_state, TS_SO_OLOWAT);
2053 error = ttysleep(tp, TSA_OLOWAT(tp), PCATCH, "ttywri", tp->t_timeout);
2054 crit_exit();
2055 if (error == EWOULDBLOCK)
2056 error = EIO;
2057 if (error)
2058 goto out;
2059 goto loop;
2060 }
2061
2062 /*
2063 * Rubout one character from the rawq of tp
2064 * as cleanly as possible.
2065 */
2066 static void
2067 ttyrub(int c, struct tty *tp)
2068 {
2069 char *cp;
2070 int savecol;
2071 int tabc;
2072
2073 if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2074 return;
2075 CLR(tp->t_lflag, FLUSHO);
2076 if (ISSET(tp->t_lflag, ECHOE)) {
2077 if (tp->t_rocount == 0) {
2078 /*
2079 * Screwed by ttwrite; retype
2080 */
2081 ttyretype(tp);
2082 return;
2083 }
2084 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2085 ttyrubo(tp, 2);
2086 else {
2087 CLR(c, ~TTY_CHARMASK);
2088 switch (CCLASS(c)) {
2089 case ORDINARY:
2090 ttyrubo(tp, 1);
2091 break;
2092 case BACKSPACE:
2093 case CONTROL:
2094 case NEWLINE:
2095 case RETURN:
2096 case VTAB:
2097 if (ISSET(tp->t_lflag, ECHOCTL))
2098 ttyrubo(tp, 2);
2099 break;
2100 case TAB:
2101 if (tp->t_rocount < tp->t_rawq.c_cc) {
2102 ttyretype(tp);
2103 return;
2104 }
2105 crit_enter();
2106 savecol = tp->t_column;
2107 SET(tp->t_state, TS_CNTTB);
2108 SET(tp->t_lflag, FLUSHO);
2109 tp->t_column = tp->t_rocol;
2110 cp = tp->t_rawq.c_cf;
2111 if (cp)
2112 tabc = *cp; /* XXX FIX NEXTC */
2113 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2114 ttyecho(tabc, tp);
2115 CLR(tp->t_lflag, FLUSHO);
2116 CLR(tp->t_state, TS_CNTTB);
2117 crit_exit();
2118
2119 /* savecol will now be length of the tab. */
2120 savecol -= tp->t_column;
2121 tp->t_column += savecol;
2122 if (savecol > 8)
2123 savecol = 8; /* overflow screw */
2124 while (--savecol >= 0)
2125 (void)ttyoutput('\b', tp);
2126 break;
2127 default: /* XXX */
2128 #define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
2129 (void)kprintf(PANICSTR, c, CCLASS(c));
2130 #ifdef notdef
2131 panic(PANICSTR, c, CCLASS(c));
2132 #endif
2133 }
2134 }
2135 } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2136 if (!ISSET(tp->t_state, TS_ERASE)) {
2137 SET(tp->t_state, TS_ERASE);
2138 (void)ttyoutput('\\', tp);
2139 }
2140 ttyecho(c, tp);
2141 } else {
2142 ttyecho(tp->t_cc[VERASE], tp);
2143 /*
2144 * This code may be executed not only when an ERASE key
2145 * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2146 * So, I didn't think it was worthwhile to pass the extra
2147 * information (which would need an extra parameter,
2148 * changing every call) needed to distinguish the ERASE2
2149 * case from the ERASE.
2150 */
2151 }
2152 --tp->t_rocount;
2153 }
2154
2155 /*
2156 * Back over cnt characters, erasing them.
2157 */
2158 static void
2159 ttyrubo(struct tty *tp, int cnt)
2160 {
2161
2162 while (cnt-- > 0) {
2163 (void)ttyoutput('\b', tp);
2164 (void)ttyoutput(' ', tp);
2165 (void)ttyoutput('\b', tp);
2166 }
2167 }
2168
2169 /*
2170 * ttyretype --
2171 * Reprint the rawq line. Note, it is assumed that c_cc has already
2172 * been checked.
2173 */
2174 static void
2175 ttyretype(struct tty *tp)
2176 {
2177 char *cp;
2178 int c;
2179
2180 /* Echo the reprint character. */
2181 if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2182 ttyecho(tp->t_cc[VREPRINT], tp);
2183
2184 (void)ttyoutput('\n', tp);
2185
2186 /*
2187 * XXX
2188 * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2189 * BIT OF FIRST CHAR.
2190 */
2191 crit_enter();
2192 for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2193 cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2194 ttyecho(c, tp);
2195 for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2196 cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2197 ttyecho(c, tp);
2198 CLR(tp->t_state, TS_ERASE);
2199 crit_exit();
2200
2201 tp->t_rocount = tp->t_rawq.c_cc;
2202 tp->t_rocol = 0;
2203 }
2204
2205 /*
2206 * Echo a typed character to the terminal.
2207 */
2208 static void
2209 ttyecho(int c, struct tty *tp)
2210 {
2211
2212 if (!ISSET(tp->t_state, TS_CNTTB))
2213 CLR(tp->t_lflag, FLUSHO);
2214 if ((!ISSET(tp->t_lflag, ECHO) &&
2215 (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2216 ISSET(tp->t_lflag, EXTPROC))
2217 return;
2218 if (ISSET(tp->t_lflag, ECHOCTL) &&
2219 ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2220 ISSET(c, TTY_CHARMASK) == 0177)) {
2221 (void)ttyoutput('^', tp);
2222 CLR(c, ~TTY_CHARMASK);
2223 if (c == 0177)
2224 c = '?';
2225 else
2226 c += 'A' - 1;
2227 }
2228 (void)ttyoutput(c, tp);
2229 }
2230
2231 /*
2232 * Wake up any readers on a tty.
2233 */
2234 void
2235 ttwakeup(struct tty *tp)
2236 {
2237
2238 if (tp->t_rsel.si_pid != 0)
2239 selwakeup(&tp->t_rsel);
2240 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2241 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2242 wakeup(TSA_HUP_OR_INPUT(tp));
2243 KNOTE(&tp->t_rsel.si_note, 0);
2244 }
2245
2246 /*
2247 * Wake up any writers on a tty.
2248 */
2249 void
2250 ttwwakeup(struct tty *tp)
2251 {
2252
2253 if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat)
2254 selwakeup(&tp->t_wsel);
2255 if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2256 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2257 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2258 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2259 CLR(tp->t_state, TS_SO_OCOMPLETE);
2260 wakeup(TSA_OCOMPLETE(tp));
2261 }
2262 if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2263 tp->t_outq.c_cc <= tp->t_olowat) {
2264 CLR(tp->t_state, TS_SO_OLOWAT);
2265 wakeup(TSA_OLOWAT(tp));
2266 }
2267 KNOTE(&tp->t_wsel.si_note, 0);
2268 }
2269
2270 /*
2271 * Look up a code for a specified speed in a conversion table;
2272 * used by drivers to map software speed values to hardware parameters.
2273 */
2274 int
2275 ttspeedtab(int speed, struct speedtab *table)
2276 {
2277
2278 for ( ; table->sp_speed != -1; table++)
2279 if (table->sp_speed == speed)
2280 return (table->sp_code);
2281 return (-1);
2282 }
2283
2284 /*
2285 * Set input and output watermarks and buffer sizes. For input, the
2286 * high watermark is about one second's worth of input above empty, the
2287 * low watermark is slightly below high water, and the buffer size is a
2288 * driver-dependent amount above high water. For output, the watermarks
2289 * are near the ends of the buffer, with about 1 second's worth of input
2290 * between them. All this only applies to the standard line discipline.
2291 */
2292 void
2293 ttsetwater(struct tty *tp)
2294 {
2295 int cps, ttmaxhiwat, x;
2296
2297 /* Input. */
2298 clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2299 switch (tp->t_ispeedwat) {
2300 case (speed_t)-1:
2301 cps = tp->t_ispeed / 10;
2302 break;
2303 case 0:
2304 /*
2305 * This case is for old drivers that don't know about
2306 * t_ispeedwat. Arrange for them to get the old buffer
2307 * sizes and watermarks.
2308 */
2309 cps = TTYHOG - 2 * 256;
2310 tp->t_ififosize = 2 * 2048;
2311 break;
2312 default:
2313 cps = tp->t_ispeedwat / 10;
2314 break;
2315 }
2316 tp->t_ihiwat = cps;
2317 tp->t_ilowat = 7 * cps / 8;
2318 x = cps + tp->t_ififosize;
2319 clist_alloc_cblocks(&tp->t_rawq, x, x);
2320
2321 /* Output. */
2322 switch (tp->t_ospeedwat) {
2323 case (speed_t)-1:
2324 cps = tp->t_ospeed / 10;
2325 ttmaxhiwat = 2 * TTMAXHIWAT;
2326 break;
2327 case 0:
2328 cps = tp->t_ospeed / 10;
2329 ttmaxhiwat = TTMAXHIWAT;
2330 break;
2331 default:
2332 cps = tp->t_ospeedwat / 10;
2333 ttmaxhiwat = 8 * TTMAXHIWAT;
2334 break;
2335 }
2336 #define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
2337 tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2338 x += cps;
2339 x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
2340 tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
2341 x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
2342 x += OBUFSIZ + 100;
2343 clist_alloc_cblocks(&tp->t_outq, x, x);
2344 #undef CLAMP
2345 }
2346
2347 /*
2348 * Report on state of foreground process group.
2349 */
2350 void
2351 ttyinfo(struct tty *tp)
2352 {
2353 struct proc *p, *pick;
2354 struct lwp *lp;
2355 struct rusage ru;
2356 int tmp;
2357
2358 if (ttycheckoutq(tp,0) == 0)
2359 return;
2360
2361 /*
2362 * We always print the load average, then figure out what else to
2363 * print based on the state of the current process group.
2364 */
2365 tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2366 ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2367
2368 if (tp->t_session == NULL) {
2369 ttyprintf(tp, "not a controlling terminal\n");
2370 } else if (tp->t_pgrp == NULL) {
2371 ttyprintf(tp, "no foreground process group\n");
2372 } else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
2373 ttyprintf(tp, "empty foreground process group\n");
2374 } else {
2375 /*
2376 * Pick an interesting process. Note that certain elements,
2377 * in particular the wmesg, require a critical section for
2378 * safe access (YYY and we are still not MP safe).
2379 *
2380 * NOTE: lwp_wmesg is lwp_thread->td_wmesg.
2381 */
2382 char buf[64];
2383 const char *str;
2384 int isinmem;
2385 long vmsz;
2386 int pctcpu;
2387
2388 crit_enter();
2389
2390 /* XXX lwp should compare lwps */
2391
2392 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist)) {
2393 if (proc_compare(pick, p))
2394 pick = p;
2395 }
2396
2397 /* XXX lwp */
2398 lp = FIRST_LWP_IN_PROC(pick);
2399 if (lp == NULL) {
2400 ttyprintf(tp, "foreground process without lwp\n");
2401 tp->t_rocount = 0;
2402 return;
2403 }
2404
2405 /*
2406 * Figure out what wait/process-state message, and command
2407 * buffer to present
2408 */
2409 /*
2410 * XXX lwp This is a horrible mixture. We need to rework this
2411 * as soon as lwps have their own runnable status.
2412 */
2413 if (pick->p_flag & P_WEXIT)
2414 str = "exiting";
2415 else if (lp->lwp_stat == LSRUN)
2416 str = "running";
2417 else if (pick->p_stat == SIDL)
2418 str = "spawning";
2419 else if (lp->lwp_wmesg) /* lwp_thread must not be NULL */
2420 str = lp->lwp_wmesg;
2421 else
2422 str = "iowait";
2423
2424 ksnprintf(buf, sizeof(buf), "cmd: %s %d [%s]",
2425 pick->p_comm, pick->p_pid, str);
2426
2427 /*
2428 * Calculate cpu usage, percent cpu, and cmsz. Note that
2429 * 'pick' becomes invalid the moment we exit the critical
2430 * section.
2431 */
2432 if (lp->lwp_thread && (pick->p_flag & P_SWAPPEDOUT) == 0) {
2433 calcru_proc(pick, &ru);
2434 isinmem = 1;
2435 } else {
2436 isinmem = 0;
2437 }
2438
2439 pctcpu = (lp->lwp_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2440
2441 if (pick->p_stat == SIDL || pick->p_stat == SZOMB)
2442 vmsz = 0;
2443 else
2444 vmsz = pgtok(vmspace_resident_count(pick->p_vmspace));
2445
2446 crit_exit();
2447
2448 /*
2449 * Dump the output
2450 */
2451 ttyprintf(tp, " %s ", buf);
2452 ttyprintf(tp, "%ld.%02ldu ",
2453 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000);
2454 ttyprintf(tp, "%ld.%02lds ",
2455 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000);
2456 ttyprintf(tp, "%d%% %ldk\n", pctcpu / 100, vmsz);
2457 }
2458 tp->t_rocount = 0; /* so pending input will be retyped if BS */
2459 }
2460
2461 /*
2462 * Returns 1 if p2 is "better" than p1
2463 *
2464 * The algorithm for picking the "interesting" process is thus:
2465 *
2466 * 1) Only foreground processes are eligible - implied.
2467 * 2) Runnable processes are favored over anything else. The runner
2468 * with the highest cpu utilization is picked (p_cpticks). Ties are
2469 * broken by picking the highest pid.
2470 * 3) The sleeper with the shortest sleep time is next. With ties,
2471 * we pick out just "short-term" sleepers (LWP_SINTR == 0).
2472 * 4) Further ties are broken by picking the highest pid.
2473 */
2474 #define ISRUN(lp) ((lp)->lwp_stat == LSRUN)
2475 #define TESTAB(a, b) ((a)<<1 | (b))
2476 #define ONLYA 2
2477 #define ONLYB 1
2478 #define BOTH 3
2479
2480 static int
2481 proc_compare(struct proc *p1, struct proc *p2)
2482 {
2483 struct lwp *lp1, *lp2;
2484 if (p1 == NULL)
2485 return (1);
2486
2487 /*
2488 * weed out zombies
2489 */
2490 switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2491 case ONLYA:
2492 return (1);
2493 case ONLYB:
2494 return (0);
2495 case BOTH:
2496 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2497 }
2498
2499 /* XXX lwp */
2500 lp1 = FIRST_LWP_IN_PROC(p1);
2501 lp2 = FIRST_LWP_IN_PROC(p2);
2502
2503 /*
2504 * see if at least one of them is runnable
2505 */
2506 switch (TESTAB(ISRUN(lp1), ISRUN(lp2))) {
2507 case ONLYA:
2508 return (0);
2509 case ONLYB:
2510 return (1);
2511 case BOTH:
2512 /*
2513 * tie - favor one with highest recent cpu utilization
2514 */
2515 if (lp2->lwp_cpticks > lp1->lwp_cpticks)
2516 return (1);
2517 if (lp1->lwp_cpticks > lp2->lwp_cpticks)
2518 return (0);
2519 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2520 }
2521 /*
2522 * pick the one with the smallest sleep time
2523 */
2524 if (lp2->lwp_slptime > lp1->lwp_slptime)
2525 return (0);
2526 if (lp1->lwp_slptime > lp2->lwp_slptime)
2527 return (1);
2528 /*
2529 * favor one sleeping in a non-interruptible sleep
2530 */
2531 if (lp1->lwp_flag & LWP_SINTR && (lp2->lwp_flag & LWP_SINTR) == 0)
2532 return (1);
2533 if (lp2->lwp_flag & LWP_SINTR && (lp1->lwp_flag & LWP_SINTR) == 0)
2534 return (0);
2535 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2536 }
2537
2538 /*
2539 * Output char to tty; console putchar style.
2540 */
2541 int
2542 tputchar(int c, struct tty *tp)
2543 {
2544 crit_enter();
2545 if (!ISSET(tp->t_state, TS_CONNECTED)) {
2546 crit_exit();
2547 return (-1);
2548 }
2549 if (c == '\n')
2550 (void)ttyoutput('\r', tp);
2551 (void)ttyoutput(c, tp);
2552 ttstart(tp);
2553 crit_exit();
2554 return (0);
2555 }
2556
2557 /*
2558 * Sleep on chan, returning ERESTART if tty changed while we napped and
2559 * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
2560 * the tty is revoked, restarting a pending call will redo validation done
2561 * at the start of the call.
2562 */
2563 int
2564 ttysleep(struct tty *tp, void *chan, int slpflags, char *wmesg, int timo)
2565 {
2566 int error;
2567 int gen;
2568
2569 gen = tp->t_gen;
2570 error = tsleep(chan, slpflags, wmesg, timo);
2571 if (error)
2572 return (error);
2573 return (tp->t_gen == gen ? 0 : ERESTART);
2574 }
2575
2576 /*
2577 * Allocate a tty struct. Clists in the struct will be allocated by
2578 * ttyopen().
2579 */
2580 struct tty *
2581 ttymalloc(struct tty *tp)
2582 {
2583
2584 if (tp)
2585 return(tp);
2586 tp = kmalloc(sizeof *tp, M_TTYS, M_WAITOK|M_ZERO);
2587 ttyregister(tp);
2588 return (tp);
2589 }
2590
2591 #if 0
2592 /*
2593 * Free a tty struct. Clists in the struct should have been freed by
2594 * ttyclose().
2595 *
2596 * XXX not yet usable: since we support a half-closed state and do not
2597 * ref count the tty reference from the session, it is possible for a
2598 * session to hold a ref on the tty. See TTY_DO_FULL_CLOSE.
2599 */
2600 void
2601 ttyfree(struct tty *tp)
2602 {
2603 kfree(tp, M_TTYS);
2604 }
2605 #endif /* 0 */
2606
2607 void
2608 ttyregister(struct tty *tp)
2609 {
2610 SLIST_INSERT_HEAD(&tty_list, tp, t_list);
2611 }
2612
2613 static int
2614 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2615 {
2616 int error;
2617 struct tty *tp, t;
2618 SLIST_FOREACH(tp, &tty_list, t_list) {
2619 t = *tp;
2620 if (t.t_dev)
2621 t.t_dev = (cdev_t)dev2udev(t.t_dev);
2622 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2623 if (error)
2624 return (error);
2625 }
2626 return (0);
2627 }
2628
2629 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2630 0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2631
2632 void
2633 nottystop(struct tty *tp, int rw)
2634 {
2635
2636 return;
2637 }
2638
2639 int
2640 ttyread(struct dev_read_args *ap)
2641 {
2642 struct tty *tp;
2643
2644 tp = ap->a_head.a_dev->si_tty;
2645 if (tp == NULL)
2646 return (ENODEV);
2647 return ((*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag));
2648 }
2649
2650 int
2651 ttywrite(struct dev_write_args *ap)
2652 {
2653 struct tty *tp;
2654
2655 tp = ap->a_head.a_dev->si_tty;
2656 if (tp == NULL)
2657 return (ENODEV);
2658 return ((*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag));
2659 }
DragonFly BSD