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