sys/kern/tty.c

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