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