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