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.3 2003/06/23 17:55: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         struct tty *tp;
 705         u_long cmd;
 706         int flag;
 707         void *data;
 708 {
 709         struct proc *p = curproc;
 710         int s, error;
 711
 712         /* If the ioctl involves modification, hang if in the background. */
 713         switch (cmd) {
 714         case  TIOCCBRK:
 715         case  TIOCCONS:
 716         case  TIOCDRAIN:
 717         case  TIOCEXCL:
 718         case  TIOCFLUSH:
 719 #ifdef TIOCHPCL
 720         case  TIOCHPCL:
 721 #endif
 722         case  TIOCNXCL:
 723         case  TIOCSBRK:
 724         case  TIOCSCTTY:
 725         case  TIOCSDRAINWAIT:
 726         case  TIOCSETA:
 727         case  TIOCSETAF:
 728         case  TIOCSETAW:
 729         case  TIOCSETD:
 730         case  TIOCSPGRP:
 731         case  TIOCSTART:
 732         case  TIOCSTAT:
 733         case  TIOCSTI:
 734         case  TIOCSTOP:
 735         case  TIOCSWINSZ:
 736 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
 737         case  TIOCLBIC:
 738         case  TIOCLBIS:
 739         case  TIOCLSET:
 740         case  TIOCSETC:
 741         case OTIOCSETD:
 742         case  TIOCSETN:
 743         case  TIOCSETP:
 744         case  TIOCSLTC:
 745 #endif
 746                 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
 747                     !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
 748                     !SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
 749                         if (p->p_pgrp->pg_jobc == 0)
 750                                 return (EIO);
 751                         pgsignal(p->p_pgrp, SIGTTOU, 1);
 752                         error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
 753                                          0);
 754                         if (error)
 755                                 return (error);
 756                 }
 757                 break;
 758         }
 759
 760         switch (cmd) {                  /* Process the ioctl. */
 761         case FIOASYNC:                  /* set/clear async i/o */
 762                 s = spltty();
 763                 if (*(int *)data)
 764                         SET(tp->t_state, TS_ASYNC);
 765                 else
 766                         CLR(tp->t_state, TS_ASYNC);
 767                 splx(s);
 768                 break;
 769         case FIONBIO:                   /* set/clear non-blocking i/o */
 770                 break;                  /* XXX: delete. */
 771         case FIONREAD:                  /* get # bytes to read */
 772                 s = spltty();
 773                 *(int *)data = ttnread(tp);
 774                 splx(s);
 775                 break;
 776
 777         case FIOSETOWN:
 778                 /*
 779                  * Policy -- Don't allow FIOSETOWN on someone else's
 780                  *           controlling tty
 781                  */
 782                 if (tp->t_session != NULL && !isctty(p, tp))
 783                         return (ENOTTY);
 784
 785                 error = fsetown(*(int *)data, &tp->t_sigio);
 786                 if (error)
 787                         return (error);
 788                 break;
 789         case FIOGETOWN:
 790                 if (tp->t_session != NULL && !isctty(p, tp))
 791                         return (ENOTTY);
 792                 *(int *)data = fgetown(tp->t_sigio);
 793                 break;
 794
 795         case TIOCEXCL:                  /* set exclusive use of tty */
 796                 s = spltty();
 797                 SET(tp->t_state, TS_XCLUDE);
 798                 splx(s);
 799                 break;
 800         case TIOCFLUSH: {               /* flush buffers */
 801                 register int flags = *(int *)data;
 802
 803                 if (flags == 0)
 804                         flags = FREAD | FWRITE;
 805                 else
 806                         flags &= FREAD | FWRITE;
 807                 ttyflush(tp, flags);
 808                 break;
 809         }
 810         case TIOCCONS:                  /* become virtual console */
 811                 if (*(int *)data) {
 812                         if (constty && constty != tp &&
 813                             ISSET(constty->t_state, TS_CONNECTED))
 814                                 return (EBUSY);
 815 #ifndef UCONSOLE
 816                         if ((error = suser()) != 0)
 817                                 return (error);
 818 #endif
 819                         constty = tp;
 820                 } else if (tp == constty)
 821                         constty = NULL;
 822                 break;
 823         case TIOCDRAIN:                 /* wait till output drained */
 824                 error = ttywait(tp);
 825                 if (error)
 826                         return (error);
 827                 break;
 828         case TIOCGETA: {                /* get termios struct */
 829                 struct termios *t = (struct termios *)data;
 830
 831                 bcopy(&tp->t_termios, t, sizeof(struct termios));
 832                 break;
 833         }
 834         case TIOCGETD:                  /* get line discipline */
 835                 *(int *)data = tp->t_line;
 836                 break;
 837         case TIOCGWINSZ:                /* get window size */
 838                 *(struct winsize *)data = tp->t_winsize;
 839                 break;
 840         case TIOCGPGRP:                 /* get pgrp of tty */
 841                 if (!isctty(p, tp))
 842                         return (ENOTTY);
 843                 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
 844                 break;
 845 #ifdef TIOCHPCL
 846         case TIOCHPCL:                  /* hang up on last close */
 847                 s = spltty();
 848                 SET(tp->t_cflag, HUPCL);
 849                 splx(s);
 850                 break;
 851 #endif
 852         case TIOCNXCL:                  /* reset exclusive use of tty */
 853                 s = spltty();
 854                 CLR(tp->t_state, TS_XCLUDE);
 855                 splx(s);
 856                 break;
 857         case TIOCOUTQ:                  /* output queue size */
 858                 *(int *)data = tp->t_outq.c_cc;
 859                 break;
 860         case TIOCSETA:                  /* set termios struct */
 861         case TIOCSETAW:                 /* drain output, set */
 862         case TIOCSETAF: {               /* drn out, fls in, set */
 863                 register struct termios *t = (struct termios *)data;
 864
 865                 if (t->c_ispeed == 0)
 866                         t->c_ispeed = t->c_ospeed;
 867                 if (t->c_ispeed == 0)
 868                         t->c_ispeed = tp->t_ospeed;
 869                 if (t->c_ispeed == 0)
 870                         return (EINVAL);
 871                 s = spltty();
 872                 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
 873                         error = ttywait(tp);
 874                         if (error) {
 875                                 splx(s);
 876                                 return (error);
 877                         }
 878                         if (cmd == TIOCSETAF)
 879                                 ttyflush(tp, FREAD);
 880                 }
 881                 if (!ISSET(t->c_cflag, CIGNORE)) {
 882                         /*
 883                          * Set device hardware.
 884                          */
 885                         if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
 886                                 splx(s);
 887                                 return (error);
 888                         }
 889                         if (ISSET(t->c_cflag, CLOCAL) &&
 890                             !ISSET(tp->t_cflag, CLOCAL)) {
 891                                 /*
 892                                  * XXX disconnections would be too hard to
 893                                  * get rid of without this kludge.  The only
 894                                  * way to get rid of controlling terminals
 895                                  * is to exit from the session leader.
 896                                  */
 897                                 CLR(tp->t_state, TS_ZOMBIE);
 898
 899                                 wakeup(TSA_CARR_ON(tp));
 900                                 ttwakeup(tp);
 901                                 ttwwakeup(tp);
 902                         }
 903                         if ((ISSET(tp->t_state, TS_CARR_ON) ||
 904                              ISSET(t->c_cflag, CLOCAL)) &&
 905                             !ISSET(tp->t_state, TS_ZOMBIE))
 906                                 SET(tp->t_state, TS_CONNECTED);
 907                         else
 908                                 CLR(tp->t_state, TS_CONNECTED);
 909                         tp->t_cflag = t->c_cflag;
 910                         tp->t_ispeed = t->c_ispeed;
 911                         if (t->c_ospeed != 0)
 912                                 tp->t_ospeed = t->c_ospeed;
 913                         ttsetwater(tp);
 914                 }
 915                 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
 916                     cmd != TIOCSETAF) {
 917                         if (ISSET(t->c_lflag, ICANON))
 918                                 SET(tp->t_lflag, PENDIN);
 919                         else {
 920                                 /*
 921                                  * XXX we really shouldn't allow toggling
 922                                  * ICANON while we're in a non-termios line
 923                                  * discipline.  Now we have to worry about
 924                                  * panicing for a null queue.
 925                                  */
 926                                 if (tp->t_canq.c_cbreserved > 0 &&
 927                                     tp->t_rawq.c_cbreserved > 0) {
 928                                         catq(&tp->t_rawq, &tp->t_canq);
 929                                         /*
 930                                          * XXX the queue limits may be
 931                                          * different, so the old queue
 932                                          * swapping method no longer works.
 933                                          */
 934                                         catq(&tp->t_canq, &tp->t_rawq);
 935                                 }
 936                                 CLR(tp->t_lflag, PENDIN);
 937                         }
 938                         ttwakeup(tp);
 939                 }
 940                 tp->t_iflag = t->c_iflag;
 941                 tp->t_oflag = t->c_oflag;
 942                 /*
 943                  * Make the EXTPROC bit read only.
 944                  */
 945                 if (ISSET(tp->t_lflag, EXTPROC))
 946                         SET(t->c_lflag, EXTPROC);
 947                 else
 948                         CLR(t->c_lflag, EXTPROC);
 949                 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
 950                 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
 951                     t->c_cc[VTIME] != tp->t_cc[VTIME])
 952                         ttwakeup(tp);
 953                 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
 954                 splx(s);
 955                 break;
 956         }
 957         case TIOCSETD: {                /* set line discipline */
 958                 register int t = *(int *)data;
 959                 dev_t device = tp->t_dev;
 960
 961                 if ((u_int)t >= nlinesw)
 962                         return (ENXIO);
 963                 if (t != tp->t_line) {
 964                         s = spltty();
 965                         (*linesw[tp->t_line].l_close)(tp, flag);
 966                         error = (*linesw[t].l_open)(device, tp);
 967                         if (error) {
 968                                 (void)(*linesw[tp->t_line].l_open)(device, tp);
 969                                 splx(s);
 970                                 return (error);
 971                         }
 972                         tp->t_line = t;
 973                         splx(s);
 974                 }
 975                 break;
 976         }
 977         case TIOCSTART:                 /* start output, like ^Q */
 978                 s = spltty();
 979                 if (ISSET(tp->t_state, TS_TTSTOP) ||
 980                     ISSET(tp->t_lflag, FLUSHO)) {
 981                         CLR(tp->t_lflag, FLUSHO);
 982                         CLR(tp->t_state, TS_TTSTOP);
 983                         ttstart(tp);
 984                 }
 985                 splx(s);
 986                 break;
 987         case TIOCSTI:                   /* simulate terminal input */
 988                 if ((flag & FREAD) == 0 && suser())
 989                         return (EPERM);
 990                 if (!isctty(p, tp) && suser())
 991                         return (EACCES);
 992                 s = spltty();
 993                 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
 994                 splx(s);
 995                 break;
 996         case TIOCSTOP:                  /* stop output, like ^S */
 997                 s = spltty();
 998                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
 999                         SET(tp->t_state, TS_TTSTOP);
