root/kern/tty.c

DEFINITIONS

1. ttyopen
2. ttyclose
3. ttyinput
4. ttyoutput
5. ttioctl
6. ttpoll
7. ttkqfilter
8. filt_ttyrdetach
9. filt_ttyread
10. filt_ttywdetach
11. filt_ttywrite
12. ttnread
13. ttywait
14. ttywflush
15. ttyflush
16. ttychars
17. ttyblock
18. ttrstrt
19. ttstart
20. ttylclose
21. ttymodem
22. nullmodem
23. ttypend
24. ttvtimeout
25. ttread
26. ttyunblock
27. ttycheckoutq
28. ttwrite
29. ttyrub
30. ttyrubo
31. ttyretype
32. ttyecho
33. ttwakeup
34. ttspeedtab
35. ttsetwater
36. ttyinfo
37. proc_compare
38. tputchar
39. ttysleep
40. tty_init
41. ttymalloc
42. ttyfree
43. ttystats_init
44. sysctl_tty
45. ttytstamp

    1 /*      $OpenBSD: tty.c,v 1.72 2007/03/15 10:22:30 art Exp $    */
    2 /*      $NetBSD: tty.c,v 1.68.4.2 1996/06/06 16:04:52 thorpej Exp $     */
    4 /*-
    5  * Copyright (c) 1982, 1986, 1990, 1991, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  * (c) UNIX System Laboratories, Inc.
    8  * All or some portions of this file are derived from material licensed
    9  * to the University of California by American Telephone and Telegraph
   10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   11  * the permission of UNIX System Laboratories, Inc.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  *      @(#)tty.c       8.8 (Berkeley) 1/21/94
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/ioctl.h>
   43 #include <sys/proc.h>
   44 #define TTYDEFCHARS
   45 #include <sys/tty.h>
   46 #undef  TTYDEFCHARS
   47 #include <sys/file.h>
   48 #include <sys/conf.h>
   49 #include <sys/dkstat.h>
   50 #include <sys/uio.h>
   51 #include <sys/kernel.h>
   52 #include <sys/vnode.h>
   53 #include <sys/syslog.h>
   54 #include <sys/malloc.h>
   55 #include <sys/signalvar.h>
   56 #include <sys/resourcevar.h>
   57 #include <sys/sysctl.h>
   58 #include <sys/pool.h>
   59 #include <sys/poll.h>
   61 #include <sys/namei.h>
   63 #include <uvm/uvm_extern.h>
   64 #include <dev/rndvar.h>
   66 #include "pty.h"
   68 static int ttnread(struct tty *);
   69 static void ttyblock(struct tty *);
   70 void ttyunblock(struct tty *);
   71 static void ttyecho(int, struct tty *);
   72 static void ttyrubo(struct tty *, int);
   73 static int proc_compare(struct proc *, struct proc *);
   74 int     filt_ttyread(struct knote *kn, long hint);
   75 void    filt_ttyrdetach(struct knote *kn);
   76 int     filt_ttywrite(struct knote *kn, long hint);
   77 void    filt_ttywdetach(struct knote *kn);
   78 int     ttystats_init(void);
   80 /* Symbolic sleep message strings. */
   81 char ttclos[]   = "ttycls";
   82 char ttopen[]   = "ttyopn";
   83 char ttybg[]    = "ttybg";
   84 char ttyin[]    = "ttyin";
   85 char ttyout[]   = "ttyout";
   87 /*
   88  * Table with character classes and parity. The 8th bit indicates parity,
   89  * the 7th bit indicates the character is an alphameric or underscore (for
   90  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
   91  * are 0 then the character needs no special processing on output; classes
   92  * other than 0 might be translated or (not currently) require delays.
   93  */
   94 #define E       0x00    /* Even parity. */
   95 #define O       0x80    /* Odd parity. */
   96 #define PARITY(c)       (char_type[c] & O)
   98 #define ALPHA   0x40    /* Alpha or underscore. */
   99 #define ISALPHA(c)      (char_type[(c) & TTY_CHARMASK] & ALPHA)
  101 #define CCLASSMASK      0x3f
  102 #define CCLASS(c)       (char_type[c] & CCLASSMASK)
  104 #define BS      BACKSPACE
  105 #define CC      CONTROL
  106 #define CR      RETURN
  107 #define NA      ORDINARY | ALPHA
  108 #define NL      NEWLINE
  109 #define NO      ORDINARY
  110 #define TB      TAB
  111 #define VT      VTAB
u_char const char_type[] = {
E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
  130         /*
  131          * Meta chars; should be settable per character set;
  132          * for now, treat them all as normal characters.
  133          */
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  150 };
  151 #undef  BS
  152 #undef  CC
  153 #undef  CR
  154 #undef  NA
  155 #undef  NL
  156 #undef  NO
  157 #undef  TB
  158 #undef  VT
  160 #define islower(c)      ((c) >= 'a' && (c) <= 'z')
  161 #define isupper(c)      ((c) >= 'A' && (c) <= 'Z')
  163 #define tolower(c)      ((c) - 'A' + 'a')
  164 #define toupper(c)      ((c) - 'a' + 'A')
  166 struct ttylist_head ttylist;    /* TAILQ_HEAD */
  167 int tty_count;
int64_t tk_cancc, tk_nin, tk_nout, tk_rawcc;
  171 /*
  172  * Initial open of tty, or (re)entry to standard tty line discipline.
  173  */
  174 int
ttyopen(dev_t device, struct tty *tp)
  176 {
  177         int s;
s = spltty();
tp->t_dev = device;
  181         if (!ISSET(tp->t_state, TS_ISOPEN)) {
SET(tp->t_state, TS_ISOPEN);
bzero(&tp->t_winsize, sizeof(tp->t_winsize));
  184 #ifdef COMPAT_OLDTTY
tp->t_flags = 0;
  186 #endif
  187         }
CLR(tp->t_state, TS_WOPEN);
splx(s);
  190         return (0);
  191 }
  193 /*
  194  * Handle close() on a tty line: flush and set to initial state,
  195  * bumping generation number so that pending read/write calls
  196  * can detect recycling of the tty.
  197  */
  198 int
ttyclose(struct tty *tp)
  200 {
  201         extern struct tty *constty;     /* Temporary virtual console. */
  203         if (constty == tp)
constty = NULL;
ttyflush(tp, FREAD | FWRITE);
tp->t_gen++;
tp->t_pgrp = NULL;
  210         if (tp->t_session)
SESSRELE(tp->t_session);
tp->t_session = NULL;
tp->t_state = 0;
  214         return (0);
  215 }
  217 #define FLUSHQ(q) {                                                     \
  218         if ((q)->c_cc)                                                  \
ndflush(q, (q)->c_cc);                                  \
  220 }
  222 /* Is 'c' a line delimiter ("break" character)? */
  223 #define TTBREAKC(c, lflag)                                              \
  224         ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] ||         \
  225         ((c) == cc[VEOL2] && (lflag & IEXTEN))) && (c) != _POSIX_VDISABLE))
  228 /*
  229  * Process input of a single character received on a tty.
  230  */
  231 int
ttyinput(int c, struct tty *tp)
  233 {
  234         int iflag, lflag;
u_char *cc;
  236         int i, error;
  237         int s;
add_tty_randomness(tp->t_dev << 8 | c);
  240         /*
  241          * If receiver is not enabled, drop it.
  242          */
  243         if (!ISSET(tp->t_cflag, CREAD))
  244                 return (0);
  246         /*
  247          * If input is pending take it first.
  248          */
lflag = tp->t_lflag;
s = spltty();
  251         if (ISSET(lflag, PENDIN))
ttypend(tp);
splx(s);
  254         /*
  255          * Gather stats.
  256          */
  257         if (ISSET(lflag, ICANON)) {
  258                 ++tk_cancc;
  259                 ++tp->t_cancc;
  260         } else {
  261                 ++tk_rawcc;
  262                 ++tp->t_rawcc;
  263         }
  264         ++tk_nin;
  266         /* Handle exceptional conditions (break, parity, framing). */
cc = tp->t_cc;
iflag = tp->t_iflag;
  269         if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
CLR(c, TTY_ERRORMASK);
  271                 if (ISSET(error, TTY_FE) && !c) {       /* Break. */
  272                         if (ISSET(iflag, IGNBRK))
  273                                 return (0);
ttyflush(tp, FREAD | FWRITE);
  275                         if (ISSET(iflag, BRKINT)) {
pgsignal(tp->t_pgrp, SIGINT, 1);
  277                             goto endcase;
  278                         }
  279                         else if (ISSET(iflag, PARMRK))
  280                                 goto parmrk;
  281                 } else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
ISSET(error, TTY_FE)) {
  283                         if (ISSET(iflag, IGNPAR))
  284                                 goto endcase;
  285                         else if (ISSET(iflag, PARMRK)) {
parmrk:                         (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
  287                                 if (ISSET(iflag, ISTRIP) || c != 0377)
  288                                         (void)putc(0 | TTY_QUOTE, &tp->t_rawq);
  289                                 (void)putc(c | TTY_QUOTE, &tp->t_rawq);
  290                                 goto endcase;
  291                         } else
c = 0;
  293                 }
  294         }
  295         if (c == 0377 && !ISSET(iflag, ISTRIP) && ISSET(iflag, PARMRK))
  296                 goto parmrk;
  298         /*
  299          * In tandem mode, check high water mark.
  300          */
  301         if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
ttyblock(tp);
  303         if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
