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