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