sys/kern/tty.c

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