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