CLR(c, 0x80);
  305         if (!ISSET(lflag, EXTPROC)) {
  306                 /*
  307                  * Check for literal nexting very first
  308                  */
  309                 if (ISSET(tp->t_state, TS_LNCH)) {
SET(c, TTY_QUOTE);
CLR(tp->t_state, TS_LNCH);
  312                 }
  313                 /*
  314                  * Scan for special characters.  This code
  315                  * is really just a big case statement with
  316                  * non-constant cases.  The bottom of the
  317                  * case statement is labeled ``endcase'', so goto
  318                  * it after a case match, or similar.
  319                  */
  321                 /*
  322                  * Control chars which aren't controlled
  323                  * by ICANON, ISIG, or IXON.
  324                  */
  325                 if (ISSET(lflag, IEXTEN)) {
  326                         if (CCEQ(cc[VLNEXT], c)) {
  327                                 if (ISSET(lflag, ECHO)) {
  328                                         if (ISSET(lflag, ECHOE)) {
  329                                                 (void)ttyoutput('^', tp);
  330                                                 (void)ttyoutput('\b', tp);
  331                                         } else
ttyecho(c, tp);
  333                                 }
SET(tp->t_state, TS_LNCH);
  335                                 goto endcase;
  336                         }
  337                         if (CCEQ(cc[VDISCARD], c)) {
  338                                 if (ISSET(lflag, FLUSHO))
CLR(tp->t_lflag, FLUSHO);
  340                                 else {
ttyflush(tp, FWRITE);
ttyecho(c, tp);
  343                                         if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
ttyretype(tp);
SET(tp->t_lflag, FLUSHO);
  346                                 }
  347                                 goto startoutput;
  348                         }
  349                 }
  350                 /*
  351                  * Signals.
  352                  */
  353                 if (ISSET(lflag, ISIG)) {
  354                         if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
  355                                 if (!ISSET(lflag, NOFLSH))
ttyflush(tp, FREAD | FWRITE);
ttyecho(c, tp);
pgsignal(tp->t_pgrp,
CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
  360                                 goto endcase;
  361                         }
  362                         if (CCEQ(cc[VSUSP], c)) {
  363                                 if (!ISSET(lflag, NOFLSH))
ttyflush(tp, FREAD);
ttyecho(c, tp);
pgsignal(tp->t_pgrp, SIGTSTP, 1);
  367                                 goto endcase;
  368                         }
  369                 }
  370                 /*
  371                  * Handle start/stop characters.
  372                  */
  373                 if (ISSET(iflag, IXON)) {
  374                         if (CCEQ(cc[VSTOP], c)) {
  375                                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
SET(tp->t_state, TS_TTSTOP);
  377                                         (*cdevsw[major(tp->t_dev)].d_stop)(tp,
  378                                            0);
  379                                         return (0);
  380                                 }
  381                                 if (!CCEQ(cc[VSTART], c))
  382                                         return (0);
  383                                 /*
  384                                  * if VSTART == VSTOP then toggle
  385                                  */
  386                                 goto endcase;
  387                         }
  388                         if (CCEQ(cc[VSTART], c))
  389                                 goto restartoutput;
  390                 }
  391                 /*
  392                  * IGNCR, ICRNL, & INLCR
  393                  */
  394                 if (c == '\r') {
  395                         if (ISSET(iflag, IGNCR))
  396                                 goto endcase;
  397                         else if (ISSET(iflag, ICRNL))
c = '\n';
  399                 } else if (c == '\n' && ISSET(iflag, INLCR))
c = '\r';
  401         }
  402         if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
  403                 /*
  404                  * From here on down canonical mode character
  405                  * processing takes place.
  406                  */
  407                 /*
  408                  * upper case or specials with IUCLC and XCASE
  409                  */
  410                 if (ISSET(lflag, XCASE) && ISSET(iflag, IUCLC)) {
  411                         if (ISSET(tp->t_state, TS_BKSL)) {
CLR(tp->t_state, TS_BKSL);
  413                                 switch (c) {
  414                                 case '\'':
c = '`';
  416                                         break;
  417                                 case '!':
c = '|';
  419                                         break;
  420                                 case '^':
c = '~';
  422                                         break;
  423                                 case '(':
c = '{';
  425                                         break;
  426                                 case ')':
c = '}';
  428                                         break;
  429                                 }
  430                         }
  431                         else if (c == '\\') {
SET(tp->t_state, TS_BKSL);
  433                                 goto endcase;
  434                         }
  435                         else if (isupper(c))
c = tolower(c);
  437                 }
  438                 else if (ISSET(iflag, IUCLC) && isupper(c))
c = tolower(c);
  440                 /*
  441                  * erase (^H / ^?)
  442                  */
  443                 if (CCEQ(cc[VERASE], c)) {
  444                         if (tp->t_rawq.c_cc)
ttyrub(unputc(&tp->t_rawq), tp);
  446                         goto endcase;
  447                 }
  448                 /*
  449                  * kill (^U)
  450                  */
  451                 if (CCEQ(cc[VKILL], c)) {
  452                         if (ISSET(lflag, ECHOKE) &&
tp->t_rawq.c_cc == tp->t_rocount &&
  454                             !ISSET(lflag, ECHOPRT))
  455                                 while (tp->t_rawq.c_cc)
ttyrub(unputc(&tp->t_rawq), tp);
  457                         else {
ttyecho(c, tp);
  459                                 if (ISSET(lflag, ECHOK) ||
ISSET(lflag, ECHOKE))
ttyecho('\n', tp);
FLUSHQ(&tp->t_rawq);
tp->t_rocount = 0;
  464                         }
CLR(tp->t_state, TS_LOCAL);
  466                         goto endcase;
  467                 }
  468                 /*
  469                  * word erase (^W)
  470                  */
  471                 if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
  472                         int alt = ISSET(lflag, ALTWERASE);
  473                         int ctype;
  475                         /*
  476                          * erase whitespace
  477                          */
  478                         while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
ttyrub(c, tp);
  480                         if (c == -1)
  481                                 goto endcase;
  482                         /*
  483                          * erase last char of word and remember the
  484                          * next chars type (for ALTWERASE)
  485                          */
ttyrub(c, tp);
c = unputc(&tp->t_rawq);
  488                         if (c == -1)
  489                                 goto endcase;
  490                         if (c == ' ' || c == '\t') {
  491                                 (void)putc(c, &tp->t_rawq);
  492                                 goto endcase;
  493                         }
ctype = ISALPHA(c);
  495                         /*
  496                          * erase rest of word
  497                          */
  498                         do {
ttyrub(c, tp);
c = unputc(&tp->t_rawq);
  501                                 if (c == -1)
  502                                         goto endcase;
  503                         } while (c != ' ' && c != '\t' &&
  504                             (alt == 0 || ISALPHA(c) == ctype));
  505                         (void)putc(c, &tp->t_rawq);
  506                         goto endcase;
  507                 }
  508                 /*
  509                  * reprint line (^R)
  510                  */
  511                 if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
ttyretype(tp);
  513                         goto endcase;
  514                 }
  515                 /*
  516                  * ^T - kernel info and generate SIGINFO
  517                  */
  518                 if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
  519                         if (ISSET(lflag, ISIG))
pgsignal(tp->t_pgrp, SIGINFO, 1);
  521                         if (!ISSET(lflag, NOKERNINFO))
ttyinfo(tp);
  523                         goto endcase;
  524                 }
  525         }
  526         /*
  527          * Check for input buffer overflow
  528          */
  529         if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
  530                 if (ISSET(iflag, IMAXBEL)) {
  531                         if (tp->t_outq.c_cc < tp->t_hiwat)
  532                                 (void)ttyoutput(CTRL('g'), tp);
  533                 } else
ttyflush(tp, FREAD | FWRITE);
  535                 goto endcase;
  536         }
  537         /*
  538          * Put data char in q for user and
  539          * wakeup on seeing a line delimiter.
  540          */
  541         if (putc(c, &tp->t_rawq) >= 0) {
  542                 if (!ISSET(lflag, ICANON)) {
ttwakeup(tp);
ttyecho(c, tp);
  545                         goto endcase;
  546                 }
  547                 if (TTBREAKC(c, lflag)) {
tp->t_rocount = 0;
catq(&tp->t_rawq, &tp->t_canq);
ttwakeup(tp);
  551                 } else if (tp->t_rocount++ == 0)
tp->t_rocol = tp->t_column;
  553                 if (ISSET(tp->t_state, TS_ERASE)) {
  554                         /*
  555                          * end of prterase \.../
  556                          */
CLR(tp->t_state, TS_ERASE);
  558                         (void)ttyoutput('/', tp);
  559                 }
i = tp->t_column;
ttyecho(c, tp);
  562                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
  563                         /*
  564                          * Place the cursor over the '^' of the ^D.
  565                          */
i = min(2, tp->t_column - i);
  567                         while (i > 0) {
  568                                 (void)ttyoutput('\b', tp);
i--;
  570                         }
  571                 }
  572         }
endcase:
  574         /*
  575          * IXANY means allow any character to restart output.
  576          */
  577         if (ISSET(tp->t_state, TS_TTSTOP) &&
  578             !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
  579                 return (0);
restartoutput:
CLR(tp->t_lflag, FLUSHO);
CLR(tp->t_state, TS_TTSTOP);
startoutput:
  584         return (ttstart(tp));
  585 }
  587 /*
  588  * Output a single character on a tty, doing output processing
  589  * as needed (expanding tabs, newline processing, etc.).
  590  * Returns < 0 if succeeds, otherwise returns char to resend.
  591  * Must be recursive.
  592  */
  593 int
