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