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