ttyoutput(int c, struct tty *tp)
  595 {
  596         long oflag;
  597         int col, notout, s, c2;
oflag = tp->t_oflag;
  600         if (!ISSET(oflag, OPOST)) {
tk_nout++;
tp->t_outcc++;
  603                 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
  604                         return (c);
  605                 return (-1);
  606         }
  607         /*
  608          * Do tab expansion if OXTABS is set.  Special case if we external
  609          * processing, we don't do the tab expansion because we'll probably
  610          * get it wrong.  If tab expansion needs to be done, let it happen
  611          * externally.
  612          */
CLR(c, ~TTY_CHARMASK);
  614         if (c == '\t' &&
ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
c = 8 - (tp->t_column & 7);
  617                 if (ISSET(tp->t_lflag, FLUSHO)) {
notout = 0;
  619                 } else {
s = spltty();           /* Don't interrupt tabs. */
notout = b_to_q("        ", c, &tp->t_outq);
c -= notout;
tk_nout += c;
tp->t_outcc += c;
splx(s);
  626                 }
tp->t_column += c;
  628                 return (notout ? '\t' : -1);
  629         }
  630         if (c == CEOT && ISSET(oflag, ONOEOT))
  631                 return (-1);
  633         /*
  634          * Newline translation: if ONLCR is set,
  635          * translate newline into "\r\n".  If OCRNL
  636          * is set, translate '\r' into '\n'.
  637          */
  638         if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
tk_nout++;
tp->t_outcc++;
  641                 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
  642                         return (c);
tp->t_column = 0;
  644         }
  645         else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
c = '\n';
  648         if (ISSET(tp->t_oflag, OLCUC) && islower(c))
c = toupper(c);
  650         else if (ISSET(tp->t_oflag, OLCUC) && ISSET(tp->t_lflag, XCASE)) {
c2 = c;
  652                 switch (c) {
  653                 case '`':
c2 = '\'';
  655                         break;
  656                 case '|':
c2 = '!';
  658                         break;
  659                 case '~':
c2 = '^';
  661                         break;
  662                 case '{':
c2 = '(';
  664                         break;
  665                 case '}':
c2 = ')';
  667                         break;
  668                 }
  669                 if (c == '\\' || isupper(c) || c != c2) {
tk_nout++;
tp->t_outcc++;
  672                         if (putc('\\', &tp->t_outq))
  673                                 return (c);
c = c2;
  675                 }
  676         }
  677         if (ISSET(tp->t_oflag, ONOCR) && c == '\r' && tp->t_column == 0)
  678                 return (-1);
tk_nout++;
tp->t_outcc++;
  682         if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
  683                 return (c);
col = tp->t_column;
  686         switch (CCLASS(c)) {
  687         case BACKSPACE:
  688                 if (col > 0)
  689                         --col;
  690                 break;
  691         case CONTROL:
  692                 break;
  693         case NEWLINE:
  694                 if (ISSET(tp->t_oflag, ONLRET) || ISSET(tp->t_oflag, OCRNL))
col = 0;
  696                 break;
  697         case RETURN:
col = 0;
  699                 break;
  700         case ORDINARY:
  701                 ++col;
  702                 break;
  703         case TAB:
col = (col + 8) & ~7;
  705                 break;
  706         }
tp->t_column = col;
  708         return (-1);
  709 }
  711 /*
  712  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
  713  * has been called to do discipline-specific functions and/or reject any
  714  * of these ioctl commands.
  715  */
  716 /* ARGSUSED */
  717 int
ttioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p)
  719 {
  720         extern struct tty *constty;     /* Temporary virtual console. */
  721         extern int nlinesw;
  722         int s, error;
  724         /* If the ioctl involves modification, hang if in the background. */
  725         switch (cmd) {
  726         case  TIOCFLUSH:
  727         case  TIOCDRAIN:
  728         case  TIOCSBRK:
  729         case  TIOCCBRK:
  730         case  TIOCSETA:
  731         case  TIOCSETD:
  732         case  TIOCSETAF:
  733         case  TIOCSETAW:
  734 #ifdef notdef
  735         case  TIOCSPGRP:
  736 #endif
  737         case  TIOCSTAT:
  738         case  TIOCSTI:
  739         case  TIOCSWINSZ:
  740 #ifdef COMPAT_OLDTTY
  741         case  TIOCLBIC:
  742         case  TIOCLBIS:
  743         case  TIOCLSET:
  744         case  TIOCSETC:
  745         case OTIOCSETD:
  746         case  TIOCSETN:
  747         case  TIOCSETP:
  748         case  TIOCSLTC:
  749 #endif
  750                 while (isbackground(p, tp) &&
  751                     (p->p_flag & P_PPWAIT) == 0 &&
  752                     (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
  753                     (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
  754                         if (p->p_pgrp->pg_jobc == 0)
  755                                 return (EIO);
pgsignal(p->p_pgrp, SIGTTOU, 1);
error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
ttybg, 0);
  759                         if (error)
  760                                 return (error);
  761                 }
  762                 break;
  763         }
  765         switch (cmd) {                  /* Process the ioctl. */
  766         case FIOASYNC:                  /* set/clear async i/o */
s = spltty();
  768                 if (*(int *)data)
SET(tp->t_state, TS_ASYNC);
  770                 else
CLR(tp->t_state, TS_ASYNC);
splx(s);
  773                 break;
  774         case FIONBIO:                   /* set/clear non-blocking i/o */
  775                 break;                  /* XXX: delete. */
  776         case FIONREAD:                  /* get # bytes to read */
s = spltty();
  778                 *(int *)data = ttnread(tp);
splx(s);
  780                 break;
  781         case TIOCEXCL:                  /* set exclusive use of tty */
s = spltty();
SET(tp->t_state, TS_XCLUDE);
splx(s);
  785                 break;
  786         case TIOCFLUSH: {               /* flush buffers */
  787                 int flags = *(int *)data;
  789                 if (flags == 0)
flags = FREAD | FWRITE;
  791                 else
flags &= FREAD | FWRITE;
ttyflush(tp, flags);
  794                 break;
  795         }
  796         case TIOCCONS: {                /* become virtual console */
  797                 if (*(int *)data) {
  798                         struct nameidata nid;
  800                         if (constty != NULL && constty != tp &&
ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
  802                             (TS_CARR_ON | TS_ISOPEN))
  803                                 return (EBUSY);
  805                         /* ensure user can open the real console */
NDINIT(&nid, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/console", p);
error = namei(&nid);
  808                         if (error)
  809                                 return (error);
vn_lock(nid.ni_vp, LK_EXCLUSIVE | LK_RETRY, p);
error = VOP_ACCESS(nid.ni_vp, VREAD, p->p_ucred, p);
VOP_UNLOCK(nid.ni_vp, 0, p);
vrele(nid.ni_vp);
  814                         if (error)
  815                                 return (error);
constty = tp;
  818                 } else if (tp == constty)
constty = NULL;
  820                 break;
  821         }
  822         case TIOCDRAIN:                 /* wait till output drained */
  823                 if ((error = ttywait(tp)) != 0)
  824                         return (error);
  825                 break;
  826         case TIOCGETA: {                /* get termios struct */
  827                 struct termios *t = (struct termios *)data;
bcopy(&tp->t_termios, t, sizeof(struct termios));
  830                 break;
  831         }
  832         case TIOCGETD:                  /* get line discipline */
  833                 *(int *)data = tp->t_line;
  834                 break;
  835         case TIOCGWINSZ:                /* get window size */
  836                 *(struct winsize *)data = tp->t_winsize;
  837                 break;
  838         case TIOCGTSTAMP:
s = spltty();
  840                 *(struct timeval *)data = tp->t_tv;
splx(s);
  842                 break;
  843         case TIOCGPGRP:                 /* get pgrp of tty */
  844                 if (!isctty(p, tp) && suser(p, 0))
  845                         return (ENOTTY);
  846                 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
  847                 break;
  848 #ifdef TIOCHPCL
  849         case TIOCHPCL:                  /* hang up on last close */
s = spltty();
SET(tp->t_cflag, HUPCL);
splx(s);
  853                 break;
  854 #endif
  855         case TIOCNXCL:                  /* reset exclusive use of tty */
s = spltty();
CLR(tp->t_state, TS_XCLUDE);
splx(s);
  859                 break;
  860         case TIOCOUTQ:                  /* output queue size */
  861                 *(int *)data = tp->t_outq.c_cc;
  862                 break;
  863         case TIOCSETA:                  /* set termios struct */
  864         case TIOCSETAW:                 /* drain output, set */
  865         case TIOCSETAF: {               /* drn out, fls in, set */
  866                 struct termios *t = (struct termios *)data;
s = spltty();
  869                 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
  870                         if ((error = ttywait(tp)) != 0) {
splx(s);
  872                                 return (error);
  873                         }
  874                         if (cmd == TIOCSETAF)
ttyflush(tp, FREAD);
  876                 }
  877                 if (!ISSET(t->c_cflag, CIGNORE)) {
  878                         /*
  879                          * Set device hardware.
  880                          */
  881                         if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
splx(s);
  883                                 return (error);
  884                         } else {
  885                                 if (!ISSET(tp->t_state, TS_CARR_ON) &&
ISSET(tp->t_cflag, CLOCAL) &&
  887                                     !ISSET(t->c_cflag, CLOCAL)) {
CLR(tp->t_state, TS_ISOPEN);
SET(tp->t_state, TS_WOPEN);
ttwakeup(tp);
  891                                 }
tp->t_cflag = t->c_cflag;
tp->t_ispeed = t->c_ispeed;
tp->t_ospeed = t->c_ospeed;
  895                                 if (t->c_ospeed == 0 && tp->t_session &&
tp->t_session->s_leader)
psignal(tp->t_session->s_leader,
SIGHUP);
  899                         }
ttsetwater(tp);
  901                 }
  902                 if (cmd != TIOCSETAF) {
  903                         if (ISSET(t->c_lflag, ICANON) !=
ISSET(tp->t_lflag, ICANON)) {
  905                                 if (ISSET(t->c_lflag, ICANON)) {
SET(tp->t_lflag, PENDIN);
ttwakeup(tp);
  908                                 } else {
  909                                         struct clist tq;
catq(&tp->t_rawq, &tp->t_canq);
tq = tp->t_rawq;
tp->t_rawq = tp->t_canq;
tp->t_canq = tq;
CLR(tp->t_lflag, PENDIN);
  916                                 }
  917                         }
  918                 }
tp->t_iflag = t->c_iflag;
tp->t_oflag = t->c_oflag;
  921                 /*
  922                  * Make the EXTPROC bit read only.
  923                  */
  924                 if (ISSET(tp->t_lflag, EXTPROC))
SET(t->c_lflag, EXTPROC);
  926                 else
CLR(t->c_lflag, EXTPROC);
tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
splx(s);
  931                 break;
  932         }
  933         case TIOCSETD: {                /* set line discipline */
  934                 int t = *(int *)data;
dev_t device = tp->t_dev;
  937                 if ((u_int)t >= nlinesw)
  938                         return (ENXIO);
  939                 if (t != tp->t_line) {
s = spltty();
  941                         (*linesw[tp->t_line].l_close)(tp, flag);
error = (*linesw[t].l_open)(device, tp);
  943                         if (error) {
  944                                 (void)(*linesw[tp->t_line].l_open)(device, tp);
splx(s);
  946                                 return (error);
  947                         }
tp->t_line = t;
splx(s);
  950                 }
  951                 break;
  952         }
  953         case TIOCSTART:                 /* start output, like ^Q */
s = spltty();
  955                 if (ISSET(tp->t_state, TS_TTSTOP) ||
ISSET(tp->t_lflag, FLUSHO)) {
CLR(tp->t_lflag, FLUSHO);
CLR(tp->t_state, TS_TTSTOP);
ttstart(tp);
  960                 }
splx(s);
  962                 break;
  963         case TIOCSTI:                   /* simulate terminal input */
  964                 if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
  965                         return (EPERM);
  966                 if (p->p_ucred->cr_uid && !isctty(p, tp))
  967                         return (EACCES);
  968                 (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
  969                 break;
  970         case TIOCSTOP:                  /* stop output, like ^S */
s = spltty();
  972                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
SET(tp->t_state, TS_TTSTOP);
  974                         (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
  975                 }
splx(s);
  977                 break;
  978         case TIOCSCTTY:                 /* become controlling tty */
  979                 /* Session ctty vnode pointer set in vnode layer. */
  980                 if (!SESS_LEADER(p) ||
  981                     ((p->p_session->s_ttyvp || tp->t_session) &&
  982                      (tp->t_session != p->p_session)))
  983                         return (EPERM);
  984                 if (tp->t_session)
SESSRELE(tp->t_session);
SESSHOLD(p->p_session);
tp->t_session = p->p_session;
tp->t_pgrp = p->p_pgrp;
p->p_session->s_ttyp = tp;
atomic_setbits_int(&p->p_flag, P_CONTROLT);
  991                 break;
  992         case TIOCSPGRP: {               /* set pgrp of tty */
  993                 struct pgrp *pgrp = pgfind(*(int *)data);
  995                 if (!isctty(p, tp))
  996                         return (ENOTTY);
  997                 else if (pgrp == NULL)
  998                         return (EINVAL);
  999                 else if (pgrp->pg_session != p->p_session)
 1000                         return (EPERM);
tp->t_pgrp = pgrp;
 1002                 break;
 1003         }
 1004         case TIOCSTAT:                  /* get load avg stats */
ttyinfo(tp);
 1006                 break;
 1007         case TIOCSWINSZ:                /* set window size */
 1008                 if (bcmp((caddr_t)&tp->t_winsize, data,
 1009                     sizeof (struct winsize))) {
tp->t_winsize = *(struct winsize *)data;
pgsignal(tp->t_pgrp, SIGWINCH, 1);
 1012                 }
 1013                 break;
 1014         case TIOCSTSTAMP: {
 1015                 struct tstamps *ts = (struct tstamps *)data;
s = spltty();
CLR(tp->t_flags, TS_TSTAMPDCDSET);
CLR(tp->t_flags, TS_TSTAMPCTSSET);
CLR(tp->t_flags, TS_TSTAMPDCDCLR);
CLR(tp->t_flags, TS_TSTAMPCTSCLR);
 1022                 if (ISSET(ts->ts_set, TIOCM_CAR))
SET(tp->t_flags, TS_TSTAMPDCDSET);
 1024                 if (ISSET(ts->ts_set, TIOCM_CTS))
SET(tp->t_flags, TS_TSTAMPCTSSET);
 1026                 if (ISSET(ts->ts_clr, TIOCM_CAR))
SET(tp->t_flags, TS_TSTAMPDCDCLR);
 1028                 if (ISSET(ts->ts_clr, TIOCM_CTS))
SET(tp->t_flags, TS_TSTAMPCTSCLR);
splx(s);
 1031                 break;
 1032         }
 1033         default:
 1034 #ifdef COMPAT_OLDTTY
 1035                 return (ttcompat(tp, cmd, data, flag, p));
 1036 #else
 1037                 return (-1);
 1038 #endif
 1039         }
 1040         return (0);
 1041 }
 1043 int
ttpoll(dev_t device, int events, struct proc *p)
 1045 {
 1046         struct tty *tp;
 1047         int revents, s;
tp = (*cdevsw[major(device)].d_tty)(device);
revents = 0;
s = spltty();
 1053         if (events & (POLLIN | POLLRDNORM)) {
 1054                 if (ttnread(tp) > 0 || (!ISSET(tp->t_cflag, CLOCAL) &&
 1055                     !ISSET(tp->t_state, TS_CARR_ON)))
revents |= events & (POLLIN | POLLRDNORM);
 1057         }
 1058         if (events & (POLLOUT | POLLWRNORM)) {
 1059                 if (tp->t_outq.c_cc <= tp->t_lowat)
revents |= events & (POLLOUT | POLLWRNORM);
 1061         }
 1062         if (revents == 0) {
 1063                 if (events & (POLLIN | POLLRDNORM))
selrecord(p, &tp->t_rsel);
 1065                 if (events & (POLLOUT | POLLWRNORM))
selrecord(p, &tp->t_wsel);
 1067         }
splx(s);
 1069         return (revents);
 1070 }
 1072 struct filterops ttyread_filtops =
 1073         { 1, NULL, filt_ttyrdetach, filt_ttyread };
 1074 struct filterops ttywrite_filtops =
 1075         { 1, NULL, filt_ttywdetach, filt_ttywrite };
 1077 int
ttkqfilter(dev_t dev, struct knote *kn)
 1079 {
 1080         struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
 1081         struct klist *klist;
 1082         int s;
 1084         switch (kn->kn_filter) {
 1085         case EVFILT_READ:
klist = &tp->t_rsel.si_note;
kn->kn_fop = &ttyread_filtops;
 1088                 break;
 1089         case EVFILT_WRITE:
klist = &tp->t_wsel.si_note;
kn->kn_fop = &ttywrite_filtops;
 1092                 break;
 1093         default:
 1094                 return (1);
 1095         }
kn->kn_hook = (caddr_t)((u_long)dev);
s = spltty();
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
splx(s);
 1103         return (0);
 1104 }
 1106 void
filt_ttyrdetach(struct knote *kn)
 1108 {
dev_t dev = (dev_t)((u_long)kn->kn_hook);
 1110         struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
 1111         int s = spltty();
SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
splx(s);
 1115 }
 1117 int
filt_ttyread(struct knote *kn, long hint)
 1119 {
dev_t dev = (dev_t)((u_long)kn->kn_hook);
 1121         struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
 1122         int s;
s = spltty();
kn->kn_data = ttnread(tp);
splx(s);
 1127         if (!ISSET(tp->t_cflag, CLOCAL) && !ISSET(tp->t_state, TS_CARR_ON)) {
kn->kn_flags |= EV_EOF;
 1129                 return (1);
 1130         }
 1131         return (kn->kn_data > 0);
 1132 }
 1134 void
filt_ttywdetach(struct knote *kn)
 1136 {
dev_t dev = (dev_t)((u_long)kn->kn_hook);
 1138         struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
 1139         int s = spltty();
SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
splx(s);
 1143 }
 1145 int
filt_ttywrite(struct knote *kn, long hint)
 1147 {
dev_t dev = (dev_t)((u_long)kn->kn_hook);
 1149         struct tty *tp = (*cdevsw[major(dev)].d_tty)(dev);
kn->kn_data = tp->t_outq.c_cc;
 1152         return (kn->kn_data <= tp->t_lowat);
 1153 }
 1155 static int
ttnread(struct tty *tp)
 1157 {
 1158         int nread;
splassert(IPL_TTY);
 1162         if (ISSET(tp->t_lflag, PENDIN))
ttypend(tp);
nread = tp->t_canq.c_cc;
 1165         if (!ISSET(tp->t_lflag, ICANON)) {
nread += tp->t_rawq.c_cc;
 1167                 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
nread = 0;
 1169         }
 1170         return (nread);
 1171 }
 1173 /*
 1174  * Wait for output to drain.
 1175  */
 1176 int
ttywait(struct tty *tp)
 1178 {
 1179         int error, s;
error = 0;
s = spltty();
 1183         while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
 1184             (ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL)) &&
tp->t_oproc) {
 1186                 (*tp->t_oproc)(tp);
 1187                 if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
 1188                     (ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL))
 1189                     && tp->t_oproc) {
SET(tp->t_state, TS_ASLEEP);
error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
 1192                         if (error)
 1193                                 break;
 1194                 } else
 1195                         break;
 1196         }
