The Design and Implementation of the FreeBSD Operating System, Second Edition
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/tty.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: tty.c,v 1.227.4.2 2009/10/11 18:03:21 sborrill Exp $   */
    2 
    3 /*-
    4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   26  * POSSIBILITY OF SUCH DAMAGE.
   27  */
   28 
   29 /*-
   30  * Copyright (c) 1982, 1986, 1990, 1991, 1993
   31  *      The Regents of the University of California.  All rights reserved.
   32  * (c) UNIX System Laboratories, Inc.
   33  * All or some portions of this file are derived from material licensed
   34  * to the University of California by American Telephone and Telegraph
   35  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   36  * the permission of UNIX System Laboratories, Inc.
   37  *
   38  * Redistribution and use in source and binary forms, with or without
   39  * modification, are permitted provided that the following conditions
   40  * are met:
   41  * 1. Redistributions of source code must retain the above copyright
   42  *    notice, this list of conditions and the following disclaimer.
   43  * 2. Redistributions in binary form must reproduce the above copyright
   44  *    notice, this list of conditions and the following disclaimer in the
   45  *    documentation and/or other materials provided with the distribution.
   46  * 3. Neither the name of the University nor the names of its contributors
   47  *    may be used to endorse or promote products derived from this software
   48  *    without specific prior written permission.
   49  *
   50  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   53  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   60  * SUCH DAMAGE.
   61  *
   62  *      @(#)tty.c       8.13 (Berkeley) 1/9/95
   63  */
   64 
   65 #include <sys/cdefs.h>
   66 __KERNEL_RCSID(0, "$NetBSD: tty.c,v 1.227.4.2 2009/10/11 18:03:21 sborrill Exp $");
   67 
   68 #include <sys/param.h>
   69 #include <sys/systm.h>
   70 #include <sys/ioctl.h>
   71 #include <sys/proc.h>
   72 #define TTYDEFCHARS
   73 #include <sys/tty.h>
   74 #undef  TTYDEFCHARS
   75 #include <sys/file.h>
   76 #include <sys/conf.h>
   77 #include <sys/dkstat.h>
   78 #include <sys/uio.h>
   79 #include <sys/kernel.h>
   80 #include <sys/vnode.h>
   81 #include <sys/syslog.h>
   82 #include <sys/malloc.h>
   83 #include <sys/kmem.h>
   84 #include <sys/signalvar.h>
   85 #include <sys/resourcevar.h>
   86 #include <sys/poll.h>
   87 #include <sys/kprintf.h>
   88 #include <sys/namei.h>
   89 #include <sys/sysctl.h>
   90 #include <sys/kauth.h>
   91 #include <sys/intr.h>
   92 
   93 #include <machine/stdarg.h>
   94 
   95 static int      ttnread(struct tty *);
   96 static void     ttyblock(struct tty *);
   97 static void     ttyecho(int, struct tty *);
   98 static void     ttyrubo(struct tty *, int);
   99 static void     ttyprintf_nolock(struct tty *, const char *fmt, ...)
  100     __attribute__((__format__(__printf__,2,3)));
  101 static int      proc_compare(struct proc *, struct proc *);
  102 static void     ttysigintr(void *);
  103 
  104 /* Symbolic sleep message strings. */
  105 const char      ttclos[] = "ttycls";
  106 const char      ttopen[] = "ttyopn";
  107 const char      ttybg[] = "ttybg";
  108 const char      ttyin[] = "ttyin";
  109 const char      ttyout[] = "ttyout";
  110 
  111 /*
  112  * Used to determine whether we still have a connection.  This is true in
  113  * one of 3 cases:
  114  * 1) We have carrier.
  115  * 2) It's a locally attached terminal, and we are therefore ignoring carrier.
  116  * 3) We're using a flow control mechanism that overloads the carrier signal.
  117  */
  118 #define CONNECTED(tp)   (ISSET(tp->t_state, TS_CARR_ON) ||      \
  119                          ISSET(tp->t_cflag, CLOCAL | MDMBUF))
  120 
  121 /*
  122  * Table with character classes and parity. The 8th bit indicates parity,
  123  * the 7th bit indicates the character is an alphameric or underscore (for
  124  * ALTWERASE), and the low 6 bits indicate delay type.  If the low 6 bits
  125  * are 0 then the character needs no special processing on output; classes
  126  * other than 0 might be translated or (not currently) require delays.
  127  */
  128 #define E       0x00    /* Even parity. */
  129 #define O       0x80    /* Odd parity. */
  130 #define PARITY(c)       (char_type[c] & O)
  131 
  132 #define ALPHA   0x40    /* Alpha or underscore. */
  133 #define ISALPHA(c)      (char_type[(c) & TTY_CHARMASK] & ALPHA)
  134 
  135 #define CCLASSMASK      0x3f
  136 #define CCLASS(c)       (char_type[c] & CCLASSMASK)
  137 
  138 #define BS      BACKSPACE
  139 #define CC      CONTROL
  140 #define CR      RETURN
  141 #define NA      ORDINARY | ALPHA
  142 #define NL      NEWLINE
  143 #define NO      ORDINARY
  144 #define TB      TAB
  145 #define VT      VTAB
  146 
  147 unsigned char const char_type[] = {
  148         E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
  149         O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
  150         O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
  151         E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
  152         O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
  153         E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
  154         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
  155         O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
  156         O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
  157         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
  158         E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
  159         O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
  160         E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
  161         O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
  162         O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
  163         E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
  164         /*
  165          * Meta chars; should be settable per character set;
  166          * for now, treat them all as normal characters.
  167          */
  168         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  169         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  170         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  171         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  172         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  173         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  174         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  175         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  176         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  177         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  178         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  179         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  180         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  181         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  182         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  183         NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
  184 };
  185 #undef  BS
  186 #undef  CC
  187 #undef  CR
  188 #undef  NA
  189 #undef  NL
  190 #undef  NO
  191 #undef  TB
  192 #undef  VT
  193 
  194 static struct ttylist_head tty_sigqueue = TAILQ_HEAD_INITIALIZER(tty_sigqueue);
  195 static void *tty_sigsih;
  196 
  197 struct ttylist_head ttylist = TAILQ_HEAD_INITIALIZER(ttylist);
  198 int tty_count;
  199 kmutex_t tty_lock;
  200 
  201 uint64_t tk_cancc;
  202 uint64_t tk_nin;
  203 uint64_t tk_nout;
  204 uint64_t tk_rawcc;
  205 
  206 SYSCTL_SETUP(sysctl_kern_tkstat_setup, "sysctl kern.tkstat subtree setup")
  207 {
  208 
  209         sysctl_createv(clog, 0, NULL, NULL,
  210                        CTLFLAG_PERMANENT,
  211                        CTLTYPE_NODE, "kern", NULL,
  212                        NULL, 0, NULL, 0,
  213                        CTL_KERN, CTL_EOL);
  214         sysctl_createv(clog, 0, NULL, NULL,
  215                        CTLFLAG_PERMANENT,
  216                        CTLTYPE_NODE, "tkstat",
  217                        SYSCTL_DESCR("Number of characters sent and and "
  218                                     "received on ttys"),
  219                        NULL, 0, NULL, 0,
  220                        CTL_KERN, KERN_TKSTAT, CTL_EOL);
  221 
  222         sysctl_createv(clog, 0, NULL, NULL,
  223                        CTLFLAG_PERMANENT,
  224                        CTLTYPE_QUAD, "nin",
  225                        SYSCTL_DESCR("Total number of tty input characters"),
  226                        NULL, 0, &tk_nin, 0,
  227                        CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NIN, CTL_EOL);
  228         sysctl_createv(clog, 0, NULL, NULL,
  229                        CTLFLAG_PERMANENT,
  230                        CTLTYPE_QUAD, "nout",
  231                        SYSCTL_DESCR("Total number of tty output characters"),
  232                        NULL, 0, &tk_nout, 0,
  233                        CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_NOUT, CTL_EOL);
  234         sysctl_createv(clog, 0, NULL, NULL,
  235                        CTLFLAG_PERMANENT,
  236                        CTLTYPE_QUAD, "cancc",
  237                        SYSCTL_DESCR("Number of canonical tty input characters"),
  238                        NULL, 0, &tk_cancc, 0,
  239                        CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_CANCC, CTL_EOL);
  240         sysctl_createv(clog, 0, NULL, NULL,
  241                        CTLFLAG_PERMANENT,
  242                        CTLTYPE_QUAD, "rawcc",
  243                        SYSCTL_DESCR("Number of raw tty input characters"),
  244                        NULL, 0, &tk_rawcc, 0,
  245                        CTL_KERN, KERN_TKSTAT, KERN_TKSTAT_RAWCC, CTL_EOL);
  246 }
  247 
  248 int
  249 ttyopen(struct tty *tp, int dialout, int nonblock)
  250 {
  251         int     error;
  252 
  253         error = 0;
  254 
  255         mutex_spin_enter(&tty_lock);
  256 
  257         if (dialout) {
  258                 /*
  259                  * If the device is already open for non-dialout, fail.
  260                  * Otherwise, set TS_DIALOUT to block any pending non-dialout
  261                  * opens.
  262                  */
  263                 if (ISSET(tp->t_state, TS_ISOPEN) &&
  264                     !ISSET(tp->t_state, TS_DIALOUT)) {
  265                         error = EBUSY;
  266                         goto out;
  267                 }
  268                 SET(tp->t_state, TS_DIALOUT);
  269         } else {
  270                 if (!nonblock) {
  271                         /*
  272                          * Wait for carrier.  Also wait for any dialout
  273                          * processes to close the tty first.
  274                          */
  275                         while (ISSET(tp->t_state, TS_DIALOUT) ||
  276                                !CONNECTED(tp)) {
  277                                 tp->t_wopen++;
  278                                 error = ttysleep(tp, &tp->t_rawcv, true, 0);
  279                                 tp->t_wopen--;
  280                                 if (error)
  281                                         goto out;
  282                         }
  283                 } else {
  284                         /*
  285                          * Don't allow a non-blocking non-dialout open if the
  286                          * device is already open for dialout.
  287                          */
  288                         if (ISSET(tp->t_state, TS_DIALOUT)) {
  289                                 error = EBUSY;
  290                                 goto out;
  291                         }
  292                 }
  293         }
  294 
  295 out:
  296         mutex_spin_exit(&tty_lock);
  297         return (error);
  298 }
  299 
  300 /*
  301  * Initial open of tty, or (re)entry to standard tty line discipline.
  302  */
  303 int
  304 ttylopen(dev_t device, struct tty *tp)
  305 {
  306 
  307         mutex_spin_enter(&tty_lock);
  308         tp->t_dev = device;
  309         if (!ISSET(tp->t_state, TS_ISOPEN)) {
  310                 SET(tp->t_state, TS_ISOPEN);
  311                 memset(&tp->t_winsize, 0, sizeof(tp->t_winsize));
  312 #ifdef COMPAT_OLDTTY
  313                 tp->t_flags = 0;
  314 #endif
  315         }
  316         mutex_spin_exit(&tty_lock);
  317         return (0);
  318 }
  319 
  320 /*
  321  * Handle close() on a tty line: flush and set to initial state,
  322  * bumping generation number so that pending read/write calls
  323  * can detect recycling of the tty.
  324  */
  325 int
  326 ttyclose(struct tty *tp)
  327 {
  328         extern struct tty *constty;     /* Temporary virtual console. */
  329         struct session *sess;
  330 
  331         mutex_spin_enter(&tty_lock);
  332 
  333         if (constty == tp)
  334                 constty = NULL;
  335 
  336         ttyflush(tp, FREAD | FWRITE);
  337 
  338         tp->t_gen++;
  339         tp->t_pgrp = NULL;
  340         tp->t_state = 0;
  341         sess = tp->t_session;
  342         tp->t_session = NULL;
  343 
  344         mutex_spin_exit(&tty_lock);
  345 
  346         mutex_enter(proc_lock);
  347         if (sess != NULL)
  348                 SESSRELE(sess);
  349         mutex_exit(proc_lock);
  350 
  351         return (0);
  352 }
  353 
  354 #define FLUSHQ(q) {                                                     \
  355         if ((q)->c_cc)                                                  \
  356                 ndflush(q, (q)->c_cc);                                  \
  357 }
  358 
  359 /*
  360  * This macro is used in canonical mode input processing, where a read
  361  * request shall not return unless a 'line delimiter' ('\n') or 'break'
  362  * (EOF, EOL, EOL2) character (or a signal) has been received. As EOL2
  363  * is an extension to the POSIX.1 defined set of special characters,
  364  * recognize it only if IEXTEN is set in the set of local flags.
  365  */
  366 #define TTBREAKC(c, lflg)                                               \
  367         ((c) == '\n' || (((c) == cc[VEOF] || (c) == cc[VEOL] ||         \
  368         ((c) == cc[VEOL2] && ISSET(lflg, IEXTEN))) && (c) != _POSIX_VDISABLE))
  369 
  370 
  371 
  372 /*
  373  * ttyinput() helper.
  374  * Call with the tty lock held.
  375  */
  376 /* XXX static */ int
  377 ttyinput_wlock(int c, struct tty *tp)
  378 {
  379         int     iflag, lflag, i, error;
  380         u_char  *cc;
  381 
  382         KASSERT(mutex_owned(&tty_lock));
  383 
  384         /*
  385          * If input is pending take it first.
  386          */
  387         lflag = tp->t_lflag;
  388         if (ISSET(lflag, PENDIN))
  389                 ttypend(tp);
  390         /*
  391          * Gather stats.
  392          */
  393         if (ISSET(lflag, ICANON)) {
  394                 ++tk_cancc;
  395                 ++tp->t_cancc;
  396         } else {
  397                 ++tk_rawcc;
  398                 ++tp->t_rawcc;
  399         }
  400         ++tk_nin;
  401 
  402         cc = tp->t_cc;
  403 
  404         /*
  405          * Handle exceptional conditions (break, parity, framing).
  406          */
  407         iflag = tp->t_iflag;
  408         if ((error = (ISSET(c, TTY_ERRORMASK))) != 0) {
  409                 CLR(c, TTY_ERRORMASK);
  410                 if (ISSET(error, TTY_FE) && c == 0) {           /* Break. */
  411                         if (ISSET(iflag, IGNBRK))
  412                                 return (0);
  413                         else if (ISSET(iflag, BRKINT)) {
  414                                 ttyflush(tp, FREAD | FWRITE);
  415                                 ttysig(tp, TTYSIG_PG1, SIGINT);
  416                                 return (0);
  417                         } else if (ISSET(iflag, PARMRK))
  418                                 goto parmrk;
  419                 } else if ((ISSET(error, TTY_PE) && ISSET(iflag, INPCK)) ||
  420                     ISSET(error, TTY_FE)) {
  421                         if (ISSET(iflag, IGNPAR))
  422                                 return (0);
  423                         else if (ISSET(iflag, PARMRK)) {
  424  parmrk:                        (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
  425                                 (void)putc(0    | TTY_QUOTE, &tp->t_rawq);
  426                                 (void)putc(c    | TTY_QUOTE, &tp->t_rawq);
  427                                 return (0);
  428                         } else
  429                                 c = 0;
  430                 }
  431         } else if (c == 0377 &&
  432             ISSET(iflag, ISTRIP|IGNPAR|INPCK|PARMRK) == (INPCK|PARMRK)) {
  433                 /* "Escape" a valid character of '\377'. */
  434                 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
  435                 (void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
  436                 goto endcase;
  437         }
  438 
  439         /*
  440          * In tandem mode, check high water mark.
  441          */
  442         if (ISSET(iflag, IXOFF) || ISSET(tp->t_cflag, CHWFLOW))
  443                 ttyblock(tp);
  444         if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
  445                 CLR(c, 0x80);
  446         if (!ISSET(lflag, EXTPROC)) {
  447                 /*
  448                  * Check for literal nexting very first
  449                  */
  450                 if (ISSET(tp->t_state, TS_LNCH)) {
  451                         SET(c, TTY_QUOTE);
  452                         CLR(tp->t_state, TS_LNCH);
  453                 }
  454                 /*
  455                  * Scan for special characters.  This code
  456                  * is really just a big case statement with
  457                  * non-constant cases.  The bottom of the
  458                  * case statement is labeled ``endcase'', so goto
  459                  * it after a case match, or similar.
  460                  */
  461 
  462                 /*
  463                  * Control chars which aren't controlled
  464                  * by ICANON, ISIG, or IXON.
  465                  */
  466                 if (ISSET(lflag, IEXTEN)) {
  467                         if (CCEQ(cc[VLNEXT], c)) {
  468                                 if (ISSET(lflag, ECHO)) {
  469                                         if (ISSET(lflag, ECHOE)) {
  470                                                 (void)ttyoutput('^', tp);
  471                                                 (void)ttyoutput('\b', tp);
  472                                         } else
  473                                                 ttyecho(c, tp);
  474                                 }
  475                                 SET(tp->t_state, TS_LNCH);
  476                                 goto endcase;
  477                         }
  478                         if (CCEQ(cc[VDISCARD], c)) {
  479                                 if (ISSET(lflag, FLUSHO))
  480                                         CLR(tp->t_lflag, FLUSHO);
  481                                 else {
  482                                         ttyflush(tp, FWRITE);
  483                                         ttyecho(c, tp);
  484                                         if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
  485                                                 ttyretype(tp);
  486                                         SET(tp->t_lflag, FLUSHO);
  487                                 }
  488                                 goto startoutput;
  489                         }
  490                 }
  491                 /*
  492                  * Signals.
  493                  */
  494                 if (ISSET(lflag, ISIG)) {
  495                         if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
  496                                 if (!ISSET(lflag, NOFLSH))
  497                                         ttyflush(tp, FREAD | FWRITE);
  498                                 ttyecho(c, tp);
  499                                 ttysig(tp, TTYSIG_PG1, CCEQ(cc[VINTR], c) ?
  500                                     SIGINT : SIGQUIT);
  501                                 goto endcase;
  502                         }
  503                         if (CCEQ(cc[VSUSP], c)) {
  504                                 if (!ISSET(lflag, NOFLSH))
  505                                         ttyflush(tp, FREAD);
  506                                 ttyecho(c, tp);
  507                                 ttysig(tp, TTYSIG_PG1, SIGTSTP);
  508                                 goto endcase;
  509                         }
  510                 }
  511                 /*
  512                  * Handle start/stop characters.
  513                  */
  514                 if (ISSET(iflag, IXON)) {
  515                         if (CCEQ(cc[VSTOP], c)) {
  516                                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
  517                                         SET(tp->t_state, TS_TTSTOP);
  518                                         cdev_stop(tp, 0);
  519                                         return (0);
  520                                 }
  521                                 if (!CCEQ(cc[VSTART], c))
  522                                         return (0);
  523                                 /*
  524                                  * if VSTART == VSTOP then toggle
  525                                  */
  526                                 goto endcase;
  527                         }
  528                         if (CCEQ(cc[VSTART], c))
  529                                 goto restartoutput;
  530                 }
  531                 /*
  532                  * IGNCR, ICRNL, & INLCR
  533                  */
  534                 if (c == '\r') {
  535                         if (ISSET(iflag, IGNCR))
  536                                 goto endcase;
  537                         else if (ISSET(iflag, ICRNL))
  538                                 c = '\n';
  539                 } else if (c == '\n' && ISSET(iflag, INLCR))
  540                         c = '\r';
  541         }
  542         if (!ISSET(lflag, EXTPROC) && ISSET(lflag, ICANON)) {
  543                 /*
  544                  * From here on down canonical mode character
  545                  * processing takes place.
  546                  */
  547                 /*
  548                  * erase (^H / ^?)
  549                  */
  550                 if (CCEQ(cc[VERASE], c)) {
  551                         if (tp->t_rawq.c_cc)
  552                                 ttyrub(unputc(&tp->t_rawq), tp);
  553                         goto endcase;
  554                 }
  555                 /*
  556                  * kill (^U)
  557                  */
  558                 if (CCEQ(cc[VKILL], c)) {
  559                         if (ISSET(lflag, ECHOKE) &&
  560                             tp->t_rawq.c_cc == tp->t_rocount &&
  561                             !ISSET(lflag, ECHOPRT))
  562                                 while (tp->t_rawq.c_cc)
  563                                         ttyrub(unputc(&tp->t_rawq), tp);
  564                         else {
  565                                 ttyecho(c, tp);
  566                                 if (ISSET(lflag, ECHOK) ||
  567                                     ISSET(lflag, ECHOKE))
  568                                         ttyecho('\n', tp);
  569                                 FLUSHQ(&tp->t_rawq);
  570                                 tp->t_rocount = 0;
  571                         }
  572                         CLR(tp->t_state, TS_LOCAL);
  573                         goto endcase;
  574                 }
  575                 /*
  576                  * Extensions to the POSIX.1 GTI set of functions.
  577                  */
  578                 if (ISSET(lflag, IEXTEN)) {
  579                         /*
  580                          * word erase (^W)
  581                          */
  582                         if (CCEQ(cc[VWERASE], c)) {
  583                                 int alt = ISSET(lflag, ALTWERASE);
  584                                 int ctype;
  585 
  586                                 /*
  587                                  * erase whitespace
  588                                  */
  589                                 while ((c = unputc(&tp->t_rawq)) == ' ' ||
  590                                     c == '\t')
  591                                         ttyrub(c, tp);
  592                                 if (c == -1)
  593                                         goto endcase;
  594                                 /*
  595                                  * erase last char of word and remember the
  596                                  * next chars type (for ALTWERASE)
  597                                  */
  598                                 ttyrub(c, tp);
  599                                 c = unputc(&tp->t_rawq);
  600                                 if (c == -1)
  601                                         goto endcase;
  602                                 if (c == ' ' || c == '\t') {
  603                                         (void)putc(c, &tp->t_rawq);
  604                                         goto endcase;
  605                                 }
  606                                 ctype = ISALPHA(c);
  607                                 /*
  608                                  * erase rest of word
  609                                  */
  610                                 do {
  611                                         ttyrub(c, tp);
  612                                         c = unputc(&tp->t_rawq);
  613                                         if (c == -1)
  614                                                 goto endcase;
  615                                 } while (c != ' ' && c != '\t' &&
  616                                     (alt == 0 || ISALPHA(c) == ctype));
  617                                 (void)putc(c, &tp->t_rawq);
  618                                 goto endcase;
  619                         }
  620                         /*
  621                          * reprint line (^R)
  622                          */
  623                         if (CCEQ(cc[VREPRINT], c)) {
  624                                 ttyretype(tp);
  625                                 goto endcase;
  626                         }
  627                         /*
  628                          * ^T - kernel info and generate SIGINFO
  629                          */
  630                         if (CCEQ(cc[VSTATUS], c)) {
  631                                 ttysig(tp, TTYSIG_PG1, SIGINFO);
  632                                 goto endcase;
  633                         }
  634                 }
  635         }
  636         /*
  637          * Check for input buffer overflow
  638          */
  639         if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
  640                 if (ISSET(iflag, IMAXBEL)) {
  641                         if (tp->t_outq.c_cc < tp->t_hiwat)
  642                                 (void)ttyoutput(CTRL('g'), tp);
  643                 } else
  644                         ttyflush(tp, FREAD | FWRITE);
  645                 goto endcase;
  646         }
  647         /*
  648          * Put data char in q for user and
  649          * wakeup on seeing a line delimiter.
  650          */
  651         if (putc(c, &tp->t_rawq) >= 0) {
  652                 if (!ISSET(lflag, ICANON)) {
  653                         ttwakeup(tp);
  654                         ttyecho(c, tp);
  655                         goto endcase;
  656                 }
  657                 if (TTBREAKC(c, lflag)) {
  658                         tp->t_rocount = 0;
  659                         catq(&tp->t_rawq, &tp->t_canq);
  660                         ttwakeup(tp);
  661                 } else if (tp->t_rocount++ == 0)
  662                         tp->t_rocol = tp->t_column;
  663                 if (ISSET(tp->t_state, TS_ERASE)) {
  664                         /*
  665                          * end of prterase \.../
  666                          */
  667                         CLR(tp->t_state, TS_ERASE);
  668                         (void)ttyoutput('/', tp);
  669                 }
  670                 i = tp->t_column;
  671                 ttyecho(c, tp);
  672                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
  673                         /*
  674                          * Place the cursor over the '^' of the ^D.
  675                          */
  676                         i = min(2, tp->t_column - i);
  677                         while (i > 0) {
  678                                 (void)ttyoutput('\b', tp);
  679                                 i--;
  680                         }
  681                 }
  682         }
  683  endcase:
  684         /*
  685          * IXANY means allow any character to restart output.
  686          */
  687         if (ISSET(tp->t_state, TS_TTSTOP) &&
  688             !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP]) {
  689                 return (0);
  690         }
  691  restartoutput:
  692         CLR(tp->t_lflag, FLUSHO);
  693         CLR(tp->t_state, TS_TTSTOP);
  694  startoutput:
  695         return (ttstart(tp));
  696 }
  697 
  698 /*
  699  * Process input of a single character received on a tty.
  700  *
  701  * XXX - this is a hack, all drivers must changed to acquire the
  702  *       lock before calling linesw->l_rint()
  703  */
  704 int
  705 ttyinput(int c, struct tty *tp)
  706 {
  707         int error;
  708 
  709         /*
  710          * Unless the receiver is enabled, drop incoming data.
  711          */
  712         if (!ISSET(tp->t_cflag, CREAD))
  713                 return (0);
  714 
  715         mutex_spin_enter(&tty_lock);
  716         error = ttyinput_wlock(c, tp);
  717         mutex_spin_exit(&tty_lock);
  718 
  719         return (error);
  720 }
  721 
  722 /*
  723  * Output a single character on a tty, doing output processing
  724  * as needed (expanding tabs, newline processing, etc.).
  725  * Returns < 0 if succeeds, otherwise returns char to resend.
  726  * Must be recursive.
  727  *
  728  * Call with tty lock held.
  729  */
  730 int
  731 ttyoutput(int c, struct tty *tp)
  732 {
  733         long    oflag;
  734         int     col, notout;
  735 
  736         KASSERT(mutex_owned(&tty_lock));
  737 
  738         oflag = tp->t_oflag;
  739         if (!ISSET(oflag, OPOST)) {
  740                 tk_nout++;
  741                 tp->t_outcc++;
  742                 if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
  743                         return (c);
  744                 return (-1);
  745         }
  746         /*
  747          * Do tab expansion if OXTABS is set.  Special case if we do external
  748          * processing, we don't do the tab expansion because we'll probably
  749          * get it wrong.  If tab expansion needs to be done, let it happen
  750          * externally.
  751          */
  752         CLR(c, ~TTY_CHARMASK);
  753         if (c == '\t' &&
  754             ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
  755                 c = 8 - (tp->t_column & 7);
  756                 if (ISSET(tp->t_lflag, FLUSHO)) {
  757                         notout = 0;
  758                 } else {
  759                         notout = b_to_q("        ", c, &tp->t_outq);
  760                         c -= notout;
  761                         tk_nout += c;
  762                         tp->t_outcc += c;
  763                 }
  764                 tp->t_column += c;
  765                 return (notout ? '\t' : -1);
  766         }
  767         if (c == CEOT && ISSET(oflag, ONOEOT))
  768                 return (-1);
  769 
  770         /*
  771          * Newline translation: if ONLCR is set,
  772          * translate newline into "\r\n".
  773          */
  774         if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
  775                 tk_nout++;
  776                 tp->t_outcc++;
  777                 if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
  778                         return (c);
  779         }
  780         /* If OCRNL is set, translate "\r" into "\n". */
  781         else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
  782                 c = '\n';
  783         /* If ONOCR is set, don't transmit CRs when on column 0. */
  784         else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
  785                 return (-1);
  786 
  787         tk_nout++;
  788         tp->t_outcc++;
  789         if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
  790                 return (c);
  791 
  792         col = tp->t_column;
  793         switch (CCLASS(c)) {
  794         case BACKSPACE:
  795                 if (col > 0)
  796                         --col;
  797                 break;
  798         case CONTROL:
  799                 break;
  800         case NEWLINE:
  801                 if (ISSET(tp->t_oflag, ONLCR | ONLRET))
  802                         col = 0;
  803                 break;
  804         case RETURN:
  805                 col = 0;
  806                 break;
  807         case ORDINARY:
  808                 ++col;
  809                 break;
  810         case TAB:
  811                 col = (col + 8) & ~7;
  812                 break;
  813         }
  814         tp->t_column = col;
  815         return (-1);
  816 }
  817 
  818 /*
  819  * Ioctls for all tty devices.  Called after line-discipline specific ioctl
  820  * has been called to do discipline-specific functions and/or reject any
  821  * of these ioctl commands.
  822  */
  823 /* ARGSUSED */
  824 int
  825 ttioctl(struct tty *tp, u_long cmd, void *data, int flag, struct lwp *l)
  826 {
  827         extern struct tty *constty;     /* Temporary virtual console. */
  828         struct proc *p = l ? l->l_proc : NULL;
  829         struct linesw   *lp;
  830         int             s, error;
  831         struct nameidata nd;
  832         char            infobuf[200];
  833 
  834         /* If the ioctl involves modification, hang if in the background. */
  835         switch (cmd) {
  836         case  TIOCFLUSH:
  837         case  TIOCDRAIN:
  838         case  TIOCSBRK:
  839         case  TIOCCBRK:
  840         case  TIOCSTART:
  841         case  TIOCSETA:
  842         case  TIOCSETD:
  843         case  TIOCSLINED:
  844         case  TIOCSETAF:
  845         case  TIOCSETAW:
  846 #ifdef notdef
  847         case  TIOCSPGRP:
  848         case  FIOSETOWN:
  849 #endif
  850         case  TIOCSTAT:
  851         case  TIOCSTI:
  852         case  TIOCSWINSZ:
  853 #ifdef COMPAT_OLDTTY
  854         case  TIOCLBIC:
  855         case  TIOCLBIS:
  856         case  TIOCLSET:
  857         case  TIOCSETC:
  858         case OTIOCSETD:
  859         case  TIOCSETN:
  860         case  TIOCSETP:
  861         case  TIOCSLTC:
  862 #endif
  863                 mutex_spin_enter(&tty_lock);
  864                 while (isbackground(curproc, tp) &&
  865                     p->p_pgrp->pg_jobc && (p->p_lflag & PL_PPWAIT) == 0 &&
  866                     !sigismasked(l, SIGTTOU)) {
  867                         mutex_spin_exit(&tty_lock);
  868 
  869                         mutex_enter(proc_lock);
  870                         pgsignal(p->p_pgrp, SIGTTOU, 1);
  871                         mutex_exit(proc_lock);
  872                         
  873                         mutex_spin_enter(&tty_lock);
  874                         error = ttysleep(tp, &lbolt, true, 0);
  875                         if (error) {
  876                                 mutex_spin_exit(&tty_lock);
  877                                 return (error);
  878                         }
  879                 }
  880                 mutex_spin_exit(&tty_lock);
  881                 break;
  882         }
  883 
  884         switch (cmd) {                  /* Process the ioctl. */
  885         case FIOASYNC:                  /* set/clear async i/o */
  886                 mutex_spin_enter(&tty_lock);
  887                 if (*(int *)data)
  888                         SET(tp->t_state, TS_ASYNC);
  889                 else
  890                         CLR(tp->t_state, TS_ASYNC);
  891                 mutex_spin_exit(&tty_lock);
  892                 break;
  893         case FIONBIO:                   /* set/clear non-blocking i/o */
  894                 break;                  /* XXX: delete. */
  895         case FIONREAD:                  /* get # bytes to read */
  896                 mutex_spin_enter(&tty_lock);
  897                 *(int *)data = ttnread(tp);
  898                 mutex_spin_exit(&tty_lock);
  899                 break;
  900         case FIONWRITE:                 /* get # bytes to written & unsent */
  901                 mutex_spin_enter(&tty_lock);
  902                 *(int *)data = tp->t_outq.c_cc;
  903                 mutex_spin_exit(&tty_lock);
  904                 break;
  905         case FIONSPACE:                 /* get # bytes to written & unsent */
  906                 mutex_spin_enter(&tty_lock);
  907                 *(int *)data = tp->t_outq.c_cn - tp->t_outq.c_cc;
  908                 mutex_spin_exit(&tty_lock);
  909                 break;
  910         case TIOCEXCL:                  /* set exclusive use of tty */
  911                 mutex_spin_enter(&tty_lock);
  912                 SET(tp->t_state, TS_XCLUDE);
  913                 mutex_spin_exit(&tty_lock);
  914                 break;
  915         case TIOCFLUSH: {               /* flush buffers */
  916                 int flags = *(int *)data;
  917 
  918                 if (flags == 0)
  919                         flags = FREAD | FWRITE;
  920                 else
  921                         flags &= FREAD | FWRITE;
  922                 mutex_spin_enter(&tty_lock);
  923                 ttyflush(tp, flags);
  924                 mutex_spin_exit(&tty_lock);
  925                 break;
  926         }
  927         case TIOCCONS:                  /* become virtual console */
  928                 if (*(int *)data) {
  929                         if (constty && constty != tp &&
  930                             ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
  931                             (TS_CARR_ON | TS_ISOPEN))
  932                                 return EBUSY;
  933 
  934                         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
  935                             "/dev/console");
  936                         if ((error = namei(&nd)) != 0)
  937                                 return error;
  938                         error = VOP_ACCESS(nd.ni_vp, VREAD, l->l_cred);
  939                         vput(nd.ni_vp);
  940                         if (error)
  941                                 return error;
  942 
  943                         constty = tp;
  944                 } else if (tp == constty)
  945                         constty = NULL;
  946                 break;
  947         case TIOCDRAIN:                 /* wait till output drained */
  948                 if ((error = ttywait(tp)) != 0)
  949                         return (error);
  950                 break;
  951         case TIOCGETA: {                /* get termios struct */
  952                 struct termios *t = (struct termios *)data;
  953 
  954                 memcpy(t, &tp->t_termios, sizeof(struct termios));
  955                 break;
  956         }
  957         case TIOCGETD:                  /* get line discipline (old) */
  958                 *(int *)data = tp->t_linesw->l_no;
  959                 break;
  960         case TIOCGLINED:                /* get line discipline (new) */
  961                 (void)strncpy((char *)data, tp->t_linesw->l_name,
  962                     TTLINEDNAMELEN - 1);
  963                 break;
  964         case TIOCGWINSZ:                /* get window size */
  965                 *(struct winsize *)data = tp->t_winsize;
  966                 break;
  967         case FIOGETOWN:
  968                 mutex_enter(proc_lock);
  969                 if (tp->t_session != NULL && !isctty(p, tp)) {
  970                         mutex_exit(proc_lock);
  971                         return (ENOTTY);
  972                 }
  973                 *(int *)data = tp->t_pgrp ? -tp->t_pgrp->pg_id : 0;
  974                 mutex_exit(proc_lock);
  975                 break;
  976         case TIOCGPGRP:                 /* get pgrp of tty */
  977                 mutex_enter(proc_lock);
  978                 if (!isctty(p, tp)) {
  979                         mutex_exit(proc_lock);
  980                         return (ENOTTY);
  981                 }
  982                 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
  983                 mutex_exit(proc_lock);
  984                 break;
  985         case TIOCGSID:                  /* get sid of tty */
  986                 mutex_enter(proc_lock);
  987                 if (!isctty(p, tp)) {
  988                         mutex_exit(proc_lock);
  989                         return (ENOTTY);
  990                 }
  991                 *(int *)data = tp->t_session->s_sid;
  992                 mutex_exit(proc_lock);
  993                 break;
  994 #ifdef TIOCHPCL
  995         case TIOCHPCL:                  /* hang up on last close */
  996                 mutex_spin_enter(&tty_lock);
  997                 SET(tp->t_cflag, HUPCL);
  998                 mutex_spin_exit(&tty_lock);
  999                 break;
 1000 #endif
 1001         case TIOCNXCL:                  /* reset exclusive use of tty */
 1002                 mutex_spin_enter(&tty_lock);
 1003                 CLR(tp->t_state, TS_XCLUDE);
 1004                 mutex_spin_exit(&tty_lock);
 1005                 break;
 1006         case TIOCOUTQ:                  /* output queue size */
 1007                 *(int *)data = tp->t_outq.c_cc;
 1008                 break;
 1009         case TIOCSETA:                  /* set termios struct */
 1010         case TIOCSETAW:                 /* drain output, set */
 1011         case TIOCSETAF: {               /* drn out, fls in, set */
 1012                 struct termios *t = (struct termios *)data;
 1013 
 1014                 if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
 1015                         if ((error = ttywait(tp)) != 0)
 1016                                 return (error);
 1017 
 1018                         if (cmd == TIOCSETAF) {
 1019                                 mutex_spin_enter(&tty_lock);
 1020                                 ttyflush(tp, FREAD);
 1021                                 mutex_spin_exit(&tty_lock);
 1022                         }
 1023                 }
 1024 
 1025                 s = spltty();
 1026                 /*
 1027                  * XXXSMP - some drivers call back on us from t_param(), so
 1028                  *          don't take the tty spin lock here.
 1029                  *          require t_param() to unlock upon callback?
 1030                  */
 1031                 /* wanted here: mutex_spin_enter(&tty_lock); */
 1032                 if (!ISSET(t->c_cflag, CIGNORE)) {
 1033                         /*
 1034                          * Set device hardware.
 1035                          */
 1036                         if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
 1037                                 /* wanted here: mutex_spin_exit(&tty_lock); */
 1038                                 splx(s);
 1039                                 return (error);
 1040                         } else {
 1041                                 tp->t_cflag = t->c_cflag;
 1042                                 tp->t_ispeed = t->c_ispeed;
 1043                                 tp->t_ospeed = t->c_ospeed;
 1044                                 if (t->c_ospeed == 0)
 1045                                         ttysig(tp, TTYSIG_LEADER, SIGHUP);
 1046                         }
 1047                         ttsetwater(tp);
 1048                 }
 1049 
 1050                 /* delayed lock acquiring */
 1051                 mutex_spin_enter(&tty_lock);
 1052                 if (cmd != TIOCSETAF) {
 1053                         if (ISSET(t->c_lflag, ICANON) !=
 1054                             ISSET(tp->t_lflag, ICANON)) {
 1055                                 if (ISSET(t->c_lflag, ICANON)) {
 1056                                         SET(tp->t_lflag, PENDIN);
 1057                                         ttwakeup(tp);
 1058                                 } else {
 1059                                         struct clist tq;
 1060 
 1061                                         catq(&tp->t_rawq, &tp->t_canq);
 1062                                         tq = tp->t_rawq;
 1063                                         tp->t_rawq = tp->t_canq;
 1064                                         tp->t_canq = tq;
 1065                                         CLR(tp->t_lflag, PENDIN);
 1066                                 }
 1067                         }
 1068                 }
 1069                 tp->t_iflag = t->c_iflag;
 1070                 tp->t_oflag = t->c_oflag;
 1071                 /*
 1072                  * Make the EXTPROC bit read only.
 1073                  */
 1074                 if (ISSET(tp->t_lflag, EXTPROC))
 1075                         SET(t->c_lflag, EXTPROC);
 1076                 else
 1077                         CLR(t->c_lflag, EXTPROC);
 1078                 tp->t_lflag = t->c_lflag | ISSET(tp->t_lflag, PENDIN);
 1079                 memcpy(tp->t_cc, t->c_cc, sizeof(t->c_cc));
 1080                 mutex_spin_exit(&tty_lock);
 1081                 splx(s);
 1082                 break;
 1083         }
 1084         case TIOCSETD:                  /* set line discipline (old) */
 1085                 lp = ttyldisc_lookup_bynum(*(int *)data);
 1086                 goto setldisc;
 1087 
 1088         case TIOCSLINED: {              /* set line discipline (new) */
 1089                 char *name = (char *)data;
 1090                 dev_t device;
 1091 
 1092                 /* Null terminate to prevent buffer overflow */
 1093                 name[TTLINEDNAMELEN - 1] = '\0';
 1094                 lp = ttyldisc_lookup(name);
 1095  setldisc:
 1096                 if (lp == NULL)
 1097                         return (ENXIO);
 1098 
 1099                 if (lp != tp->t_linesw) {
 1100                         device = tp->t_dev;
 1101                         s = spltty();
 1102                         (*tp->t_linesw->l_close)(tp, flag);
 1103                         error = (*lp->l_open)(device, tp);
 1104                         if (error) {
 1105                                 (void)(*tp->t_linesw->l_open)(device, tp);
 1106                                 splx(s);
 1107                                 ttyldisc_release(lp);
 1108                                 return (error);
 1109                         }
 1110                         ttyldisc_release(tp->t_linesw);
 1111                         tp->t_linesw = lp;
 1112                         splx(s);
 1113                 } else {
 1114                         /* Drop extra reference. */
 1115                         ttyldisc_release(lp);
 1116                 }
 1117                 break;
 1118         }
 1119         case TIOCSTART:                 /* start output, like ^Q */
 1120                 mutex_spin_enter(&tty_lock);
 1121                 if (ISSET(tp->t_state, TS_TTSTOP) ||
 1122                     ISSET(tp->t_lflag, FLUSHO)) {
 1123                         CLR(tp->t_lflag, FLUSHO);
 1124                         CLR(tp->t_state, TS_TTSTOP);
 1125                         ttstart(tp);
 1126                 }
 1127                 mutex_spin_exit(&tty_lock);
 1128                 break;
 1129         case TIOCSTI:                   /* simulate terminal input */
 1130                 if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_STI,
 1131                     tp) != 0) {
 1132                         if (!ISSET(flag, FREAD))
 1133                                 return (EPERM);
 1134                         if (!isctty(p, tp))
 1135                                 return (EACCES);
 1136                 }
 1137                 (*tp->t_linesw->l_rint)(*(u_char *)data, tp);
 1138                 break;
 1139         case TIOCSTOP:                  /* stop output, like ^S */
 1140         {
 1141                 mutex_spin_enter(&tty_lock);
 1142                 if (!ISSET(tp->t_state, TS_TTSTOP)) {
 1143                         SET(tp->t_state, TS_TTSTOP);
 1144                         cdev_stop(tp, 0);
 1145                 }
 1146                 mutex_spin_exit(&tty_lock);
 1147                 break;
 1148         }
 1149         case TIOCSCTTY:                 /* become controlling tty */
 1150                 mutex_enter(proc_lock);
 1151                 mutex_spin_enter(&tty_lock);
 1152 
 1153                 /* Session ctty vnode pointer set in vnode layer. */
 1154                 if (!SESS_LEADER(p) ||
 1155                     ((p->p_session->s_ttyvp || tp->t_session) &&
 1156                     (tp->t_session != p->p_session))) {
 1157                         mutex_spin_exit(&tty_lock);
 1158                         mutex_exit(proc_lock);
 1159                         return (EPERM);
 1160                 }
 1161 
 1162                 /*
 1163                  * `p_session' acquires a reference.
 1164                  * But note that if `t_session' is set at this point,
 1165                  * it must equal `p_session', in which case the session
 1166                  * already has the correct reference count.
 1167                  */
 1168                 if (tp->t_session == NULL)
 1169                         SESSHOLD(p->p_session);
 1170 
 1171                 tp->t_session = p->p_session;
 1172                 tp->t_pgrp = p->p_pgrp;
 1173                 p->p_session->s_ttyp = tp;
 1174                 p->p_lflag |= PL_CONTROLT;
 1175                 mutex_spin_exit(&tty_lock);
 1176                 mutex_exit(proc_lock);
 1177                 break;
 1178         case FIOSETOWN: {               /* set pgrp of tty */
 1179                 pid_t pgid = *(int *)data;
 1180                 struct pgrp *pgrp;
 1181 
 1182                 mutex_enter(proc_lock); 
 1183                 if (tp->t_session != NULL && !isctty(p, tp)) {
 1184                         mutex_exit(proc_lock);
 1185                         return (ENOTTY);
 1186                 }
 1187 
 1188                 if (pgid < 0) {
 1189                         pgrp = pg_find(-pgid, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
 1190                         if (pgrp == NULL)
 1191                                 return (EINVAL);
 1192                 } else {
 1193                         struct proc *p1;
 1194                         p1 = p_find(pgid, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
 1195                         if (!p1)
 1196                                 return (ESRCH);
 1197                         pgrp = p1->p_pgrp;
 1198                 }
 1199 
 1200                 if (pgrp->pg_session != p->p_session) {
 1201                         mutex_exit(proc_lock);
 1202                         return (EPERM);
 1203                 }
 1204                 mutex_spin_enter(&tty_lock);
 1205                 tp->t_pgrp = pgrp;
 1206                 mutex_spin_exit(&tty_lock);
 1207                 mutex_exit(proc_lock);
 1208                 break;
 1209         }
 1210         case TIOCSPGRP: {               /* set pgrp of tty */
 1211                 struct pgrp *pgrp;
 1212 
 1213                 mutex_enter(proc_lock); 
 1214                 if (!isctty(p, tp)) {
 1215                         mutex_exit(proc_lock);
 1216                         return (ENOTTY);
 1217                 }
 1218                 pgrp = pg_find(*(int *)data, PFIND_LOCKED | PFIND_UNLOCK_FAIL);
 1219                 if (pgrp == NULL)
 1220                         return (EINVAL);
 1221                 if (pgrp->pg_session != p->p_session) {
 1222                         mutex_exit(proc_lock);
 1223                         return (EPERM);
 1224                 }
 1225                 mutex_spin_enter(&tty_lock);
 1226                 tp->t_pgrp = pgrp;
 1227                 mutex_spin_exit(&tty_lock);
 1228                 mutex_exit(proc_lock);
 1229                 break;
 1230         }
 1231         case TIOCSTAT:                  /* get load avg stats */
 1232                 mutex_enter(proc_lock);
 1233                 ttygetinfo(tp, 0, infobuf, sizeof(infobuf));
 1234                 mutex_exit(proc_lock);
 1235 
 1236                 mutex_spin_enter(&tty_lock);
 1237                 ttyputinfo(tp, infobuf);
 1238                 mutex_spin_exit(&tty_lock);
 1239                 break;
 1240         case TIOCSWINSZ:                /* set window size */
 1241                 mutex_spin_enter(&tty_lock);
 1242                 if (memcmp((void *)&tp->t_winsize, data,
 1243                     sizeof(struct winsize))) {
 1244                         tp->t_winsize = *(struct winsize *)data;
 1245                         ttysig(tp, TTYSIG_PG1, SIGWINCH);
 1246                 }
 1247                 mutex_spin_exit(&tty_lock);
 1248                 break;
 1249         default:
 1250 #ifdef COMPAT_OLDTTY
 1251                 return (ttcompat(tp, cmd, data, flag, l));
 1252 #else
 1253                 return (EPASSTHROUGH);
 1254 #endif
 1255         }
 1256         return (0);
 1257 }
 1258 
 1259 int
 1260 ttpoll(struct tty *tp, int events, struct lwp *l)
 1261 {
 1262         int     revents;
 1263 
 1264         revents = 0;
 1265         mutex_spin_enter(&tty_lock);
 1266         if (events & (POLLIN | POLLRDNORM))
 1267                 if (ttnread(tp) > 0)
 1268                         revents |= events & (POLLIN | POLLRDNORM);
 1269 
 1270         if (events & (POLLOUT | POLLWRNORM))
 1271                 if (tp->t_outq.c_cc <= tp->t_lowat)
 1272                         revents |= events & (POLLOUT | POLLWRNORM);
 1273 
 1274         if (events & POLLHUP)
 1275                 if (!CONNECTED(tp))
 1276                         revents |= POLLHUP;
 1277 
 1278         if (revents == 0) {
 1279                 if (events & (POLLIN | POLLHUP | POLLRDNORM))
 1280                         selrecord(l, &tp->t_rsel);
 1281 
 1282                 if (events & (POLLOUT | POLLWRNORM))
 1283                         selrecord(l, &tp->t_wsel);
 1284         }
 1285 
 1286         mutex_spin_exit(&tty_lock);
 1287 
 1288         return (revents);
 1289 }
 1290 
 1291 static void
 1292 filt_ttyrdetach(struct knote *kn)
 1293 {
 1294         struct tty      *tp;
 1295 
 1296         tp = kn->kn_hook;
 1297         mutex_spin_enter(&tty_lock);
 1298         SLIST_REMOVE(&tp->t_rsel.sel_klist, kn, knote, kn_selnext);
 1299         mutex_spin_exit(&tty_lock);
 1300 }
 1301 
 1302 static int
 1303 filt_ttyread(struct knote *kn, long hint)
 1304 {
 1305         struct tty      *tp;
 1306 
 1307         tp = kn->kn_hook;
 1308         if ((hint & NOTE_SUBMIT) == 0)
 1309                 mutex_spin_enter(&tty_lock);
 1310         kn->kn_data = ttnread(tp);
 1311         if ((hint & NOTE_SUBMIT) == 0)
 1312                 mutex_spin_exit(&tty_lock);
 1313         return (kn->kn_data > 0);
 1314 }
 1315 
 1316 static void
 1317 filt_ttywdetach(struct knote *kn)
 1318 {
 1319         struct tty      *tp;
 1320 
 1321         tp = kn->kn_hook;
 1322         mutex_spin_enter(&tty_lock);
 1323         SLIST_REMOVE(&tp->t_wsel.sel_klist, kn, knote, kn_selnext);
 1324         mutex_spin_exit(&tty_lock);
 1325 }
 1326 
 1327 static int
 1328 filt_ttywrite(struct knote *kn, long hint)
 1329 {
 1330         struct tty      *tp;
 1331         int             canwrite;
 1332 
 1333         tp = kn->kn_hook;
 1334         if ((hint & NOTE_SUBMIT) == 0)
 1335                 mutex_spin_enter(&tty_lock);
 1336         kn->kn_data = tp->t_outq.c_cn - tp->t_outq.c_cc;
 1337         canwrite = (tp->t_outq.c_cc <= tp->t_lowat) && CONNECTED(tp);
 1338         if ((hint & NOTE_SUBMIT) == 0)
 1339                 mutex_spin_exit(&tty_lock);
 1340         return (canwrite);
 1341 }
 1342 
 1343 static const struct filterops ttyread_filtops =
 1344         { 1, NULL, filt_ttyrdetach, filt_ttyread };
 1345 static const struct filterops ttywrite_filtops =
 1346         { 1, NULL, filt_ttywdetach, filt_ttywrite };
 1347 
 1348 int
 1349 ttykqfilter(dev_t dev, struct knote *kn)
 1350 {
 1351         struct tty      *tp;
 1352         struct klist    *klist;
 1353 
 1354         if ((tp = cdev_tty(dev)) == NULL)
 1355                 return (ENXIO);
 1356 
 1357         switch (kn->kn_filter) {
 1358         case EVFILT_READ:
 1359                 klist = &tp->t_rsel.sel_klist;
 1360                 kn->kn_fop = &ttyread_filtops;
 1361                 break;
 1362         case EVFILT_WRITE:
 1363                 klist = &tp->t_wsel.sel_klist;
 1364                 kn->kn_fop = &ttywrite_filtops;
 1365                 break;
 1366         default:
 1367                 return EINVAL;
 1368         }
 1369 
 1370         kn->kn_hook = tp;
 1371 
 1372         mutex_spin_enter(&tty_lock);
 1373         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 1374         mutex_spin_exit(&tty_lock);
 1375 
 1376         return (0);
 1377 }
 1378 
 1379 /*
 1380  * Find the number of chars ready to be read from this tty.
 1381  * Call with the tty lock held.
 1382  */
 1383 static int
 1384 ttnread(struct tty *tp)
 1385 {
 1386         int     nread;
 1387 
 1388         KASSERT(mutex_owned(&tty_lock));
 1389 
 1390         if (ISSET(tp->t_lflag, PENDIN))
 1391                 ttypend(tp);
 1392         nread = tp->t_canq.c_cc;
 1393         if (!ISSET(tp->t_lflag, ICANON)) {
 1394                 nread += tp->t_rawq.c_cc;
 1395                 if (nread < tp->t_cc[VMIN] && !tp->t_cc[VTIME])
 1396                         nread = 0;
 1397         }
 1398         return (nread);
 1399 }
 1400 
 1401 /*
 1402  * Wait for output to drain.
 1403  */
 1404 int
 1405 ttywait(struct tty *tp)
 1406 {
 1407         int     error;
 1408 
 1409         error = 0;
 1410 
 1411         mutex_spin_enter(&tty_lock);
 1412         while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
 1413             CONNECTED(tp) && tp->t_oproc) {
 1414                 (*tp->t_oproc)(tp);
 1415                 error = ttysleep(tp, &tp->t_outcv, true, 0);
 1416                 if (error)
 1417                         break;
 1418         }
 1419         mutex_spin_exit(&tty_lock);
 1420 
 1421         return (error);
 1422 }
 1423 
 1424 /*
 1425  * Flush if successfully wait.
 1426  */
 1427 int
 1428 ttywflush(struct tty *tp)
 1429 {
 1430         int     error;
 1431 
 1432         if ((error = ttywait(tp)) == 0) {
 1433                 mutex_spin_enter(&tty_lock);
 1434                 ttyflush(tp, FREAD);
 1435                 mutex_spin_exit(&tty_lock);
 1436         }
 1437         return (error);
 1438 }
 1439 
 1440 /*
 1441  * Flush tty read and/or write queues, notifying anyone waiting.
 1442  * Call with the tty lock held.
 1443  */
 1444 void
 1445 ttyflush(struct tty *tp, int rw)
 1446 {
 1447 
 1448         KASSERT(mutex_owned(&tty_lock));
 1449 
 1450         if (rw & FREAD) {
 1451                 FLUSHQ(&tp->t_canq);
 1452                 FLUSHQ(&tp->t_rawq);
 1453                 tp->t_rocount = 0;
 1454                 tp->t_rocol = 0;
 1455                 CLR(tp->t_state, TS_LOCAL);
 1456                 ttwakeup(tp);
 1457         }
 1458         if (rw & FWRITE) {
 1459                 CLR(tp->t_state, TS_TTSTOP);
 1460                 cdev_stop(tp, rw);
 1461                 FLUSHQ(&tp->t_outq);
 1462                 cv_broadcast(&tp->t_outcv);
 1463                 selnotify(&tp->t_wsel, 0, NOTE_SUBMIT);
 1464         }
 1465 }
 1466 
 1467 /*
 1468  * Copy in the default termios characters.
 1469  */
 1470 void
 1471 ttychars(struct tty *tp)
 1472 {
 1473 
 1474         memcpy(tp->t_cc, ttydefchars, sizeof(ttydefchars));
 1475 }
 1476 
 1477 /*
 1478  * Send stop character on input overflow.
 1479  * Call with the tty lock held.
 1480  */
 1481 static void
 1482 ttyblock(struct tty *tp)
 1483 {
 1484         int     total;
 1485 
 1486         KASSERT(mutex_owned(&tty_lock));
 1487 
 1488         total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
 1489         if (tp->t_rawq.c_cc > TTYHOG) {
 1490                 ttyflush(tp, FREAD | FWRITE);
 1491                 CLR(tp->t_state, TS_TBLOCK);
 1492         }
 1493         /*
 1494          * Block further input iff: current input > threshold
 1495          * AND input is available to user program.
 1496          */
 1497         if (total >= TTYHOG / 2 &&
 1498             !ISSET(tp->t_state, TS_TBLOCK) &&
 1499             (!ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0)) {
 1500                 if (ISSET(tp->t_iflag, IXOFF) &&
 1501                     tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
 1502                     putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
 1503                         SET(tp->t_state, TS_TBLOCK);
 1504                         ttstart(tp);
 1505                 }
 1506                 /* Try to block remote output via hardware flow control. */
 1507                 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
 1508                     (*tp->t_hwiflow)(tp, 1) != 0)
 1509                         SET(tp->t_state, TS_TBLOCK);
 1510         }
 1511 }
 1512 
 1513 /*
 1514  * Delayed line discipline output
 1515  */
 1516 void
 1517 ttrstrt(void *tp_arg)
 1518 {
 1519         struct tty      *tp;
 1520 
 1521 #ifdef DIAGNOSTIC
 1522         if (tp_arg == NULL)
 1523                 panic("ttrstrt");
 1524 #endif
 1525         tp = tp_arg;
 1526         mutex_spin_enter(&tty_lock);
 1527 
 1528         CLR(tp->t_state, TS_TIMEOUT);
 1529         ttstart(tp); /* XXX - Shouldn't this be tp->l_start(tp)? */
 1530 
 1531         mutex_spin_exit(&tty_lock);
 1532 }
 1533 
 1534 /*
 1535  * start a line discipline
 1536  * Always call with tty lock held?
 1537  */
 1538 int
 1539 ttstart(struct tty *tp)
 1540 {
 1541 
 1542         if (tp->t_oproc != NULL)        /* XXX: Kludge for pty. */
 1543                 (*tp->t_oproc)(tp);
 1544         return (0);
 1545 }
 1546 
 1547 /*
 1548  * "close" a line discipline
 1549  */
 1550 int
 1551 ttylclose(struct tty *tp, int flag)
 1552 {
 1553 
 1554         if (flag & FNONBLOCK) {
 1555                 mutex_spin_enter(&tty_lock);
 1556                 ttyflush(tp, FREAD | FWRITE);
 1557                 mutex_spin_exit(&tty_lock);
 1558         } else
 1559                 ttywflush(tp);
 1560         return (0);
 1561 }
 1562 
 1563 /*
 1564  * Handle modem control transition on a tty.
 1565  * Flag indicates new state of carrier.
 1566  * Returns 0 if the line should be turned off, otherwise 1.
 1567  */
 1568 int
 1569 ttymodem(struct tty *tp, int flag)
 1570 {
 1571 
 1572         mutex_spin_enter(&tty_lock);
 1573         if (flag == 0) {
 1574                 if (ISSET(tp->t_state, TS_CARR_ON)) {
 1575                         /*
 1576                          * Lost carrier.
 1577                          */
 1578                         CLR(tp->t_state, TS_CARR_ON);
 1579                         if (ISSET(tp->t_state, TS_ISOPEN) && !CONNECTED(tp)) {
 1580                                 ttysig(tp, TTYSIG_LEADER, SIGHUP);
 1581                                 ttyflush(tp, FREAD | FWRITE);
 1582                                 mutex_spin_exit(&tty_lock);
 1583                                 return (0);
 1584                         }
 1585                 }
 1586         } else {
 1587                 if (!ISSET(tp->t_state, TS_CARR_ON)) {
 1588                         /*
 1589                          * Carrier now on.
 1590                          */
 1591                         SET(tp->t_state, TS_CARR_ON);
 1592                         ttwakeup(tp);
 1593                 }
 1594         }
 1595         mutex_spin_exit(&tty_lock);
 1596 
 1597         return (1);
 1598 }
 1599 
 1600 /*
 1601  * Default modem control routine (for other line disciplines).
 1602  * Return argument flag, to turn off device on carrier drop.
 1603  */
 1604 int
 1605 nullmodem(struct tty *tp, int flag)
 1606 {
 1607 
 1608         mutex_spin_enter(&tty_lock);
 1609         if (flag)
 1610                 SET(tp->t_state, TS_CARR_ON);
 1611         else {
 1612                 CLR(tp->t_state, TS_CARR_ON);
 1613                 if (!CONNECTED(tp)) {
 1614                         ttysig(tp, TTYSIG_LEADER, SIGHUP);
 1615                         mutex_spin_exit(&tty_lock);
 1616                         return (0);
 1617                 }
 1618         }
 1619         mutex_spin_exit(&tty_lock);
 1620 
 1621         return (1);
 1622 }
 1623 
 1624 /*
 1625  * Reinput pending characters after state switch.
 1626  */
 1627 void
 1628 ttypend(struct tty *tp)
 1629 {
 1630         struct clist    tq;
 1631         int             c;
 1632 
 1633         KASSERT(mutex_owned(&tty_lock));
 1634 
 1635         CLR(tp->t_lflag, PENDIN);
 1636         SET(tp->t_state, TS_TYPEN);
 1637         tq = tp->t_rawq;
 1638         tp->t_rawq.c_cc = 0;
 1639         tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
 1640         while ((c = getc(&tq)) >= 0)
 1641                 ttyinput_wlock(c, tp);
 1642         CLR(tp->t_state, TS_TYPEN);
 1643 }
 1644 
 1645 /*
 1646  * Process a read call on a tty device.
 1647  */
 1648 int
 1649 ttread(struct tty *tp, struct uio *uio, int flag)
 1650 {
 1651         struct clist    *qp;
 1652         u_char          *cc;
 1653         struct proc     *p;
 1654         int             c, first, error, has_stime, last_cc;
 1655         long            lflag, slp;
 1656         struct timeval  now, stime;
 1657 
 1658         if (uio->uio_resid == 0)
 1659                 return 0;
 1660 
 1661         stime.tv_usec = 0;      /* XXX gcc */
 1662         stime.tv_sec = 0;       /* XXX gcc */
 1663 
 1664         cc = tp->t_cc;
 1665         p = curproc;
 1666         error = 0;
 1667         has_stime = 0;
 1668         last_cc = 0;
 1669         slp = 0;
 1670 
 1671  loop:
 1672         mutex_spin_enter(&tty_lock);
 1673         lflag = tp->t_lflag;
 1674         /*
 1675          * take pending input first
 1676          */
 1677         if (ISSET(lflag, PENDIN))
 1678                 ttypend(tp);
 1679 
 1680         /*
 1681          * Hang process if it's in the background.
 1682          */
 1683         if (isbackground(p, tp)) {
 1684                 if (sigismasked(curlwp, SIGTTIN) ||
 1685                     p->p_lflag & PL_PPWAIT || p->p_pgrp->pg_jobc == 0) {
 1686                         mutex_spin_exit(&tty_lock);
 1687                         return (EIO);
 1688                 }
 1689                 mutex_spin_exit(&tty_lock);
 1690 
 1691                 mutex_enter(proc_lock);
 1692                 pgsignal(p->p_pgrp, SIGTTIN, 1);
 1693                 mutex_exit(proc_lock);
 1694 
 1695                 mutex_spin_enter(&tty_lock);
 1696                 error = ttysleep(tp, &lbolt, true, 0);
 1697                 mutex_spin_exit(&tty_lock);
 1698                 if (error)
 1699                         return (error);
 1700                 goto loop;
 1701         }
 1702 
 1703         if (!ISSET(lflag, ICANON)) {
 1704                 int m = cc[VMIN];
 1705                 long t = cc[VTIME];
 1706 
 1707                 qp = &tp->t_rawq;
 1708                 /*
 1709                  * Check each of the four combinations.
 1710                  * (m > 0 && t == 0) is the normal read case.
 1711                  * It should be fairly efficient, so we check that and its
 1712                  * companion case (m == 0 && t == 0) first.
 1713                  * For the other two cases, we compute the target sleep time
 1714                  * into slp.
 1715                  */
 1716                 if (t == 0) {
 1717                         if (qp->c_cc < m)
 1718                                 goto sleep;
 1719                         goto read;
 1720                 }
 1721                 t *= hz;                /* time in deca-ticks */
 1722 /*
 1723  * Time difference in deca-ticks, split division to avoid numeric overflow.
 1724  * Ok for hz < ~200kHz
 1725  */
 1726 #define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 10 * hz + \
 1727                          ((t1).tv_usec - (t2).tv_usec) / 100 * hz / 1000)
 1728                 if (m > 0) {
 1729                         if (qp->c_cc <= 0)
 1730                                 goto sleep;
 1731                         if (qp->c_cc >= m)
 1732                                 goto read;
 1733                         if (!has_stime) {
 1734                                 /* first character, start timer */
 1735                                 has_stime = 1;
 1736                                 getmicrotime(&stime);
 1737                                 slp = t;
 1738                         } else if (qp->c_cc > last_cc) {
 1739                                 /* got a character, restart timer */
 1740                                 getmicrotime(&stime);
 1741                                 slp = t;
 1742                         } else {
 1743                                 /* nothing, check expiration */
 1744                                 getmicrotime(&now);
 1745                                 slp = t - diff(now, stime);
 1746                         }
 1747                 } else {        /* m == 0 */
 1748                         if (qp->c_cc > 0)
 1749                                 goto read;
 1750                         if (!has_stime) {
 1751                                 has_stime = 1;
 1752                                 getmicrotime(&stime);
 1753                                 slp = t;
 1754                         } else {
 1755                                 getmicrotime(&now);
 1756                                 slp = t - diff(now, stime);
 1757                         }
 1758                 }
 1759                 last_cc = qp->c_cc;
 1760 #undef diff
 1761                 if (slp > 0) {
 1762                         /*
 1763                          * Convert deca-ticks back to ticks.
 1764                          * Rounding down may make us wake up just short
 1765                          * of the target, so we round up.
 1766                          * Maybe we should do 'slp/10 + 1' because the
 1767                          * first tick maybe almost immediate.
 1768                          * However it is more useful for a program that sets
 1769                          * VTIME=10 to wakeup every second not every 1.01
 1770                          * seconds (if hz=100).
 1771                          */
 1772                         slp = (slp + 9)/ 10;
 1773                         goto sleep;
 1774                 }
 1775         } else if ((qp = &tp->t_canq)->c_cc <= 0) {
 1776                 int     carrier;
 1777 
 1778  sleep:
 1779                 /*
 1780                  * If there is no input, sleep on rawq
 1781                  * awaiting hardware receipt and notification.
 1782                  * If we have data, we don't need to check for carrier.
 1783                  */
 1784                 carrier = CONNECTED(tp);
 1785                 if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
 1786                         mutex_spin_exit(&tty_lock);
 1787                         return (0);     /* EOF */
 1788                 }
 1789                 if (flag & IO_NDELAY) {
 1790                         mutex_spin_exit(&tty_lock);
 1791                         return (EWOULDBLOCK);
 1792                 }
 1793                 error = ttysleep(tp, &tp->t_rawcv, true, slp);
 1794                 mutex_spin_exit(&tty_lock);
 1795                 /* VMIN == 0: any quantity read satisfies */
 1796                 if (cc[VMIN] == 0 && error == EWOULDBLOCK)
 1797                         return (0);
 1798                 if (error && error != EWOULDBLOCK)
 1799                         return (error);
 1800                 goto loop;
 1801         }
 1802  read:
 1803         mutex_spin_exit(&tty_lock);
 1804 
 1805         /*
 1806          * Input present, check for input mapping and processing.
 1807          */
 1808         first = 1;
 1809         while ((c = getc(qp)) >= 0) {
 1810                 /*
 1811                  * delayed suspend (^Y)
 1812                  */
 1813                 if (CCEQ(cc[VDSUSP], c) &&
 1814                     ISSET(lflag, IEXTEN|ISIG) == (IEXTEN|ISIG)) {
 1815                         mutex_spin_enter(&tty_lock);
 1816                         ttysig(tp, TTYSIG_PG1, SIGTSTP);
 1817                         if (first) {
 1818                                 error = ttysleep(tp, &lbolt, true, 0);
 1819                                 mutex_spin_exit(&tty_lock);
 1820                                 if (error)
 1821                                         break;
 1822                                 goto loop;
 1823                         } else
 1824                                 mutex_spin_exit(&tty_lock);
 1825                         break;
 1826                 }
 1827                 /*
 1828                  * Interpret EOF only in canonical mode.
 1829                  */
 1830                 if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
 1831                         break;
 1832                 /*
 1833                  * Give user character.
 1834                  */
 1835                 error = ureadc(c, uio);
 1836                 if (error)
 1837                         break;
 1838                 if (uio->uio_resid == 0)
 1839                         break;
 1840                 /*
 1841                  * In canonical mode check for a "break character"
 1842                  * marking the end of a "line of input".
 1843                  */
 1844                 if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
 1845                         break;
 1846                 first = 0;
 1847         }
 1848         /*
 1849          * Look to unblock output now that (presumably)
 1850          * the input queue has gone down.
 1851          */
 1852         mutex_spin_enter(&tty_lock);
 1853         if (ISSET(tp->t_state, TS_TBLOCK) && tp->t_rawq.c_cc < TTYHOG / 5) {
 1854                 if (ISSET(tp->t_iflag, IXOFF) &&
 1855                     cc[VSTART] != _POSIX_VDISABLE &&
 1856                     putc(cc[VSTART], &tp->t_outq) == 0) {
 1857                         CLR(tp->t_state, TS_TBLOCK);
 1858                         ttstart(tp);
 1859                 }
 1860                 /* Try to unblock remote output via hardware flow control. */
 1861                 if (ISSET(tp->t_cflag, CHWFLOW) && tp->t_hwiflow &&
 1862                     (*tp->t_hwiflow)(tp, 0) != 0)
 1863                         CLR(tp->t_state, TS_TBLOCK);
 1864         }
 1865         mutex_spin_exit(&tty_lock);
 1866 
 1867         return (error);
 1868 }
 1869 
 1870 /*
 1871  * Check the output queue on tp for space for a kernel message (from uprintf
 1872  * or tprintf).  Allow some space over the normal hiwater mark so we don't
 1873  * lose messages due to normal flow control, but don't let the tty run amok.
 1874  * Sleeps here are not interruptible, but we return prematurely if new signals
 1875  * arrive.
 1876  * Call with tty lock held.
 1877  */
 1878 static int
 1879 ttycheckoutq_wlock(struct tty *tp, int wait)
 1880 {
 1881         int     hiwat, error;
 1882 
 1883         KASSERT(mutex_owned(&tty_lock));
 1884 
 1885         hiwat = tp->t_hiwat;
 1886         if (tp->t_outq.c_cc > hiwat + 200)
 1887                 while (tp->t_outq.c_cc > hiwat) {
 1888                         ttstart(tp);
 1889                         if (wait == 0)
 1890                                 return (0);
 1891                         error = ttysleep(tp, &tp->t_outcv, true, hz);
 1892                         if (error == EINTR)
 1893                                 wait = 0;
 1894                 }
 1895 
 1896         return (1);
 1897 }
 1898 
 1899 int
 1900 ttycheckoutq(struct tty *tp, int wait)
 1901 {
 1902         int     r;
 1903 
 1904         mutex_spin_enter(&tty_lock);
 1905         r = ttycheckoutq_wlock(tp, wait);
 1906         mutex_spin_exit(&tty_lock);
 1907 
 1908         return (r);
 1909 }
 1910 
 1911 /*
 1912  * Process a write call on a tty device.
 1913  */
 1914 int
 1915 ttwrite(struct tty *tp, struct uio *uio, int flag)
 1916 {
 1917         u_char          *cp;
 1918         struct proc     *p;
 1919         int             cc, ce, i, hiwat, error;
 1920         u_char          obuf[OBUFSIZ];
 1921 
 1922         cp = NULL;
 1923         hiwat = tp->t_hiwat;
 1924         error = 0;
 1925         cc = 0;
 1926  loop:
 1927         mutex_spin_enter(&tty_lock);
 1928         if (!CONNECTED(tp)) {
 1929                 if (ISSET(tp->t_state, TS_ISOPEN)) {
 1930                         mutex_spin_exit(&tty_lock);
 1931                         return (EIO);
 1932                 } else if (flag & IO_NDELAY) {
 1933                         mutex_spin_exit(&tty_lock);
 1934                         error = EWOULDBLOCK;
 1935                         goto out;
 1936                 } else {
 1937                         /* Sleep awaiting carrier. */
 1938                         error = ttysleep(tp, &tp->t_rawcv, true, 0);
 1939                         mutex_spin_exit(&tty_lock);
 1940                         if (error)
 1941                                 goto out;
 1942                         goto loop;
 1943                 }
 1944         }
 1945 
 1946         /*
 1947          * Hang the process if it's in the background.
 1948          */
 1949         p = curproc;
 1950         if (isbackground(p, tp) &&
 1951             ISSET(tp->t_lflag, TOSTOP) && (p->p_lflag & PL_PPWAIT) == 0 &&
 1952             !sigismasked(curlwp, SIGTTOU)) {
 1953                 if (p->p_pgrp->pg_jobc == 0) {
 1954                         error = EIO;
 1955                         mutex_spin_exit(&tty_lock);
 1956                         goto out;
 1957                 }
 1958                 mutex_spin_exit(&tty_lock);
 1959 
 1960                 mutex_enter(proc_lock);
 1961                 pgsignal(p->p_pgrp, SIGTTOU, 1);
 1962                 mutex_exit(proc_lock);
 1963 
 1964                 mutex_spin_enter(&tty_lock);
 1965                 error = ttysleep(tp, &lbolt, true, 0);
 1966                 mutex_spin_exit(&tty_lock);
 1967                 if (error)
 1968                         goto out;
 1969                 goto loop;
 1970         }
 1971         mutex_spin_exit(&tty_lock);
 1972 
 1973         /*
 1974          * Process the user's data in at most OBUFSIZ chunks.  Perform any
 1975          * output translation.  Keep track of high water mark, sleep on
 1976          * overflow awaiting device aid in acquiring new space.
 1977          */
 1978         while (uio->uio_resid > 0 || cc > 0) {
 1979                 if (ISSET(tp->t_lflag, FLUSHO)) {
 1980                         uio->uio_resid = 0;
 1981                         return (0);
 1982                 }
 1983                 if (tp->t_outq.c_cc > hiwat)
 1984                         goto ovhiwat;
 1985                 /*
 1986                  * Grab a hunk of data from the user, unless we have some
 1987                  * leftover from last time.
 1988                  */
 1989                 if (cc == 0) {
 1990                         cc = min(uio->uio_resid, OBUFSIZ);
 1991                         cp = obuf;
 1992                         error = uiomove(cp, cc, uio);
 1993                         if (error) {
 1994                                 cc = 0;
 1995                                 goto out;
 1996                         }
 1997                 }
 1998                 /*
 1999                  * If nothing fancy need be done, grab those characters we
 2000                  * can handle without any of ttyoutput's processing and
 2001                  * just transfer them to the output q.  For those chars
 2002                  * which require special processing (as indicated by the
 2003                  * bits in char_type), call ttyoutput.  After processing
 2004                  * a hunk of data, look for FLUSHO so ^O's will take effect
 2005                  * immediately.
 2006                  */
 2007                 mutex_spin_enter(&tty_lock);
 2008                 while (cc > 0) {
 2009                         if (!ISSET(tp->t_oflag, OPOST))
 2010                                 ce = cc;
 2011                         else {
 2012                                 ce = cc - scanc((u_int)cc, cp, char_type,
 2013                                     CCLASSMASK);
 2014                                 /*
 2015                                  * If ce is zero, then we're processing
 2016                                  * a special character through ttyoutput.
 2017                                  */
 2018                                 if (ce == 0) {
 2019                                         tp->t_rocount = 0;
 2020                                         if (ttyoutput(*cp, tp) >= 0) {
 2021                                                 /* out of space */
 2022                                                 mutex_spin_exit(&tty_lock);
 2023                                                 goto overfull;
 2024                                         }
 2025                                         cp++;
 2026                                         cc--;
 2027                                         if (ISSET(tp->t_lflag, FLUSHO) ||
 2028                                             tp->t_outq.c_cc > hiwat) {
 2029                                                 mutex_spin_exit(&tty_lock);
 2030                                                 goto ovhiwat;
 2031                                         }
 2032                                         continue;
 2033                                 }
 2034                         }
 2035                         /*
 2036                          * A bunch of normal characters have been found.
 2037                          * Transfer them en masse to the output queue and
 2038                          * continue processing at the top of the loop.
 2039                          * If there are any further characters in this
 2040                          * <= OBUFSIZ chunk, the first should be a character
 2041                          * requiring special handling by ttyoutput.
 2042                          */
 2043                         tp->t_rocount = 0;
 2044                         i = b_to_q(cp, ce, &tp->t_outq);
 2045                         ce -= i;
 2046                         tp->t_column += ce;
 2047                         cp += ce, cc -= ce, tk_nout += ce;
 2048                         tp->t_outcc += ce;
 2049                         if (i > 0) {
 2050                                 /* out of space */
 2051                                 mutex_spin_exit(&tty_lock);
 2052                                 goto overfull;
 2053                         }
 2054                         if (ISSET(tp->t_lflag, FLUSHO) ||
 2055                             tp->t_outq.c_cc > hiwat)
 2056                                 break;
 2057                 }
 2058                 ttstart(tp);
 2059                 mutex_spin_exit(&tty_lock);
 2060         }
 2061 
 2062  out:
 2063         /*
 2064          * If cc is nonzero, we leave the uio structure inconsistent, as the
 2065          * offset and iov pointers have moved forward, but it doesn't matter
 2066          * (the call will either return short or restart with a new uio).
 2067          */
 2068         uio->uio_resid += cc;
 2069         return (error);
 2070 
 2071  overfull:
 2072         /*
 2073          * Since we are using ring buffers, if we can't insert any more into
 2074          * the output queue, we can assume the ring is full and that someone
 2075          * forgot to set the high water mark correctly.  We set it and then
 2076          * proceed as normal.
 2077          */
 2078         hiwat = tp->t_outq.c_cc - 1;
 2079 
 2080  ovhiwat:
 2081         mutex_spin_enter(&tty_lock);
 2082         ttstart(tp);
 2083         /*
 2084          * This can only occur if FLUSHO is set in t_lflag,
 2085          * or if ttstart/oproc is synchronous (or very fast).
 2086          */
 2087         if (tp->t_outq.c_cc <= hiwat) {
 2088                 mutex_spin_exit(&tty_lock);
 2089                 goto loop;
 2090         }
 2091         if (flag & IO_NDELAY) {
 2092                 mutex_spin_exit(&tty_lock);
 2093                 error = EWOULDBLOCK;
 2094                 goto out;
 2095         }
 2096         error = ttysleep(tp, &tp->t_outcv, true, 0);
 2097         mutex_spin_exit(&tty_lock);
 2098         if (error)
 2099                 goto out;
 2100         goto loop;
 2101 }
 2102 
 2103 /*
 2104  * Try to pull more output from the producer.  Return non-zero if
 2105  * there is output ready to be sent.
 2106  */
 2107 bool
 2108 ttypull(struct tty *tp)
 2109 {
 2110 
 2111         /* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */
 2112 
 2113         if (tp->t_outq.c_cc <= tp->t_lowat) {
 2114                 cv_broadcast(&tp->t_outcv);
 2115                 selnotify(&tp->t_wsel, 0, NOTE_SUBMIT);
 2116         }
 2117         return tp->t_outq.c_cc != 0;
 2118 }
 2119 
 2120 /*
 2121  * Rubout one character from the rawq of tp
 2122  * as cleanly as possible.
 2123  * Called with tty lock held.
 2124  */
 2125 void
 2126 ttyrub(int c, struct tty *tp)
 2127 {
 2128         u_char  *cp;
 2129         int     savecol, tabc;
 2130 
 2131         KASSERT(mutex_owned(&tty_lock));
 2132 
 2133         if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
 2134                 return;
 2135         CLR(tp->t_lflag, FLUSHO);
 2136         if (ISSET(tp->t_lflag, ECHOE)) {
 2137                 if (tp->t_rocount == 0) {
 2138                         /*
 2139                          * Screwed by ttwrite; retype
 2140                          */
 2141                         ttyretype(tp);
 2142                         return;
 2143                 }
 2144                 if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
 2145                         ttyrubo(tp, 2);
 2146                 else {
 2147                         CLR(c, ~TTY_CHARMASK);
 2148                         switch (CCLASS(c)) {
 2149                         case ORDINARY:
 2150                                 ttyrubo(tp, 1);
 2151                                 break;
 2152                         case BACKSPACE:
 2153                         case CONTROL:
 2154                         case NEWLINE:
 2155                         case RETURN:
 2156                         case VTAB:
 2157                                 if (ISSET(tp->t_lflag, ECHOCTL))
 2158                                         ttyrubo(tp, 2);
 2159                                 break;
 2160                         case TAB:
 2161                                 if (tp->t_rocount < tp->t_rawq.c_cc) {
 2162                                         ttyretype(tp);
 2163                                         return;
 2164                                 }
 2165                                 savecol = tp->t_column;
 2166                                 SET(tp->t_state, TS_CNTTB);
 2167                                 SET(tp->t_lflag, FLUSHO);
 2168                                 tp->t_column = tp->t_rocol;
 2169                                 for (cp = firstc(&tp->t_rawq, &tabc); cp;
 2170                                     cp = nextc(&tp->t_rawq, cp, &tabc))
 2171                                         ttyecho(tabc, tp);
 2172                                 CLR(tp->t_lflag, FLUSHO);
 2173                                 CLR(tp->t_state, TS_CNTTB);
 2174 
 2175                                 /* savecol will now be length of the tab. */
 2176                                 savecol -= tp->t_column;
 2177                                 tp->t_column += savecol;
 2178                                 if (savecol > 8)
 2179                                         savecol = 8;    /* overflow screw */
 2180                                 while (--savecol >= 0)
 2181                                         (void)ttyoutput('\b', tp);
 2182                                 break;
 2183                         default:                        /* XXX */
 2184                                 (void)printf("ttyrub: would panic c = %d, "
 2185                                     "val = %d\n", c, CCLASS(c));
 2186                         }
 2187                 }
 2188         } else if (ISSET(tp->t_lflag, ECHOPRT)) {
 2189                 if (!ISSET(tp->t_state, TS_ERASE)) {
 2190                         SET(tp->t_state, TS_ERASE);
 2191                         (void)ttyoutput('\\', tp);
 2192                 }
 2193                 ttyecho(c, tp);
 2194         } else
 2195                 ttyecho(tp->t_cc[VERASE], tp);
 2196         --tp->t_rocount;
 2197 }
 2198 
 2199 /*
 2200  * Back over cnt characters, erasing them.
 2201  * Called with tty lock held.
 2202  */
 2203 static void
 2204 ttyrubo(struct tty *tp, int cnt)
 2205 {
 2206 
 2207         KASSERT(mutex_owned(&tty_lock));
 2208 
 2209         while (cnt-- > 0) {
 2210                 (void)ttyoutput('\b', tp);
 2211                 (void)ttyoutput(' ', tp);
 2212                 (void)ttyoutput('\b', tp);
 2213         }
 2214 }
 2215 
 2216 /*
 2217  * ttyretype --
 2218  *      Reprint the rawq line.  Note, it is assumed that c_cc has already
 2219  *      been checked.
 2220  *
 2221  * Called with tty lock held.
 2222  */
 2223 void
 2224 ttyretype(struct tty *tp)
 2225 {
 2226         u_char  *cp;
 2227         int     c;
 2228 
 2229         KASSERT(mutex_owned(&tty_lock));
 2230 
 2231         /* Echo the reprint character. */
 2232         if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
 2233                 ttyecho(tp->t_cc[VREPRINT], tp);
 2234 
 2235         (void)ttyoutput('\n', tp);
 2236 
 2237         for (cp = firstc(&tp->t_canq, &c); cp; cp = nextc(&tp->t_canq, cp, &c))
 2238                 ttyecho(c, tp);
 2239         for (cp = firstc(&tp->t_rawq, &c); cp; cp = nextc(&tp->t_rawq, cp, &c))
 2240                 ttyecho(c, tp);
 2241         CLR(tp->t_state, TS_ERASE);
 2242 
 2243         tp->t_rocount = tp->t_rawq.c_cc;
 2244         tp->t_rocol = 0;
 2245 }
 2246 
 2247 /*
 2248  * Echo a typed character to the terminal.
 2249  * Called with tty lock held.
 2250  */
 2251 static void
 2252 ttyecho(int c, struct tty *tp)
 2253 {
 2254 
 2255         KASSERT(mutex_owned(&tty_lock));
 2256 
 2257         if (!ISSET(tp->t_state, TS_CNTTB))
 2258                 CLR(tp->t_lflag, FLUSHO);
 2259         if ((!ISSET(tp->t_lflag, ECHO) &&
 2260             (!ISSET(tp->t_lflag, ECHONL) || c != '\n')) ||
 2261             ISSET(tp->t_lflag, EXTPROC))
 2262                 return;
 2263         if (((ISSET(tp->t_lflag, ECHOCTL) &&
 2264             (ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n')) ||
 2265             ISSET(c, TTY_CHARMASK) == 0177)) {
 2266                 (void)ttyoutput('^', tp);
 2267                 CLR(c, ~TTY_CHARMASK);
 2268                 if (c == 0177)
 2269                         c = '?';
 2270                 else
 2271                         c += 'A' - 1;
 2272         }
 2273         (void)ttyoutput(c, tp);
 2274 }
 2275 
 2276 /*
 2277  * Wake up any readers on a tty.
 2278  * Called with tty lock held.
 2279  */
 2280 void
 2281 ttwakeup(struct tty *tp)
 2282 {
 2283 
 2284         KASSERT(mutex_owned(&tty_lock));
 2285 
 2286         selnotify(&tp->t_rsel, 0, NOTE_SUBMIT);
 2287         if (ISSET(tp->t_state, TS_ASYNC))
 2288                 ttysig(tp, TTYSIG_PG2, SIGIO);
 2289         cv_broadcast(&tp->t_rawcv);
 2290 }
 2291 
 2292 /*
 2293  * Look up a code for a specified speed in a conversion table;
 2294  * used by drivers to map software speed values to hardware parameters.
 2295  */
 2296 int
 2297 ttspeedtab(int speed, const struct speedtab *table)
 2298 {
 2299 
 2300         for (; table->sp_speed != -1; table++)
 2301                 if (table->sp_speed == speed)
 2302                         return (table->sp_code);
 2303         return (-1);
 2304 }
 2305 
 2306 /*
 2307  * Set tty hi and low water marks.
 2308  *
 2309  * Try to arrange the dynamics so there's about one second
 2310  * from hi to low water.
 2311  */
 2312 void
 2313 ttsetwater(struct tty *tp)
 2314 {
 2315         int     cps, x;
 2316 
 2317         /* XXX not yet KASSERT(mutex_owned(&tty_lock)); */
 2318 
 2319 #define CLAMP(x, h, l)  ((x) > h ? h : ((x) < l) ? l : (x))
 2320 
 2321         cps = tp->t_ospeed / 10;
 2322         tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
 2323         x += cps;
 2324         x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
 2325         tp->t_hiwat = roundup(x, CBSIZE);
 2326 #undef  CLAMP
 2327 }
 2328 
 2329 /*
 2330  * Prepare report on state of foreground process group.
 2331  * Call with proc_lock held.
 2332  */
 2333 void
 2334 ttygetinfo(struct tty *tp, int fromsig, char *buf, size_t bufsz)
 2335 {
 2336         struct lwp      *l;
 2337         struct proc     *p, *pick = NULL;
 2338         struct timeval  utime, stime;
 2339         int             tmp;
 2340         fixpt_t         pctcpu = 0;
 2341         const char      *msg;
 2342         char            lmsg[100];
 2343         long            rss;
 2344 
 2345         KASSERT(mutex_owned(proc_lock));
 2346 
 2347         *buf = '\0';
 2348 
 2349         if (tp->t_session == NULL)
 2350                 msg = "not a controlling terminal\n";
 2351         else if (tp->t_pgrp == NULL)
 2352                 msg = "no foreground process group\n";
 2353         else if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == NULL)
 2354                 msg = "empty foreground process group\n";
 2355         else {
 2356                 /* Pick interesting process. */
 2357                 for (; p != NULL; p = LIST_NEXT(p, p_pglist)) {
 2358                         struct proc *oldpick;
 2359 
 2360                         if (pick == NULL) {
 2361                                 pick = p;
 2362                                 continue;
 2363                         }
 2364                         if (pick->p_lock < p->p_lock) {
 2365                                 mutex_enter(pick->p_lock);
 2366                                 mutex_enter(p->p_lock);
 2367                         } else if (pick->p_lock > p->p_lock) {
 2368                                 mutex_enter(p->p_lock);
 2369                                 mutex_enter(pick->p_lock);
 2370                         } else
 2371                                 mutex_enter(p->p_lock);
 2372                         oldpick = pick;
 2373                         if (proc_compare(pick, p))
 2374                                 pick = p;
 2375                         mutex_exit(p->p_lock);
 2376                         if (p->p_lock != oldpick->p_lock)
 2377                                 mutex_exit(oldpick->p_lock);
 2378                 }
 2379                 if (fromsig &&
 2380                     (SIGACTION_PS(pick->p_sigacts, SIGINFO).sa_flags &
 2381                     SA_NOKERNINFO))
 2382                         return;
 2383                 msg = NULL;
 2384         }
 2385 
 2386         /* Print load average. */
 2387         tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
 2388         snprintf(lmsg, sizeof(lmsg), "load: %d.%02d ", tmp / 100, tmp % 100);
 2389         strlcat(buf, lmsg, bufsz);
 2390 
 2391         if (pick == NULL) {
 2392                 strlcat(buf, msg, bufsz);
 2393                 return;
 2394         }
 2395 
 2396         snprintf(lmsg, sizeof(lmsg), " cmd: %s %d [", pick->p_comm,
 2397             pick->p_pid);
 2398         strlcat(buf, lmsg, bufsz);
 2399 
 2400         mutex_enter(pick->p_lock);
 2401         LIST_FOREACH(l, &pick->p_lwps, l_sibling) {
 2402                 lwp_lock(l);
 2403                 snprintf(lmsg, sizeof(lmsg), "%s%s",
 2404                     l->l_stat == LSONPROC ? "running" :
 2405                     l->l_stat == LSRUN ? "runnable" :
 2406                     l->l_wchan ? l->l_wmesg : "iowait",
 2407                     (LIST_NEXT(l, l_sibling) != NULL) ? " " : "] ");
 2408                 lwp_unlock(l);
 2409                 strlcat(buf, lmsg, bufsz);
 2410                 pctcpu += l->l_pctcpu;
 2411         }
 2412         pctcpu += pick->p_pctcpu;
 2413         calcru(pick, &utime, &stime, NULL, NULL);
 2414         mutex_exit(pick->p_lock);
 2415 
 2416         /* Round up and print user+system time, %CPU and RSS. */
 2417         utime.tv_usec += 5000;
 2418         if (utime.tv_usec >= 1000000) {
 2419                 utime.tv_sec += 1;
 2420                 utime.tv_usec -= 1000000;
 2421         }
 2422         stime.tv_usec += 5000;
 2423         if (stime.tv_usec >= 1000000) {
 2424                 stime.tv_sec += 1;
 2425                 stime.tv_usec -= 1000000;
 2426         }
 2427 #define pgtok(a)        (((u_long) ((a) * PAGE_SIZE) / 1024))
 2428         tmp = (pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
 2429         if (pick->p_stat == SIDL || P_ZOMBIE(pick))
 2430                 rss = 0;
 2431         else
 2432                 rss = pgtok(vm_resident_count(pick->p_vmspace));
 2433 
 2434         snprintf(lmsg, sizeof(lmsg), "%ld.%02ldu %ld.%02lds %d%% %ldk",
 2435             (long)utime.tv_sec, (long)utime.tv_usec / 10000,
 2436             (long)stime.tv_sec, (long)stime.tv_usec / 10000,
 2437             tmp / 100, rss);
 2438         strlcat(buf, lmsg, bufsz);
 2439 }
 2440 
 2441 /*
 2442  * Print report on state of foreground process group.
 2443  * Call with tty_lock held.
 2444  */
 2445 void
 2446 ttyputinfo(struct tty *tp, char *buf)
 2447 {
 2448 
 2449         KASSERT(mutex_owned(&tty_lock));
 2450 
 2451         if (ttycheckoutq_wlock(tp, 0) == 0)
 2452                 return;
 2453         ttyprintf_nolock(tp, "%s\n", buf);
 2454         tp->t_rocount = 0;      /* so pending input will be retyped if BS */
 2455 }
 2456 
 2457 /*
 2458  * Returns 1 if p2 is "better" than p1
 2459  *
 2460  * The algorithm for picking the "interesting" process is thus:
 2461  *
 2462  *      1) Only foreground processes are eligible - implied.
 2463  *      2) Runnable processes are favored over anything else.  The runner
 2464  *         with the highest CPU utilization is picked (l_pctcpu).  Ties are
 2465  *         broken by picking the highest pid.
 2466  *      3) The sleeper with the shortest sleep time is next.  With ties,
 2467  *         we pick out just "short-term" sleepers (P_SINTR == 0).
 2468  *      4) Further ties are broken by picking the highest pid.
 2469  */
 2470 #define ISRUN(p)        ((p)->p_nrlwps > 0)
 2471 #define TESTAB(a, b)    ((a)<<1 | (b))
 2472 #define ONLYA   2
 2473 #define ONLYB   1
 2474 #define BOTH    3
 2475 
 2476 static int
 2477 proc_compare(struct proc *p1, struct proc *p2)
 2478 {
 2479         lwp_t *l1, *l2;
 2480 
 2481         KASSERT(mutex_owned(p1->p_lock));
 2482         KASSERT(mutex_owned(p2->p_lock));
 2483 
 2484         if ((l1 = LIST_FIRST(&p1->p_lwps)) == NULL)
 2485                 return (1);
 2486         if ((l2 = LIST_FIRST(&p2->p_lwps)) == NULL)
 2487                 return (0);
 2488         /*
 2489          * see if at least one of them is runnable
 2490          */
 2491         switch (TESTAB(ISRUN(p1), ISRUN(p2))) {
 2492         case ONLYA:
 2493                 return (0);
 2494         case ONLYB:
 2495                 return (1);
 2496         case BOTH:
 2497                 /*
 2498                  * tie - favor one with highest recent CPU utilization
 2499                  */
 2500                 if (l2->l_pctcpu > l1->l_pctcpu)
 2501                         return (1);
 2502                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
 2503         }
 2504         /*
 2505          * weed out zombies
 2506          */
 2507         switch (TESTAB(P_ZOMBIE(p1), P_ZOMBIE(p2))) {
 2508         case ONLYA:
 2509                 return (1);
 2510         case ONLYB:
 2511                 return (0);
 2512         case BOTH:
 2513                 return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
 2514         }
 2515         /*
 2516          * pick the one with the smallest sleep time
 2517          */
 2518         if (l2->l_slptime > l2->l_slptime)
 2519                 return (0);
 2520         if (l2->l_slptime > l2->l_slptime)
 2521                 return (1);
 2522         /*
 2523          * favor one sleeping in a non-interruptible sleep
 2524          */
 2525         if (l2->l_flag & LW_SINTR && (l2->l_flag & LW_SINTR) == 0)
 2526                 return (1);
 2527         if (l2->l_flag & LW_SINTR && (l2->l_flag & LW_SINTR) == 0)
 2528                 return (0);
 2529         return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
 2530 }
 2531 
 2532 /*
 2533  * Output char to tty; console putchar style.
 2534  * Can be called with tty lock held through kprintf() machinery..
 2535  */
 2536 int
 2537 tputchar(int c, int flags, struct tty *tp)
 2538 {
 2539         int r = 0;
 2540 
 2541         if ((flags & NOLOCK) == 0)
 2542                 mutex_spin_enter(&tty_lock);
 2543         if (!CONNECTED(tp)) {
 2544                 r = -1;
 2545                 goto out;
 2546         }
 2547         if (c == '\n')
 2548                 (void)ttyoutput('\r', tp);
 2549         (void)ttyoutput(c, tp);
 2550         ttstart(tp);
 2551 out:
 2552         if ((flags & NOLOCK) == 0)
 2553                 mutex_spin_exit(&tty_lock);
 2554         return (r);
 2555 }
 2556 
 2557 /*
 2558  * Sleep on chan, returning ERESTART if tty changed while we napped and
 2559  * returning any errors (e.g. EINTR/ETIMEDOUT) reported by tsleep.  If
 2560  * the tty is revoked, restarting a pending call will redo validation done
 2561  * at the start of the call.
 2562  *
 2563  * Must be called with the tty lock held.
 2564  */
 2565 int
 2566 ttysleep(struct tty *tp, kcondvar_t *cv, bool catch, int timo)
 2567 {
 2568         int     error;
 2569         short   gen;
 2570 
 2571         KASSERT(mutex_owned(&tty_lock));
 2572 
 2573         gen = tp->t_gen;
 2574         if (catch)
 2575                 error = cv_timedwait_sig(cv, &tty_lock, timo);
 2576         else
 2577                 error = cv_timedwait(cv, &tty_lock, timo);
 2578         if (error != 0)
 2579                 return (error);
 2580         return (tp->t_gen == gen ? 0 : ERESTART);
 2581 }
 2582 
 2583 /*
 2584  * Attach a tty to the tty list.
 2585  *
 2586  * This should be called ONLY once per real tty (including pty's).
 2587  * eg, on the sparc, the keyboard and mouse have struct tty's that are
 2588  * distinctly NOT usable as tty's, and thus should not be attached to
 2589  * the ttylist.  This is why this call is not done from ttymalloc().
 2590  *
 2591  * Device drivers should attach tty's at a similar time that they are
 2592  * ttymalloc()'ed, or, for the case of statically allocated struct tty's
 2593  * either in the attach or (first) open routine.
 2594  */
 2595 void
 2596 tty_attach(struct tty *tp)
 2597 {
 2598 
 2599         mutex_spin_enter(&tty_lock);
 2600         TAILQ_INSERT_TAIL(&ttylist, tp, tty_link);
 2601         ++tty_count;
 2602         mutex_spin_exit(&tty_lock);
 2603 }
 2604 
 2605 /*
 2606  * Remove a tty from the tty list.
 2607  */
 2608 void
 2609 tty_detach(struct tty *tp)
 2610 {
 2611 
 2612         mutex_spin_enter(&tty_lock);
 2613         --tty_count;
 2614 #ifdef DIAGNOSTIC
 2615         if (tty_count < 0)
 2616                 panic("tty_detach: tty_count < 0");
 2617 #endif
 2618         TAILQ_REMOVE(&ttylist, tp, tty_link);
 2619         mutex_spin_exit(&tty_lock);
 2620 }
 2621 
 2622 /*
 2623  * Allocate a tty structure and its associated buffers.
 2624  */
 2625 struct tty *
 2626 ttymalloc(void)
 2627 {
 2628         struct tty      *tp;
 2629         int i;  
 2630 
 2631         tp = kmem_zalloc(sizeof(*tp), KM_SLEEP);
 2632         callout_init(&tp->t_rstrt_ch, 0);
 2633         callout_setfunc(&tp->t_rstrt_ch, ttrstrt, tp);
 2634         /* XXX: default to 1024 chars for now */
 2635         clalloc(&tp->t_rawq, 1024, 1);
 2636         cv_init(&tp->t_rawcv, "ttyraw");
 2637         cv_init(&tp->t_rawcvf, "ttyrawf");
 2638         clalloc(&tp->t_canq, 1024, 1);
 2639         cv_init(&tp->t_cancv, "ttycan");
 2640         cv_init(&tp->t_cancvf, "ttycanf");
 2641         /* output queue doesn't need quoting */
 2642         clalloc(&tp->t_outq, 1024, 0);
 2643         cv_init(&tp->t_outcv, "ttyout");
 2644         cv_init(&tp->t_outcvf, "ttyoutf");
 2645         /* Set default line discipline. */
 2646         tp->t_linesw = ttyldisc_default();
 2647         selinit(&tp->t_rsel);
 2648         selinit(&tp->t_wsel);
 2649         for (i = 0; i < TTYSIG_COUNT; i++) 
 2650                 sigemptyset(&tp->t_sigs[i]);
 2651         return (tp);
 2652 }
 2653 
 2654 /*
 2655  * Free a tty structure and its buffers.
 2656  *
 2657  * Be sure to call tty_detach() for any tty that has been
 2658  * tty_attach()ed.
 2659  */
 2660 void
 2661 ttyfree(struct tty *tp)
 2662 {
 2663         int i;
 2664 
 2665         mutex_enter(proc_lock);
 2666         mutex_enter(&tty_lock);
 2667         for (i = 0; i < TTYSIG_COUNT; i++) 
 2668                 sigemptyset(&tp->t_sigs[i]);
 2669         if (tp->t_sigcount != 0)
 2670                 TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue);
 2671         mutex_exit(&tty_lock);
 2672         mutex_exit(proc_lock);
 2673 
 2674         callout_halt(&tp->t_rstrt_ch, NULL);
 2675         callout_destroy(&tp->t_rstrt_ch);
 2676         ttyldisc_release(tp->t_linesw);
 2677         clfree(&tp->t_rawq);
 2678         clfree(&tp->t_canq);
 2679         clfree(&tp->t_outq);
 2680         cv_destroy(&tp->t_rawcv);
 2681         cv_destroy(&tp->t_rawcvf);
 2682         cv_destroy(&tp->t_cancv);
 2683         cv_destroy(&tp->t_cancvf);
 2684         cv_destroy(&tp->t_outcv);
 2685         cv_destroy(&tp->t_outcvf);
 2686         seldestroy(&tp->t_rsel);
 2687         seldestroy(&tp->t_wsel);
 2688         kmem_free(tp, sizeof(*tp));
 2689 }
 2690 
 2691 /*
 2692  * ttyprintf_nolock: send a message to a specific tty, without locking.
 2693  *
 2694  * => should be used only by tty driver or anything that knows the
 2695  *    underlying tty will not be revoked(2)'d away.  [otherwise,
 2696  *    use tprintf]
 2697  */
 2698 static void
 2699 ttyprintf_nolock(struct tty *tp, const char *fmt, ...)
 2700 {
 2701         va_list ap;
 2702 
 2703         /* No mutex needed; going to process TTY. */
 2704         va_start(ap, fmt);
 2705         kprintf(fmt, TOTTY|NOLOCK, tp, NULL, ap);
 2706         va_end(ap);
 2707 }
 2708 
 2709 /*
 2710  * Initialize the tty subsystem.
 2711  */
 2712 void
 2713 tty_init(void)
 2714 {
 2715 
 2716         mutex_init(&tty_lock, MUTEX_DEFAULT, IPL_VM);
 2717         tty_sigsih = softint_establish(SOFTINT_CLOCK, ttysigintr, NULL);
 2718         KASSERT(tty_sigsih != NULL);
 2719 }
 2720 
 2721 /*
 2722  * Send a signal from a tty to its process group or session leader.
 2723  * Handoff to the target is deferred to a soft interrupt.
 2724  */
 2725 void
 2726 ttysig(struct tty *tp, enum ttysigtype st, int sig)
 2727 {
 2728         sigset_t *sp;
 2729 
 2730         /* XXXSMP not yet KASSERT(mutex_owned(&tty_lock)); */
 2731 
 2732         sp = &tp->t_sigs[st];
 2733         if (sigismember(sp, sig))
 2734                 return;
 2735         sigaddset(sp, sig);
 2736         if (tp->t_sigcount++ == 0)
 2737                 TAILQ_INSERT_TAIL(&tty_sigqueue, tp, t_sigqueue);
 2738         softint_schedule(tty_sigsih);
 2739 }
 2740 
 2741 /*
 2742  * Deliver deferred signals from ttys.  Note that the process groups
 2743  * and sessions associated with the ttys may have changed from when
 2744  * the signal was originally sent, but in practice it should not matter.
 2745  * For signals produced as a result of a syscall, the soft interrupt
 2746  * will fire before the syscall returns to the user.
 2747  */
 2748 static void
 2749 ttysigintr(void *cookie)
 2750 {
 2751         struct tty *tp;
 2752         enum ttysigtype st;
 2753         struct pgrp *pgrp;
 2754         struct session *sess;
 2755         int sig, lflag;
 2756         char infobuf[200];
 2757 
 2758         mutex_enter(proc_lock);
 2759         mutex_spin_enter(&tty_lock);
 2760         while ((tp = TAILQ_FIRST(&tty_sigqueue)) != NULL) {
 2761                 KASSERT(tp->t_sigcount > 0);
 2762                 for (st = 0; st < TTYSIG_COUNT; st++) {
 2763                         if ((sig = firstsig(&tp->t_sigs[st])) != 0)
 2764                                 break;
 2765                 }
 2766                 KASSERT(st < TTYSIG_COUNT);
 2767                 sigdelset(&tp->t_sigs[st], sig);
 2768                 if (--tp->t_sigcount == 0)
 2769                         TAILQ_REMOVE(&tty_sigqueue, tp, t_sigqueue);
 2770                 pgrp = tp->t_pgrp;
 2771                 sess = tp->t_session;
 2772                 lflag = tp->t_lflag;
 2773                 if  (sig == SIGINFO) {
 2774                         if (ISSET(tp->t_state, TS_SIGINFO)) {
 2775                                 /* Via ioctl: ignore tty option. */
 2776                                 tp->t_state &= ~TS_SIGINFO;
 2777                                 lflag |= ISIG;
 2778                         }
 2779                         if (!ISSET(lflag, NOKERNINFO)) {
 2780                                 mutex_spin_exit(&tty_lock);
 2781                                 ttygetinfo(tp, 1, infobuf, sizeof(infobuf));
 2782                                 mutex_spin_enter(&tty_lock);
 2783                                 ttyputinfo(tp, infobuf);
 2784                         }
 2785                         if (!ISSET(lflag, ISIG))
 2786                                 continue;
 2787                 }
 2788                 mutex_spin_exit(&tty_lock);
 2789                 KASSERT(sig != 0);
 2790                 switch (st) {
 2791                 case TTYSIG_PG1:
 2792                         if (pgrp != NULL)
 2793                                 pgsignal(pgrp, sig, 1);
 2794                         break;
 2795                 case TTYSIG_PG2:
 2796                         if (pgrp != NULL)
 2797                                 pgsignal(pgrp, sig, sess != NULL);
 2798                         break;
 2799                 case TTYSIG_LEADER:
 2800                         if (sess != NULL && sess->s_leader != NULL)
 2801                                 psignal(sess->s_leader, sig);
 2802                         break;
 2803                 default:
 2804                         /* NOTREACHED */
 2805                         break;
 2806                 }
 2807                 mutex_spin_enter(&tty_lock);
 2808         }
 2809         mutex_spin_exit(&tty_lock);
 2810         mutex_exit(proc_lock);
 2811 }

Cache object: e4f06fba5daff090c471926f83b36b37


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.