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