sys/kern/tty.c

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