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