1000                         (*tp->t_stop)(tp, 0);
1001                 }
1002                 splx(s);
1003                 break;
1004         case TIOCSCTTY:                 /* become controlling tty */
1005                 /* Session ctty vnode pointer set in vnode layer. */
1006                 if (!SESS_LEADER(p) ||
1007                     ((p->p_session->s_ttyvp || tp->t_session) &&
1008                     (tp->t_session != p->p_session)))
1009                         return (EPERM);
1010                 tp->t_session = p->p_session;
1011                 tp->t_pgrp = p->p_pgrp;
1012                 p->p_session->s_ttyp = tp;
1013                 p->p_flag |= P_CONTROLT;
1014                 break;
1015         case TIOCSPGRP: {               /* set pgrp of tty */
1016                 register struct pgrp *pgrp = pgfind(*(int *)data);
1017
1018                 if (!isctty(p, tp))
1019                         return (ENOTTY);
1020                 else if (pgrp == NULL || pgrp->pg_session != p->p_session)
1021                         return (EPERM);
1022                 tp->t_pgrp = pgrp;
1023                 break;
1024         }
1025         case TIOCSTAT:                  /* simulate control-T */
1026                 s = spltty();
1027                 ttyinfo(tp);
1028                 splx(s);
1029                 break;
1030         case TIOCSWINSZ:                /* set window size */
1031                 if (bcmp((caddr_t)&tp->t_winsize, data,
1032                     sizeof (struct winsize))) {
1033                         tp->t_winsize = *(struct winsize *)data;
1034                         pgsignal(tp->t_pgrp, SIGWINCH, 1);
1035                 }
1036                 break;
1037         case TIOCSDRAINWAIT:
1038                 error = suser();
1039                 if (error)
1040                         return (error);
1041                 tp->t_timeout = *(int *)data * hz;
1042                 wakeup(TSA_OCOMPLETE(tp));
1043                 wakeup(TSA_OLOWAT(tp));
1044                 break;
1045         case TIOCGDRAINWAIT:
1046                 *(int *)data = tp->t_timeout / hz;
1047                 break;
1048         default:
1049 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1050                 return (ttcompat(tp, cmd, data, flag));
1051 #else
1052                 return (ENOIOCTL);
1053 #endif
1054         }
1055         return (0);
1056 }
1057
1058 int
1059 ttypoll(dev, events, td)
1060         dev_t dev;
1061         int events;
1062         struct thread *td;
1063 {
1064         int s;
1065         int revents = 0;
1066         struct tty *tp;
1067
1068         tp = dev->si_tty;
1069         if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
1070                 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
1071                         | POLLHUP);
1072
1073         s = spltty();
1074         if (events & (POLLIN | POLLRDNORM)) {
1075                 if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
1076                         revents |= events & (POLLIN | POLLRDNORM);
1077                 else
1078                         selrecord(td, &tp->t_rsel);
1079         }
1080         if (events & (POLLOUT | POLLWRNORM)) {
1081                 if ((tp->t_outq.c_cc <= tp->t_olowat &&
1082                      ISSET(tp->t_state, TS_CONNECTED))
1083                     || ISSET(tp->t_state, TS_ZOMBIE))
1084                         revents |= events & (POLLOUT | POLLWRNORM);
1085                 else
1086                         selrecord(td, &tp->t_wsel);
1087         }
1088         splx(s);
1089         return (revents);
1090 }
1091
1092 static struct filterops ttyread_filtops =
1093         { 1, NULL, filt_ttyrdetach, filt_ttyread };
1094 static struct filterops ttywrite_filtops =
1095         { 1, NULL, filt_ttywdetach, filt_ttywrite };
1096
1097 int
1098 ttykqfilter(dev, kn)
1099         dev_t dev;
1100         struct knote *kn;
1101 {
1102         struct tty *tp = dev->si_tty;
1103         struct klist *klist;
1104         int s;
1105
1106         switch (kn->kn_filter) {
1107         case EVFILT_READ:
1108                 klist = &tp->t_rsel.si_note;
1109                 kn->kn_fop = &ttyread_filtops;
1110                 break;
1111         case EVFILT_WRITE:
1112                 klist = &tp->t_wsel.si_note;
1113                 kn->kn_fop = &ttywrite_filtops;
1114                 break;
1115         default:
1116                 return (1);
1117         }
1118
1119         kn->kn_hook = (caddr_t)dev;
1120
1121         s = spltty();
1122         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
1123         splx(s);
1124
1125         return (0);
1126 }
1127
1128 static void
1129 filt_ttyrdetach(struct knote *kn)
1130 {
1131         struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1132         int s = spltty();
1133
1134         SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
1135         splx(s);
1136 }
1137
1138 static int
1139 filt_ttyread(struct knote *kn, long hint)
1140 {
1141         struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1142
1143         kn->kn_data = ttnread(tp);
1144         if (ISSET(tp->t_state, TS_ZOMBIE)) {
1145                 kn->kn_flags |= EV_EOF;
1146                 return (1);
1147         }
1148         return (kn->kn_data > 0);
1149 }
1150
1151 static void
1152 filt_ttywdetach(struct knote *kn)
1153 {
1154         struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1155         int s = spltty();
1156
1157         SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
1158         splx(s);
1159 }
1160
1161 static int
1162 filt_ttywrite(kn, hint)
1163         struct knote *kn;
1164         long hint;
1165 {
1166         struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
1167
1168         kn->kn_data = tp->t_outq.c_cc;
1169         if (ISSET(tp->t_state, TS_ZOMBIE))
1170                 return (1);
1171         return (kn->kn_data <= tp->t_olowat &&
1172             ISSET(tp->t_state, TS_CONNECTED));
1173 }
1174
1175 /*
1176  * Must be called at spltty().
1177  */
1178 static int
1179 ttnread(tp)
1180         struct tty *tp;
1181 {
1182         int nread;
1183
1184         if (ISSET(tp->t_lflag, PENDIN))
1185                 ttypend(tp);
1186         nread = tp->t_canq.c_cc;
1187         if (!ISSET(tp->t_lflag, ICANON)) {
1188                 nread += tp->t_rawq.c_cc;
1189                 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1190                         nread = 0;
1191         }
1192         return (nread);
1193 }
1194
1195 /*
1196  * Wait for output to drain.
1197  */
1198 int
1199 ttywait(tp)
1200         register struct tty *tp;
1201 {
1202         int error, s;
1203
1204         error = 0;
1205         s = spltty();
1206         while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1207                ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1208                 (*tp->t_oproc)(tp);
1209                 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1210                     ISSET(tp->t_state, TS_CONNECTED)) {
1211                         SET(tp->t_state, TS_SO_OCOMPLETE);
1212                         error = ttysleep(tp, TSA_OCOMPLETE(tp),
1213                                          TTOPRI | PCATCH, "ttywai",
1214                                          tp->t_timeout);
1215                         if (error) {
1216                                 if (error == EWOULDBLOCK)
1217                                         error = EIO;
1218                                 break;
1219                         }
1220                 } else
1221                         break;
1222         }
1223         if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1224                 error = EIO;
1225         splx(s);
1226         return (error);
1227 }
1228
1229 /*
1230  * Flush if successfully wait.
1231  */
1232 static int
1233 ttywflush(tp)
1234         struct tty *tp;
1235 {
1236         int error;
1237
1238         if ((error = ttywait(tp)) == 0)
1239                 ttyflush(tp, FREAD);
1240         return (error);
1241 }
1242
1243 /*
1244  * Flush tty read and/or write queues, notifying anyone waiting.
1245  */
1246 void
1247 ttyflush(tp, rw)
1248         register struct tty *tp;
1249         int rw;
1250 {
1251         register int s;
1252
1253         s = spltty();
1254 #if 0
1255 again:
1256 #endif
1257         if (rw & FWRITE) {
1258                 FLUSHQ(&tp->t_outq);
1259                 CLR(tp->t_state, TS_TTSTOP);
1260         }
1261         (*tp->t_stop)(tp, rw);
1262         if (rw & FREAD) {
1263                 FLUSHQ(&tp->t_canq);
1264                 FLUSHQ(&tp->t_rawq);
1265                 CLR(tp->t_lflag, PENDIN);
1266                 tp->t_rocount = 0;
1267                 tp->t_rocol = 0;
1268                 CLR(tp->t_state, TS_LOCAL);
1269                 ttwakeup(tp);
1270                 if (ISSET(tp->t_state, TS_TBLOCK)) {
1271                         if (rw & FWRITE)
1272                                 FLUSHQ(&tp->t_outq);
1273                         ttyunblock(tp);
1274
1275                         /*
1276                          * Don't let leave any state that might clobber the
1277                          * next line discipline (although we should do more
1278                          * to send the START char).  Not clearing the state
1279                          * may have caused the "putc to a clist with no
1280                          * reserved cblocks" panic/printf.
1281                          */
1282                         CLR(tp->t_state, TS_TBLOCK);
1283
1284 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1285                         if (ISSET(tp->t_iflag, IXOFF)) {
1286                                 /*
1287                                  * XXX wait a bit in the hope that the stop
1288                                  * character (if any) will go out.  Waiting
1289                                  * isn't good since it allows races.  This
1290                                  * will be fixed when the stop character is
1291                                  * put in a special queue.  Don't bother with
1292                                  * the checks in ttywait() since the timeout
1293                                  * will save us.
1294                                  */
1295                                 SET(tp->t_state, TS_SO_OCOMPLETE);
1296                                 ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
1297                                          "ttyfls", hz / 10);
1298                                 /*
1299                                  * Don't try sending the stop character again.
1300                                  */
1301                                 CLR(tp->t_state, TS_TBLOCK);
1302                                 goto again;
1303                         }
1304 #endif
1305                 }
1306         }
1307         if (rw & FWRITE) {
1308                 FLUSHQ(&tp->t_outq);
1309                 ttwwakeup(tp);
1310         }
1311         splx(s);
1312 }
1313
1314 /*
1315  * Copy in the default termios characters.
1316  */
1317 void
1318 termioschars(t)
1319         struct termios *t;
1320 {
1321
1322         bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1323 }
1324
1325 /*
1326  * Old interface.
1327  */
1328 void
1329 ttychars(tp)
1330         struct tty *tp;
1331 {
1332
1333         termioschars(&tp->t_termios);
1334 }
1335
1336 /*
1337  * Handle input high water.  Send stop character for the IXOFF case.  Turn
1338  * on our input flow control bit and propagate the changes to the driver.
1339  * XXX the stop character should be put in a special high priority queue.
1340  */
1341 void
1342 ttyblock(tp)
1343         struct tty *tp;
1344 {
1345
1346         SET(tp->t_state, TS_TBLOCK);
1347         if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1348             putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1349                 CLR(tp->t_state, TS_TBLOCK);    /* try again later */
1350         ttstart(tp);
1351 }
1352
1353 /*
1354  * Handle input low water.  Send start character for the IXOFF case.  Turn
1355  * off our input flow control bit and propagate the changes to the driver.
1356  * XXX the start character should be put in a special high priority queue.
1357  */
1358 static void
1359 ttyunblock(tp)
1360         struct tty *tp;
1361 {
1362
1363         CLR(tp->t_state, TS_TBLOCK);
1364         if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1365             putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1366                 SET(tp->t_state, TS_TBLOCK);    /* try again later */
1367         ttstart(tp);
1368 }
1369
1370 #ifdef notyet
1371 /* Not used by any current (i386) drivers. */
1372 /*
1373  * Restart after an inter-char delay.
1374  */
1375 void
1376 ttrstrt(tp_arg)
1377         void *tp_arg;
1378 {
1379         struct tty *tp;
1380         int s;
1381
1382         KASSERT(tp_arg != NULL, ("ttrstrt"));
1383
1384         tp = tp_arg;
1385         s = spltty();
1386
1387         CLR(tp->t_state, TS_TIMEOUT);
1388         ttstart(tp);
1389
1390         splx(s);
1391 }
1392 #endif
1393
1394 int
1395 ttstart(tp)
1396         struct tty *tp;
1397 {
1398
1399         if (tp->t_oproc != NULL)        /* XXX: Kludge for pty. */
1400                 (*tp->t_oproc)(tp);
1401         return (0);
1402 }
1403
1404 /*
1405  * "close" a line discipline
1406  */
1407 int
1408 ttylclose(tp, flag)
1409         struct tty *tp;
1410         int flag;
1411 {
1412
1413         if (flag & FNONBLOCK || ttywflush(tp))
1414                 ttyflush(tp, FREAD | FWRITE);
1415         return (0);
1416 }
1417
1418 /*
1419  * Handle modem control transition on a tty.
1420  * Flag indicates new state of carrier.
1421  * Returns 0 if the line should be turned off, otherwise 1.
1422  */
1423 int
1424 ttymodem(tp, flag)
1425         register struct tty *tp;
1426         int flag;
1427 {
1428
1429         if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1430                 /*
1431                  * MDMBUF: do flow control according to carrier flag
1432                  * XXX TS_CAR_OFLOW doesn't do anything yet.  TS_TTSTOP
1433                  * works if IXON and IXANY are clear.
1434                  */
1435                 if (flag) {
1436                         CLR(tp->t_state, TS_CAR_OFLOW);
1437                         CLR(tp->t_state, TS_TTSTOP);
1438                         ttstart(tp);
1439                 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1440                         SET(tp->t_state, TS_CAR_OFLOW);
1441                         SET(tp->t_state, TS_TTSTOP);
1442                         (*tp->t_stop)(tp, 0);
1443                 }
1444         } else if (flag == 0) {
1445                 /*
1446                  * Lost carrier.
1447                  */
1448                 CLR(tp->t_state, TS_CARR_ON);
1449                 if (ISSET(tp->t_state, TS_ISOPEN) &&
1450                     !ISSET(tp->t_cflag, CLOCAL)) {
1451                         SET(tp->t_state, TS_ZOMBIE);
1452                         CLR(tp->t_state, TS_CONNECTED);
1453                         if (tp->t_session && tp->t_session->s_leader)
1454                                 psignal(tp->t_session->s_leader, SIGHUP);
1455                         ttyflush(tp, FREAD | FWRITE);
1456                         return (0);
1457                 }
1458         } else {
1459                 /*
1460                  * Carrier now on.
1461                  */
1462                 SET(tp->t_state, TS_CARR_ON);
1463                 if (!ISSET(tp->t_state, TS_ZOMBIE))
1464                         SET(tp->t_state, TS_CONNECTED);
1465                 wakeup(TSA_CARR_ON(tp));
1466                 ttwakeup(tp);
1467                 ttwwakeup(tp);
1468         }
1469         return (1);
1470 }
1471
1472 /*
1473  * Reinput pending characters after state switch
1474  * call at spltty().
1475  */
1476 static void
1477 ttypend(tp)
1478         register struct tty *tp;
1479 {
1480         struct clist tq;
1481         register int c;
1482
1483         CLR(tp->t_lflag, PENDIN);
1484         SET(tp->t_state, TS_TYPEN);
1485         /*
1486          * XXX this assumes too much about clist internals.  It may even
1487          * fail if the cblock slush pool is empty.  We can't allocate more
1488          * cblocks here because we are called from an interrupt handler
1489          * and clist_alloc_cblocks() can wait.
1490          */
1491         tq = tp->t_rawq;
1492         bzero(&tp->t_rawq, sizeof tp->t_rawq);
1493         tp->t_rawq.c_cbmax = tq.c_cbmax;
1494         tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1495         while ((c = getc(&tq)) >= 0)
1496                 ttyinput(c, tp);
1497         CLR(tp->t_state, TS_TYPEN);
1498 }
1499
1500 /*
1501  * Process a read call on a tty device.
1502  */
1503 int
1504 ttread(tp, uio, flag)
1505         register struct tty *tp;
1506         struct uio *uio;
1507         int flag;
1508 {
1509         register struct clist *qp;
1510         register int c;
1511         register tcflag_t lflag;
1512         register cc_t *cc = tp->t_cc;
1513         register struct proc *p = curproc;
1514         int s, first, error = 0;
1515         int has_stime = 0, last_cc = 0;
1516         long slp = 0;           /* XXX this should be renamed `timo'. */
1517         struct timeval stime;
1518
1519 loop:
1520         s = spltty();
1521         lflag = tp->t_lflag;
1522         /*
1523          * take pending input first
1524          */
1525         if (ISSET(lflag, PENDIN)) {
1526                 ttypend(tp);
1527                 splx(s);        /* reduce latency */
1528                 s = spltty();
1529                 lflag = tp->t_lflag;    /* XXX ttypend() clobbers it */
1530         }
1531
1532         /*
1533          * Hang process if it's in the background.
1534          */
1535         if (isbackground(p, tp)) {
1536                 splx(s);
1537                 if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
1538                     SIGISMEMBER(p->p_sigmask, SIGTTIN) ||
1539                     (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0)
1540                         return (EIO);
1541                 pgsignal(p->p_pgrp, SIGTTIN, 1);
1542                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
1543                 if (error)
1544                         return (error);
1545                 goto loop;
1546         }
1547
1548         if (ISSET(tp->t_state, TS_ZOMBIE)) {
1549                 splx(s);
1550                 return (0);     /* EOF */
1551         }
1552
1553         /*
1554          * If canonical, use the canonical queue,
1555          * else use the raw queue.
1556          *
1557          * (should get rid of clists...)
1558          */
1559         qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1560
1561         if (flag & IO_NDELAY) {
1562                 if (qp->c_cc > 0)
1563                         goto read;
1564                 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1565                         splx(s);
1566                         return (0);
1567                 }
1568                 splx(s);
1569                 return (EWOULDBLOCK);
1570         }
1571         if (!ISSET(lflag, ICANON)) {
1572                 int m = cc[VMIN];
1573                 long t = cc[VTIME];
1574                 struct timeval timecopy;
1575
1576                 /*
1577                  * Check each of the four combinations.
1578                  * (m > 0 && t == 0) is the normal read case.
1579                  * It should be fairly efficient, so we check that and its
1580                  * companion case (m == 0 && t == 0) first.
1581                  * For the other two cases, we compute the target sleep time
1582                  * into slp.
1583                  */
1584                 if (t == 0) {
1585                         if (qp->c_cc < m)
1586                                 goto sleep;
1587                         if (qp->c_cc > 0)
1588                                 goto read;
1589
1590                         /* m, t and qp->c_cc are all 0.  0 is enough input. */
1591                         splx(s);
1592                         return (0);
1593                 }
1594                 t *= 100000;            /* time in us */
1595 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1596                          ((t1).tv_usec - (t2).tv_usec))
1597                 if (m > 0) {
1598                         if (qp->c_cc <= 0)
1599                                 goto sleep;
1600                         if (qp->c_cc >= m)
1601                                 goto read;
1602                         getmicrotime(&timecopy);
1603                         if (!has_stime) {
1604                                 /* first character, start timer */
1605                                 has_stime = 1;
1606                                 stime = timecopy;
1607                                 slp = t;
1608                         } else if (qp->c_cc > last_cc) {
1609                                 /* got a character, restart timer */
1610                                 stime = timecopy;
1611                                 slp = t;
1612                         } else {
1613                                 /* nothing, check expiration */
1614                                 slp = t - diff(timecopy, stime);
1615                                 if (slp <= 0)
1616                                         goto read;
1617                         }
1618                         last_cc = qp->c_cc;
1619                 } else {        /* m == 0 */
1620                         if (qp->c_cc > 0)
1621                                 goto read;
1622                         getmicrotime(&timecopy);
1623                         if (!has_stime) {
1624                                 has_stime = 1;
1625                                 stime = timecopy;
1626                                 slp = t;
1627                         } else {
1628                                 slp = t - diff(timecopy, stime);
1629                                 if (slp <= 0) {
1630                                         /* Timed out, but 0 is enough input. */
1631                                         splx(s);
1632                                         return (0);
1633                                 }
1634                         }
1635                 }
1636 #undef diff
1637                 /*
1638                  * Rounding down may make us wake up just short
1639                  * of the target, so we round up.
1640                  * The formula is ceiling(slp * hz/1000000).
1641                  * 32-bit arithmetic is enough for hz < 169.
1642                  * XXX see tvtohz() for how to avoid overflow if hz
1643                  * is large (divide by `tick' and/or arrange to
1644                  * use tvtohz() if hz is large).
1645                  */
1646                 slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
1647                 goto sleep;
1648         }
1649         if (qp->c_cc <= 0) {
1650 sleep:
1651                 /*
1652                  * There is no input, or not enough input and we can block.
1653                  */
1654                 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
1655                                  ISSET(tp->t_state, TS_CONNECTED) ?
1656                                  "ttyin" : "ttyhup", (int)slp);
1657                 splx(s);
1658                 if (error == EWOULDBLOCK)
1659                         error = 0;
1660                 else if (error)
1661                         return (error);
1662                 /*
1663                  * XXX what happens if another process eats some input
1664                  * while we are asleep (not just here)?  It would be
1665                  * safest to detect changes and reset our state variables
1666                  * (has_stime and last_cc).
1667                  */
1668                 slp = 0;
1669                 goto loop;
1670         }
1671 read:
1672         splx(s);
1673         /*
1674          * Input present, check for input mapping and processing.
1675          */
1676         first = 1;
1677         if (ISSET(lflag, ICANON | ISIG))
1678                 goto slowcase;
1679         for (;;) {
1680                 char ibuf[IBUFSIZ];
1681                 int icc;
1682
1683                 icc = imin(uio->uio_resid, IBUFSIZ);
1684                 icc = q_to_b(qp, ibuf, icc);
1685                 if (icc <= 0) {
1686                         if (first)
1687                                 goto loop;
1688                         break;
1689                 }
1690                 error = uiomove(ibuf, icc, uio);
1691                 /*
1692                  * XXX if there was an error then we should ungetc() the
1693                  * unmoved chars and reduce icc here.
1694                  */
1695                 if (error)
1696                         break;
1697                 if (uio->uio_resid == 0)
1698                         break;
1699                 first = 0;
1700         }
1701         goto out;
1702 slowcase:
1703         for (;;) {
1704                 c = getc(qp);
1705                 if (c < 0) {
1706                         if (first)
1707                                 goto loop;
1708                         break;
1709                 }
1710                 /*
1711                  * delayed suspend (^Y)
1712                  */
1713                 if (CCEQ(cc[VDSUSP], c) &&
1714                     ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1715                         pgsignal(tp->t_pgrp, SIGTSTP, 1);
1716                         if (first) {
1717                                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
1718                                                  "ttybg3", 0);
1719                                 if (error)
1720                                         break;
1721                                 goto loop;
1722                         }
1723                         break;
1724                 }
1725                 /*
1726                  * Interpret EOF only in canonical mode.
1727                  */
1728                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1729                         break;
1730                 /*
1731                  * Give user character.
1732                  */
1733                 error = ureadc(c, uio);
1734                 if (error)
1735                         /* XXX should ungetc(c, qp). */
1736                         break;
1737                 if (uio->uio_resid == 0)
1738                         break;
1739                 /*
1740                  * In canonical mode check for a "break character"
1741                  * marking the end of a "line of input".
1742                  */
1743                 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1744                         break;
1745                 first = 0;
1746         }
1747
1748 out:
1749         /*
1750          * Look to unblock input now that (presumably)
1751          * the input queue has gone down.
1752          */
1753         s = spltty();
1754         if (ISSET(tp->t_state, TS_TBLOCK) &&
1755             tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1756                 ttyunblock(tp);
1757         splx(s);
1758
1759         return (error);
1760 }
1761
1762 /*
1763  * Check the output queue on tp for space for a kernel message (from uprintf
1764  * or tprintf).  Allow some space over the normal hiwater mark so we don't
1765  * lose messages due to normal flow control, but don't let the tty run amok.
1766  * Sleeps here are not interruptible, but we return prematurely if new signals
1767  * arrive.
1768  */
1769 int
1770 ttycheckoutq(tp, wait)
1771         register struct tty *tp;
1772         int wait;
1773 {
1774         int hiwat, s;
1775         sigset_t oldmask;
1776
1777         hiwat = tp->t_ohiwat;
1778         SIGEMPTYSET(oldmask);
1779         s = spltty();
1780         if (wait)
1781                 oldmask = curproc->p_siglist;
1782         if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
1783                 while (tp->t_outq.c_cc > hiwat) {
1784                         ttstart(tp);
1785                         if (tp->t_outq.c_cc <= hiwat)
1786                                 break;
1787                         if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
1788                                 splx(s);
1789                                 return (0);
1790                         }
1791                         SET(tp->t_state, TS_SO_OLOWAT);
1792                         tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
1793                 }
1794         splx(s);
1795         return (1);
1796 }
1797
1798 /*
1799  * Process a write call on a tty device.
1800  */
1801 int
1802 ttwrite(tp, uio, flag)
1803         register struct tty *tp;
1804         register struct uio *uio;
1805         int flag;
1806 {
1807         register char *cp = NULL;
1808         register int cc, ce;
1809         register struct proc *p;
1810         int i, hiwat, cnt, error, s;
1811         char obuf[OBUFSIZ];
1812
1813         hiwat = tp->t_ohiwat;
1814         cnt = uio->uio_resid;
1815         error = 0;
1816         cc = 0;
1817 loop:
1818         s = spltty();
1819         if (ISSET(tp->t_state, TS_ZOMBIE)) {
1820                 splx(s);
1821                 if (uio->uio_resid == cnt)
1822                         error = EIO;
1823                 goto out;
1824         }
1825         if (!ISSET(tp->t_state, TS_CONNECTED)) {
1826                 if (flag & IO_NDELAY) {
1827                         splx(s);
1828                         error = EWOULDBLOCK;
1829                         goto out;
1830                 }
1831                 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
1832                                  "ttydcd", 0);
1833                 splx(s);
1834                 if (error)
1835                         goto out;
1836                 goto loop;
1837         }
1838         splx(s);
1839         /*
1840          * Hang the process if it's in the background.
1841          */
1842         p = curproc;
1843         if (isbackground(p, tp) &&
1844             ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
1845             !SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
1846             !SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
1847                 if (p->p_pgrp->pg_jobc == 0) {
1848                         error = EIO;
1849                         goto out;
1850                 }
1851                 pgsignal(p->p_pgrp, SIGTTOU, 1);
1852                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
1853                 if (error)
1854                         goto out;
1855                 goto loop;
1856         }
1857         /*
1858          * Process the user's data in at most OBUFSIZ chunks.  Perform any
1859          * output translation.  Keep track of high water mark, sleep on
1860          * overflow awaiting device aid in acquiring new space.
1861          */
1862         while (uio->uio_resid > 0 || cc > 0) {
1863                 if (ISSET(tp->t_lflag, FLUSHO)) {
1864                         uio->uio_resid = 0;
1865                         return (0);
1866                 }
1867                 if (tp->t_outq.c_cc > hiwat)
1868                         goto ovhiwat;
1869                 /*
1870                  * Grab a hunk of data from the user, unless we have some
1871                  * leftover from last time.
1872                  */
1873                 if (cc == 0) {
1874                         cc = imin(uio->uio_resid, OBUFSIZ);
1875                         cp = obuf;
1876                         error = uiomove(cp, cc, uio);
1877                         if (error) {
1878                                 cc = 0;
1879                                 break;
1880                         }
1881                 }
1882                 /*
1883                  * If nothing fancy need be done, grab those characters we
1884                  * can handle without any of ttyoutput's processing and
1885                  * just transfer them to the output q.  For those chars
1886                  * which require special processing (as indicated by the
1887                  * bits in char_type), call ttyoutput.  After processing
1888                  * a hunk of data, look for FLUSHO so ^O's will take effect
1889                  * immediately.
1890                  */
1891                 while (cc > 0) {
1892                         if (!ISSET(tp->t_oflag, OPOST))
1893                                 ce = cc;
1894                         else {
1895                                 ce = cc - scanc((u_int)cc, (u_char *)cp,
1896                                                 char_type, CCLASSMASK);
1897                                 /*
1898                                  * If ce is zero, then we're processing
1899                                  * a special character through ttyoutput.
1900                                  */
1901                                 if (ce == 0) {
1902                                         tp->t_rocount = 0;
1903                                         if (ttyoutput(*cp, tp) >= 0) {
1904                                                 /* No Clists, wait a bit. */
1905                                                 ttstart(tp);
1906                                                 if (flag & IO_NDELAY) {
1907                                                         error = EWOULDBLOCK;
1908                                                         goto out;
1909                                                 }
1910                                                 error = ttysleep(tp, &lbolt,
1911                                                                  TTOPRI|PCATCH,
1912                                                                  "ttybf1", 0);
1913                                                 if (error)
1914                                                         goto out;
1915                                                 goto loop;
1916                                         }
1917                                         cp++;
1918                                         cc--;
1919                                         if (ISSET(tp->t_lflag, FLUSHO) ||
1920                                             tp->t_outq.c_cc > hiwat)
1921                                                 goto ovhiwat;
1922                                         continue;
1923                                 }
1924                         }
1925                         /*
1926                          * A bunch of normal characters have been found.
1927                          * Transfer them en masse to the output queue and
1928                          * continue processing at the top of the loop.
1929                          * If there are any further characters in this
1930                          * <= OBUFSIZ chunk, the first should be a character
1931                          * requiring special handling by ttyoutput.
1932                          */
1933                         tp->t_rocount = 0;
1934                         i = b_to_q(cp, ce, &tp->t_outq);
1935                         ce -= i;
1936                         tp->t_column += ce;
1937                         cp += ce, cc -= ce, tk_nout += ce;
1938                         tp->t_outcc += ce;
1939                         if (i > 0) {
1940                                 /* No Clists, wait a bit. */
1941                                 ttstart(tp);
1942                                 if (flag & IO_NDELAY) {
1943                                         error = EWOULDBLOCK;
1944                                         goto out;
1945                                 }
1946                                 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
1947                                                  "ttybf2", 0);
1948                                 if (error)
1949                                         goto out;
1950                                 goto loop;
1951                         }
1952                         if (ISSET(tp->t_lflag, FLUSHO) ||
1953                             tp->t_outq.c_cc > hiwat)
1954                                 break;
1955                 }
1956                 ttstart(tp);
1957         }
1958 out:
1959         /*
1960          * If cc is nonzero, we leave the uio structure inconsistent, as the
1961          * offset and iov pointers have moved forward, but it doesn't matter
1962          * (the call will either return short or restart with a new uio).
1963          */
1964         uio->uio_resid += cc;
1965         return (error);
1966
1967 ovhiwat:
1968         ttstart(tp);
1969         s = spltty();
1970         /*
1971          * This can only occur if FLUSHO is set in t_lflag,
1972          * or if ttstart/oproc is synchronous (or very fast).
1973          */
1974         if (tp->t_outq.c_cc <= hiwat) {
1975                 splx(s);
1976                 goto loop;
1977         }
1978         if (flag & IO_NDELAY) {
1979                 splx(s);
1980                 uio->uio_resid += cc;
1981                 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
1982         }
1983         SET(tp->t_state, TS_SO_OLOWAT);
1984         error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
1985                          tp->t_timeout);
1986         splx(s);
1987         if (error == EWOULDBLOCK)
1988                 error = EIO;
1989         if (error)
1990                 goto out;
1991         goto loop;
1992 }
1993
1994 /*
1995  * Rubout one character from the rawq of tp
1996  * as cleanly as possible.
1997  */
1998 static void
1999 ttyrub(c, tp)
2000         register int c;
2001         register struct tty *tp;
2002 {
2003         register char *cp;
2004         register int savecol;
2005         int tabc, s;
2006
2007         if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2008                 return;
2009         CLR(tp->t_lflag, FLUSHO);
2010         if (ISSET(tp->t_lflag, ECHOE)) {
2011                 if (tp->t_rocount == 0) {
2012                         /*
2013                          * Screwed by ttwrite; retype
2014                          */
2015                         ttyretype(tp);
2016                         return;
2017                 }
2018                 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2019                         ttyrubo(tp, 2);
2020                 else {
2021                         CLR(c, ~TTY_CHARMASK);
2022                         switch (CCLASS(c)) {
2023                         case ORDINARY:
2024                                 ttyrubo(tp, 1);
2025                                 break;
2026                         case BACKSPACE:
2027                         case CONTROL:
2028                         case NEWLINE:
2029                         case RETURN:
2030                         case VTAB:
2031                                 if (ISSET(tp->t_lflag, ECHOCTL))
2032                                         ttyrubo(tp, 2);
2033                                 break;
2034                         case TAB:
2035                                 if (tp->t_rocount < tp->t_rawq.c_cc) {
2036                                         ttyretype(tp);
2037                                         return;
2038                                 }
2039                                 s = spltty();
2040                                 savecol = tp->t_column;
2041                                 SET(tp->t_state, TS_CNTTB);
2042                                 SET(tp->t_lflag, FLUSHO);
2043                                 tp->t_column = tp->t_rocol;
2044                                 cp = tp->t_rawq.c_cf;
2045                                 if (cp)
2046                                         tabc = *cp;     /* XXX FIX NEXTC */
2047                                 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2048                                         ttyecho(tabc, tp);
2049                                 CLR(tp->t_lflag, FLUSHO);
2050                                 CLR(tp->t_state, TS_CNTTB);
2051                                 splx(s);
2052
2053                                 /* savecol will now be length of the tab. */
2054                                 savecol -= tp->t_column;
2055                                 tp->t_column += savecol;
2056                                 if (savecol > 8)
2057                                         savecol = 8;    /* overflow screw */
2058                                 while (--savecol >= 0)
2059                                         (void)ttyoutput('\b', tp);
2060                                 break;
2061                         default:                        /* XXX */
2062 #define PANICSTR        "ttyrub: would panic c = %d, val = %d\n"
2063                                 (void)printf(PANICSTR, c, CCLASS(c));
2064 #ifdef notdef
2065                                 panic(PANICSTR, c, CCLASS(c));
2066 #endif
2067                         }
2068                 }
2069         } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2070                 if (!ISSET(tp->t_state, TS_ERASE)) {
2071                         SET(tp->t_state, TS_ERASE);
2072                         (void)ttyoutput('\\', tp);
2073                 }
2074                 ttyecho(c, tp);
2075         } else {
2076                 ttyecho(tp->t_cc[VERASE], tp);
2077                 /*
2078                  * This code may be executed not only when an ERASE key
2079                  * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2080                  * So, I didn't think it was worthwhile to pass the extra
2081                  * information (which would need an extra parameter,
2082                  * changing every call) needed to distinguish the ERASE2
2083                  * case from the ERASE.
2084                  */
2085         }
2086         --tp->t_rocount;
2087 }
2088
2089 /*
2090  * Back over cnt characters, erasing them.
2091  */
2092 static void
2093 ttyrubo(tp, cnt)
2094         register struct tty *tp;
2095         int cnt;
2096 {
2097
2098         while (cnt-- > 0) {
2099                 (void)ttyoutput('\b', tp);
2100                 (void)ttyoutput(' ', tp);
2101                 (void)ttyoutput('\b', tp);
2102         }
2103 }
2104
2105 /*
2106  * ttyretype --
2107  *      Reprint the rawq line.  Note, it is assumed that c_cc has already
2108  *      been checked.
2109  */
2110 static void
2111 ttyretype(tp)
2112         register struct tty *tp;
2113 {
2114         register char *cp;
2115         int s, c;
2116
2117         /* Echo the reprint character. */
2118         if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2119                 ttyecho(tp->t_cc[VREPRINT], tp);
2120
2121         (void)ttyoutput('\n', tp);
2122
2123         /*
2124          * XXX
2125          * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2126          * BIT OF FIRST CHAR.
2127          */
2128         s = spltty();
2129         for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2130             cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2131                 ttyecho(c, tp);
2132         for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2133             cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2134                 ttyecho(c, tp);
2135         CLR(tp->t_state, TS_ERASE);
2136         splx(s);
2137
2138         tp->t_rocount = tp->t_rawq.c_cc;
2139         tp->t_rocol = 0;
2140 }
2141
2142 /*
2143  * Echo a typed character to the terminal.
2144  */
2145 static void
2146 ttyecho(c, tp)
2147         register int c;
2148         register struct tty *tp;
2149 {
2150
2151         if (!ISSET(tp->t_state, TS_CNTTB))
2152                 CLR(tp->t_lflag, FLUSHO);
2153         if ((!ISSET(tp->t_lflag, ECHO) &&
2154              (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2155             ISSET(tp->t_lflag, EXTPROC))
2156                 return;
2157         if (ISSET(tp->t_lflag, ECHOCTL) &&
2158             ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2159             ISSET(c, TTY_CHARMASK) == 0177)) {
2160                 (void)ttyoutput('^', tp);
2161                 CLR(c, ~TTY_CHARMASK);
2162                 if (c == 0177)
2163                         c = '?';
2164                 else
2165                         c += 'A' - 1;
2166         }
2167         (void)ttyoutput(c, tp);
2168 }
2169
2170 /*
2171  * Wake up any readers on a tty.
2172  */
2173 void
2174 ttwakeup(tp)
2175         register struct tty *tp;
2176 {
2177
2178         if (tp->t_rsel.si_pid != 0)
2179                 selwakeup(&tp->t_rsel);
2180         if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2181                 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2182         wakeup(TSA_HUP_OR_INPUT(tp));
2183         KNOTE(&tp->t_rsel.si_note, 0);
2184 }
2185
2186 /*
2187  * Wake up any writers on a tty.
2188  */
2189 void
2190 ttwwakeup(tp)
2191         register struct tty *tp;
2192 {
2193
2194         if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat)
2195                 selwakeup(&tp->t_wsel);
2196         if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2197                 pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
2198         if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2199             TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2200                 CLR(tp->t_state, TS_SO_OCOMPLETE);
2201                 wakeup(TSA_OCOMPLETE(tp));
2202         }
2203         if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2204             tp->t_outq.c_cc <= tp->t_olowat) {
2205                 CLR(tp->t_state, TS_SO_OLOWAT);
2206                 wakeup(TSA_OLOWAT(tp));
2207         }
2208         KNOTE(&tp->t_wsel.si_note, 0);
2209 }
2210
2211 /*
2212  * Look up a code for a specified speed in a conversion table;
2213  * used by drivers to map software speed values to hardware parameters.
2214  */
2215 int
2216 ttspeedtab(speed, table)
2217         int speed;
2218         register struct speedtab *table;
2219 {
2220
2221         for ( ; table->sp_speed != -1; table++)
2222                 if (table->sp_speed == speed)
2223                         return (table->sp_code);
2224         return (-1);
2225 }
2226
2227 /*
2228  * Set input and output watermarks and buffer sizes.  For input, the
2229  * high watermark is about one second's worth of input above empty, the
2230  * low watermark is slightly below high water, and the buffer size is a
2231  * driver-dependent amount above high water.  For output, the watermarks
2232  * are near the ends of the buffer, with about 1 second's worth of input
2233  * between them.  All this only applies to the standard line discipline.
2234  */
2235 void
2236 ttsetwater(tp)
2237         struct tty *tp;
2238 {
2239         register int cps, ttmaxhiwat, x;
2240
2241         /* Input. */
2242         clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2243         switch (tp->t_ispeedwat) {
2244         case (speed_t)-1:
2245                 cps = tp->t_ispeed / 10;
2246                 break;
2247         case 0:
2248                 /*
2249                  * This case is for old drivers that don't know about
2250                  * t_ispeedwat.  Arrange for them to get the old buffer
2251                  * sizes and watermarks.
2252                  */
2253                 cps = TTYHOG - 2 * 256;
2254                 tp->t_ififosize = 2 * 256;
2255                 break;
2256         default:
2257                 cps = tp->t_ispeedwat / 10;
2258                 break;
2259         }
2260         tp->t_ihiwat = cps;
2261         tp->t_ilowat = 7 * cps / 8;
2262         x = cps + tp->t_ififosize;
2263         clist_alloc_cblocks(&tp->t_rawq, x, x);
2264
2265         /* Output. */
2266         switch (tp->t_ospeedwat) {
2267         case (speed_t)-1:
2268                 cps = tp->t_ospeed / 10;
2269                 ttmaxhiwat = 2 * TTMAXHIWAT;
2270                 break;
2271         case 0:
2272                 cps = tp->t_ospeed / 10;
2273                 ttmaxhiwat = TTMAXHIWAT;
2274                 break;
2275         default:
2276                 cps = tp->t_ospeedwat / 10;
2277                 ttmaxhiwat = 8 * TTMAXHIWAT;
2278                 break;
2279         }
2280 #define CLAMP(x, h, l)  ((x) > h ? h : ((x) < l) ? l : (x))
2281         tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2282         x += cps;
2283         x = CLAMP(x, ttmaxhiwat, TTMINHIWAT);   /* XXX clamps are too magic */
2284         tp->t_ohiwat = roundup(x, CBSIZE);      /* XXX for compat */
2285         x = imax(tp->t_ohiwat, TTMAXHIWAT);     /* XXX for compat/safety */
2286         x += OBUFSIZ + 100;
2287         clist_alloc_cblocks(&tp->t_outq, x, x);
2288 #undef  CLAMP
2289 }
2290
2291 /*
2292  * Report on state of foreground process group.
2293  */
2294 void
2295 ttyinfo(tp)
2296         register struct tty *tp;
2297 {
2298         register struct proc *p, *pick;
2299         struct timeval utime, stime;
2300         int tmp;
2301
2302         if (ttycheckoutq(tp,0) == 0)
2303                 return;
2304
2305         /* Print load average. */
2306         tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2307         ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
2308
2309         if (tp->t_session == NULL)
2310                 ttyprintf(tp, "not a controlling terminal\n");
2311         else if (tp->t_pgrp == NULL)
2312                 ttyprintf(tp, "no foreground process group\n");
2313         else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0)
2314                 ttyprintf(tp, "empty foreground process group\n");
2315         else {
2316                 /* Pick interesting process. */
2317                 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist))
2318                         if (proc_compare(pick, p))
2319                                 pick = p;
2320
2321                 ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
2322                     pick->p_stat == SRUN ? "running" :
2323                     pick->p_wmesg ? pick->p_wmesg : "iowait");
2324
2325                 if (pick->p_flag & P_INMEM) {
2326                         calcru(pick, &utime, &stime, NULL);
2327
2328                         /* Print user time. */
2329                         ttyprintf(tp, "%ld.%02ldu ",
2330                             utime.tv_sec, utime.tv_usec / 10000);
2331
2332                         /* Print system time. */
2333                         ttyprintf(tp, "%ld.%02lds ",
2334                             stime.tv_sec, stime.tv_usec / 10000);
2335                 } else
2336                         ttyprintf(tp, "?.??u ?.??s ");
2337
2338                 /* Print percentage cpu, resident set size. */
2339                 tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
2340                 ttyprintf(tp, "%d%% %ldk\n",
2341                     tmp / 100,
2342                     pick->p_stat == SIDL || pick->p_stat == SZOMB ? 0 :
2343                     (long)pgtok(vmspace_resident_count(pick->p_vmspace)));
2344         }
2345         tp->t_rocount = 0;      /* so pending input will be retyped if BS */
2346 }
2347
2348 /*
2349  * Returns 1 if p2 is "better" than p1
2350  *
2351  * The algorithm for picking the "interesting" process is thus:
2352  *
2353  *      1) Only foreground processes are eligible - implied.
2354  *      2) Runnable processes are favored over anything else.  The runner
2355  *         with the highest cpu utilization is picked (p_estcpu).  Ties are
2356  *         broken by picking the highest pid.
2357  *      3) The sleeper with the shortest sleep time is next.  With ties,
2358  *         we pick out just "short-term" sleepers (P_SINTR == 0).
2359  *      4) Further ties are broken by picking the highest pid.
2360  */
2361 #define ISRUN(p)        (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
2362 #define TESTAB(a, b)    ((a)<<1 | (b))
2363 #define ONLYA   2
2364 #define ONLYB   1
2365 #define BOTH    3
2366
2367 static int
2368 proc_compare(p1, p2)
2369         register struct proc *p1, *p2;
2370 {
2371
2372         if (p1 == NULL)
2373                 return (1);
2374         /*
2375          * see if at least one of them is runnable
2376          */
2377         switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
2378         case ONLYA:
2379                 return (0);
2380         case ONLYB:
2381                 return (1);
2382         case BOTH:
2383                 /*
2384                  * tie - favor one with highest recent cpu utilization
2385                  */
2386                 if (p2->p_estcpu > p1->p_estcpu)
2387                         return (1);
2388                 if (p1->p_estcpu > p2->p_estcpu)
2389                         return (0);
2390                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2391         }
2392         /*
2393          * weed out zombies
2394          */
2395         switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
2396         case ONLYA:
2397                 return (1);
2398         case ONLYB:
2399                 return (0);
2400         case BOTH:
2401                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2402         }
2403         /*
2404          * pick the one with the smallest sleep time
2405          */
2406         if (p2->p_slptime > p1->p_slptime)
2407                 return (0);
2408         if (p1->p_slptime > p2->p_slptime)
2409                 return (1);
2410         /*
2411          * favor one sleeping in a non-interruptible sleep
2412          */
2413         if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
2414                 return (1);
2415         if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
2416                 return (0);
2417         return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
2418 }
2419
2420 /*
2421  * Output char to tty; console putchar style.
2422  */
2423 int
2424 tputchar(c, tp)
2425         int c;
2426         struct tty *tp;
2427 {
2428         register int s;
2429
2430         s = spltty();
2431         if (!ISSET(tp->t_state, TS_CONNECTED)) {
2432                 splx(s);
2433                 return (-1);
2434         }
2435         if (c == '\n')
2436                 (void)ttyoutput('\r', tp);
2437         (void)ttyoutput(c, tp);
2438         ttstart(tp);
2439         splx(s);
2440         return (0);
2441 }
2442
2443 /*
2444  * Sleep on chan, returning ERESTART if tty changed while we napped and
2445  * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep.  If
2446  * the tty is revoked, restarting a pending call will redo validation done
2447  * at the start of the call.
2448  */
2449 int
2450 ttysleep(tp, chan, pri, wmesg, timo)
2451         struct tty *tp;
2452         void *chan;
2453         int pri, timo;
2454         char *wmesg;
2455 {
2456         int error;
2457         int gen;
2458
2459         gen = tp->t_gen;
2460         error = tsleep(chan, pri, wmesg, timo);
2461         if (error)
2462                 return (error);
2463         return (tp->t_gen == gen ? 0 : ERESTART);
2464 }
2465
2466 /*
2467  * Allocate a tty struct.  Clists in the struct will be allocated by
2468  * ttyopen().
2469  */
2470 struct tty *
2471 ttymalloc(tp)
2472         struct tty *tp;
2473 {
2474
2475         if (tp)
2476                 return(tp);
2477         tp = malloc(sizeof *tp, M_TTYS, M_WAITOK);
2478         bzero(tp, sizeof *tp);
2479         ttyregister(tp);
2480         return (tp);
2481 }
2482
2483 #if 0 /* XXX not yet usable: session leader holds a ref (see kern_exit.c). */
2484 /*
2485  * Free a tty struct.  Clists in the struct should have been freed by
2486  * ttyclose().
2487  */
2488 void
2489 ttyfree(tp)
2490         struct tty *tp;
2491 {
2492         free(tp, M_TTYS);
2493 }
2494 #endif /* 0 */
2495
2496 void
2497 ttyregister(tp)
2498         struct tty *tp;
2499 {
2500         SLIST_INSERT_HEAD(&tty_list, tp, t_list);
2501 }
2502
2503 static int
2504 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
2505 {
2506         int error;
2507         struct tty *tp, t;
2508         SLIST_FOREACH(tp, &tty_list, t_list) {
2509                 t = *tp;
2510                 if (t.t_dev)
2511                         t.t_dev = (dev_t)dev2udev(t.t_dev);
2512                 error = SYSCTL_OUT(req, (caddr_t)&t, sizeof(t));
2513                 if (error)
2514                         return (error);
2515         }
2516         return (0);
2517 }
2518
2519 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
2520         0, 0, sysctl_kern_ttys, "S,tty", "All struct ttys");
2521
2522 void
2523 nottystop(tp, rw)
2524         struct tty *tp;
2525         int rw;
2526 {
2527
2528         return;
2529 }
2530
2531 int
2532 ttyread(dev, uio, flag)
2533         dev_t dev;
2534         struct uio *uio;
2535         int flag;
2536 {
2537         struct tty *tp;
2538
2539         tp = dev->si_tty;
2540         if (tp == NULL)
2541                 return (ENODEV);
2542         return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
2543 }
2544
2545 int
2546 ttywrite(dev, uio, flag)
2547         dev_t dev;
2548         struct uio *uio;
2549         int flag;
2550 {
2551         struct tty *tp;
2552
2553         tp = dev->si_tty;
2554         if (tp == NULL)
2555                 return (ENODEV);
2556         return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
2557 }