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  * Copyright (c) 2002 Networks Associates Technologies, Inc.
  11  * All rights reserved.
  12  *
  13  * Portions of this software were developed for the FreeBSD Project by
  14  * ThinkSec AS and NAI Labs, the Security Research Division of Network
  15  * Associates, Inc.  under DARPA/SPAWAR contract N66001-01-C-8035
  16  * ("CBOSS"), as part of the DARPA CHATS research program.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions and the following disclaimer.
  23  * 2. Redistributions in binary form must reproduce the above copyright
  24  *    notice, this list of conditions and the following disclaimer in the
  25  *    documentation and/or other materials provided with the distribution.
  26  * 4. Neither the name of the University nor the names of its contributors
  27  *    may be used to endorse or promote products derived from this software
  28  *    without specific prior written permission.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40  * SUCH DAMAGE.
  41  *
  42  *      @(#)tty.c       8.8 (Berkeley) 1/21/94
  43  */
  44
  45 /*-
  46  * TODO:
  47  *      o Fix races for sending the start char in ttyflush().
  48  *      o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
  49  *        With luck, there will be MIN chars before select() returns().
  50  *      o Handle CLOCAL consistently for ptys.  Perhaps disallow setting it.
  51  *      o Don't allow input in TS_ZOMBIE case.  It would be visible through
  52  *        FIONREAD.
  53  *      o Do the new sio locking stuff here and use it to avoid special
  54  *        case for EXTPROC?
  55  *      o Lock PENDIN too?
  56  *      o Move EXTPROC and/or PENDIN to t_state?
  57  *      o Wrap most of ttioctl in spltty/splx.
  58  *      o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
  59  *      o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
  60  *      o Don't allow certain termios flags to affect disciplines other
  61  *        than TTYDISC.  Cancel their effects before switch disciplines
  62  *        and ignore them if they are set while we are in another
  63  *        discipline.
  64  *      o Now that historical speed conversions are handled here, don't
  65  *        do them in drivers.
  66  *      o Check for TS_CARR_ON being set while everything is closed and not
  67  *        waiting for carrier.  TS_CARR_ON isn't cleared if nothing is open,
  68  *        so it would live until the next open even if carrier drops.
  69  *      o Restore TS_WOPEN since it is useful in pstat.  It must be cleared
  70  *        only when _all_ openers leave open().
  71  */
  72
  73 #include <sys/cdefs.h>
  74 __FBSDID("$FreeBSD$");
  75
  76 #include "opt_compat.h"
  77 #include "opt_tty.h"
  78
  79 #include <sys/param.h>
  80 #include <sys/systm.h>
  81 #include <sys/filio.h>
  82 #include <sys/lock.h>
  83 #include <sys/mutex.h>
  84 #include <sys/namei.h>
  85 #include <sys/sx.h>
  86 #ifndef BURN_BRIDGES
  87 #if defined(COMPAT_43)
  88 #include <sys/ioctl_compat.h>
  89 #endif
  90 #endif
  91 #include <sys/proc.h>
  92 #define TTYDEFCHARS
  93 #include <sys/tty.h>
  94 #undef  TTYDEFCHARS
  95 #include <sys/fcntl.h>
  96 #include <sys/conf.h>
  97 #include <sys/poll.h>
  98 #include <sys/kernel.h>
  99 #include <sys/vnode.h>
 100 #include <sys/serial.h>
 101 #include <sys/signalvar.h>
 102 #include <sys/resourcevar.h>
 103 #include <sys/malloc.h>
 104 #include <sys/filedesc.h>
 105 #include <sys/sched.h>
 106 #include <sys/sysctl.h>
 107 #include <sys/timepps.h>
 108
 109 #include <machine/stdarg.h>
 110
 111 #include <vm/vm.h>
 112 #include <vm/pmap.h>
 113 #include <vm/vm_map.h>
 114
 115 MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
 116
 117 long tk_cancc;
 118 long tk_nin;
 119 long tk_nout;
 120 long tk_rawcc;
 121
 122 static  d_open_t        ttysopen;
 123 static  d_close_t       ttysclose;
 124 static  d_read_t        ttysrdwr;
 125 static  d_ioctl_t       ttysioctl;
 126 static  d_purge_t       ttypurge;
 127
 128 /* Default cdevsw for common tty devices */
 129 static struct cdevsw tty_cdevsw = {
 130         .d_version =    D_VERSION,
 131         .d_open =       ttyopen,
 132         .d_close =      ttyclose,
 133         .d_ioctl =      ttyioctl,
 134         .d_purge =      ttypurge,
 135         .d_name =       "ttydrv",
 136         .d_flags =      D_TTY | D_NEEDGIANT,
 137 };
 138
 139 /* Cdevsw for slave tty devices */
 140 static struct cdevsw ttys_cdevsw = {
 141         .d_version =    D_VERSION,
 142         .d_open =       ttysopen,
 143         .d_close =      ttysclose,
 144         .d_read =       ttysrdwr,
 145         .d_write =      ttysrdwr,
 146         .d_ioctl =      ttysioctl,
 147         .d_name =       "TTYS",
 148         .d_flags =      D_TTY | D_NEEDGIANT,
 149 };
 150
 151 static int      proc_compare(struct proc *p1, struct proc *p2);
 152 static int      ttnread(struct tty *tp);
 153 static void     ttyecho(int c, struct tty *tp);
 154 static int      ttyoutput(int c, struct tty *tp);
 155 static void     ttypend(struct tty *tp);
 156 static void     ttyretype(struct tty *tp);
 157 static void     ttyrub(int c, struct tty *tp);
 158 static void     ttyrubo(struct tty *tp, int cnt);
 159 static void     ttyunblock(struct tty *tp);
 160 static int      ttywflush(struct tty *tp);
 161 static int      filt_ttyread(struct knote *kn, long hint);
 162 static void     filt_ttyrdetach(struct knote *kn);
 163 static int      filt_ttywrite(struct knote *kn, long hint);
 164 static void     filt_ttywdetach(struct knote *kn);
 165
 166 /*
 167  * Table with character classes and parity. The 8th bit indicates parity,
 168  * the 7th bit indicates the character is an alphameric or underscore (for
 169  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
 170  * are 0 then the character needs no special processing on output; classes
 171  * other than 0 might be translated or (not currently) require delays.
 172  */
 173 #define E       0x00    /* Even parity. */
 174 #define O       0x80    /* Odd parity. */
 175 #define PARITY(c)       (char_type[c] & O)
 176
 177 #define ALPHA   0x40    /* Alpha or underscore. */
 178 #define ISALPHA(c)      (char_type[(c) & TTY_CHARMASK] & ALPHA)
 179
 180 #define CCLASSMASK      0x3f
 181 #define CCLASS(c)       (char_type[c] & CCLASSMASK)
 182
 183 #define BS      BACKSPACE
 184 #define CC      CONTROL
 185 #define CR      RETURN
 186 #define NA      ORDINARY | ALPHA
 187 #define NL      NEWLINE
 188 #define NO      ORDINARY
 189 #define TB      TAB
 190 #define VT      VTAB
 191
 192 static u_char const char_type[] = {
 193         E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
 194         O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
 195         O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
 196         E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
 197         O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
 198         E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
 199         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
 200         O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
 201         O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
 202         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
 203         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
 204         O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
 205         E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
 206         O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
 207         O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
 208         E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
 209         /*
 210          * Meta chars; should be settable per character set;
 211          * for now, treat them all as normal characters.
 212          */
 213         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 214         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 215         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 216         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 217         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 218         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 219         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 220         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 221         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 222         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 223         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 224         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 225         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 226         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 227         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 228         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 229 };
 230 #undef  BS
 231 #undef  CC
 232 #undef  CR
 233 #undef  NA
 234 #undef  NL
 235 #undef  NO
 236 #undef  TB
 237 #undef  VT
 238
 239 /* Macros to clear/set/test flags. */
 240 #define SET(t, f)       (t) |= (f)
 241 #define CLR(t, f)       (t) &= ~(f)
 242 #define ISSET(t, f)     ((t) & (f))
 243
 244 #undef MAX_INPUT                /* XXX wrong in <sys/syslimits.h> */
 245 #define MAX_INPUT       TTYHOG  /* XXX limit is usually larger for !ICANON */
 246
 247 /*
 248  * list of struct tty where pstat(8) can pick it up with sysctl
 249  *
 250  * The lock order is to grab the list mutex before the tty mutex.
 251  * Together with additions going on the tail of the list, this allows
 252  * the sysctl to avoid doing retries.
 253  */
 254 static  TAILQ_HEAD(, tty) tty_list = TAILQ_HEAD_INITIALIZER(tty_list);
 255 static struct mtx tty_list_mutex;
 256
 257 static struct unrhdr *tty_unit;
 258
 259 static int  drainwait = 5*60;
 260 SYSCTL_INT(_kern, OID_AUTO, drainwait, CTLFLAG_RW, &drainwait,
 261         0, "Output drain timeout in seconds");
 262
 263 static struct tty *
 264 tty_gettp(struct cdev *dev)
 265 {
 266         struct tty *tp;
 267         struct cdevsw *csw;
 268
 269         csw = dev_refthread(dev);
 270         KASSERT(csw != NULL, ("No cdevsw in ttycode (%s)", devtoname(dev)));
 271         KASSERT(csw->d_flags & D_TTY,
 272             ("non D_TTY (%s) in tty code", devtoname(dev)));
 273         dev_relthread(dev);
 274         tp = dev->si_tty;
 275         KASSERT(tp != NULL,
 276             ("no tty pointer on (%s) in tty code", devtoname(dev)));
 277         return (tp);
 278 }
 279
 280 /*
 281  * Initial open of tty, or (re)entry to standard tty line discipline.
 282  */
 283 int
 284 tty_open(struct cdev *device, struct tty *tp)
 285 {
 286         int s;
 287
 288         s = spltty();
 289         tp->t_dev = device;
 290         tp->t_hotchar = 0;
 291         if (!ISSET(tp->t_state, TS_ISOPEN)) {
 292                 ttyref(tp);
 293                 SET(tp->t_state, TS_ISOPEN);
 294                 if (ISSET(tp->t_cflag, CLOCAL))
 295                         SET(tp->t_state, TS_CONNECTED);
 296                 bzero(&tp->t_winsize, sizeof(tp->t_winsize));
 297         }
 298         /* XXX don't hang forever on output */
 299         if (tp->t_timeout < 0)
 300                 tp->t_timeout = drainwait*hz;
 301         ttsetwater(tp);
 302         splx(s);
 303         return (0);
 304 }
 305
 306 /*
 307  * Handle close() on a tty line: flush and set to initial state,
 308  * bumping generation number so that pending read/write calls
 309  * can detect recycling of the tty.
 310  * XXX our caller should have done `spltty(); l_close(); tty_close();'
 311  * and l_close() should have flushed, but we repeat the spltty() and
 312  * the flush in case there are buggy callers.
 313  */
 314 int
 315 tty_close(struct tty *tp)
 316 {
 317         int s;
 318
 319         funsetown(&tp->t_sigio);
 320         s = spltty();
 321         if (constty == tp)
 322                 constty_clear();
 323
 324         ttyflush(tp, FREAD | FWRITE);
 325         clist_free_cblocks(&tp->t_canq);
 326         clist_free_cblocks(&tp->t_outq);
 327         clist_free_cblocks(&tp->t_rawq);
 328
 329         tp->t_gen++;
 330         tp->t_line = TTYDISC;
 331         tp->t_hotchar = 0;
 332         tp->t_pgrp = NULL;
 333         tp->t_session = NULL;
 334         tp->t_state = 0;
 335         knlist_clear(&tp->t_rsel.si_note, 0);
 336         knlist_clear(&tp->t_wsel.si_note, 0);
 337         ttyrel(tp);
 338         splx(s);
 339         return (0);
 340 }
 341
 342 #define FLUSHQ(q) {                                                     \
 343         if ((q)->c_cc)                                                  \
 344                 ndflush(q, (q)->c_cc);                                  \
 345 }
 346
 347 /* Is 'c' a line delimiter ("break" character)? */
 348 #define TTBREAKC(c, lflag)                                                      \
 349         ((c) == '\n' || (((c) == cc[VEOF] ||                            \
 350           (c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) &&   \
 351          (c) != _POSIX_VDISABLE))
 352
 353 /*
 354  * Process input of a single character received on a tty.
 355  */
 356 int
 357 ttyinput(int c, struct tty *tp)
 358 {
 359         tcflag_t iflag, lflag;
 360         cc_t *cc;
 361         int i, err;
 362
 363         /*
 364          * If input is pending take it first.
 365          */
 366         lflag = tp->t_lflag;
 367         if (ISSET(lflag, PENDIN))
 368                 ttypend(tp);
 369         /*
 370          * Gather stats.
 371          */
 372         if (ISSET(lflag, ICANON)) {
 373                 ++tk_cancc;
 374                 ++tp->t_cancc;
 375         } else {
 376                 ++tk_rawcc;
 377                 ++tp->t_rawcc;
 378         }
 379         ++tk_nin;
 380
 381         /*
 382          * Block further input iff:
 383          * current input > threshold AND input is available to user program
 384          * AND input flow control is enabled and not yet invoked.
 385          * The 3 is slop for PARMRK.
 386          */
 387         iflag = tp->t_iflag;
 388         if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
 389             (!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
 390             (ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
 391             !ISSET(tp->t_state, TS_TBLOCK))
 392                 ttyblock(tp);
 393
 394         /* Handle exceptional conditions (break, parity, framing). */
 395         cc = tp->t_cc;
 396         err = (ISSET(c, TTY_ERRORMASK));
 397         if (err) {
 398                 CLR(c, TTY_ERRORMASK);
 399                 if (ISSET(err, TTY_BI)) {
 400                         if (ISSET(iflag, IGNBRK))
 401                                 return (0);
 402                         if (ISSET(iflag, BRKINT)) {
 403                                 ttyflush(tp, FREAD | FWRITE);
 404                                 if (tp->t_pgrp != NULL) {
 405                                         PGRP_LOCK(tp->t_pgrp);
 406                                         pgsignal(tp->t_pgrp, SIGINT, 1);
 407                                         PGRP_UNLOCK(tp->t_pgrp);
 408                                 }
 409                                 goto endcase;
 410                         }
 411                         if (ISSET(iflag, PARMRK))
 412                                 goto parmrk;
 413                 } else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
 414                         || ISSET(err, TTY_FE)) {
 415                         if (ISSET(iflag, IGNPAR))
 416                                 return (0);
 417                         else if (ISSET(iflag, PARMRK)) {
 418 parmrk:
 419                                 if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
 420                                     MAX_INPUT - 3)
 421                                         goto input_overflow;
 422                                 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
 423                                 (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
 424                                 (void)putc(c | TTY_QUOTE, &tp->t_rawq);
 425                                 goto endcase;
 426                         } else
 427                                 c = 0;
 428                 }
 429         }
 430
 431         if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
 432                 CLR(c, 0x80);
 433         if (!ISSET(lflag, EXTPROC)) {
 434                 /*
 435                  * Check for literal nexting very first
 436                  */
 437                 if (ISSET(tp->t_state, TS_LNCH)) {
 438                         SET(c, TTY_QUOTE);
 439                         CLR(tp->t_state, TS_LNCH);
 440                 }
 441                 /*
 442                  * Scan for special characters.  This code
 443                  * is really just a big case statement with
 444                  * non-constant cases.  The bottom of the
 445                  * case statement is labeled ``endcase'', so goto
 446                  * it after a case match, or similar.
 447                  */
 448
 449                 /*
 450                  * Control chars which aren't controlled
 451                  * by ICANON, ISIG, or IXON.
 452                  */
 453                 if (ISSET(lflag, IEXTEN)) {
 454                         if (CCEQ(cc[VLNEXT], c)) {
 455                                 if (ISSET(lflag, ECHO)) {
 456                                         if (ISSET(lflag, ECHOE)) {
 457                                                 (void)ttyoutput('^', tp);
 458                                                 (void)ttyoutput('\b', tp);
 459                                         } else
 460                                                 ttyecho(c, tp);
 461                                 }
 462                                 SET(tp->t_state, TS_LNCH);
 463                                 goto endcase;
 464                         }
 465                         if (CCEQ(cc[VDISCARD], c)) {
 466                                 if (ISSET(lflag, FLUSHO))
 467                                         CLR(tp->t_lflag, FLUSHO);
 468                                 else {
 469                                         ttyflush(tp, FWRITE);
 470                                         ttyecho(c, tp);
 471                                         if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
 472                                                 ttyretype(tp);
 473                                         SET(tp->t_lflag, FLUSHO);
 474                                 }
 475                                 goto startoutput;
 476                         }
 477                 }
 478                 /*
 479                  * Signals.
 480                  */
 481                 if (ISSET(lflag, ISIG)) {
 482                         if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
 483                                 if (!ISSET(lflag, NOFLSH))
 484                                         ttyflush(tp, FREAD | FWRITE);
 485                                 ttyecho(c, tp);
 486                                 if (tp->t_pgrp != NULL) {
 487                                         PGRP_LOCK(tp->t_pgrp);
 488                                         pgsignal(tp->t_pgrp,
 489                                             CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
 490                                         PGRP_UNLOCK(tp->t_pgrp);
 491                                 }
 492                                 goto endcase;
 493                         }
 494                         if (CCEQ(cc[VSUSP], c)) {
 495                                 if (!ISSET(lflag, NOFLSH))
 496                                         ttyflush(tp, FREAD);
 497                                 ttyecho(c, tp);
 498                                 if (tp->t_pgrp != NULL) {
 499                                         PGRP_LOCK(tp->t_pgrp);
 500                                         pgsignal(tp->t_pgrp, SIGTSTP, 1);
 501                                         PGRP_UNLOCK(tp->t_pgrp);
 502                                 }
 503                                 goto endcase;
 504                         }
 505                 }
 506                 /*
 507                  * Handle start/stop characters.
 508                  */
 509                 if (ISSET(iflag, IXON)) {
 510                         if (CCEQ(cc[VSTOP], c)) {
 511                                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
 512                                         SET(tp->t_state, TS_TTSTOP);
 513                                         (*tp->t_stop)(tp, 0);
 514                                         return (0);
 515                                 }
 516                                 if (!CCEQ(cc[VSTART], c))
 517                                         return (0);
 518                                 /*
 519                                  * if VSTART == VSTOP then toggle
 520                                  */
 521                                 goto endcase;
 522                         }
 523                         if (CCEQ(cc[VSTART], c))
 524                                 goto restartoutput;
 525                 }
 526                 /*
 527                  * IGNCR, ICRNL, & INLCR
 528                  */
 529                 if (c == '\r') {
 530                         if (ISSET(iflag, IGNCR))
 531                                 return (0);
 532                         else if (ISSET(iflag, ICRNL))
 533                                 c = '\n';
 534                 } else if (c == '\n' && ISSET(iflag, INLCR))
 535                         c = '\r';
 536         }
 537         if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
 538                 /*
 539                  * From here on down canonical mode character
 540                  * processing takes place.
 541                  */
 542                 /*
 543                  * erase or erase2 (^H / ^?)
 544                  */
 545                 if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
 546                         if (tp->t_rawq.c_cc)
 547                                 ttyrub(unputc(&tp->t_rawq), tp);
 548                         goto endcase;
 549                 }
 550                 /*
 551                  * kill (^U)
 552                  */
 553                 if (CCEQ(cc[VKILL], c)) {
 554                         if (ISSET(lflag, ECHOKE) &&
 555                             tp->t_rawq.c_cc == tp->t_rocount &&
 556                             !ISSET(lflag, ECHOPRT))
 557                                 while (tp->t_rawq.c_cc)
 558                                         ttyrub(unputc(&tp->t_rawq), tp);
 559                         else {
 560                                 ttyecho(c, tp);
 561                                 if (ISSET(lflag, ECHOK) ||
 562                                     ISSET(lflag, ECHOKE))
 563                                         ttyecho('\n', tp);
 564                                 FLUSHQ(&tp->t_rawq);
 565                                 tp->t_rocount = 0;
 566                         }
 567                         CLR(tp->t_state, TS_LOCAL);
 568                         goto endcase;
 569                 }
 570                 /*
 571                  * word erase (^W)
 572                  */
 573                 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
 574                         int ctype;
 575
 576                         /*
 577                          * erase whitespace
 578                          */
 579                         while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
 580                                 ttyrub(c, tp);
 581                         if (c == -1)
 582                                 goto endcase;
 583                         /*
 584                          * erase last char of word and remember the
 585                          * next chars type (for ALTWERASE)
 586                          */
 587                         ttyrub(c, tp);
 588                         c = unputc(&tp->t_rawq);
 589                         if (c == -1)
 590                                 goto endcase;
 591                         if (c == ' ' || c == '\t') {
 592                                 (void)putc(c, &tp->t_rawq);
 593                                 goto endcase;
 594                         }
 595                         ctype = ISALPHA(c);
 596                         /*
 597                          * erase rest of word
 598                          */
 599                         do {
 600                                 ttyrub(c, tp);
 601                                 c = unputc(&tp->t_rawq);
 602                                 if (c == -1)
 603                                         goto endcase;
 604                         } while (c != ' ' && c != '\t' &&
 605                             (!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
 606                         (void)putc(c, &tp->t_rawq);
 607                         goto endcase;
 608                 }
 609                 /*
 610                  * reprint line (^R)
 611                  */
 612                 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
 613                         ttyretype(tp);
 614                         goto endcase;
 615                 }
 616                 /*
 617                  * ^T - kernel info and generate SIGINFO
 618                  */
 619                 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
 620                         if (ISSET(lflag, ISIG) && tp->t_pgrp != NULL) {
 621                                 PGRP_LOCK(tp->t_pgrp);
 622                                 pgsignal(tp->t_pgrp, SIGINFO, 1);
 623                                 PGRP_UNLOCK(tp->t_pgrp);
 624                         }
 625                         if (!ISSET(lflag, NOKERNINFO))
 626                                 ttyinfo(tp);
 627                         goto endcase;
 628                 }
 629         }
 630         /*
 631          * Check for input buffer overflow
 632          */
 633         if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
 634 input_overflow:
 635                 if (ISSET(iflag, IMAXBEL)) {
 636                         if (tp->t_outq.c_cc < tp->t_ohiwat)
 637                                 (void)ttyoutput(CTRL('g'), tp);
 638                 }
 639                 goto endcase;
 640         }
 641
 642         if (   c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
 643              && ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
 644                 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
 645
 646         /*
 647          * Put data char in q for user and
 648          * wakeup on seeing a line delimiter.
 649          */
 650         if (putc(c, &tp->t_rawq) >= 0) {
 651                 if (!ISSET(lflag, ICANON)) {
 652                         ttwakeup(tp);
 653                         ttyecho(c, tp);
 654                         goto endcase;
 655                 }
 656                 if (TTBREAKC(c, lflag)) {
 657                         tp->t_rocount = 0;
 658                         catq(&tp->t_rawq, &tp->t_canq);
 659                         ttwakeup(tp);
 660                 } else if (tp->t_rocount++ == 0)
 661                         tp->t_rocol = tp->t_column;
 662                 if (ISSET(tp->t_state, TS_ERASE)) {
 663                         /*
 664                          * end of prterase \.../
 665                          */
 666                         CLR(tp->t_state, TS_ERASE);
 667                         (void)ttyoutput('/', tp);
 668                 }
 669                 i = tp->t_column;
 670                 ttyecho(c, tp);
 671                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
 672                         /*
 673                          * Place the cursor over the '^' of the ^D.
 674                          */
 675                         i = imin(2, tp->t_column - i);
 676                         while (i > 0) {
 677                                 (void)ttyoutput('\b', tp);
 678                                 i--;
 679                         }
 680                 }
 681         }
 682 endcase:
 683         /*
 684          * IXANY means allow any character to restart output.
 685          */
 686         if (ISSET(tp->t_state, TS_TTSTOP) &&
 687             !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
 688                 return (0);
 689 restartoutput:
 690         CLR(tp->t_lflag, FLUSHO);
 691         CLR(tp->t_state, TS_TTSTOP);
 692 startoutput:
 693         return (ttstart(tp));
 694 }
 695
 696 /*
 697  * Output a single character on a tty, doing output processing
 698  * as needed (expanding tabs, newline processing, etc.).
 699  * Returns < 0 if succeeds, otherwise returns char to resend.
 700  * Must be recursive.
 701  */
 702 static int
 703 ttyoutput(int c, struct tty *tp)
 704 {
 705         tcflag_t oflag;
 706         int col, s;
 707
 708         oflag = tp->t_oflag;
 709         if (!ISSET(oflag, OPOST)) {
 710                 if (ISSET(tp->t_lflag, FLUSHO))
 711                         return (-1);
 712                 if (putc(c, &tp->t_outq))
 713                         return (c);
 714                 tk_nout++;
 715                 tp->t_outcc++;
 716                 return (-1);
 717         }
 718         /*
 719          * Do tab expansion if OXTABS is set.  Special case if we external
 720          * processing, we don't do the tab expansion because we'll probably
 721          * get it wrong.  If tab expansion needs to be done, let it happen
 722          * externally.
 723          */
 724         CLR(c, ~TTY_CHARMASK);
 725         if (c == '\t' &&
 726             ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
 727                 c = 8 - (tp->t_column & 7);
 728                 if (!ISSET(tp->t_lflag, FLUSHO)) {
 729                         s = spltty();           /* Don't interrupt tabs. */
 730                         c -= b_to_q("        ", c, &tp->t_outq);
 731                         tk_nout += c;
 732                         tp->t_outcc += c;
 733                         splx(s);
 734                 }
 735                 tp->t_column += c;
 736                 return (c ? -1 : '\t');
 737         }
 738         if (c == CEOT && ISSET(oflag, ONOEOT))
 739                 return (-1);
 740
 741         /*
 742          * Newline translation: if ONLCR is set,
 743          * translate newline into "\r\n".
 744          */
 745         if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
 746                 tk_nout++;
 747                 tp->t_outcc++;
 748                 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
 749                         return (c);
 750         }
 751         /* If OCRNL is set, translate "\r" into "\n". */
 752         else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
 753                 c = '\n';
 754         /* If ONOCR is set, don't transmit CRs when on column 0. */
 755         else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
 756                 return (-1);
 757
 758         tk_nout++;
 759         tp->t_outcc++;
 760         if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
 761                 return (c);
 762
 763         col = tp->t_column;
 764         switch (CCLASS(c)) {
 765         case BACKSPACE:
 766                 if (col > 0)
 767                         --col;
 768                 break;
 769         case CONTROL:
 770                 break;
 771         case NEWLINE:
 772                 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
 773                         col = 0;
 774                 break;
 775         case RETURN:
 776                 col = 0;
 777                 break;
 778         case ORDINARY:
 779                 ++col;
 780                 break;
 781         case TAB:
 782                 col = (col + 8) & ~7;
 783                 break;
 784         }
 785         tp->t_column = col;
 786         return (-1);
 787 }
 788
 789 /*
 790  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
 791  * has been called to do discipline-specific functions and/or reject any
 792  * of these ioctl commands.
 793  */
 794 /* ARGSUSED */
 795 int
 796 ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
 797 {
 798         struct proc *p;
 799         struct thread *td;
 800         struct pgrp *pgrp;
 801         int s, error, bits, sig, sig2;
 802
 803         td = curthread;                 /* XXX */
 804         p = td->td_proc;
 805
 806         /* If the ioctl involves modification, hang if in the background. */
 807         switch (cmd) {
 808         case  TIOCCBRK:
 809         case  TIOCCONS:
 810         case  TIOCDRAIN:
 811         case  TIOCEXCL:
 812         case  TIOCFLUSH:
 813 #ifdef TIOCHPCL
 814         case  TIOCHPCL:
 815 #endif
 816         case  TIOCNXCL:
 817         case  TIOCSBRK:
 818         case  TIOCSCTTY:
 819         case  TIOCSDRAINWAIT:
 820         case  TIOCSETA:
 821         case  TIOCSETAF:
 822         case  TIOCSETAW:
 823         case  TIOCSETD:
 824         case  TIOCSPGRP:
 825         case  TIOCSTART:
 826         case  TIOCSTAT:
 827         case  TIOCSTI:
 828         case  TIOCSTOP:
 829         case  TIOCSWINSZ:
 830 #ifndef BURN_BRIDGES
 831 #if defined(COMPAT_43)
 832         case  TIOCLBIC:
 833         case  TIOCLBIS:
 834         case  TIOCLSET:
 835         case  TIOCSETC:
 836         case OTIOCSETD:
 837         case  TIOCSETN:
 838         case  TIOCSETP:
 839         case  TIOCSLTC:
 840 #endif
 841 #endif
 842                 sx_slock(&proctree_lock);
 843                 PROC_LOCK(p);
 844                 while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
 845                     !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
 846                     !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
 847                         pgrp = p->p_pgrp;
 848                         PROC_UNLOCK(p);
 849                         if (pgrp->pg_jobc == 0) {
 850                                 sx_sunlock(&proctree_lock);
 851                                 return (EIO);
 852                         }
 853                         PGRP_LOCK(pgrp);
 854                         sx_sunlock(&proctree_lock);
 855                         pgsignal(pgrp, SIGTTOU, 1);
 856                         PGRP_UNLOCK(pgrp);
 857                         error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
 858                                          0);
 859                         if (error)
 860                                 return (error);
 861                         sx_slock(&proctree_lock);
 862                         PROC_LOCK(p);
 863                 }
 864                 PROC_UNLOCK(p);
 865                 sx_sunlock(&proctree_lock);
 866                 break;
 867         }
 868
 869         if (tp->t_break != NULL) {
 870                 switch (cmd) {
 871                 case TIOCSBRK:
 872                         tp->t_break(tp, 1);
 873                         return (0);
 874                 case TIOCCBRK:
 875                         tp->t_break(tp, 0);
 876                         return (0);
 877                 default:
 878                         break;
 879                 }
 880         }
 881
 882         if (tp->t_modem != NULL) {
 883                 switch (cmd) {
 884                 case TIOCSDTR:
 885                         tp->t_modem(tp, SER_DTR, 0);
 886                         return (0);
 887                 case TIOCCDTR:
 888                         tp->t_modem(tp, 0, SER_DTR);
 889                         return (0);
 890                 case TIOCMSET:
 891                         bits = *(int *)data;
 892                         sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
 893                         sig2 = ((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1;
 894                         tp->t_modem(tp, sig, sig2);
 895                         return (0);
 896                 case TIOCMBIS:
 897                         bits = *(int *)data;
 898                         sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
 899                         tp->t_modem(tp, sig, 0);
 900                         return (0);
 901                 case TIOCMBIC:
 902                         bits = *(int *)data;
 903                         sig = (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1;
 904                         tp->t_modem(tp, 0, sig);
 905                         return (0);
 906                 case TIOCMGET:
 907                         sig = tp->t_modem(tp, 0, 0);
 908                         /* See <sys/serial.h. for the "<< 1" stuff */
 909                         bits = TIOCM_LE + (sig << 1);
 910                         *(int *)data = bits;
 911                         return (0);
 912                 default:
 913                         break;
 914                 }
 915         }
 916
 917         if (tp->t_pps != NULL) {
 918                 error = pps_ioctl(cmd, data, tp->t_pps);
 919                 if (error != ENOIOCTL)
 920                         return (error);
 921         }
 922
 923         switch (cmd) {                  /* Process the ioctl. */
 924         case FIOASYNC:                  /* set/clear async i/o */
 925                 s = spltty();
 926                 if (*(int *)data)
 927                         SET(tp->t_state, TS_ASYNC);
 928                 else
 929                         CLR(tp->t_state, TS_ASYNC);
 930                 splx(s);
 931                 break;
 932         case FIONBIO:                   /* set/clear non-blocking i/o */
 933                 break;                  /* XXX: delete. */
 934         case FIONREAD:                  /* get # bytes to read */
 935                 s = spltty();
 936                 *(int *)data = ttnread(tp);
 937                 splx(s);
 938                 break;
 939
 940         case FIOSETOWN:
 941                 /*
 942                  * Policy -- Don't allow FIOSETOWN on someone else's
 943                  *           controlling tty
 944                  */
 945                 if (tp->t_session != NULL && !isctty(p, tp))
 946                         return (ENOTTY);
 947
 948                 error = fsetown(*(int *)data, &tp->t_sigio);
 949                 if (error)
 950                         return (error);
 951                 break;
 952         case FIOGETOWN:
 953                 if (tp->t_session != NULL && !isctty(p, tp))
 954                         return (ENOTTY);
 955                 *(int *)data = fgetown(&tp->t_sigio);
 956                 break;
 957
 958         case TIOCEXCL:                  /* set exclusive use of tty */
 959                 s = spltty();
 960                 SET(tp->t_state, TS_XCLUDE);
 961                 splx(s);
 962                 break;
 963         case TIOCFLUSH: {               /* flush buffers */
 964                 int flags = *(int *)data;
 965
 966                 if (flags == 0)
 967                         flags = FREAD | FWRITE;
 968                 else
 969                         flags &= FREAD | FWRITE;
 970                 ttyflush(tp, flags);
 971                 break;
 972         }
 973         case TIOCCONS:                  /* become virtual console */
 974                 if (*(int *)data) {
 975                         struct nameidata nid;
 976
 977                         if (constty && constty != tp &&
 978                             ISSET(constty->t_state, TS_CONNECTED))
 979                                 return (EBUSY);
 980
 981                         /* Ensure user can open the real console. */
 982                         NDINIT(&nid, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE,
 983                             "/dev/console", td);
 984                         if ((error = namei(&nid)) != 0)
 985                                 return (error);
 986                         NDFREE(&nid, NDF_ONLY_PNBUF);
 987                         error = VOP_ACCESS(nid.ni_vp, VREAD, td->td_ucred, td);
 988                         vput(nid.ni_vp);
 989                         if (error)
 990                                 return (error);
 991
 992                         constty_set(tp);
 993                 } else if (tp == constty)
 994                         constty_clear();
 995                 break;
 996         case TIOCDRAIN:                 /* wait till output drained */
 997                 error = ttywait(tp);
 998                 if (error)
 999                         return (error);
1000                 break;
1001         case TIOCGETA: {                /* get termios struct */
1002                 struct termios *t = (struct termios *)data;
1003
1004                 bcopy(&tp->t_termios, t, sizeof(struct termios));
1005                 break;
1006         }
1007         case TIOCGETD:                  /* get line discipline */
1008                 *(int *)data = tp->t_line;
1009                 break;
1010         case TIOCGWINSZ:                /* get window size */
1011                 *(struct winsize *)data = tp->t_winsize;
1012                 break;
1013         case TIOCGPGRP:                 /* get pgrp of tty */
1014                 if (!isctty(p, tp))
1015                         return (ENOTTY);
1016                 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
1017                 break;
1018 #ifdef TIOCHPCL
1019         case TIOCHPCL:                  /* hang up on last close */
1020                 s = spltty();
1021                 SET(tp->t_cflag, HUPCL);
1022                 splx(s);
1023                 break;
1024 #endif
1025         case TIOCMGDTRWAIT:
1026                 *(int *)data = tp->t_dtr_wait * 100 / hz;
1027                 break;
1028         case TIOCMSDTRWAIT:
1029                 /* must be root since the wait applies to following logins */
1030                 error = suser(td);
1031                 if (error)
1032                         return (error);
1033                 tp->t_dtr_wait = *(int *)data * hz / 100;
1034                 break;
1035         case TIOCNXCL:                  /* reset exclusive use of tty */
1036                 s = spltty();
1037                 CLR(tp->t_state, TS_XCLUDE);
1038                 splx(s);
1039                 break;
1040         case TIOCOUTQ:                  /* output queue size */
1041                 *(int *)data = tp->t_outq.c_cc;
1042                 break;
1043         case TIOCSETA:                  /* set termios struct */
1044         case TIOCSETAW:                 /* drain output, set */
1045         case TIOCSETAF: {               /* drn out, fls in, set */
1046                 struct termios *t = (struct termios *)data;
1047
1048                 if (t->c_ispeed == 0)
1049                         t->c_ispeed = t->c_ospeed;
1050                 if (t->c_ispeed == 0)
1051                         t->c_ispeed = tp->t_ospeed;
1052                 if (t->c_ispeed == 0)
1053                         return (EINVAL);
1054                 s = spltty();
1055                 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
1056                         error = ttywait(tp);
1057                         if (error) {
1058                                 splx(s);
1059                                 return (error);
1060                         }
1061                         if (cmd == TIOCSETAF)
1062                                 ttyflush(tp, FREAD);
1063                 }
1064                 if (!ISSET(t->c_cflag, CIGNORE)) {
1065                         /*
1066                          * Set device hardware.
1067                          */
1068                         if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
1069                                 splx(s);
1070                                 return (error);
1071                         }
1072                         if (ISSET(t->c_cflag, CLOCAL) &&
1073                             !ISSET(tp->t_cflag, CLOCAL)) {
1074                                 /*
1075                                  * XXX disconnections would be too hard to
1076                                  * get rid of without this kludge.  The only
1077                                  * way to get rid of controlling terminals
1078                                  * is to exit from the session leader.
1079                                  */
1080                                 CLR(tp->t_state, TS_ZOMBIE);
1081
1082                                 wakeup(TSA_CARR_ON(tp));
1083                                 ttwakeup(tp);
1084                                 ttwwakeup(tp);
1085                         }
1086                         if ((ISSET(tp->t_state, TS_CARR_ON) ||
1087                              ISSET(t->c_cflag, CLOCAL)) &&
1088                             !ISSET(tp->t_state, TS_ZOMBIE))
1089                                 SET(tp->t_state, TS_CONNECTED);
1090                         else
1091                                 CLR(tp->t_state, TS_CONNECTED);
1092                         tp->t_cflag = t->c_cflag;
1093                         tp->t_ispeed = t->c_ispeed;
1094                         if (t->c_ospeed != 0)
1095                                 tp->t_ospeed = t->c_ospeed;
1096                         ttsetwater(tp);
1097                 }
1098                 if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
1099                     cmd != TIOCSETAF) {
1100                         if (ISSET(t->c_lflag, ICANON))
1101                                 SET(tp->t_lflag, PENDIN);
1102                         else {
1103                                 /*
1104                                  * XXX we really shouldn't allow toggling
1105                                  * ICANON while we're in a non-termios line
1106                                  * discipline.  Now we have to worry about
1107                                  * panicing for a null queue.
1108                                  */
1109                                 if (tp->t_canq.c_cbreserved > 0 &&
1110                                     tp->t_rawq.c_cbreserved > 0) {
1111                                         catq(&tp->t_rawq, &tp->t_canq);
1112                                         /*
1113                                          * XXX the queue limits may be
1114                                          * different, so the old queue
1115                                          * swapping method no longer works.
1116                                          */
1117                                         catq(&tp->t_canq, &tp->t_rawq);
1118                                 }
1119                                 CLR(tp->t_lflag, PENDIN);
1120                         }
1121                         ttwakeup(tp);
1122                 }
1123                 tp->t_iflag = t->c_iflag;
1124                 tp->t_oflag = t->c_oflag;
1125                 /*
1126                  * Make the EXTPROC bit read only.
1127                  */
1128                 if (ISSET(tp->t_lflag, EXTPROC))
1129                         SET(t->c_lflag, EXTPROC);
1130                 else
1131                         CLR(t->c_lflag, EXTPROC);
1132                 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
1133                 if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
1134                     t->c_cc[VTIME] != tp->t_cc[VTIME])
1135                         ttwakeup(tp);
1136                 bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
1137                 splx(s);
1138                 break;
1139         }
1140         case TIOCSETD: {                /* set line discipline */
1141                 int t = *(int *)data;
1142
1143                 if ((u_int)t >= nlinesw)
1144                         return (ENXIO);
1145                 if (t == tp->t_line)
1146                         return (0);
1147                 s = spltty();
1148                 ttyld_close(tp, flag);
1149                 tp->t_line = t;
1150                 /* XXX: we should use the correct cdev here */
1151                 error = ttyld_open(tp, tp->t_dev);
1152                 if (error) {
1153                         /*
1154                          * If we fail to switch line discipline we cannot
1155                          * fall back to the previous, because we can not
1156                          * trust that ldisc to open successfully either.
1157                          * Fall back to the default ldisc which we know
1158                          * will allways succeed.
1159                          */
1160                         tp->t_line = TTYDISC;
1161                         (void)ttyld_open(tp, tp->t_dev);
1162                 }
1163                 splx(s);
1164                 return (error);
1165                 break;
1166         }
1167         case TIOCSTART:                 /* start output, like ^Q */
1168                 s = spltty();
1169                 if (ISSET(tp->t_state, TS_TTSTOP) ||
1170                     ISSET(tp->t_lflag, FLUSHO)) {
1171                         CLR(tp->t_lflag, FLUSHO);
1172                         CLR(tp->t_state, TS_TTSTOP);
1173                         ttstart(tp);
1174                 }
1175                 splx(s);
1176                 break;
1177         case TIOCSTI:                   /* simulate terminal input */
1178                 if ((flag & FREAD) == 0 && suser(td))
1179                         return (EPERM);
1180                 if (!isctty(p, tp) && suser(td))
1181                         return (EACCES);
1182                 s = spltty();
1183                 ttyld_rint(tp, *(u_char *)data);
1184                 splx(s);
1185                 break;
1186         case TIOCSTOP:                  /* stop output, like ^S */
1187                 s = spltty();
1188                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
1189                         SET(tp->t_state, TS_TTSTOP);
1190                         (*tp->t_stop)(tp, 0);
1191                 }
1192                 splx(s);
1193                 break;
1194         case TIOCSCTTY:                 /* become controlling tty */
1195                 /* Session ctty vnode pointer set in vnode layer. */
1196                 sx_slock(&proctree_lock);
1197                 if (!SESS_LEADER(p) ||
1198                     ((p->p_session->s_ttyvp || tp->t_session) &&
1199                      (tp->t_session != p->p_session))) {
1200                         sx_sunlock(&proctree_lock);
1201                         return (EPERM);
1202                 }
1203                 tp->t_session = p->p_session;
1204                 tp->t_pgrp = p->p_pgrp;
1205                 SESS_LOCK(p->p_session);
1206                 ttyref(tp);             /* ttyrel(): kern_proc.c:pgdelete() */
1207                 p->p_session->s_ttyp = tp;
1208                 SESS_UNLOCK(p->p_session);
1209                 PROC_LOCK(p);
1210                 p->p_flag |= P_CONTROLT;
1211                 PROC_UNLOCK(p);
1212                 sx_sunlock(&proctree_lock);
1213                 break;
1214         case TIOCSPGRP: {               /* set pgrp of tty */
1215                 sx_slock(&proctree_lock);
1216                 pgrp = pgfind(*(int *)data);
1217                 if (!isctty(p, tp)) {
1218                         if (pgrp != NULL)
1219                                 PGRP_UNLOCK(pgrp);
1220                         sx_sunlock(&proctree_lock);
1221                         return (ENOTTY);
1222                 }
1223                 if (pgrp == NULL) {
1224                         sx_sunlock(&proctree_lock);
1225                         return (EPERM);
1226                 }
1227                 PGRP_UNLOCK(pgrp);
1228                 if (pgrp->pg_session != p->p_session) {
1229                         sx_sunlock(&proctree_lock);
1230                         return (EPERM);
1231                 }
1232                 sx_sunlock(&proctree_lock);
1233                 tp->t_pgrp = pgrp;
1234                 break;
1235         }
1236         case TIOCSTAT:                  /* simulate control-T */
1237                 s = spltty();
1238                 ttyinfo(tp);
1239                 splx(s);
1240                 break;
1241         case TIOCSWINSZ:                /* set window size */
1242                 if (bcmp((caddr_t)&tp->t_winsize, data,
1243                     sizeof (struct winsize))) {
1244                         tp->t_winsize = *(struct winsize *)data;
1245                         if (tp->t_pgrp != NULL) {
1246                                 PGRP_LOCK(tp->t_pgrp);
1247                                 pgsignal(tp->t_pgrp, SIGWINCH, 1);
1248                                 PGRP_UNLOCK(tp->t_pgrp);
1249                         }
1250                 }
1251                 break;
1252         case TIOCSDRAINWAIT:
1253                 error = suser(td);
1254                 if (error)
1255                         return (error);
1256                 tp->t_timeout = *(int *)data * hz;
1257                 wakeup(TSA_OCOMPLETE(tp));
1258                 wakeup(TSA_OLOWAT(tp));
1259                 break;
1260         case TIOCGDRAINWAIT:
1261                 *(int *)data = tp->t_timeout / hz;
1262                 break;
1263         default:
1264 #if defined(COMPAT_43)
1265 #ifndef BURN_BRIDGES
1266                 return (ttcompat(tp, cmd, data, flag));
1267 #else
1268                 return (ENOIOCTL);
1269 #endif
1270 #else
1271                 return (ENOIOCTL);
1272 #endif
1273         }
1274         return (0);
1275 }
1276
1277 int
1278 ttypoll(struct cdev *dev, int events, struct thread *td)
1279 {
1280         int s;
1281         int revents = 0;
1282         struct tty *tp;
1283
1284         tp = tty_gettp(dev);
1285
1286         if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
1287                 return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
1288                         | POLLHUP);
1289
1290         s = spltty();
1291         if (events & (POLLIN | POLLRDNORM)) {
1292                 if (ISSET(tp->t_state, TS_ZOMBIE))
1293                         revents |= (events & (POLLIN | POLLRDNORM)) |
1294                             POLLHUP;
1295                 else if (ttnread(tp) > 0)
1296                         revents |= events & (POLLIN | POLLRDNORM);
1297                 else
1298                         selrecord(td, &tp->t_rsel);
1299         }
1300         if (events & POLLOUT) {
1301                 if (ISSET(tp->t_state, TS_ZOMBIE))
1302                         revents |= POLLHUP;
1303                 else if (tp->t_outq.c_cc <= tp->t_olowat &&
1304                     ISSET(tp->t_state, TS_CONNECTED))
1305                         revents |= events & POLLOUT;
1306                 else
1307                         selrecord(td, &tp->t_wsel);
1308         }
1309         splx(s);
1310         return (revents);
1311 }
1312
1313 static struct filterops ttyread_filtops =
1314         { 1, NULL, filt_ttyrdetach, filt_ttyread };
1315 static struct filterops ttywrite_filtops =
1316         { 1, NULL, filt_ttywdetach, filt_ttywrite };
1317
1318 int
1319 ttykqfilter(struct cdev *dev, struct knote *kn)
1320 {
1321         struct tty *tp;
1322         struct knlist *klist;
1323         int s;
1324
1325         tp = tty_gettp(dev);
1326
1327         switch (kn->kn_filter) {
1328         case EVFILT_READ:
1329                 klist = &tp->t_rsel.si_note;
1330                 kn->kn_fop = &ttyread_filtops;
1331                 break;
1332         case EVFILT_WRITE:
1333                 klist = &tp->t_wsel.si_note;
1334                 kn->kn_fop = &ttywrite_filtops;
1335                 break;
1336         default:
1337                 return (EINVAL);
1338         }
1339
1340         kn->kn_hook = (caddr_t)dev;
1341
1342         s = spltty();
1343         knlist_add(klist, kn, 0);
1344         splx(s);
1345
1346         return (0);
1347 }
1348
1349 static void
1350 filt_ttyrdetach(struct knote *kn)
1351 {
1352         struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1353         int s = spltty();
1354
1355         knlist_remove(&tp->t_rsel.si_note, kn, 0);
1356         splx(s);
1357 }
1358
1359 static int
1360 filt_ttyread(struct knote *kn, long hint)
1361 {
1362         struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1363
1364         kn->kn_data = ttnread(tp);
1365         if (ISSET(tp->t_state, TS_ZOMBIE)) {
1366                 kn->kn_flags |= EV_EOF;
1367                 return (1);
1368         }
1369         return (kn->kn_data > 0);
1370 }
1371
1372 static void
1373 filt_ttywdetach(struct knote *kn)
1374 {
1375         struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1376         int s = spltty();
1377
1378         knlist_remove(&tp->t_wsel.si_note, kn, 0);
1379         splx(s);
1380 }
1381
1382 static int
1383 filt_ttywrite(struct knote *kn, long hint)
1384 {
1385         struct tty *tp = ((struct cdev *)kn->kn_hook)->si_tty;
1386
1387         kn->kn_data = tp->t_outq.c_cc;
1388         if (ISSET(tp->t_state, TS_ZOMBIE))
1389                 return (1);
1390         return (kn->kn_data <= tp->t_olowat &&
1391             ISSET(tp->t_state, TS_CONNECTED));
1392 }
1393
1394 /*
1395  * Must be called at spltty().
1396  */
1397 static int
1398 ttnread(struct tty *tp)
1399 {
1400         int nread;
1401
1402         if (ISSET(tp->t_lflag, PENDIN))
1403                 ttypend(tp);
1404         nread = tp->t_canq.c_cc;
1405         if (!ISSET(tp->t_lflag, ICANON)) {
1406                 nread += tp->t_rawq.c_cc;
1407                 if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
1408                         nread = 0;
1409         }
1410         return (nread);
1411 }
1412
1413 /*
1414  * Wait for output to drain.
1415  */
1416 int
1417 ttywait(struct tty *tp)
1418 {
1419         int error, s;
1420
1421         error = 0;
1422         s = spltty();
1423         while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1424                ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
1425                 (*tp->t_oproc)(tp);
1426                 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
1427                     ISSET(tp->t_state, TS_CONNECTED)) {
1428                         SET(tp->t_state, TS_SO_OCOMPLETE);
1429                         error = ttysleep(tp, TSA_OCOMPLETE(tp),
1430                                          TTOPRI | PCATCH, "ttywai",
1431                                          tp->t_timeout);
1432                         if (error) {
1433                                 if (error == EWOULDBLOCK)
1434                                         error = EIO;
1435                                 break;
1436                         }
1437                 } else
1438                         break;
1439         }
1440         if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
1441                 error = EIO;
1442         splx(s);
1443         return (error);
1444 }
1445
1446 /*
1447  * Flush if successfully wait.
1448  */
1449 static int
1450 ttywflush(struct tty *tp)
1451 {
1452         int error;
1453
1454         if ((error = ttywait(tp)) == 0)
1455                 ttyflush(tp, FREAD);
1456         return (error);
1457 }
1458
1459 /*
1460  * Flush tty read and/or write queues, notifying anyone waiting.
1461  */
1462 void
1463 ttyflush(struct tty *tp, int rw)
1464 {
1465         int s;
1466
1467         s = spltty();
1468 #if 0
1469 again:
1470 #endif
1471         if (rw & FWRITE) {
1472                 FLUSHQ(&tp->t_outq);
1473                 CLR(tp->t_state, TS_TTSTOP);
1474         }
1475         (*tp->t_stop)(tp, rw);
1476         if (rw & FREAD) {
1477                 FLUSHQ(&tp->t_canq);
1478                 FLUSHQ(&tp->t_rawq);
1479                 CLR(tp->t_lflag, PENDIN);
1480                 tp->t_rocount = 0;
1481                 tp->t_rocol = 0;
1482                 CLR(tp->t_state, TS_LOCAL);
1483                 ttwakeup(tp);
1484                 if (ISSET(tp->t_state, TS_TBLOCK)) {
1485                         if (rw & FWRITE)
1486                                 FLUSHQ(&tp->t_outq);
1487                         ttyunblock(tp);
1488
1489                         /*
1490                          * Don't let leave any state that might clobber the
1491                          * next line discipline (although we should do more
1492                          * to send the START char).  Not clearing the state
1493                          * may have caused the "putc to a clist with no
1494                          * reserved cblocks" panic/printf.
1495                          */
1496                         CLR(tp->t_state, TS_TBLOCK);
1497
1498 #if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
1499                         if (ISSET(tp->t_iflag, IXOFF)) {
1500                                 /*
1501                                  * XXX wait a bit in the hope that the stop
1502                                  * character (if any) will go out.  Waiting
1503                                  * isn't good since it allows races.  This
1504                                  * will be fixed when the stop character is
1505                                  * put in a special queue.  Don't bother with
1506                                  * the checks in ttywait() since the timeout
1507                                  * will save us.
1508                                  */
1509                                 SET(tp->t_state, TS_SO_OCOMPLETE);
1510                                 ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
1511                                          "ttyfls", hz / 10);
1512                                 /*
1513                                  * Don't try sending the stop character again.
1514                                  */
1515                                 CLR(tp->t_state, TS_TBLOCK);
1516                                 goto again;
1517                         }
1518 #endif
1519                 }
1520         }
1521         if (rw & FWRITE) {
1522                 FLUSHQ(&tp->t_outq);
1523                 ttwwakeup(tp);
1524         }
1525         splx(s);
1526 }
1527
1528 /*
1529  * Copy in the default termios characters.
1530  */
1531 void
1532 termioschars(struct termios *t)
1533 {
1534
1535         bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
1536 }
1537
1538 /*
1539  * Old interface.
1540  */
1541 void
1542 ttychars(struct tty *tp)
1543 {
1544
1545         termioschars(&tp->t_termios);
1546 }
1547
1548 /*
1549  * Handle input high water.  Send stop character for the IXOFF case.  Turn
1550  * on our input flow control bit and propagate the changes to the driver.
1551  * XXX the stop character should be put in a special high priority queue.
1552  */
1553 void
1554 ttyblock(struct tty *tp)
1555 {
1556
1557         SET(tp->t_state, TS_TBLOCK);
1558         if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
1559             putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
1560                 CLR(tp->t_state, TS_TBLOCK);    /* try again later */
1561         ttstart(tp);
1562 }
1563
1564 /*
1565  * Handle input low water.  Send start character for the IXOFF case.  Turn
1566  * off our input flow control bit and propagate the changes to the driver.
1567  * XXX the start character should be put in a special high priority queue.
1568  */
1569 static void
1570 ttyunblock(struct tty *tp)
1571 {
1572
1573         CLR(tp->t_state, TS_TBLOCK);
1574         if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
1575             putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
1576                 SET(tp->t_state, TS_TBLOCK);    /* try again later */
1577         ttstart(tp);
1578 }
1579
1580 #ifdef notyet
1581 /* Not used by any current (i386) drivers. */
1582 /*
1583  * Restart after an inter-char delay.
1584  */
1585 void
1586 ttrstrt(void *tp_arg)
1587 {
1588         struct tty *tp;
1589         int s;
1590
1591         KASSERT(tp_arg != NULL, ("ttrstrt"));
1592
1593         tp = tp_arg;
1594         s = spltty();
1595
1596         CLR(tp->t_state, TS_TIMEOUT);
1597         ttstart(tp);
1598
1599         splx(s);
1600 }
1601 #endif
1602
1603 int
1604 ttstart(struct tty *tp)
1605 {
1606
1607         if (tp->t_oproc != NULL)        /* XXX: Kludge for pty. */
1608                 (*tp->t_oproc)(tp);
1609         return (0);
1610 }
1611
1612 /*
1613  * "close" a line discipline
1614  */
1615 int
1616 ttylclose(struct tty *tp, int flag)
1617 {
1618
1619         if (flag & FNONBLOCK || ttywflush(tp))
1620                 ttyflush(tp, FREAD | FWRITE);
1621         return (0);
1622 }
1623
1624 /*
1625  * Handle modem control transition on a tty.
1626  * Flag indicates new state of carrier.
1627  * Returns 0 if the line should be turned off, otherwise 1.
1628  */
1629 int
1630 ttymodem(struct tty *tp, int flag)
1631 {
1632
1633         if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
1634                 /*
1635                  * MDMBUF: do flow control according to carrier flag
1636                  * XXX TS_CAR_OFLOW doesn't do anything yet.  TS_TTSTOP
1637                  * works if IXON and IXANY are clear.
1638                  */
1639                 if (flag) {
1640                         CLR(tp->t_state, TS_CAR_OFLOW);
1641                         CLR(tp->t_state, TS_TTSTOP);
1642                         ttstart(tp);
1643                 } else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
1644                         SET(tp->t_state, TS_CAR_OFLOW);
1645                         SET(tp->t_state, TS_TTSTOP);
1646                         (*tp->t_stop)(tp, 0);
1647                 }
1648         } else if (flag == 0) {
1649                 /*
1650                  * Lost carrier.
1651                  */
1652                 CLR(tp->t_state, TS_CARR_ON);
1653                 if (ISSET(tp->t_state, TS_ISOPEN) &&
1654                     !ISSET(tp->t_cflag, CLOCAL)) {
1655                         SET(tp->t_state, TS_ZOMBIE);
1656                         CLR(tp->t_state, TS_CONNECTED);
1657                         if (tp->t_session) {
1658                                 sx_slock(&proctree_lock);
1659                                 if (tp->t_session->s_leader) {
1660                                         struct proc *p;
1661
1662                                         p = tp->t_session->s_leader;
1663                                         PROC_LOCK(p);
1664                                         psignal(p, SIGHUP);
1665                                         PROC_UNLOCK(p);
1666                                 }
1667                                 sx_sunlock(&proctree_lock);
1668                         }
1669                         ttyflush(tp, FREAD | FWRITE);
1670                         return (0);
1671                 }
1672         } else {
1673                 /*
1674                  * Carrier now on.
1675                  */
1676                 SET(tp->t_state, TS_CARR_ON);
1677                 if (!ISSET(tp->t_state, TS_ZOMBIE))
1678                         SET(tp->t_state, TS_CONNECTED);
1679                 wakeup(TSA_CARR_ON(tp));
1680                 ttwakeup(tp);
1681                 ttwwakeup(tp);
1682         }
1683         return (1);
1684 }
1685
1686 /*
1687  * Reinput pending characters after state switch
1688  * call at spltty().
1689  */
1690 static void
1691 ttypend(struct tty *tp)
1692 {
1693         struct clist tq;
1694         int c;
1695
1696         CLR(tp->t_lflag, PENDIN);
1697         SET(tp->t_state, TS_TYPEN);
1698         /*
1699          * XXX this assumes too much about clist internals.  It may even
1700          * fail if the cblock slush pool is empty.  We can't allocate more
1701          * cblocks here because we are called from an interrupt handler
1702          * and clist_alloc_cblocks() can wait.
1703          */
1704         tq = tp->t_rawq;
1705         bzero(&tp->t_rawq, sizeof tp->t_rawq);
1706         tp->t_rawq.c_cbmax = tq.c_cbmax;
1707         tp->t_rawq.c_cbreserved = tq.c_cbreserved;
1708         while ((c = getc(&tq)) >= 0)
1709                 ttyinput(c, tp);
1710         CLR(tp->t_state, TS_TYPEN);
1711 }
1712
1713 /*
1714  * Process a read call on a tty device.
1715  */
1716 int
1717 ttread(struct tty *tp, struct uio *uio, int flag)
1718 {
1719         struct clist *qp;
1720         int c;
1721         tcflag_t lflag;
1722         cc_t *cc = tp->t_cc;
1723         struct thread *td;
1724         struct proc *p;
1725         int s, first, error = 0;
1726         int has_stime = 0, last_cc = 0;
1727         long slp = 0;           /* XXX this should be renamed `timo'. */
1728         struct timeval stime;
1729         struct pgrp *pg;
1730
1731         td = curthread;
1732         p = td->td_proc;
1733 loop:
1734         s = spltty();
1735         lflag = tp->t_lflag;
1736         /*
1737          * take pending input first
1738          */
1739         if (ISSET(lflag, PENDIN)) {
1740                 ttypend(tp);
1741                 splx(s);        /* reduce latency */
1742                 s = spltty();
1743                 lflag = tp->t_lflag;    /* XXX ttypend() clobbers it */
1744         }
1745
1746         /*
1747          * Hang process if it's in the background.
1748          */
1749         if (isbackground(p, tp)) {
1750                 splx(s);
1751                 sx_slock(&proctree_lock);
1752                 PROC_LOCK(p);
1753                 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) ||
1754                     SIGISMEMBER(td->td_sigmask, SIGTTIN) ||
1755                     (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) {
1756                         PROC_UNLOCK(p);
1757                         sx_sunlock(&proctree_lock);
1758                         return (EIO);
1759                 }
1760                 pg = p->p_pgrp;
1761                 PROC_UNLOCK(p);
1762                 PGRP_LOCK(pg);
1763                 sx_sunlock(&proctree_lock);
1764                 pgsignal(pg, SIGTTIN, 1);
1765                 PGRP_UNLOCK(pg);
1766                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
1767                 if (error)
1768                         return (error);
1769                 goto loop;
1770         }
1771
1772         if (ISSET(tp->t_state, TS_ZOMBIE)) {
1773                 splx(s);
1774                 return (0);     /* EOF */
1775         }
1776
1777         /*
1778          * If canonical, use the canonical queue,
1779          * else use the raw queue.
1780          *
1781          * (should get rid of clists...)
1782          */
1783         qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
1784
1785         if (flag & IO_NDELAY) {
1786                 if (qp->c_cc > 0)
1787                         goto read;
1788                 if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
1789                         splx(s);
1790                         return (0);
1791                 }
1792                 splx(s);
1793                 return (EWOULDBLOCK);
1794         }
1795         if (!ISSET(lflag, ICANON)) {
1796                 int m = cc[VMIN];
1797                 long t = cc[VTIME];
1798                 struct timeval timecopy;
1799
1800                 /*
1801                  * Check each of the four combinations.
1802                  * (m > 0 && t == 0) is the normal read case.
1803                  * It should be fairly efficient, so we check that and its
1804                  * companion case (m == 0 && t == 0) first.
1805                  * For the other two cases, we compute the target sleep time
1806                  * into slp.
1807                  */
1808                 if (t == 0) {
1809                         if (qp->c_cc < m)
1810                                 goto sleep;
1811                         if (qp->c_cc > 0)
1812                                 goto read;
1813
1814                         /* m, t and qp->c_cc are all 0.  0 is enough input. */
1815                         splx(s);
1816                         return (0);
1817                 }
1818                 t *= 100000;            /* time in us */
1819 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
1820                          ((t1).tv_usec - (t2).tv_usec))
1821                 if (m > 0) {
1822                         if (qp->c_cc <= 0)
1823                                 goto sleep;
1824                         if (qp->c_cc >= m)
1825                                 goto read;
1826                         getmicrotime(&timecopy);
1827                         if (!has_stime) {
1828                                 /* first character, start timer */
1829                                 has_stime = 1;
1830                                 stime = timecopy;
1831                                 slp = t;
1832                         } else if (qp->c_cc > last_cc) {
1833                                 /* got a character, restart timer */
1834                                 stime = timecopy;
1835                                 slp = t;
1836                         } else {
1837                                 /* nothing, check expiration */
1838                                 slp = t - diff(timecopy, stime);
1839                                 if (slp <= 0)
1840                                         goto read;
1841                         }
1842                         last_cc = qp->c_cc;
1843                 } else {        /* m == 0 */
1844                         if (qp->c_cc > 0)
1845                                 goto read;
1846                         getmicrotime(&timecopy);
1847                         if (!has_stime) {
1848                                 has_stime = 1;
1849                                 stime = timecopy;
1850                                 slp = t;
1851                         } else {
1852                                 slp = t - diff(timecopy, stime);
1853                                 if (slp <= 0) {
1854                                         /* Timed out, but 0 is enough input. */
1855                                         splx(s);
1856                                         return (0);
1857                                 }
1858                         }
1859                 }
1860 #undef diff
1861                 if (slp != 0) {
1862                         struct timeval tv;      /* XXX style bug. */
1863
1864                         tv.tv_sec = slp / 1000000;
1865                         tv.tv_usec = slp % 1000000;
1866                         slp = tvtohz(&tv);
1867                         /*
1868                          * XXX bad variable names.  slp was the timeout in
1869                          * usec.  Now it is the timeout in ticks.
1870                          */
1871                 }
1872                 goto sleep;
1873         }
1874         if (qp->c_cc <= 0) {
1875 sleep:
1876                 /*
1877                  * There is no input, or not enough input and we can block.
1878                  */
1879                 error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
1880                                  ISSET(tp->t_state, TS_CONNECTED) ?
1881                                  "ttyin" : "ttyhup", (int)slp);
1882                 splx(s);
1883                 if (error == EWOULDBLOCK)
1884                         error = 0;
1885                 else if (error)
1886                         return (error);
1887                 /*
1888                  * XXX what happens if another process eats some input
1889                  * while we are asleep (not just here)?  It would be
1890                  * safest to detect changes and reset our state variables
1891                  * (has_stime and last_cc).
1892                  */
1893                 slp = 0;
1894                 goto loop;
1895         }
1896 read:
1897         splx(s);
1898         /*
1899          * Input present, check for input mapping and processing.
1900          */
1901         first = 1;
1902         if (ISSET(lflag, ICANON | ISIG))
1903                 goto slowcase;
1904         for (;;) {
1905                 char ibuf[IBUFSIZ];
1906                 int icc;
1907
1908                 icc = imin(uio->uio_resid, IBUFSIZ);
1909                 icc = q_to_b(qp, ibuf, icc);
1910                 if (icc <= 0) {
1911                         if (first)
1912                                 goto loop;
1913                         break;
1914                 }
1915                 error = uiomove(ibuf, icc, uio);
1916                 /*
1917                  * XXX if there was an error then we should ungetc() the
1918                  * unmoved chars and reduce icc here.
1919                  */
1920                 if (error)
1921                         break;
1922                 if (uio->uio_resid == 0)
1923                         break;
1924                 first = 0;
1925         }
1926         goto out;
1927 slowcase:
1928         for (;;) {
1929                 c = getc(qp);
1930                 if (c < 0) {
1931                         if (first)
1932                                 goto loop;
1933                         break;
1934                 }
1935                 /*
1936                  * delayed suspend (^Y)
1937                  */
1938                 if (CCEQ(cc[VDSUSP], c) &&
1939                     ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
1940                         if (tp->t_pgrp != NULL) {
1941                                 PGRP_LOCK(tp->t_pgrp);
1942                                 pgsignal(tp->t_pgrp, SIGTSTP, 1);
1943                                 PGRP_UNLOCK(tp->t_pgrp);
1944                         }
1945                         if (first) {
1946                                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
1947                                                  "ttybg3", 0);
1948                                 if (error)
1949                                         break;
1950                                 goto loop;
1951                         }
1952                         break;
1953                 }
1954                 /*
1955                  * Interpret EOF only in canonical mode.
1956                  */
1957                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
1958                         break;
1959                 /*
1960                  * Give user character.
1961                  */
1962                 error = ureadc(c, uio);
1963                 if (error)
1964                         /* XXX should ungetc(c, qp). */
1965                         break;
1966                 if (uio->uio_resid == 0)
1967                         break;
1968                 /*
1969                  * In canonical mode check for a "break character"
1970                  * marking the end of a "line of input".
1971                  */
1972                 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
1973                         break;
1974                 first = 0;
1975         }
1976
1977 out:
1978         /*
1979          * Look to unblock input now that (presumably)
1980          * the input queue has gone down.
1981          */
1982         s = spltty();
1983         if (ISSET(tp->t_state, TS_TBLOCK) &&
1984             tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
1985                 ttyunblock(tp);
1986         splx(s);
1987
1988         return (error);
1989 }
1990
1991 /*
1992  * Check the output queue on tp for space for a kernel message (from uprintf
1993  * or tprintf).  Allow some space over the normal hiwater mark so we don't
1994  * lose messages due to normal flow control, but don't let the tty run amok.
1995  * Sleeps here are not interruptible, but we return prematurely if new signals
1996  * arrive.
1997  */
1998 int
1999 ttycheckoutq(struct tty *tp, int wait)
2000 {
2001         int hiwat, s;
2002         sigset_t oldmask;
2003         struct thread *td;
2004         struct proc *p;
2005
2006         td = curthread;
2007         p = td->td_proc;
2008         hiwat = tp->t_ohiwat;
2009         SIGEMPTYSET(oldmask);
2010         s = spltty();
2011         if (wait) {
2012                 PROC_LOCK(p);
2013                 oldmask = td->td_siglist;
2014                 PROC_UNLOCK(p);
2015         }
2016         if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
2017                 while (tp->t_outq.c_cc > hiwat) {
2018                         ttstart(tp);
2019                         if (tp->t_outq.c_cc <= hiwat)
2020                                 break;
2021                         if (!wait) {
2022                                 splx(s);
2023                                 return (0);
2024                         }
2025                         PROC_LOCK(p);
2026                         if (!SIGSETEQ(td->td_siglist, oldmask)) {
2027                                 PROC_UNLOCK(p);
2028                                 splx(s);
2029                                 return (0);
2030                         }
2031                         PROC_UNLOCK(p);
2032                         SET(tp->t_state, TS_SO_OLOWAT);
2033                         tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
2034                 }
2035         splx(s);
2036         return (1);
2037 }
2038
2039 /*
2040  * Process a write call on a tty device.
2041  */
2042 int
2043 ttwrite(struct tty *tp, struct uio *uio, int flag)
2044 {
2045         char *cp = NULL;
2046         int cc, ce;
2047         struct thread *td;
2048         struct proc *p;
2049         int i, hiwat, cnt, error, s;
2050         char obuf[OBUFSIZ];
2051
2052         hiwat = tp->t_ohiwat;
2053         cnt = uio->uio_resid;
2054         error = 0;
2055         cc = 0;
2056         td = curthread;
2057         p = td->td_proc;
2058 loop:
2059         s = spltty();
2060         if (ISSET(tp->t_state, TS_ZOMBIE)) {
2061                 splx(s);
2062                 if (uio->uio_resid == cnt)
2063                         error = EIO;
2064                 goto out;
2065         }
2066         if (!ISSET(tp->t_state, TS_CONNECTED)) {
2067                 if (flag & IO_NDELAY) {
2068                         splx(s);
2069                         error = EWOULDBLOCK;
2070                         goto out;
2071                 }
2072                 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
2073                                  "ttywdcd", 0);
2074                 splx(s);
2075                 if (error)
2076                         goto out;
2077                 goto loop;
2078         }
2079         splx(s);
2080         /*
2081          * Hang the process if it's in the background.
2082          */
2083         sx_slock(&proctree_lock);
2084         PROC_LOCK(p);
2085         if (isbackground(p, tp) &&
2086             ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
2087             !SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTOU) &&
2088             !SIGISMEMBER(td->td_sigmask, SIGTTOU)) {
2089                 if (p->p_pgrp->pg_jobc == 0) {
2090                         PROC_UNLOCK(p);
2091                         sx_sunlock(&proctree_lock);
2092                         error = EIO;
2093                         goto out;
2094                 }
2095                 PROC_UNLOCK(p);
2096                 PGRP_LOCK(p->p_pgrp);
2097                 sx_sunlock(&proctree_lock);
2098                 pgsignal(p->p_pgrp, SIGTTOU, 1);
2099                 PGRP_UNLOCK(p->p_pgrp);
2100                 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
2101                 if (error)
2102                         goto out;
2103                 goto loop;
2104         } else {
2105                 PROC_UNLOCK(p);
2106                 sx_sunlock(&proctree_lock);
2107         }
2108         /*
2109          * Process the user's data in at most OBUFSIZ chunks.  Perform any
2110          * output translation.  Keep track of high water mark, sleep on
2111          * overflow awaiting device aid in acquiring new space.
2112          */
2113         while (uio->uio_resid > 0 || cc > 0) {
2114                 if (ISSET(tp->t_lflag, FLUSHO)) {
2115                         uio->uio_resid = 0;
2116                         return (0);
2117                 }
2118                 if (tp->t_outq.c_cc > hiwat)
2119                         goto ovhiwat;
2120                 /*
2121                  * Grab a hunk of data from the user, unless we have some
2122                  * leftover from last time.
2123                  */
2124                 if (cc == 0) {
2125                         cc = imin(uio->uio_resid, OBUFSIZ);
2126                         cp = obuf;
2127                         error = uiomove(cp, cc, uio);
2128                         if (error) {
2129                                 cc = 0;
2130                                 break;
2131                         }
2132                 }
2133                 /*
2134                  * If nothing fancy need be done, grab those characters we
2135                  * can handle without any of ttyoutput's processing and
2136                  * just transfer them to the output q.  For those chars
2137                  * which require special processing (as indicated by the
2138                  * bits in char_type), call ttyoutput.  After processing
2139                  * a hunk of data, look for FLUSHO so ^O's will take effect
2140                  * immediately.
2141                  */
2142                 while (cc > 0) {
2143                         if (!ISSET(tp->t_oflag, OPOST))
2144                                 ce = cc;
2145                         else {
2146                                 ce = cc - scanc((u_int)cc, (u_char *)cp,
2147                                                 char_type, CCLASSMASK);
2148                                 /*
2149                                  * If ce is zero, then we're processing
2150                                  * a special character through ttyoutput.
2151                                  */
2152                                 if (ce == 0) {
2153                                         tp->t_rocount = 0;
2154                                         if (ttyoutput(*cp, tp) >= 0) {
2155                                                 /* No Clists, wait a bit. */
2156                                                 ttstart(tp);
2157                                                 if (flag & IO_NDELAY) {
2158                                                         error = EWOULDBLOCK;
2159                                                         goto out;
2160                                                 }
2161                                                 error = ttysleep(tp, &lbolt,
2162                                                                  TTOPRI|PCATCH,
2163                                                                  "ttybf1", 0);
2164                                                 if (error)
2165                                                         goto out;
2166                                                 goto loop;
2167                                         }
2168                                         cp++;
2169                                         cc--;
2170                                         if (ISSET(tp->t_lflag, FLUSHO) ||
2171                                             tp->t_outq.c_cc > hiwat)
2172                                                 goto ovhiwat;
2173                                         continue;
2174                                 }
2175                         }
2176                         /*
2177                          * A bunch of normal characters have been found.
2178                          * Transfer them en masse to the output queue and
2179                          * continue processing at the top of the loop.
2180                          * If there are any further characters in this
2181                          * <= OBUFSIZ chunk, the first should be a character
2182                          * requiring special handling by ttyoutput.
2183                          */
2184                         tp->t_rocount = 0;
2185                         i = b_to_q(cp, ce, &tp->t_outq);
2186                         ce -= i;
2187                         tp->t_column += ce;
2188                         cp += ce, cc -= ce, tk_nout += ce;
2189                         tp->t_outcc += ce;
2190                         if (i > 0) {
2191                                 /* No Clists, wait a bit. */
2192                                 ttstart(tp);
2193                                 if (flag & IO_NDELAY) {
2194                                         error = EWOULDBLOCK;
2195                                         goto out;
2196                                 }
2197                                 error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
2198                                                  "ttybf2", 0);
2199                                 if (error)
2200                                         goto out;
2201                                 goto loop;
2202                         }
2203                         if (ISSET(tp->t_lflag, FLUSHO) ||
2204                             tp->t_outq.c_cc > hiwat)
2205                                 break;
2206                 }
2207                 ttstart(tp);
2208         }
2209 out:
2210         /*
2211          * If cc is nonzero, we leave the uio structure inconsistent, as the
2212          * offset and iov pointers have moved forward, but it doesn't matter
2213          * (the call will either return short or restart with a new uio).
2214          */
2215         uio->uio_resid += cc;
2216         return (error);
2217
2218 ovhiwat:
2219         ttstart(tp);
2220         s = spltty();
2221         /*
2222          * This can only occur if FLUSHO is set in t_lflag,
2223          * or if ttstart/oproc is synchronous (or very fast).
2224          */
2225         if (tp->t_outq.c_cc <= hiwat) {
2226                 splx(s);
2227                 goto loop;
2228         }
2229         if (flag & IO_NDELAY) {
2230                 splx(s);
2231                 uio->uio_resid += cc;
2232                 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
2233         }
2234         SET(tp->t_state, TS_SO_OLOWAT);
2235         error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
2236                          tp->t_timeout);
2237         splx(s);
2238         if (error == EWOULDBLOCK)
2239                 error = EIO;
2240         if (error)
2241                 goto out;
2242         goto loop;
2243 }
2244
2245 /*
2246  * Rubout one character from the rawq of tp
2247  * as cleanly as possible.
2248  */
2249 static void
2250 ttyrub(int c, struct tty *tp)
2251 {
2252         char *cp;
2253         int savecol;
2254         int tabc, s;
2255
2256         if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
2257                 return;
2258         CLR(tp->t_lflag, FLUSHO);
2259         if (ISSET(tp->t_lflag, ECHOE)) {
2260                 if (tp->t_rocount == 0) {
2261                         /*
2262                          * Screwed by ttwrite; retype
2263                          */
2264                         ttyretype(tp);
2265                         return;
2266                 }
2267                 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
2268                         ttyrubo(tp, 2);
2269                 else {
2270                         CLR(c, ~TTY_CHARMASK);
2271                         switch (CCLASS(c)) {
2272                         case ORDINARY:
2273                                 ttyrubo(tp, 1);
2274                                 break;
2275                         case BACKSPACE:
2276                         case CONTROL:
2277                         case NEWLINE:
2278                         case RETURN:
2279                         case VTAB:
2280                                 if (ISSET(tp->t_lflag, ECHOCTL))
2281                                         ttyrubo(tp, 2);
2282                                 break;
2283                         case TAB:
2284                                 if (tp->t_rocount < tp->t_rawq.c_cc) {
2285                                         ttyretype(tp);
2286                                         return;
2287                                 }
2288                                 s = spltty();
2289                                 savecol = tp->t_column;
2290                                 SET(tp->t_state, TS_CNTTB);
2291                                 SET(tp->t_lflag, FLUSHO);
2292                                 tp->t_column = tp->t_rocol;
2293                                 cp = tp->t_rawq.c_cf;
2294                                 if (cp)
2295                                         tabc = *cp;     /* XXX FIX NEXTC */
2296                                 for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
2297                                         ttyecho(tabc, tp);
2298                                 CLR(tp->t_lflag, FLUSHO);
2299                                 CLR(tp->t_state, TS_CNTTB);
2300                                 splx(s);
2301
2302                                 /* savecol will now be length of the tab. */
2303                                 savecol -= tp->t_column;
2304                                 tp->t_column += savecol;
2305                                 if (savecol > 8)
2306                                         savecol = 8;    /* overflow screw */
2307                                 while (--savecol >= 0)
2308                                         (void)ttyoutput('\b', tp);
2309                                 break;
2310                         default:                        /* XXX */
2311 #define PANICSTR        "ttyrub: would panic c = %d, val = %d\n"
2312                                 (void)printf(PANICSTR, c, CCLASS(c));
2313 #ifdef notdef
2314                                 panic(PANICSTR, c, CCLASS(c));
2315 #endif
2316                         }
2317                 }
2318         } else if (ISSET(tp->t_lflag, ECHOPRT)) {
2319                 if (!ISSET(tp->t_state, TS_ERASE)) {
2320                         SET(tp->t_state, TS_ERASE);
2321                         (void)ttyoutput('\\', tp);
2322                 }
2323                 ttyecho(c, tp);
2324         } else {
2325                 ttyecho(tp->t_cc[VERASE], tp);
2326                 /*
2327                  * This code may be executed not only when an ERASE key
2328                  * is pressed, but also when ^U (KILL) or ^W (WERASE) are.
2329                  * So, I didn't think it was worthwhile to pass the extra
2330                  * information (which would need an extra parameter,
2331                  * changing every call) needed to distinguish the ERASE2
2332                  * case from the ERASE.
2333                  */
2334         }
2335         --tp->t_rocount;
2336 }
2337
2338 /*
2339  * Back over cnt characters, erasing them.
2340  */
2341 static void
2342 ttyrubo(struct tty *tp, int cnt)
2343 {
2344
2345         while (cnt-- > 0) {
2346                 (void)ttyoutput('\b', tp);
2347                 (void)ttyoutput(' ', tp);
2348                 (void)ttyoutput('\b', tp);
2349         }
2350 }
2351
2352 /*
2353  * ttyretype --
2354  *      Reprint the rawq line.  Note, it is assumed that c_cc has already
2355  *      been checked.
2356  */
2357 static void
2358 ttyretype(struct tty *tp)
2359 {
2360         char *cp;
2361         int s, c;
2362
2363         /* Echo the reprint character. */
2364         if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
2365                 ttyecho(tp->t_cc[VREPRINT], tp);
2366
2367         (void)ttyoutput('\n', tp);
2368
2369         /*
2370          * XXX
2371          * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
2372          * BIT OF FIRST CHAR.
2373          */
2374         s = spltty();
2375         for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
2376             cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
2377                 ttyecho(c, tp);
2378         for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
2379             cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
2380                 ttyecho(c, tp);
2381         CLR(tp->t_state, TS_ERASE);
2382         splx(s);
2383
2384         tp->t_rocount = tp->t_rawq.c_cc;
2385         tp->t_rocol = 0;
2386 }
2387
2388 /*
2389  * Echo a typed character to the terminal.
2390  */
2391 static void
2392 ttyecho(int c, struct tty *tp)
2393 {
2394
2395         if (!ISSET(tp->t_state, TS_CNTTB))
2396                 CLR(tp->t_lflag, FLUSHO);
2397         if ((!ISSET(tp->t_lflag, ECHO) &&
2398              (c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
2399             ISSET(tp->t_lflag, EXTPROC))
2400                 return;
2401         if (ISSET(tp->t_lflag, ECHOCTL) &&
2402             ((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
2403             ISSET(c, TTY_CHARMASK) == 0177)) {
2404                 (void)ttyoutput('^', tp);
2405                 CLR(c, ~TTY_CHARMASK);
2406                 if (c == 0177)
2407                         c = '?';
2408                 else
2409                         c += 'A' - 1;
2410         }
2411         (void)ttyoutput(c, tp);
2412 }
2413
2414 /*
2415  * Wake up any readers on a tty.
2416  */
2417 void
2418 ttwakeup(struct tty *tp)
2419 {
2420
2421         if (SEL_WAITING(&tp->t_rsel))
2422                 selwakeuppri(&tp->t_rsel, TTIPRI);
2423         if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2424                 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2425         wakeup(TSA_HUP_OR_INPUT(tp));
2426         KNOTE_UNLOCKED(&tp->t_rsel.si_note, 0);
2427 }
2428
2429 /*
2430  * Wake up any writers on a tty.
2431  */
2432 void
2433 ttwwakeup(struct tty *tp)
2434 {
2435
2436         if (SEL_WAITING(&tp->t_wsel) && tp->t_outq.c_cc <= tp->t_olowat)
2437                 selwakeuppri(&tp->t_wsel, TTOPRI);
2438         if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
2439                 pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
2440         if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
2441             TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
2442                 CLR(tp->t_state, TS_SO_OCOMPLETE);
2443                 wakeup(TSA_OCOMPLETE(tp));
2444         }
2445         if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
2446             tp->t_outq.c_cc <= tp->t_olowat) {
2447                 CLR(tp->t_state, TS_SO_OLOWAT);
2448                 wakeup(TSA_OLOWAT(tp));
2449         }
2450         KNOTE_UNLOCKED(&tp->t_wsel.si_note, 0);
2451 }
2452
2453 /*
2454  * Look up a code for a specified speed in a conversion table;
2455  * used by drivers to map software speed values to hardware parameters.
2456  */
2457 int
2458 ttspeedtab(int speed, struct speedtab *table)
2459 {
2460
2461         for ( ; table->sp_speed != -1; table++)
2462                 if (table->sp_speed == speed)
2463                         return (table->sp_code);
2464         return (-1);
2465 }
2466
2467 /*
2468  * Set input and output watermarks and buffer sizes.  For input, the
2469  * high watermark is about one second's worth of input above empty, the
2470  * low watermark is slightly below high water, and the buffer size is a
2471  * driver-dependent amount above high water.  For output, the watermarks
2472  * are near the ends of the buffer, with about 1 second's worth of input
2473  * between them.  All this only applies to the standard line discipline.
2474  */
2475 void
2476 ttsetwater(struct tty *tp)
2477 {
2478         int cps, ttmaxhiwat, x;
2479
2480         /* Input. */
2481         clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
2482         switch (tp->t_ispeedwat) {
2483         case (speed_t)-1:
2484                 cps = tp->t_ispeed / 10;
2485                 break;
2486         case 0:
2487                 /*
2488                  * This case is for old drivers that don't know about
2489                  * t_ispeedwat.  Arrange for them to get the old buffer
2490                  * sizes and watermarks.
2491                  */
2492                 cps = TTYHOG - 2 * 256;
2493                 tp->t_ififosize = 2 * 256;
2494                 break;
2495         default:
2496                 cps = tp->t_ispeedwat / 10;
2497                 break;
2498         }
2499         tp->t_ihiwat = cps;
2500         tp->t_ilowat = 7 * cps / 8;
2501         x = cps + tp->t_ififosize;
2502         clist_alloc_cblocks(&tp->t_rawq, x, x);
2503
2504         /* Output. */
2505         switch (tp->t_ospeedwat) {
2506         case (speed_t)-1:
2507                 cps = tp->t_ospeed / 10;
2508                 ttmaxhiwat = 2 * TTMAXHIWAT;
2509                 break;
2510         case 0:
2511                 cps = tp->t_ospeed / 10;
2512                 ttmaxhiwat = TTMAXHIWAT;
2513                 break;
2514         default:
2515                 cps = tp->t_ospeedwat / 10;
2516                 ttmaxhiwat = 8 * TTMAXHIWAT;
2517                 break;
2518         }
2519 #define CLAMP(x, h, l)  ((x) > h ? h : ((x) < l) ? l : (x))
2520         tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
2521         x += cps;
2522         x = CLAMP(x, ttmaxhiwat, TTMINHIWAT);   /* XXX clamps are too magic */
2523         tp->t_ohiwat = roundup(x, CBSIZE);      /* XXX for compat */
2524         x = imax(tp->t_ohiwat, TTMAXHIWAT);     /* XXX for compat/safety */
2525         x += OBUFSIZ + 100;
2526         clist_alloc_cblocks(&tp->t_outq, x, x);
2527 #undef  CLAMP
2528 }
2529
2530 /*
2531  * Report on state of foreground process group.
2532  */
2533 void
2534 ttyinfo(struct tty *tp)
2535 {
2536         struct timeval utime, stime;
2537         struct proc *p, *pick;
2538         struct thread *td;
2539         const char *stateprefix, *state;
2540         long rss;
2541         int load, pctcpu;
2542
2543         if (ttycheckoutq(tp,0) == 0)
2544                 return;
2545
2546         /* Print load average. */
2547         load = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
2548         ttyprintf(tp, "load: %d.%02d ", load / 100, load % 100);
2549
2550         /*
2551          * On return following a ttyprintf(), we set tp->t_rocount to 0 so
2552          * that pending input will be retyped on BS.
2553          */
2554         if (tp->t_session == NULL) {
2555                 ttyprintf(tp, "not a controlling terminal\n");
2556                 tp->t_rocount = 0;
2557                 return;
2558         }
2559         if (tp->t_pgrp == NULL) {
2560                 ttyprintf(tp, "no foreground process group\n");
2561                 tp->t_rocount = 0;
2562                 return;
2563         }
2564         sx_slock(&proctree_lock);
2565         if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL) {
2566                 sx_sunlock(&proctree_lock);
2567                 ttyprintf(tp, "empty foreground process group\n");
2568                 tp->t_rocount = 0;
2569                 return;
2570         }
2571
2572         /*
2573          * Pick the most interesting process and copy some of its
2574          * state for printing later.  sched_lock must be held for
2575          * most parts of this.  Holding it throughout is simplest
2576          * and prevents even unimportant inconsistencies in the
2577          * copy of the state, but may increase interrupt latency
2578          * too much.
2579          */
2580         mtx_lock_spin(&sched_lock);
2581         for (pick = NULL; p != NULL; p = LIST_NEXT(p, p_pglist))
2582                 if (proc_compare(pick, p))
2583                         pick = p;
2584
2585         td = FIRST_THREAD_IN_PROC(pick);        /* XXXKSE */
2586 #if 0
2587         KASSERT(td != NULL, ("ttyinfo: no thread"));
2588 #else
2589         if (td == NULL) {
2590                 mtx_unlock_spin(&sched_lock);
2591                 sx_sunlock(&proctree_lock);
2592                 ttyprintf(tp, "foreground process without thread\n");
2593                 tp->t_rocount = 0;
2594                 return;
2595         }
2596 #endif
2597         stateprefix = "";
2598         if (TD_IS_RUNNING(td))
2599                 state = "running";
2600         else if (TD_ON_RUNQ(td) || TD_CAN_RUN(td))
2601                 state = "runnable";
2602         else if (TD_IS_SLEEPING(td)) {
2603                 /* XXX: If we're sleeping, are we ever not in a queue? */
2604                 if (TD_ON_SLEEPQ(td))
2605                         state = td->td_wmesg;
2606                 else
2607                         state = "sleeping without queue";
2608         } else if (TD_ON_LOCK(td)) {
2609                 state = td->td_lockname;
2610                 stateprefix = "*";
2611         } else if (TD_IS_SUSPENDED(td))
2612                 state = "suspended";
2613         else if (TD_AWAITING_INTR(td))
2614                 state = "intrwait";
2615         else
2616                 state = "unknown";
2617         pctcpu = (sched_pctcpu(td) * 10000 + FSCALE / 2) >> FSHIFT;
2618         if (pick->p_state == PRS_NEW || pick->p_state == PRS_ZOMBIE)
2619                 rss = 0;
2620         else
2621                 rss = pgtok(vmspace_resident_count(pick->p_vmspace));
2622         mtx_unlock_spin(&sched_lock);
2623         PROC_LOCK(pick);
2624         calcru(pick, &utime, &stime);
2625         PROC_UNLOCK(pick);
2626
2627         /* Print command, pid, state, utime, stime, %cpu, and rss. */
2628         ttyprintf(tp,
2629             " cmd: %s %d [%s%s] %ld.%02ldu %ld.%02lds %d%% %ldk\n",
2630             pick->p_comm, pick->p_pid, stateprefix, state,
2631             (long)utime.tv_sec, utime.tv_usec / 10000,
2632             (long)stime.tv_sec, stime.tv_usec / 10000,
2633             pctcpu / 100, rss);
2634         tp->t_rocount = 0;
2635         sx_sunlock(&proctree_lock);
2636 }
2637
2638 /*
2639  * Returns 1 if p2 is "better" than p1
2640  *
2641  * The algorithm for picking the "interesting" process is thus:
2642  *
2643  *      1) Only foreground processes are eligible - implied.
2644  *      2) Runnable processes are favored over anything else.  The runner
2645  *         with the highest cpu utilization is picked (p_estcpu).  Ties are
2646  *         broken by picking the highest pid.
2647  *      3) The sleeper with the shortest sleep time is next.  With ties,
2648  *         we pick out just "short-term" sleepers (P_SINTR == 0).
2649  *      4) Further ties are broken by picking the highest pid.
2650  */
2651 #define ISRUN(p, val)                                           \
2652 do {                                                            \
2653         struct thread *td;                                      \
2654         val = 0;                                                \
2655         FOREACH_THREAD_IN_PROC(p, td) {                         \
2656                 if (TD_ON_RUNQ(td) ||                           \
2657                     TD_IS_RUNNING(td)) {                        \
2658                         val = 1;                                \
2659                         break;                                  \
2660                 }                                               \
2661         }                                                       \
2662 } while (0)
2663
2664 #define TESTAB(a, b)    ((a)<<1 | (b))
2665 #define ONLYA   2
2666 #define ONLYB   1
2667 #define BOTH    3
2668
2669 static int
2670 proc_compare(struct proc *p1, struct proc *p2)
2671 {
2672
2673         int esta, estb;
2674         struct ksegrp *kg;
2675         mtx_assert(&sched_lock, MA_OWNED);
2676         if (p1 == NULL)
2677                 return (1);
2678
2679         ISRUN(p1, esta);
2680         ISRUN(p2, estb);
2681
2682         /*
2683          * see if at least one of them is runnable
2684          */
2685         switch (TESTAB(esta, estb)) {
2686         case ONLYA:
2687                 return (0);
2688         case ONLYB:
2689                 return (1);
2690         case BOTH:
2691                 /*
2692                  * tie - favor one with highest recent cpu utilization
2693                  */
2694                 esta = estb = 0;
2695                 FOREACH_KSEGRP_IN_PROC(p1,kg) {
2696                         esta += kg->kg_estcpu;
2697                 }
2698                 FOREACH_KSEGRP_IN_PROC(p2,kg) {
2699                         estb += kg->kg_estcpu;
2700                 }
2701                 if (estb > esta)
2702                         return (1);
2703                 if (esta > estb)
2704                         return (0);
2705                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2706         }
2707         /*
2708          * weed out zombies
2709          */
2710         switch (TESTAB(p1->p_state == PRS_ZOMBIE, p2->p_state == PRS_ZOMBIE)) {
2711         case ONLYA:
2712                 return (1);
2713         case ONLYB:
2714                 return (0);
2715         case BOTH:
2716                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
2717         }
2718
2719 #if 0 /* XXXKSE */
2720         /*
2721          * pick the one with the smallest sleep time
2722          */
2723         if (p2->p_slptime > p1->p_slptime)
2724                 return (0);
2725         if (p1->p_slptime > p2->p_slptime)
2726                 return (1);
2727         /*
2728          * favor one sleeping in a non-interruptible sleep
2729          */
2730         if (p1->p_sflag & PS_SINTR && (p2->p_sflag & PS_SINTR) == 0)
2731                 return (1);
2732         if (p2->p_sflag & PS_SINTR && (p1->p_sflag & PS_SINTR) == 0)
2733                 return (0);
2734 #endif
2735         return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
2736 }
2737
2738 /*
2739  * Output char to tty; console putchar style.
2740  */
2741 int
2742 tputchar(int c, struct tty *tp)
2743 {
2744         int s;
2745
2746         s = spltty();
2747         if (!ISSET(tp->t_state, TS_CONNECTED)) {
2748                 splx(s);
2749                 return (-1);
2750         }
2751         if (c == '\n')
2752                 (void)ttyoutput('\r', tp);
2753         (void)ttyoutput(c, tp);
2754         ttstart(tp);
2755         splx(s);
2756         return (0);
2757 }
2758
2759 /*
2760  * Sleep on chan, returning ERESTART if tty changed while we napped and
2761  * returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep.  If
2762  * the tty is revoked, restarting a pending call will redo validation done
2763  * at the start of the call.
2764  */
2765 int
2766 ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo)
2767 {
2768         int error;
2769         int gen;
2770
2771         gen = tp->t_gen;
2772         error = tsleep(chan, pri, wmesg, timo);
2773         if (tp->t_state & TS_GONE)
2774                 return (ENXIO);
2775         if (error)
2776                 return (error);
2777         return (tp->t_gen == gen ? 0 : ERESTART);
2778 }
2779
2780 /*
2781  * Gain a reference to a TTY
2782  */
2783 int
2784 ttyref(struct tty *tp)
2785 {
2786         int i;
2787
2788         mtx_lock(&tp->t_mtx);
2789         KASSERT(tp->t_refcnt > 0,
2790             ("ttyref(): tty refcnt is %d (%s)",
2791             tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2792         i = ++tp->t_refcnt;
2793         mtx_unlock(&tp->t_mtx);
2794         return (i);
2795 }
2796
2797 /*
2798  * Drop a reference to a TTY.
2799  * When reference count drops to zero, we free it.
2800  */
2801 int
2802 ttyrel(struct tty *tp)
2803 {
2804         int i;
2805
2806         mtx_lock(&tty_list_mutex);
2807         mtx_lock(&tp->t_mtx);
2808         KASSERT(tp->t_refcnt > 0,
2809             ("ttyrel(): tty refcnt is %d (%s)",
2810             tp->t_refcnt, tp->t_dev != NULL ? devtoname(tp->t_dev) : "??"));
2811         i = --tp->t_refcnt;
2812         if (i != 0) {
2813                 mtx_unlock(&tp->t_mtx);
2814                 mtx_unlock(&tty_list_mutex);
2815                 return (i);
2816         }
2817         TAILQ_REMOVE(&tty_list, tp, t_list);
2818         mtx_unlock(&tp->t_mtx);
2819         mtx_unlock(&tty_list_mutex);
2820         knlist_destroy(&tp->t_rsel.si_note);
2821         knlist_destroy(&tp->t_wsel.si_note);
2822         mtx_destroy(&tp->t_mtx);
2823         free(tp, M_TTYS);
2824         return (i);
2825 }
2826
2827 /*
2828  * Allocate a tty struct.  Clists in the struct will be allocated by
2829  * tty_open().
2830  */
2831 struct tty *
2832 ttymalloc(struct tty *tp)
2833 {
2834         static int once;
2835
2836         if (!once) {
2837                 mtx_init(&tty_list_mutex, "ttylist", NULL, MTX_DEF);
2838                 once++;
2839         }
2840
2841         if (tp) {
2842                 /*
2843                  * XXX: Either this argument should go away, or we should
2844                  * XXX: require it and do a ttyrel(tp) here and allocate
2845                  * XXX: a new tty.  For now do nothing.
2846                  */
2847                 return(tp);
2848         }
2849         tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO);
2850         mtx_init(&tp->t_mtx, "tty", NULL, MTX_DEF);
2851
2852         /*
2853          * Set up the initial state
2854          */
2855         tp->t_refcnt = 1;
2856         tp->t_timeout = -1;
2857         tp->t_dtr_wait = 3 * hz;
2858
2859         ttyinitmode(tp, 0, 0);
2860         bcopy(ttydefchars, tp->t_init_in.c_cc, sizeof tp->t_init_in.c_cc);
2861
2862         /* Make callout the same as callin */
2863         tp->t_init_out = tp->t_init_in;
2864
2865         mtx_lock(&tty_list_mutex);
2866         TAILQ_INSERT_TAIL(&tty_list, tp, t_list);
2867         mtx_unlock(&tty_list_mutex);
2868         knlist_init(&tp->t_rsel.si_note, &tp->t_mtx);
2869         knlist_init(&tp->t_wsel.si_note, &tp->t_mtx);
2870         return (tp);
2871 }
2872
2873 struct tty *
2874 ttyalloc()
2875 {
2876
2877         return (ttymalloc(NULL));
2878 }
2879
2880 static void
2881 ttypurge(struct cdev *dev)
2882 {
2883
2884         if (dev->si_tty == NULL)
2885                 return;
2886         ttygone(dev->si_tty);
2887 }
2888
2889 /*
2890  * ttycreate()
2891  *
2892  * Create the device entries for this tty thereby opening it for business.
2893  *
2894  * The flags argument controls if "cua" units are created.
2895  *
2896  * The t_sc filed is copied to si_drv1 in the created cdevs.  This
2897  * is particularly important for ->t_cioctl() users.
2898  *
2899  * XXX: implement the init and lock devices by cloning.
2900  */
2901
2902 int
2903 ttycreate(struct tty *tp, struct cdevsw *csw, int unit, int flags, const char *fmt, ...)
2904 {
2905         char namebuf[SPECNAMELEN - 3];          /* XXX space for "tty" */
2906         va_list ap;
2907         struct cdev *cp;
2908         int i, minor, sminor, sunit;
2909
2910         mtx_assert(&Giant, MA_OWNED);
2911
2912         if (tty_unit == NULL)
2913                 tty_unit = new_unrhdr(0, 0xffff, NULL);
2914
2915         sunit = alloc_unr(tty_unit);
2916         tp->t_devunit = sunit;
2917
2918         if (csw == NULL) {
2919                 csw = &tty_cdevsw;
2920                 unit = sunit;
2921         }
2922         KASSERT(csw->d_purge == NULL || csw->d_purge == ttypurge,
2923             ("tty should not have d_purge"));
2924
2925         csw->d_purge = ttypurge;
2926
2927         minor = unit2minor(unit);
2928         sminor = unit2minor(sunit);
2929         va_start(ap, fmt);
2930         i = vsnrprintf(namebuf, sizeof namebuf, 32, fmt, ap);
2931         va_end(ap);
2932         KASSERT(i < sizeof namebuf, ("Too long tty name (%s)", namebuf));
2933
2934         cp = make_dev(csw, minor,
2935             UID_ROOT, GID_WHEEL, 0600, "tty%s", namebuf);
2936         tp->t_dev = cp;
2937         tp->t_mdev = cp;
2938         cp->si_tty = tp;
2939         cp->si_drv1 = tp->t_sc;
2940
2941         cp = make_dev(&ttys_cdevsw, sminor | MINOR_INIT,
2942             UID_ROOT, GID_WHEEL, 0600, "tty%s.init", namebuf);
2943         dev_depends(tp->t_dev, cp);
2944         cp->si_drv1 = tp->t_sc;
2945         cp->si_drv2 = &tp->t_init_in;
2946         cp->si_tty = tp;
2947
2948         cp = make_dev(&ttys_cdevsw, sminor | MINOR_LOCK,
2949             UID_ROOT, GID_WHEEL, 0600, "tty%s.lock", namebuf);
2950         dev_depends(tp->t_dev, cp);
2951         cp->si_drv1 = tp->t_sc;
2952         cp->si_drv2 = &tp->t_lock_in;
2953         cp->si_tty = tp;
2954
2955         if (flags & MINOR_CALLOUT) {
2956                 cp = make_dev(csw, minor | MINOR_CALLOUT,
2957                     UID_UUCP, GID_DIALER, 0660, "cua%s", namebuf);
2958                 dev_depends(tp->t_dev, cp);
2959                 cp->si_drv1 = tp->t_sc;
2960                 cp->si_tty = tp;
2961
2962                 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_INIT,
2963                     UID_UUCP, GID_DIALER, 0660, "cua%s.init", namebuf);
2964                 dev_depends(tp->t_dev, cp);
2965                 cp->si_drv1 = tp->t_sc;
2966                 cp->si_drv2 = &tp->t_init_out;
2967                 cp->si_tty = tp;
2968
2969                 cp = make_dev(&ttys_cdevsw, sminor | MINOR_CALLOUT | MINOR_LOCK,
2970                     UID_UUCP, GID_DIALER, 0660, "cua%s.lock", namebuf);
2971                 dev_depends(tp->t_dev, cp);
2972                 cp->si_drv1 = tp->t_sc;
2973                 cp->si_drv2 = &tp->t_lock_out;
2974                 cp->si_tty = tp;
2975         }
2976
2977         return (0);
2978 }
2979
2980 /*
2981  * This function is called when the hardware disappears.  We set a flag
2982  * and wake up stuff so all sleeping threads will notice.
2983  */
2984 void
2985 ttygone(struct tty *tp)
2986 {
2987
2988         tp->t_state |= TS_GONE;
2989         wakeup(&tp->t_dtr_wait);
2990         wakeup(TSA_CARR_ON(tp));
2991         wakeup(TSA_HUP_OR_INPUT(tp));
2992         wakeup(TSA_OCOMPLETE(tp));
2993         wakeup(TSA_OLOWAT(tp));
2994         if (tp->t_purge != NULL)
2995                 tp->t_purge(tp);
2996 }
2997
2998 /*
2999  * ttyfree()
3000  *
3001  * Called when the driver is ready to free the tty structure.
3002  *
3003  * XXX: This shall sleep until all threads have left the driver.
3004  */
3005
3006 void
3007 ttyfree(struct tty *tp)
3008 {
3009         u_int unit;
3010
3011         mtx_assert(&Giant, MA_OWNED);
3012         ttygone(tp);
3013         unit = tp->t_devunit;
3014         destroy_dev(tp->t_mdev);
3015         free_unr(tty_unit, unit);
3016 }
3017
3018 static int
3019 sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
3020 {
3021         struct tty *tp, *tp2;
3022         struct xtty xt;
3023         int error;
3024
3025         error = 0;
3026         mtx_lock(&tty_list_mutex);
3027         tp = TAILQ_FIRST(&tty_list);
3028         if (tp != NULL)
3029                 ttyref(tp);
3030         mtx_unlock(&tty_list_mutex);
3031         while (tp != NULL) {
3032                 bzero(&xt, sizeof xt);
3033                 xt.xt_size = sizeof xt;
3034 #define XT_COPY(field) xt.xt_##field = tp->t_##field
3035                 xt.xt_rawcc = tp->t_rawq.c_cc;
3036                 xt.xt_cancc = tp->t_canq.c_cc;
3037                 xt.xt_outcc = tp->t_outq.c_cc;
3038                 XT_COPY(line);
3039                 if (tp->t_dev != NULL)
3040                         xt.xt_dev = dev2udev(tp->t_dev);
3041                 XT_COPY(state);
3042                 XT_COPY(flags);
3043                 XT_COPY(timeout);
3044                 if (tp->t_pgrp != NULL)
3045                         xt.xt_pgid = tp->t_pgrp->pg_id;
3046                 if (tp->t_session != NULL)
3047                         xt.xt_sid = tp->t_session->s_sid;
3048                 XT_COPY(termios);
3049                 XT_COPY(winsize);
3050                 XT_COPY(column);
3051                 XT_COPY(rocount);
3052                 XT_COPY(rocol);
3053                 XT_COPY(ififosize);
3054                 XT_COPY(ihiwat);
3055                 XT_COPY(ilowat);
3056                 XT_COPY(ispeedwat);
3057                 XT_COPY(ohiwat);
3058                 XT_COPY(olowat);
3059                 XT_COPY(ospeedwat);
3060 #undef XT_COPY
3061                 error = SYSCTL_OUT(req, &xt, sizeof xt);
3062                 if (error != 0) {
3063                         ttyrel(tp);
3064                         return (error);
3065                 }
3066                 mtx_lock(&tty_list_mutex);
3067                 tp2 = TAILQ_NEXT(tp, t_list);
3068                 if (tp2 != NULL)
3069                         ttyref(tp2);
3070                 mtx_unlock(&tty_list_mutex);
3071                 ttyrel(tp);
3072                 tp = tp2;
3073         }
3074         return (0);
3075 }
3076
3077 SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
3078         0, 0, sysctl_kern_ttys, "S,xtty", "All ttys");
3079 SYSCTL_LONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD,
3080         &tk_nin, 0, "Total TTY in characters");
3081 SYSCTL_LONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD,
3082         &tk_nout, 0, "Total TTY out characters");
3083
3084 void
3085 nottystop(struct tty *tp, int rw)
3086 {
3087
3088         return;
3089 }
3090
3091 int
3092 ttyopen(struct cdev *dev, int flag, int mode, struct thread *td)
3093 {
3094         int             error;
3095         int             s;
3096         struct tty      *tp;
3097
3098         tp = dev->si_tty;
3099         s = spltty();
3100         /*
3101          * We jump to this label after all non-interrupted sleeps to pick
3102          * up any changes of the device state.
3103          */
3104 open_top:
3105         if (tp->t_state & TS_GONE)
3106                 return (ENXIO);
3107         error = ttydtrwaitsleep(tp);
3108         if (error)
3109                 goto out;
3110         if (tp->t_state & TS_ISOPEN) {
3111                 /*
3112                  * The device is open, so everything has been initialized.
3113                  * Handle conflicts.
3114                  */
3115                 if (ISCALLOUT(dev) && !tp->t_actout)
3116                         return (EBUSY);
3117                 if (tp->t_actout && !ISCALLOUT(dev)) {
3118                         if (flag & O_NONBLOCK)
3119                                 return (EBUSY);
3120                         error = tsleep(&tp->t_actout,
3121                                        TTIPRI | PCATCH, "ttybi", 0);
3122                         if (error != 0 || (tp->t_flags & TS_GONE))
3123                                 goto out;
3124                         goto open_top;
3125                 }
3126                 if (tp->t_state & TS_XCLUDE && suser(td))
3127                         return (EBUSY);
3128         } else {
3129                 /*
3130                  * The device isn't open, so there are no conflicts.
3131                  * Initialize it.  Initialization is done twice in many
3132                  * cases: to preempt sleeping callin opens if we are
3133                  * callout, and to complete a callin open after DCD rises.
3134                  */
3135                 tp->t_termios = ISCALLOUT(dev) ? tp->t_init_out : tp->t_init_in;
3136                 tp->t_cflag = tp->t_termios.c_cflag;
3137                 if (tp->t_modem != NULL)
3138                         tp->t_modem(tp, SER_DTR | SER_RTS, 0);
3139                 ++tp->t_wopeners;
3140                 error = tp->t_param(tp, &tp->t_termios);
3141                 --tp->t_wopeners;
3142                 if (error == 0 && tp->t_open != NULL)
3143                         error = tp->t_open(tp, dev);
3144                 if (error != 0)
3145                         goto out;
3146                 if (ISCALLOUT(dev) || (tp->t_modem != NULL &&
3147                     (tp->t_modem(tp, 0, 0) & SER_DCD)))
3148                         ttyld_modem(tp, 1);
3149         }
3150         /*
3151          * Wait for DCD if necessary.
3152          */
3153         if (!(tp->t_state & TS_CARR_ON) && !ISCALLOUT(dev)
3154             && !(tp->t_cflag & CLOCAL) && !(flag & O_NONBLOCK)) {
3155                 ++tp->t_wopeners;
3156                 error = tsleep(TSA_CARR_ON(tp), TTIPRI | PCATCH, "ttydcd", 0);
3157                 --tp->t_wopeners;
3158                 if (error != 0 || (tp->t_state & TS_GONE))
3159                         goto out;
3160                 goto open_top;
3161         }
3162         error = ttyld_open(tp, dev);
3163         ttyldoptim(tp);
3164         if (tp->t_state & TS_ISOPEN && ISCALLOUT(dev))
3165                 tp->t_actout = TRUE;
3166 out:
3167         splx(s);
3168         if (!(tp->t_state & TS_ISOPEN) && tp->t_wopeners == 0 &&
3169             tp->t_close != NULL)
3170                 tp->t_close(tp);
3171         return (error);
3172 }
3173
3174 int
3175 ttyclose(struct cdev *dev, int flag, int mode, struct thread *td)
3176 {
3177         struct tty *tp;
3178
3179         tp = dev->si_tty;
3180         ttyld_close(tp, flag);
3181         ttyldoptim(tp);
3182         if (tp->t_close != NULL)
3183                 tp->t_close(tp);
3184         tp->t_do_timestamp = 0;
3185         if (tp->t_pps != NULL)
3186                 tp->t_pps->ppsparam.mode = 0;
3187         tty_close(tp);
3188         return (0);
3189 }
3190
3191 int
3192 ttyread(struct cdev *dev, struct uio *uio, int flag)
3193 {
3194         struct tty *tp;
3195
3196         tp = tty_gettp(dev);
3197
3198         if (tp->t_state & TS_GONE)
3199                 return (ENODEV);
3200         return (ttyld_read(tp, uio, flag));
3201 }
3202
3203 int
3204 ttywrite(struct cdev *dev, struct uio *uio, int flag)
3205 {
3206         struct tty *tp;
3207
3208         tp = tty_gettp(dev);
3209
3210         if (tp->t_state & TS_GONE)
3211                 return (ENODEV);
3212         return (ttyld_write(tp, uio, flag));
3213 }
3214
3215 int
3216 ttyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
3217 {
3218         struct  tty *tp;
3219         int     error;
3220
3221         tp = dev->si_tty;
3222
3223         if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF) {
3224                 int cc;
3225                 struct termios *dt = (struct termios *)data;
3226                 struct termios *lt =
3227                     ISCALLOUT(dev) ?  &tp->t_lock_out : &tp->t_lock_in;
3228
3229                 dt->c_iflag = (tp->t_iflag & lt->c_iflag)
3230                     | (dt->c_iflag & ~lt->c_iflag);
3231                 dt->c_oflag = (tp->t_oflag & lt->c_oflag)
3232                     | (dt->c_oflag & ~lt->c_oflag);
3233                 dt->c_cflag = (tp->t_cflag & lt->c_cflag)
3234                     | (dt->c_cflag & ~lt->c_cflag);
3235                 dt->c_lflag = (tp->t_lflag & lt->c_lflag)
3236                     | (dt->c_lflag & ~lt->c_lflag);
3237                 for (cc = 0; cc < NCCS; ++cc)
3238                     if (lt->c_cc[cc] != 0)
3239                         dt->c_cc[cc] = tp->t_cc[cc];
3240                 if (lt->c_ispeed != 0)
3241                     dt->c_ispeed = tp->t_ispeed;
3242                 if (lt->c_ospeed != 0)
3243                     dt->c_ospeed = tp->t_ospeed;
3244         }
3245
3246         error = ttyld_ioctl(tp, cmd, data, flag, td);
3247         if (error == ENOIOCTL)
3248                 error = ttioctl(tp, cmd, data, flag);
3249         ttyldoptim(tp);
3250         if (error != ENOIOCTL)
3251                 return (error);
3252         return (ENOTTY);
3253 }
3254
3255 void
3256 ttyldoptim(struct tty *tp)
3257 {
3258         struct termios  *t;
3259
3260         t = &tp->t_termios;
3261         if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON))
3262             && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK))
3263             && (!(t->c_iflag & PARMRK)
3264                 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))
3265             && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN))
3266             && linesw[tp->t_line]->l_rint == ttyinput)
3267                 tp->t_state |= TS_CAN_BYPASS_L_RINT;
3268         else
3269                 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
3270 }
3271
3272 static void
3273 ttydtrwaitwakeup(void *arg)
3274 {
3275         struct tty *tp;
3276
3277         tp = arg;
3278         tp->t_state &= ~TS_DTR_WAIT;
3279         wakeup(&tp->t_dtr_wait);
3280 }
3281
3282
3283 void
3284 ttydtrwaitstart(struct tty *tp)
3285 {
3286
3287         if (tp->t_dtr_wait == 0)
3288                 return;
3289         if (tp->t_state & TS_DTR_WAIT)
3290                 return;
3291         timeout(ttydtrwaitwakeup, tp, tp->t_dtr_wait);
3292         tp->t_state |= TS_DTR_WAIT;
3293 }
3294
3295 int
3296 ttydtrwaitsleep(struct tty *tp)
3297 {
3298         int error;
3299
3300         error = 0;
3301         while (error == 0) {
3302                 if (tp->t_state & TS_GONE)
3303                         error = ENXIO;
3304                 else if (!(tp->t_state & TS_DTR_WAIT))
3305                         break;
3306                 else
3307                         error = tsleep(&tp->t_dtr_wait, TTIPRI | PCATCH,
3308                             "dtrwait", 0);
3309         }
3310         return (error);
3311 }
3312
3313 static int
3314 ttysopen(struct cdev *dev, int flag, int mode, struct thread *td)
3315 {
3316         struct tty *tp;
3317
3318         tp = dev->si_tty;
3319         KASSERT(tp != NULL,
3320             ("ttysopen(): no tty pointer on device (%s)", devtoname(dev)));
3321         if (tp->t_state & TS_GONE)
3322                 return (ENODEV);
3323         return (0);
3324 }
3325
3326 static int
3327 ttysclose(struct cdev *dev, int flag, int mode, struct thread *td)
3328 {
3329
3330         return (0);
3331 }
3332
3333 static int
3334 ttysrdwr(struct cdev *dev, struct uio *uio, int flag)
3335 {
3336
3337         return (ENODEV);
3338 }
3339
3340 static int
3341 ttysioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
3342 {
3343         struct tty      *tp;
3344         int             error;
3345         struct termios  *ct;
3346
3347         tp = dev->si_tty;
3348         KASSERT(tp != NULL,
3349             ("ttysopen(): no tty pointer on device (%s)", devtoname(dev)));
3350         if (tp->t_state & TS_GONE)
3351                 return (ENODEV);
3352         ct = dev->si_drv2;
3353         switch (cmd) {
3354         case TIOCSETA:
3355                 error = suser(td);
3356                 if (error != 0)
3357                         return (error);
3358                 *ct = *(struct termios *)data;
3359                 return (0);
3360         case TIOCGETA:
3361                 *(struct termios *)data = *ct;
3362                 return (0);
3363         case TIOCGETD:
3364                 *(int *)data = TTYDISC;
3365                 return (0);
3366         case TIOCGWINSZ:
3367                 bzero(data, sizeof(struct winsize));
3368                 return (0);
3369         default:
3370                 if (tp->t_cioctl != NULL)
3371                         return(tp->t_cioctl(dev, cmd, data, flag, td));
3372                 return (ENOTTY);
3373         }
3374 }
3375
3376 /*
3377  * Initialize a tty to sane modes.
3378  */
3379 void
3380 ttyinitmode(struct tty *tp, int echo, int speed)
3381 {
3382
3383         if (speed == 0)
3384                 speed = TTYDEF_SPEED;
3385         tp->t_init_in.c_iflag = TTYDEF_IFLAG;
3386         tp->t_init_in.c_oflag = TTYDEF_OFLAG;
3387         tp->t_init_in.c_cflag = TTYDEF_CFLAG;
3388         if (echo)
3389                 tp->t_init_in.c_lflag = TTYDEF_LFLAG_ECHO;
3390         else
3391                 tp->t_init_in.c_lflag = TTYDEF_LFLAG_NOECHO;
3392
3393         tp->t_init_in.c_ispeed = tp->t_init_in.c_ospeed = speed;
3394         termioschars(&tp->t_init_in);
3395         tp->t_init_out = tp->t_init_in;
3396         tp->t_termios = tp->t_init_in;
3397 }
3398
3399 /*
3400  * Use more "normal" termios paramters for consoles.
3401  */
3402 void
3403 ttyconsolemode(struct tty *tp, int speed)
3404 {
3405
3406         if (speed == 0)
3407                 speed = TTYDEF_SPEED;
3408         ttyinitmode(tp, 1, speed);
3409         tp->t_init_in.c_cflag |= CLOCAL;
3410         tp->t_lock_out.c_cflag = tp->t_lock_in.c_cflag = CLOCAL;
3411         tp->t_lock_out.c_ispeed = tp->t_lock_out.c_ospeed =
3412         tp->t_lock_in.c_ispeed = tp->t_lock_in.c_ospeed = speed;
3413         tp->t_init_out = tp->t_init_in;
3414         tp->t_termios = tp->t_init_in;
3415 }
3416
3417 /*
3418  * Record the relationship between the serial ports notion of modem control
3419  * signals and the one used in certain ioctls in a way the compiler can enforce
3420  * XXX: We should define TIOCM_* in terms of SER_ if we can limit the
3421  * XXX: consequences of the #include work that would take.
3422  */
3423 CTASSERT(SER_DTR == TIOCM_DTR / 2);
3424 CTASSERT(SER_RTS == TIOCM_RTS / 2);
3425 CTASSERT(SER_STX == TIOCM_ST / 2);
3426 CTASSERT(SER_SRX == TIOCM_SR / 2);
3427 CTASSERT(SER_CTS == TIOCM_CTS / 2);
3428 CTASSERT(SER_DCD == TIOCM_DCD / 2);
3429 CTASSERT(SER_RI == TIOCM_RI / 2);
3430 CTASSERT(SER_DSR == TIOCM_DSR / 2);
3431