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