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