splx(s);
 1198         return (error);
 1199 }
 1201 /*
 1202  * Flush if successfully wait.
 1203  */
 1204 int
ttywflush(struct tty *tp)
 1206 {
 1207         int error;
 1209         if ((error = ttywait(tp)) == 0)
ttyflush(tp, FREAD);
 1211         return (error);
 1212 }
 1214 /*
 1215  * Flush tty read and/or write queues, notifying anyone waiting.
 1216  */
 1217 void
ttyflush(struct tty *tp, int rw)
 1219 {
 1220         int s;
s = spltty();
 1223         if (rw & FREAD) {
FLUSHQ(&tp->t_canq);
FLUSHQ(&tp->t_rawq);
tp->t_rocount = 0;
tp->t_rocol = 0;
CLR(tp->t_state, TS_LOCAL);
ttyunblock(tp);
ttwakeup(tp);
 1231         }
 1232         if (rw & FWRITE) {
CLR(tp->t_state, TS_TTSTOP);
 1234                 (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
FLUSHQ(&tp->t_outq);
wakeup((caddr_t)&tp->t_outq);
selwakeup(&tp->t_wsel);
 1238         }
splx(s);
 1240 }
 1242 /*
 1243  * Copy in the default termios characters.
 1244  */
 1245 void
ttychars(struct tty *tp)
 1247 {
bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
 1250 }
 1252 /*
 1253  * Send stop character on input overflow.
 1254  */
 1255 static void
ttyblock(struct tty *tp)
 1257 {
 1258         int total;
total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
 1261         if (tp->t_rawq.c_cc > TTYHOG) {
ttyflush(tp, FREAD | FWRITE);
CLR(tp->t_state, TS_TBLOCK);
 1264         }
 1265         /*
 1266          * Block further input iff: current input > threshold
 1267          * AND input is available to user program.
 1268          */
 1269         if ((total >= TTYHOG / 2 &&
 1270              !ISSET(tp->t_state, TS_TBLOCK) &&
 1271              !ISSET(tp->t_lflag, ICANON)) || tp->t_canq.c_cc > 0) {
 1272                 if (ISSET(tp->t_iflag, IXOFF) &&
tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
SET(tp->t_state, TS_TBLOCK);
ttstart(tp);
 1277                 }
 1278                 /* Try to block remote output via hardware flow control. */
 1279                 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
 1280                     (*tp->t_hwiflow)(tp, 1) != 0)
SET(tp->t_state, TS_TBLOCK);
 1282         }
 1283 }
 1285 void
ttrstrt(void *tp_arg)
 1287 {
 1288         struct tty *tp;
 1289         int s;
 1291 #ifdef DIAGNOSTIC
 1292         if (tp_arg == NULL)
panic("ttrstrt");
 1294 #endif
tp = tp_arg;
s = spltty();
CLR(tp->t_state, TS_TIMEOUT);
ttstart(tp);
splx(s);
 1302 }
 1304 int
ttstart(struct tty *tp)
 1306 {
 1308         if (tp->t_oproc != NULL)        /* XXX: Kludge for pty. */
 1309                 (*tp->t_oproc)(tp);
 1310         return (0);
 1311 }
 1313 /*
 1314  * "close" a line discipline
 1315  */
 1316 int
ttylclose(struct tty *tp, int flag)
 1318 {
 1320         if (flag & FNONBLOCK)
ttyflush(tp, FREAD | FWRITE);
 1322         else
ttywflush(tp);
 1324         return (0);
 1325 }
 1327 /*
 1328  * Handle modem control transition on a tty.
 1329  * Flag indicates new state of carrier.
 1330  * Returns 0 if the line should be turned off, otherwise 1.
 1331  */
 1332 int
ttymodem(struct tty *tp, int flag)
 1334 {
 1336         if (!ISSET(tp->t_state, TS_WOPEN) && ISSET(tp->t_cflag, MDMBUF)) {
 1337                 /*
 1338                  * MDMBUF: do flow control according to carrier flag
 1339                  */
 1340                 if (flag) {
CLR(tp->t_state, TS_TTSTOP);
ttstart(tp);
 1343                 } else if (!ISSET(tp->t_state, TS_TTSTOP)) {
SET(tp->t_state, TS_TTSTOP);
 1345                         (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
 1346                 }
 1347         } else if (flag == 0) {
 1348                 /*
 1349                  * Lost carrier.
 1350                  */
CLR(tp->t_state, TS_CARR_ON);
 1352                 if (ISSET(tp->t_state, TS_ISOPEN) &&
 1353                     !ISSET(tp->t_cflag, CLOCAL)) {
 1354                         if (tp->t_session && tp->t_session->s_leader)
psignal(tp->t_session->s_leader, SIGHUP);
ttyflush(tp, FREAD | FWRITE);
 1357                         return (0);
 1358                 }
 1359         } else {
 1360                 /*
 1361                  * Carrier now on.
 1362                  */
SET(tp->t_state, TS_CARR_ON);
ttwakeup(tp);
 1365         }
 1366         return (1);
 1367 }
 1369 /*
 1370  * Default modem control routine (for other line disciplines).
 1371  * Return argument flag, to turn off device on carrier drop.
 1372  */
 1373 int
nullmodem(struct tty *tp, int flag)
 1375 {
 1377         if (flag)
SET(tp->t_state, TS_CARR_ON);
 1379         else {
CLR(tp->t_state, TS_CARR_ON);
 1381                 if (ISSET(tp->t_state, TS_ISOPEN) &&
 1382                     !ISSET(tp->t_cflag, CLOCAL)) {
 1383                         if (tp->t_session && tp->t_session->s_leader)
psignal(tp->t_session->s_leader, SIGHUP);
ttyflush(tp, FREAD | FWRITE);
 1386                         return (0);
 1387                 }
 1388         }
 1389         return (1);
 1390 }
 1392 /*
 1393  * Reinput pending characters after state switch
 1394  * call at spltty().
 1395  */
 1396 void
ttypend(struct tty *tp)
 1398 {
 1399         struct clist tq;
 1400         int c;
splassert(IPL_TTY);
CLR(tp->t_lflag, PENDIN);
SET(tp->t_state, TS_TYPEN);
tq = tp->t_rawq;
tp->t_rawq.c_cc = 0;
tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
 1409         while ((c = getc(&tq)) >= 0)
ttyinput(c, tp);
CLR(tp->t_state, TS_TYPEN);
 1412 }
 1414 void ttvtimeout(void *);
 1416 void
ttvtimeout(void *arg)
 1418 {
 1419         struct tty *tp = (struct tty *)arg;
wakeup(&tp->t_rawq);
 1422 }
 1424 /*
 1425  * Process a read call on a tty device.
 1426  */
 1427 int
ttread(struct tty *tp, struct uio *uio, int flag)
 1429 {
 1430         struct timeout *stime = NULL;
 1431         struct proc *p = curproc;
 1432         int s, first, error = 0;
u_char *cc = tp->t_cc;
 1434         struct clist *qp;
 1435         int last_cc = 0;
 1436         long lflag;
 1437         int c;
loop:   lflag = tp->t_lflag;
s = spltty();
 1441         /*
 1442          * take pending input first
 1443          */
 1444         if (ISSET(lflag, PENDIN))
ttypend(tp);
splx(s);
 1448         /*
 1449          * Hang process if it's in the background.
 1450          */
 1451         if (isbackground(p, tp)) {
 1452                 if ((p->p_sigignore & sigmask(SIGTTIN)) ||
 1453                    (p->p_sigmask & sigmask(SIGTTIN)) ||
p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) {
error = EIO;
 1456                         goto out;
 1457                 }
pgsignal(p->p_pgrp, SIGTTIN, 1);
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
 1460                 if (error)
 1461                         goto out;
 1462                 goto loop;
 1463         }
s = spltty();
 1466         if (!ISSET(lflag, ICANON)) {
 1467                 int m = cc[VMIN];
 1468                 long t;
 1470                 /*
 1471                  * Note - since cc[VTIME] is a u_char, this won't overflow
 1472                  * until we have 32-bit longs and a hz > 8388608.
 1473                  * Hopefully this code and 32-bit longs are obsolete by then.
 1474                  */
t = cc[VTIME] * hz / 10;
qp = &tp->t_rawq;
 1478                 /*
 1479                  * Check each of the four combinations.
 1480                  * (m > 0 && t == 0) is the normal read case.
 1481                  * It should be fairly efficient, so we check that and its
 1482                  * companion case (m == 0 && t == 0) first.
 1483                  */
 1484                 if (t == 0) {
 1485                         if (qp->c_cc < m)
 1486                                 goto sleep;
 1487                         goto read;
 1488                 }
 1489                 if (m > 0) {
 1490                         if (qp->c_cc <= 0)
 1491                                 goto sleep;
 1492                         if (qp->c_cc >= m)
 1493                                 goto read;
 1494                         if (stime == NULL) {
alloc_timer:
stime = malloc(sizeof(*stime), M_TEMP, M_WAITOK);
timeout_set(stime, ttvtimeout, tp);
timeout_add(stime, t);
 1499                         } else if (qp->c_cc > last_cc) {
 1500                                 /* got a character, restart timer */
timeout_add(stime, t);
 1502                         }
 1503                 } else {        /* m == 0 */
 1504                         if (qp->c_cc > 0)
 1505                                 goto read;
 1506                         if (stime == NULL) {
 1507                                 goto alloc_timer;
 1508                         }
 1509                 }
last_cc = qp->c_cc;
 1511                 if (stime && !timeout_triggered(stime)) {
 1512                         goto sleep;
 1513                 }
 1514         } else if ((qp = &tp->t_canq)->c_cc <= 0) {
 1515                 int carrier;
sleep:
 1518                 /*
 1519                  * If there is no input, sleep on rawq
 1520                  * awaiting hardware receipt and notification.
 1521                  * If we have data, we don't need to check for carrier.
 1522                  */
carrier = ISSET(tp->t_state, TS_CARR_ON) ||
ISSET(tp->t_cflag, CLOCAL);
 1525                 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
splx(s);
error = 0;
 1528                         goto out;
 1529                 }
 1530                 if (flag & IO_NDELAY) {
splx(s);
error = EWOULDBLOCK;
 1533                         goto out;
 1534                 }
error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
carrier ? ttyin : ttopen, 0);
splx(s);
 1538                 if (stime && timeout_triggered(stime))
error = EWOULDBLOCK;
 1540                 if (cc[VMIN] == 0 && error == EWOULDBLOCK) {
error = 0;
 1542                         goto out;
 1543                 }
 1544                 if (error && error != EWOULDBLOCK)
 1545                         goto out;
error = 0;
 1547                 goto loop;
 1548         }
