sys/kern/tty.c

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