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