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