read:
splx(s);
 1552         /*
 1553          * Input present, check for input mapping and processing.
 1554          */
first = 1;
 1556         while ((c = getc(qp)) >= 0) {
 1557                 /*
 1558                  * delayed suspend (^Y)
 1559                  */
 1560                 if (CCEQ(cc[VDSUSP], c) &&
ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
pgsignal(tp->t_pgrp, SIGTSTP, 1);
 1563                         if (first) {
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
ttybg, 0);
 1566                                 if (error)
 1567                                         break;
 1568                                 goto loop;
 1569                         }
 1570                         break;
 1571                 }
 1572                 /*
 1573                  * Interpret EOF only in canonical mode.
 1574                  */
 1575                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
 1576                         break;
 1577                 /*
 1578                  * Give user character.
 1579                  */
error = ureadc(c, uio);
 1581                 if (error)
 1582                         break;
 1583                 if (uio->uio_resid == 0)
 1584                         break;
 1585                 /*
 1586                  * In canonical mode check for a "break character"
 1587                  * marking the end of a "line of input".
 1588                  */
 1589                 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
 1590                         break;
first = 0;
 1592         }
 1593         /*
 1594          * Look to unblock output now that (presumably)
 1595          * the input queue has gone down.
 1596          */
s = spltty();
 1598         if (tp->t_rawq.c_cc < TTYHOG/5)
ttyunblock(tp);
splx(s);
out:
 1603         if (stime) {
timeout_del(stime);
free(stime, M_TEMP);
 1606         }
 1607         return (error);
 1608 }
 1610 /* Call at spltty */
 1611 void
ttyunblock(struct tty *tp)
 1613 {
u_char *cc = tp->t_cc;
splassert(IPL_TTY);
 1618         if (ISSET(tp->t_state, TS_TBLOCK)) {
 1619                 if (ISSET(tp->t_iflag, IXOFF) &&
cc[VSTART] != _POSIX_VDISABLE &&
putc(cc[VSTART], &tp->t_outq) == 0) {
CLR(tp->t_state, TS_TBLOCK);
ttstart(tp);
 1624                 }
 1625                 /* Try to unblock remote output via hardware flow control. */
 1626                 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
 1627                     (*tp->t_hwiflow)(tp, 0) != 0)
CLR(tp->t_state, TS_TBLOCK);
 1629         }
 1630 }
 1632 /*
 1633  * Check the output queue on tp for space for a kernel message (from uprintf
 1634  * or tprintf).  Allow some space over the normal hiwater mark so we don't
 1635  * lose messages due to normal flow control, but don't let the tty run amok.
 1636  * Sleeps here are not interruptible, but we return prematurely if new signals
 1637  * arrive.
 1638  */
 1639 int
ttycheckoutq(struct tty *tp, int wait)
 1641 {
 1642         int hiwat, s, oldsig;
hiwat = tp->t_hiwat;
s = spltty();
oldsig = wait ? curproc->p_siglist : 0;
 1647         if (tp->t_outq.c_cc > hiwat + 200)
 1648                 while (tp->t_outq.c_cc > hiwat) {
ttstart(tp);
 1650                         if (wait == 0 || curproc->p_siglist != oldsig) {
splx(s);
 1652                                 return (0);
 1653                         }
SET(tp->t_state, TS_ASLEEP);
tsleep(&tp->t_outq, PZERO - 1, "ttckoutq", hz);
 1656                 }
splx(s);
 1658         return (1);
 1659 }
 1661 /*
 1662  * Process a write call on a tty device.
 1663  */
 1664 int
