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