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