ttwrite(struct tty *tp, struct uio *uio, int flag)
 1666 {
u_char *cp = NULL;
 1668         int cc, ce;
 1669         struct proc *p;
 1670         int i, hiwat, cnt, error, s;
u_char obuf[OBUFSIZ];
hiwat = tp->t_hiwat;
cnt = uio->uio_resid;
error = 0;
cc = 0;
loop:
s = spltty();
 1679         if (!ISSET(tp->t_state, TS_CARR_ON) &&
 1680             !ISSET(tp->t_cflag, CLOCAL)) {
 1681                 if (ISSET(tp->t_state, TS_ISOPEN)) {
splx(s);
 1683                         return (EIO);
 1684                 } else if (flag & IO_NDELAY) {
splx(s);
error = EWOULDBLOCK;
 1687                         goto out;
 1688                 } else {
 1689                         /* Sleep awaiting carrier. */
error = ttysleep(tp,
 1691                             &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0);
splx(s);
 1693                         if (error)
 1694                                 goto out;
 1695                         goto loop;
 1696                 }
 1697         }
splx(s);
 1699         /*
 1700          * Hang the process if it's in the background.
 1701          */
p = curproc;
 1703         if (isbackground(p, tp) &&
ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
 1705             (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
 1706             (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
 1707                 if (p->p_pgrp->pg_jobc == 0) {
error = EIO;
 1709                         goto out;
 1710                 }
pgsignal(p->p_pgrp, SIGTTOU, 1);
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0);
 1713                 if (error)
 1714                         goto out;
 1715                 goto loop;
 1716         }
 1717         /*
 1718          * Process the user's data in at most OBUFSIZ chunks.  Perform any
 1719          * output translation.  Keep track of high water mark, sleep on
 1720          * overflow awaiting device aid in acquiring new space.
 1721          */
 1722         while (uio->uio_resid > 0 || cc > 0) {
 1723                 if (ISSET(tp->t_lflag, FLUSHO)) {
uio->uio_resid = 0;
 1725                         return (0);
 1726                 }
 1727                 if (tp->t_outq.c_cc > hiwat)
 1728                         goto ovhiwat;
 1729                 /*
 1730                  * Grab a hunk of data from the user, unless we have some
 1731                  * leftover from last time.
 1732                  */
 1733                 if (cc == 0) {
cc = min(uio->uio_resid, OBUFSIZ);
cp = obuf;
error = uiomove(cp, cc, uio);
 1737                         if (error) {
cc = 0;
 1739                                 break;
 1740                         }
 1741                 }
 1742                 /*
 1743                  * If nothing fancy need be done, grab those characters we
 1744                  * can handle without any of ttyoutput's processing and
 1745                  * just transfer them to the output q.  For those chars
 1746                  * which require special processing (as indicated by the
 1747                  * bits in char_type), call ttyoutput.  After processing
 1748                  * a hunk of data, look for FLUSHO so ^O's will take effect
 1749                  * immediately.
 1750                  */
 1751                 while (cc > 0) {
 1752                         if (!ISSET(tp->t_oflag, OPOST))
ce = cc;
 1754                         else {
ce = cc - scanc((u_int)cc, cp, char_type,
CCLASSMASK);
 1757                                 /*
 1758                                  * If ce is zero, then we're processing
 1759                                  * a special character through ttyoutput.
 1760                                  */
 1761                                 if (ce == 0) {
tp->t_rocount = 0;
 1763                                         if (ttyoutput(*cp, tp) >= 0) {
 1764                                                 /* out of space */
 1765                                                 goto overfull;
 1766                                         }
cp++;
cc--;
 1769                                         if (ISSET(tp->t_lflag, FLUSHO) ||
tp->t_outq.c_cc > hiwat)
 1771                                                 goto ovhiwat;
 1772                                         continue;
 1773                                 }
 1774                         }
 1775                         /*
 1776                          * A bunch of normal characters have been found.
 1777                          * Transfer them en masse to the output queue and
 1778                          * continue processing at the top of the loop.
 1779                          * If there are any further characters in this
 1780                          * <= OBUFSIZ chunk, the first should be a character
 1781                          * requiring special handling by ttyoutput.
 1782                          */
tp->t_rocount = 0;
i = b_to_q(cp, ce, &tp->t_outq);
ce -= i;
tp->t_column += ce;
cp += ce, cc -= ce, tk_nout += ce;
tp->t_outcc += ce;
 1789                         if (i > 0) {
 1790                                 /* out of space */
 1791                                 goto overfull;
 1792                         }
 1793                         if (ISSET(tp->t_lflag, FLUSHO) ||
tp->t_outq.c_cc > hiwat)
 1795                                 break;
 1796                 }
ttstart(tp);
 1798         }
out:
 1800         /*
 1801          * If cc is nonzero, we leave the uio structure inconsistent, as the
 1802          * offset and iov pointers have moved forward, but it doesn't matter
 1803          * (the call will either return short or restart with a new uio).
 1804          */
uio->uio_resid += cc;
 1806         return (error);
overfull:
 1809         /*
 1810          * Since we are using ring buffers, if we can't insert any more into
 1811          * the output queue, we can assume the ring is full and that someone
 1812          * forgot to set the high water mark correctly.  We set it and then
 1813          * proceed as normal.
 1814          */
hiwat = tp->t_outq.c_cc - 1;
ovhiwat:
ttstart(tp);
s = spltty();
 1820         /*
 1821          * This can only occur if FLUSHO is set in t_lflag,
 1822          * or if ttstart/oproc is synchronous (or very fast).
 1823          */
 1824         if (tp->t_outq.c_cc <= hiwat) {
splx(s);
 1826                 goto loop;
 1827         }
 1828         if (flag & IO_NDELAY) {
splx(s);
uio->uio_resid += cc;
 1831                 return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
 1832         }
SET(tp->t_state, TS_ASLEEP);
error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
splx(s);
 1836         if (error)
 1837                 goto out;
 1838         goto loop;
 1839 }
 1841 /*
 1842  * Rubout one character from the rawq of tp
 1843  * as cleanly as possible.
 1844  */
 1845 void
ttyrub(int c, struct tty *tp)
 1847 {
u_char *cp;
 1849         int savecol;
 1850         int tabc, s;
 1852         if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
 1853                 return;
CLR(tp->t_lflag, FLUSHO);
 1855         if (ISSET(tp->t_lflag, ECHOE)) {
 1856                 if (tp->t_rocount == 0) {
 1857                         /*
 1858                          * Screwed by ttwrite; retype
 1859                          */
ttyretype(tp);
 1861                         return;
 1862                 }
 1863                 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
ttyrubo(tp, 2);
 1865                 else {
CLR(c, ~TTY_CHARMASK);
 1867                         switch (CCLASS(c)) {
 1868                         case ORDINARY:
ttyrubo(tp, 1);
 1870                                 break;
 1871                         case BACKSPACE:
 1872                         case CONTROL:
 1873                         case NEWLINE:
 1874                         case RETURN:
 1875                         case VTAB:
 1876                                 if (ISSET(tp->t_lflag, ECHOCTL))
ttyrubo(tp, 2);
 1878                                 break;
 1879                         case TAB:
 1880                                 if (tp->t_rocount < tp->t_rawq.c_cc) {
ttyretype(tp);
 1882                                         return;
 1883                                 }
s = spltty();
savecol = tp->t_column;
SET(tp->t_state, TS_CNTTB);
SET(tp->t_lflag, FLUSHO);
tp->t_column = tp->t_rocol;
 1889                                 for (cp = firstc(&tp->t_rawq, &tabc); cp;
cp = nextc(&tp->t_rawq, cp, &tabc))
ttyecho(tabc, tp);
CLR(tp->t_lflag, FLUSHO);
CLR(tp->t_state, TS_CNTTB);
splx(s);
 1896                                 /* savecol will now be length of the tab. */
savecol -= tp->t_column;
tp->t_column += savecol;
 1899                                 if (savecol > 8)
savecol = 8;    /* overflow screw */
 1901                                 while (--savecol >= 0)
 1902                                         (void)ttyoutput('\b', tp);
 1903                                 break;
 1904                         default:                        /* XXX */
 1905 #define PANICSTR        "ttyrub: would panic c = %d, val = %d\n"
 1906                                 (void)printf(PANICSTR, c, CCLASS(c));
 1907 #ifdef notdef
panic(PANICSTR, c, CCLASS(c));
 1909 #endif
 1910                         }
 1911                 }
 1912         } else if (ISSET(tp->t_lflag, ECHOPRT)) {
 1913                 if (!ISSET(tp->t_state, TS_ERASE)) {
SET(tp->t_state, TS_ERASE);
 1915                         (void)ttyoutput('\\', tp);
 1916                 }
ttyecho(c, tp);
 1918         } else
ttyecho(tp->t_cc[VERASE], tp);
 1920         --tp->t_rocount;
 1921 }
 1923 /*
 1924  * Back over cnt characters, erasing them.
 1925  */
 1926 static void
ttyrubo(struct tty *tp, int cnt)
 1928 {
 1930         while (cnt-- > 0) {
 1931                 (void)ttyoutput('\b', tp);
 1932                 (void)ttyoutput(' ', tp);
 1933                 (void)ttyoutput('\b', tp);
 1934         }
 1935 }
 1937 /*
 1938  * ttyretype --
 1939  *      Reprint the rawq line.  Note, it is assumed that c_cc has already
 1940  *      been checked.
 1941  */
 1942 void
ttyretype(struct tty *tp)
 1944 {
u_char *cp;
 1946         int s, c;
 1948         /* Echo the reprint character. */
 1949         if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
ttyecho(tp->t_cc[VREPRINT], tp);
 1952         (void)ttyoutput('\n', tp);
s = spltty();
 1955         for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
ttyecho(c, tp);
 1957         for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
ttyecho(c, tp);
CLR(tp->t_state, TS_ERASE);
splx(s);
tp->t_rocount = tp->t_rawq.c_cc;
tp->t_rocol = 0;
 1964 }
 1966 /*
 1967  * Echo a typed character to the terminal.
 1968  */
 1969 static void
ttyecho(int c, struct tty *tp)
 1971 {
 1973         if (!ISSET(tp->t_state, TS_CNTTB))
CLR(tp->t_lflag, FLUSHO);
 1975         if ((!ISSET(tp->t_lflag, ECHO) &&
 1976             (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
ISSET(tp->t_lflag, EXTPROC))
 1978                 return;
 1979         if (((ISSET(tp->t_lflag, ECHOCTL) &&
 1980              (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
ISSET(c, TTY_CHARMASK) == 0177)) {
 1982                 (void)ttyoutput('^', tp);
CLR(c, ~TTY_CHARMASK);
 1984                 if (c == 0177)
c = '?';
 1986                 else
c += 'A' - 1;
 1988         }
 1989         (void)ttyoutput(c, tp);
 1990 }
 1992 /*
 1993  * Wake up any readers on a tty.
 1994  */
 1995 void
ttwakeup(struct tty *tp)
 1997 {
selwakeup(&tp->t_rsel);
 2000         if (ISSET(tp->t_state, TS_ASYNC))
pgsignal(tp->t_pgrp, SIGIO, 1);
wakeup((caddr_t)&tp->t_rawq);
KNOTE(&tp->t_rsel.si_note, 0);
 2004 }
 2006 /*
 2007  * Look up a code for a specified speed in a conversion table;
 2008  * used by drivers to map software speed values to hardware parameters.
 2009  */
 2010 int
ttspeedtab(int speed, const struct speedtab *table)
 2012 {
 2014         for ( ; table->sp_speed != -1; table++)
 2015                 if (table->sp_speed == speed)
 2016                         return (table->sp_code);
 2017         return (-1);
 2018 }
 2020 /*
 2021  * Set tty hi and low water marks.
 2022  *
 2023  * Try to arrange the dynamics so there's about one second
 2024  * from hi to low water.
 2025  */
 2026 void
ttsetwater(struct tty *tp)
 2028 {
 2029         int cps, x;
 2031 #define CLAMP(x, h, l)  ((x) > h ? h : ((x) < l) ? l : (x))
cps = tp->t_ospeed / 10;
tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
x += cps;
x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
tp->t_hiwat = roundup(x, CBSIZE);
 2038 #undef  CLAMP
 2039 }
 2041 /*
 2042  * Report on state of foreground process group.
 2043  */
 2044 void
ttyinfo(struct tty *tp)
 2046 {
 2047         struct proc *p, *pick;
 2048         struct timeval utime, stime;
 2049         int tmp;
 2051         if (ttycheckoutq(tp,0) == 0)
 2052                 return;
 2054         /* Print load average. */
tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
 2058         if (tp->t_session == NULL)
ttyprintf(tp, "not a controlling terminal\n");
 2060         else if (tp->t_pgrp == NULL)
ttyprintf(tp, "no foreground process group\n");
 2062         else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL)
ttyprintf(tp, "empty foreground process group\n");
 2064         else {
 2065                 /* Pick interesting process. */
 2066                 for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist))
 2067                         if (proc_compare(pick, p))
pick = p;
ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
pick->p_stat == SONPROC ? "running" :
pick->p_stat == SRUN ? "runnable" :
pick->p_wmesg ? pick->p_wmesg : "iowait");
calcru(pick, &utime, &stime, NULL);
 2077                 /* Round up and print user time. */
utime.tv_usec += 5000;
 2079                 if (utime.tv_usec >= 1000000) {
utime.tv_sec += 1;
utime.tv_usec -= 1000000;
 2082                 }
ttyprintf(tp, "%ld.%02ldu ", utime.tv_sec,
utime.tv_usec / 10000);
 2086                 /* Round up and print system time. */
stime.tv_usec += 5000;
 2088                 if (stime.tv_usec >= 1000000) {
stime.tv_sec += 1;
stime.tv_usec -= 1000000;
 2091                 }
ttyprintf(tp, "%ld.%02lds ", stime.tv_sec,
stime.tv_usec / 10000);
 2095 #define pgtok(a)        (((u_long) ((a) * PAGE_SIZE) / 1024))
 2096                 /* Print percentage cpu, resident set size. */
tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
ttyprintf(tp, "%d%% %ldk\n",
tmp / 100,
pick->p_stat == SIDL || P_ZOMBIE(pick) ? 0 :
vm_resident_count(pick->p_vmspace));
 2102         }
tp->t_rocount = 0;      /* so pending input will be retyped if BS */
 2104 }
 2106 /*
 2107  * Returns 1 if p2 is "better" than p1
 2108  *
 2109  * The algorithm for picking the "interesting" process is thus:
 2110  *
 2111  *      1) Only foreground processes are eligible - implied.
 2112  *      2) Runnable processes are favored over anything else.  The runner
 2113  *         with the highest cpu utilization is picked (p_estcpu).  Ties are
 2114  *         broken by picking the highest pid.
 2115  *      3) The sleeper with the shortest sleep time is next.  With ties,
 2116  *         we pick out just "short-term" sleepers (P_SINTR == 0).
 2117  *      4) Further ties are broken by picking the highest pid.
 2118  */
 2119 #define ISRUN(p)        (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL) || \
 2120                          ((p)->p_stat == SONPROC))
 2121 #define TESTAB(a, b)    ((a)<<1 | (b))
 2122 #define ONLYA   2
 2123 #define ONLYB   1
 2124 #define BOTH    3
 2126 static int
