[BACK]Return to tty.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

Annotation of src/sys/kern/tty.c, Revision 1.119

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

CVSweb <webmaster@jp.NetBSD.org>