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