proc_compare(struct proc *p1, struct proc *p2)
 2128 {
 2130         if (p1 == NULL)
 2131                 return (1);
 2132         /*
 2133          * see if at least one of them is runnable
 2134          */
 2135         switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
 2136         case ONLYA:
 2137                 return (0);
 2138         case ONLYB:
 2139                 return (1);
 2140         case BOTH:
 2141                 /*
 2142                  * tie - favor one with highest recent cpu utilization
 2143                  */
 2144                 if (p2->p_estcpu > p1->p_estcpu)
 2145                         return (1);
 2146                 if (p1->p_estcpu > p2->p_estcpu)
 2147                         return (0);
 2148                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
 2149         }
 2150         /*
 2151          * weed out zombies
 2152          */
 2153         switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
 2154         case ONLYA:
 2155                 return (1);
 2156         case ONLYB:
 2157                 return (0);
 2158         case BOTH:
 2159                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
 2160         }
 2161         /*
 2162          * pick the one with the smallest sleep time
 2163          */
 2164         if (p2->p_slptime > p1->p_slptime)
 2165                 return (0);
 2166         if (p1->p_slptime > p2->p_slptime)
 2167                 return (1);
 2168         /*
 2169          * favor one sleeping in a non-interruptible sleep
 2170          */
 2171         if (p1->p_flag & P_SINTR && (p2->p_flag & P_SINTR) == 0)
 2172                 return (1);
 2173         if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 0)
 2174                 return (0);
 2175         return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
 2176 }
 2178 /*
 2179  * Output char to tty; console putchar style.
 2180  */
 2181 int
tputchar(int c, struct tty *tp)
 2183 {
 2184         int s;
s = spltty();
 2187         if (ISSET(tp->t_state,
TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) {
splx(s);
 2190                 return (-1);
 2191         }
 2192         if (c == '\n')
 2193                 (void)ttyoutput('\r', tp);
 2194         (void)ttyoutput(c, tp);
ttstart(tp);
splx(s);
 2197         return (0);
 2198 }
 2200 /*
 2201  * Sleep on chan, returning ERESTART if tty changed while we napped and
 2202  * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep.  If
 2203  * the tty is revoked, restarting a pending call will redo validation done
 2204  * at the start of the call.
 2205  */
 2206 int
ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo)
 2208 {
 2209         int error;
 2210         short gen;
gen = tp->t_gen;
 2213         if ((error = tsleep(chan, pri, wmesg, timo)) != 0)
 2214                 return (error);
 2215         return (tp->t_gen == gen ? 0 : ERESTART);
 2216 }
 2218 /*
 2219  * Initialise the global tty list.
 2220  */
 2221 void
tty_init(void)
 2223 {
TAILQ_INIT(&ttylist);
tty_count = 0;
 2227 }
 2229 /*
 2230  * Allocate a tty structure and its associated buffers, and attach it to the
 2231  * tty list.
 2232  */
 2233 struct tty *
ttymalloc(void)
 2235 {
 2236         struct tty *tp;
MALLOC(tp, struct tty *, sizeof(struct tty), M_TTYS, M_WAITOK);
bzero(tp, sizeof *tp);
 2240         /* XXX: default to 1024 chars for now */
clalloc(&tp->t_rawq, 1024, 1);
clalloc(&tp->t_canq, 1024, 1);
 2243         /* output queue doesn't need quoting */
clalloc(&tp->t_outq, 1024, 0);
TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
 2247         ++tty_count;
timeout_set(&tp->t_rstrt_to, ttrstrt, tp);
 2250         return(tp);
 2251 }
 2254 /*
 2255  * Free a tty structure and its buffers, after removing it from the tty list.
 2256  */
 2257 void
ttyfree(struct tty *tp)
 2259 {
 2261         --tty_count;
 2262 #ifdef DIAGNOSTIC
 2263         if (tty_count < 0)
panic("ttyfree: tty_count < 0");
 2265 #endif
TAILQ_REMOVE(&ttylist, tp, tty_link);
clfree(&tp->t_rawq);
clfree(&tp->t_canq);
clfree(&tp->t_outq);
FREE(tp, M_TTYS);
 2272 }
 2274 struct itty *ttystats;
 2276 int
ttystats_init(void)
 2278 {
 2279         struct itty *itp;
 2280         struct tty *tp;
ttystats = malloc(tty_count * sizeof(struct itty),
M_SYSCTL, M_WAITOK);
 2284         for (tp = TAILQ_FIRST(&ttylist), itp = ttystats; tp;
tp = TAILQ_NEXT(tp, tty_link), itp++) {
itp->t_dev = tp->t_dev;
itp->t_rawq_c_cc = tp->t_rawq.c_cc;
itp->t_canq_c_cc = tp->t_canq.c_cc;
itp->t_outq_c_cc = tp->t_outq.c_cc;
itp->t_hiwat = tp->t_hiwat;
itp->t_lowat = tp->t_lowat;
itp->t_column = tp->t_column;
itp->t_state = tp->t_state;
itp->t_session = tp->t_session;
 2295                 if (tp->t_pgrp)
itp->t_pgrp_pg_id = tp->t_pgrp->pg_id;
 2297                 else
itp->t_pgrp_pg_id = 0;
itp->t_line = tp->t_line;
 2300         }
 2301         return (0);
 2302 }
 2304 /*
 2305  * Return tty-related information.
 2306  */
 2307 int
sysctl_tty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
 2310 {
 2311         int err;
 2313         if (namelen != 1)
 2314                 return (ENOTDIR);
 2316         switch (name[0]) {
 2317         case KERN_TTY_TKNIN:
 2318                 return (sysctl_rdquad(oldp, oldlenp, newp, tk_nin));
 2319         case KERN_TTY_TKNOUT:
 2320                 return (sysctl_rdquad(oldp, oldlenp, newp, tk_nout));
 2321         case KERN_TTY_TKRAWCC:
 2322                 return (sysctl_rdquad(oldp, oldlenp, newp, tk_rawcc));
 2323         case KERN_TTY_TKCANCC:
 2324                 return (sysctl_rdquad(oldp, oldlenp, newp, tk_cancc));
 2325         case KERN_TTY_INFO:
err = ttystats_init();
 2327                 if (err)
 2328                         return (err);
err = sysctl_rdstruct(oldp, oldlenp, newp, ttystats,
tty_count * sizeof(struct itty));
free(ttystats, M_SYSCTL);
 2332                 return (err);
 2333         default:
 2334 #if NPTY > 0
 2335                 return (sysctl_pty(name, namelen, oldp, oldlenp, newp, newlen));
 2336 #else
 2337                 return (EOPNOTSUPP);
 2338 #endif
 2339         }
 2340         /* NOTREACHED */
 2341 }
 2343 void
ttytstamp(struct tty *tp, int octs, int ncts, int odcd, int ndcd)
 2345 {
 2346         int doit = 0;
 2348         if (ncts ^ octs)
doit |= ncts ? ISSET(tp->t_flags, TS_TSTAMPCTSSET) :
ISSET(tp->t_flags, TS_TSTAMPCTSCLR);
 2351         if (ndcd ^ odcd)
doit |= ndcd ? ISSET(tp->t_flags, TS_TSTAMPDCDSET) :
ISSET(tp->t_flags, TS_TSTAMPDCDCLR);
 2355         if (doit)
microtime(&tp->t_tv);
 2357 }