Return to tty.c CVS log

Up to [Net/2] / Net2 / kern

Annotation of Net2/kern/tty.c, revision 1.1

1.1     ! root        1: /*-
        !             2:  * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
        !             3:  * Copyright (c) 1991 The Regents of the University of California.
        !             4:  * All rights reserved.
        !             5:  *
        !             6:  * Redistribution and use in source and binary forms, with or without
        !             7:  * modification, are permitted provided that the following conditions
        !             8:  * are met:
        !             9:  * 1. Redistributions of source code must retain the above copyright
        !            10:  *    notice, this list of conditions and the following disclaimer.
        !            11:  * 2. Redistributions in binary form must reproduce the above copyright
        !            12:  *    notice, this list of conditions and the following disclaimer in the
        !            13:  *    documentation and/or other materials provided with the distribution.
        !            14:  * 3. All advertising materials mentioning features or use of this software
        !            15:  *    must display the following acknowledgement:
        !            16:  *     This product includes software developed by the University of
        !            17:  *     California, Berkeley and its contributors.
        !            18:  * 4. Neither the name of the University nor the names of its contributors
        !            19:  *    may be used to endorse or promote products derived from this software
        !            20:  *    without specific prior written permission.
        !            21:  *
        !            22:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            23:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            24:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            25:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            26:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            27:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            28:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            29:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            30:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            31:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            32:  * SUCH DAMAGE.
        !            33:  *
        !            34:  *     @(#)tty.c       7.44 (Berkeley) 5/28/91
        !            35:  */
        !            36: 
        !            37: #include "param.h"
        !            38: #include "systm.h"
        !            39: #include "ioctl.h"
        !            40: #define TTYDEFCHARS
        !            41: #include "tty.h"
        !            42: #undef TTYDEFCHARS
        !            43: #include "proc.h"
        !            44: #include "file.h"
        !            45: #include "conf.h"
        !            46: #include "dkstat.h"
        !            47: #include "uio.h"
        !            48: #include "kernel.h"
        !            49: #include "vnode.h"
        !            50: #include "syslog.h"
        !            51: 
        !            52: #include "vm/vm.h"
        !            53: 
        !            54: static int proc_compare __P((struct proc *p1, struct proc *p2));
        !            55: 
        !            56: /* symbolic sleep message strings */
        !            57: char ttyin[] = "ttyin";
        !            58: char ttyout[] = "ttyout";
        !            59: char ttopen[] = "ttyopn";
        !            60: char ttclos[] = "ttycls";
        !            61: char ttybg[] = "ttybg";
        !            62: char ttybuf[] = "ttybuf";
        !            63: 
        !            64: /*
        !            65:  * Table giving parity for characters and indicating
        !            66:  * character classes to tty driver. The 8th bit
        !            67:  * indicates parity, the 7th bit indicates the character
        !            68:  * is an alphameric or underscore (for ALTWERASE), and the 
        !            69:  * low 6 bits indicate delay type.  If the low 6 bits are 0
        !            70:  * then the character needs no special processing on output;
        !            71:  * classes other than 0 might be translated or (not currently)
        !            72:  * require delays.
        !            73:  */
        !            74: #define        PARITY(c)       (partab[c] & 0x80)
        !            75: #define        ISALPHA(c)      (partab[(c)&TTY_CHARMASK] & 0x40)
        !            76: #define        CCLASSMASK      0x3f
        !            77: #define        CCLASS(c)       (partab[c] & CCLASSMASK)
        !            78: 
        !            79: #define        E       0x00    /* even parity */
        !            80: #define        O       0x80    /* odd parity */
        !            81: #define        ALPHA   0x40    /* alpha or underscore */
        !            82: 
        !            83: #define        NO      ORDINARY
        !            84: #define        NA      ORDINARY|ALPHA
        !            85: #define        CC      CONTROL
        !            86: #define        BS      BACKSPACE
        !            87: #define        NL      NEWLINE
        !            88: #define        TB      TAB
        !            89: #define        VT      VTAB
        !            90: #define        CR      RETURN
        !            91: 
        !            92: char partab[] = {
        !            93:        E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
        !            94:        O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
        !            95:        O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
        !            96:        E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
        !            97:        O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
        !            98:        E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
        !            99:        E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
        !           100:        O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
        !           101:        O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
        !           102:        E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
        !           103:        E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
        !           104:        O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
        !           105:        E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
        !           106:        O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
        !           107:        O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
        !           108:        E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
        !           109:        /*
        !           110:         * "meta" chars; should be settable per charset.
        !           111:         * For now, treat all as normal characters.
        !           112:         */
        !           113:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           114:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           115:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           116:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           117:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           118:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           119:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           120:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           121:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           122:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           123:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           124:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           125:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           126:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           127:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           128:        NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
        !           129: };
        !           130: #undef NO
        !           131: #undef NA
        !           132: #undef CC
        !           133: #undef BS
        !           134: #undef NL
        !           135: #undef TB
        !           136: #undef VT
        !           137: #undef CR
        !           138: 
        !           139: extern struct tty *constty;            /* temporary virtual console */
        !           140: 
        !           141: /*
        !           142:  * Is 'c' a line delimiter ("break" character)?
        !           143:  */
        !           144: #define ttbreakc(c) ((c) == '\n' || ((c) == cc[VEOF] || \
        !           145:        (c) == cc[VEOL] || (c) == cc[VEOL2]) && (c) != _POSIX_VDISABLE)
        !           146: 
        !           147: ttychars(tp)
        !           148:        struct tty *tp;
        !           149: {
        !           150: 
        !           151:        bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
        !           152: }
        !           153: 
        !           154: /*
        !           155:  * Flush tty after output has drained.
        !           156:  */
        !           157: ttywflush(tp)
        !           158:        struct tty *tp;
        !           159: {
        !           160:        int error;
        !           161: 
        !           162:        if ((error = ttywait(tp)) == 0)
        !           163:                ttyflush(tp, FREAD);
        !           164:        return (error);
        !           165: }
        !           166: 
        !           167: /*
        !           168:  * Wait for output to drain.
        !           169:  */
        !           170: ttywait(tp)
        !           171:        register struct tty *tp;
        !           172: {
        !           173:        int error = 0, s = spltty();
        !           174: 
        !           175:        while ((tp->t_outq.c_cc || tp->t_state&TS_BUSY) &&
        !           176:            (tp->t_state&TS_CARR_ON || tp->t_cflag&CLOCAL) && 
        !           177:            tp->t_oproc) {
        !           178:                (*tp->t_oproc)(tp);
        !           179:                tp->t_state |= TS_ASLEEP;
        !           180:                if (error = ttysleep(tp, (caddr_t)&tp->t_outq, 
        !           181:                    TTOPRI | PCATCH, ttyout, 0))
        !           182:                        break;
        !           183:        }
        !           184:        splx(s);
        !           185:        return (error);
        !           186: }
        !           187: 
        !           188: #define        flushq(qq) { \
        !           189:        register struct clist *q = qq; \
        !           190:        if (q->c_cc) \
        !           191:                ndflush(q, q->c_cc); \
        !           192: }
        !           193: 
        !           194: /*
        !           195:  * Flush TTY read and/or write queues,
        !           196:  * notifying anyone waiting.
        !           197:  */
        !           198: ttyflush(tp, rw)
        !           199:        register struct tty *tp;
        !           200: {
        !           201:        register s;
        !           202: 
        !           203:        s = spltty();
        !           204:        if (rw & FREAD) {
        !           205:                flushq(&tp->t_canq);
        !           206:                flushq(&tp->t_rawq);
        !           207:                tp->t_rocount = 0;
        !           208:                tp->t_rocol = 0;
        !           209:                tp->t_state &= ~TS_LOCAL;
        !           210:                ttwakeup(tp);
        !           211:        }
        !           212:        if (rw & FWRITE) {
        !           213:                tp->t_state &= ~TS_TTSTOP;
        !           214:                (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
        !           215:                flushq(&tp->t_outq);
        !           216:                wakeup((caddr_t)&tp->t_outq);
        !           217:                if (tp->t_wsel) {
        !           218:                        selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
        !           219:                        tp->t_wsel = 0;
        !           220:                        tp->t_state &= ~TS_WCOLL;
        !           221:                }
        !           222:        }
        !           223:        splx(s);
        !           224: }
        !           225: 
        !           226: /*
        !           227:  * Send stop character on input overflow.
        !           228:  */
        !           229: ttyblock(tp)
        !           230:        register struct tty *tp;
        !           231: {
        !           232:        register x;
        !           233: 
        !           234:        x = tp->t_rawq.c_cc + tp->t_canq.c_cc;
        !           235:        if (tp->t_rawq.c_cc > TTYHOG) {
        !           236:                ttyflush(tp, FREAD|FWRITE);
        !           237:                tp->t_state &= ~TS_TBLOCK;
        !           238:        }
        !           239:        /*
        !           240:         * Block further input iff:
        !           241:         * Current input > threshold AND input is available to user program
        !           242:         */
        !           243:        if (x >= TTYHOG/2 && (tp->t_state & TS_TBLOCK) == 0 &&
        !           244:            ((tp->t_lflag&ICANON) == 0) || (tp->t_canq.c_cc > 0) &&
        !           245:            tp->t_cc[VSTOP] != _POSIX_VDISABLE) {
        !           246:                if (putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
        !           247:                        tp->t_state |= TS_TBLOCK;
        !           248:                        ttstart(tp);
        !           249:                }
        !           250:        }
        !           251: }
        !           252: 
        !           253: ttstart(tp)
        !           254:        struct tty *tp;
        !           255: {
        !           256: 
        !           257:        if (tp->t_oproc)                /* kludge for pty */
        !           258:                (*tp->t_oproc)(tp);
        !           259: }
        !           260: 
        !           261: ttrstrt(tp)                            /* XXX */
        !           262:        struct tty *tp;
        !           263: {
        !           264: 
        !           265: #ifdef DIAGNOSTIC
        !           266:        if (tp == 0)
        !           267:                panic("ttrstrt");
        !           268: #endif
        !           269:        tp->t_state &= ~TS_TIMEOUT;
        !           270:        ttstart(tp);
        !           271: }
        !           272: 
        !           273: 
        !           274: /*
        !           275:  * Common code for ioctls on tty devices.
        !           276:  * Called after line-discipline-specific ioctl
        !           277:  * has been called to do discipline-specific functions
        !           278:  * and/or reject any of these ioctl commands.
        !           279:  */
        !           280: /*ARGSUSED*/
        !           281: ttioctl(tp, com, data, flag)
        !           282:        register struct tty *tp;
        !           283:        caddr_t data;
        !           284: {
        !           285:        register struct proc *p = curproc;              /* XXX */
        !           286:        extern int nldisp;
        !           287:        int s, error;
        !           288: 
        !           289:        /*
        !           290:         * If the ioctl involves modification,
        !           291:         * hang if in the background.
        !           292:         */
        !           293:        switch (com) {
        !           294: 
        !           295:        case TIOCSETD: 
        !           296:        case TIOCFLUSH:
        !           297:        /*case TIOCSPGRP:*/
        !           298:        case TIOCSTI:
        !           299:        case TIOCSWINSZ:
        !           300:        case TIOCSETA:
        !           301:        case TIOCSETAW:
        !           302:        case TIOCSETAF:
        !           303: #ifdef COMPAT_43
        !           304:        case TIOCSETP:
        !           305:        case TIOCSETN:
        !           306:        case TIOCSETC:
        !           307:        case TIOCSLTC:
        !           308:        case TIOCLBIS:
        !           309:        case TIOCLBIC:
        !           310:        case TIOCLSET:
        !           311:        case OTIOCSETD:
        !           312: #endif
        !           313:                while (isbackground(curproc, tp) && 
        !           314:                   p->p_pgrp->pg_jobc && (p->p_flag&SPPWAIT) == 0 &&
        !           315:                   (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
        !           316:                   (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
        !           317:                        pgsignal(p->p_pgrp, SIGTTOU, 1);
        !           318:                        if (error = ttysleep(tp, (caddr_t)&lbolt, 
        !           319:                            TTOPRI | PCATCH, ttybg, 0)) 
        !           320:                                return (error);
        !           321:                }
        !           322:                break;
        !           323:        }
        !           324: 
        !           325:        /*
        !           326:         * Process the ioctl.
        !           327:         */
        !           328:        switch (com) {
        !           329: 
        !           330:        /* get discipline number */
        !           331:        case TIOCGETD:
        !           332:                *(int *)data = tp->t_line;
        !           333:                break;
        !           334: 
        !           335:        /* set line discipline */
        !           336:        case TIOCSETD: {
        !           337:                register int t = *(int *)data;
        !           338:                dev_t dev = tp->t_dev;
        !           339: 
        !           340:                if ((unsigned)t >= nldisp)
        !           341:                        return (ENXIO);
        !           342:                if (t != tp->t_line) {
        !           343:                        s = spltty();
        !           344:                        (*linesw[tp->t_line].l_close)(tp, flag);
        !           345:                        error = (*linesw[t].l_open)(dev, tp);
        !           346:                        if (error) {
        !           347:                                (void)(*linesw[tp->t_line].l_open)(dev, tp);
        !           348:                                splx(s);
        !           349:                                return (error);
        !           350:                        }
        !           351:                        tp->t_line = t;
        !           352:                        splx(s);
        !           353:                }
        !           354:                break;
        !           355:        }
        !           356: 
        !           357:        /* prevent more opens on channel */
        !           358:        case TIOCEXCL:
        !           359:                tp->t_state |= TS_XCLUDE;
        !           360:                break;
        !           361: 
        !           362:        case TIOCNXCL:
        !           363:                tp->t_state &= ~TS_XCLUDE;
        !           364:                break;
        !           365: 
        !           366:        case TIOCHPCL:
        !           367:                tp->t_cflag |= HUPCL;
        !           368:                break;
        !           369: 
        !           370:        case TIOCFLUSH: {
        !           371:                register int flags = *(int *)data;
        !           372: 
        !           373:                if (flags == 0)
        !           374:                        flags = FREAD|FWRITE;
        !           375:                else
        !           376:                        flags &= FREAD|FWRITE;
        !           377:                ttyflush(tp, flags);
        !           378:                break;
        !           379:        }
        !           380: 
        !           381:        case FIOASYNC:
        !           382:                if (*(int *)data)
        !           383:                        tp->t_state |= TS_ASYNC;
        !           384:                else
        !           385:                        tp->t_state &= ~TS_ASYNC;
        !           386:                break;
        !           387: 
        !           388:        case FIONBIO:
        !           389:                break;  /* XXX remove */
        !           390: 
        !           391:        /* return number of characters immediately available */
        !           392:        case FIONREAD:
        !           393:                *(off_t *)data = ttnread(tp);
        !           394:                break;
        !           395: 
        !           396:        case TIOCOUTQ:
        !           397:                *(int *)data = tp->t_outq.c_cc;
        !           398:                break;
        !           399: 
        !           400:        case TIOCSTOP:
        !           401:                s = spltty();
        !           402:                if ((tp->t_state&TS_TTSTOP) == 0) {
        !           403:                        tp->t_state |= TS_TTSTOP;
        !           404:                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
        !           405:                }
        !           406:                splx(s);
        !           407:                break;
        !           408: 
        !           409:        case TIOCSTART:
        !           410:                s = spltty();
        !           411:                if ((tp->t_state&TS_TTSTOP) || (tp->t_lflag&FLUSHO)) {
        !           412:                        tp->t_state &= ~TS_TTSTOP;
        !           413:                        tp->t_lflag &= ~FLUSHO;
        !           414:                        ttstart(tp);
        !           415:                }
        !           416:                splx(s);
        !           417:                break;
        !           418: 
        !           419:        /*
        !           420:         * Simulate typing of a character at the terminal.
        !           421:         */
        !           422:        case TIOCSTI:
        !           423:                if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
        !           424:                        return (EPERM);
        !           425:                if (p->p_ucred->cr_uid && !isctty(p, tp))
        !           426:                        return (EACCES);
        !           427:                (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
        !           428:                break;
        !           429: 
        !           430:        case TIOCGETA: {
        !           431:                struct termios *t = (struct termios *)data;
        !           432: 
        !           433:                bcopy(&tp->t_termios, t, sizeof(struct termios));
        !           434:                break;
        !           435:        }
        !           436: 
        !           437:        case TIOCSETA:
        !           438:        case TIOCSETAW:
        !           439:        case TIOCSETAF: {
        !           440:                register struct termios *t = (struct termios *)data;
        !           441: 
        !           442:                s = spltty();
        !           443:                if (com == TIOCSETAW || com == TIOCSETAF) {
        !           444:                        if (error = ttywait(tp)) {
        !           445:                                splx(s);
        !           446:                                return (error);
        !           447:                        }
        !           448:                        if (com == TIOCSETAF)
        !           449:                                ttyflush(tp, FREAD);
        !           450:                }
        !           451:                if ((t->c_cflag&CIGNORE) == 0) {
        !           452:                        /*
        !           453:                         * set device hardware
        !           454:                         */
        !           455:                        if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
        !           456:                                splx(s);
        !           457:                                return (error);
        !           458:                        } else {
        !           459:                                if ((tp->t_state&TS_CARR_ON) == 0 &&
        !           460:                                    (tp->t_cflag&CLOCAL) &&
        !           461:                                    (t->c_cflag&CLOCAL) == 0) {
        !           462:                                        tp->t_state &= ~TS_ISOPEN;
        !           463:                                        tp->t_state |= TS_WOPEN;
        !           464:                                        ttwakeup(tp);
        !           465:                                }
        !           466:                                tp->t_cflag = t->c_cflag;
        !           467:                                tp->t_ispeed = t->c_ispeed;
        !           468:                                tp->t_ospeed = t->c_ospeed;
        !           469:                        }
        !           470:                        ttsetwater(tp);
        !           471:                }
        !           472:                if (com != TIOCSETAF) {
        !           473:                        if ((t->c_lflag&ICANON) != (tp->t_lflag&ICANON))
        !           474:                                if (t->c_lflag&ICANON) {        
        !           475:                                        tp->t_lflag |= PENDIN;
        !           476:                                        ttwakeup(tp);
        !           477:                                }
        !           478:                                else {
        !           479:                                        struct clist tq;
        !           480: 
        !           481:                                        catq(&tp->t_rawq, &tp->t_canq);
        !           482:                                        tq = tp->t_rawq;
        !           483:                                        tp->t_rawq = tp->t_canq;
        !           484:                                        tp->t_canq = tq;
        !           485:                                }
        !           486:                }
        !           487:                tp->t_iflag = t->c_iflag;
        !           488:                tp->t_oflag = t->c_oflag;
        !           489:                /*
        !           490:                 * Make the EXTPROC bit read only.
        !           491:                 */
        !           492:                if (tp->t_lflag&EXTPROC)
        !           493:                        t->c_lflag |= EXTPROC;
        !           494:                else
        !           495:                        t->c_lflag &= ~EXTPROC;
        !           496:                tp->t_lflag = t->c_lflag;
        !           497:                bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
        !           498:                splx(s);
        !           499:                break;
        !           500:        }
        !           501: 
        !           502:        /*
        !           503:         * Set controlling terminal.
        !           504:         * Session ctty vnode pointer set in vnode layer.
        !           505:         */
        !           506:        case TIOCSCTTY:
        !           507:                if (!SESS_LEADER(p) || 
        !           508:                   (p->p_session->s_ttyvp || tp->t_session) &&
        !           509:                   (tp->t_session != p->p_session))
        !           510:                        return (EPERM);
        !           511:                tp->t_session = p->p_session;
        !           512:                tp->t_pgrp = p->p_pgrp;
        !           513:                p->p_session->s_ttyp = tp;
        !           514:                p->p_flag |= SCTTY;
        !           515:                break;
        !           516:                
        !           517:        /*
        !           518:         * Set terminal process group.
        !           519:         */
        !           520:        case TIOCSPGRP: {
        !           521:                register struct pgrp *pgrp = pgfind(*(int *)data);
        !           522: 
        !           523:                if (!isctty(p, tp))
        !           524:                        return (ENOTTY);
        !           525:                else if (pgrp == NULL || pgrp->pg_session != p->p_session)
        !           526:                        return (EPERM);
        !           527:                tp->t_pgrp = pgrp;
        !           528:                break;
        !           529:        }
        !           530: 
        !           531:        case TIOCGPGRP:
        !           532:                if (!isctty(p, tp))
        !           533:                        return (ENOTTY);
        !           534:                *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
        !           535:                break;
        !           536: 
        !           537:        case TIOCSWINSZ:
        !           538:                if (bcmp((caddr_t)&tp->t_winsize, data,
        !           539:                    sizeof (struct winsize))) {
        !           540:                        tp->t_winsize = *(struct winsize *)data;
        !           541:                        pgsignal(tp->t_pgrp, SIGWINCH, 1);
        !           542:                }
        !           543:                break;
        !           544: 
        !           545:        case TIOCGWINSZ:
        !           546:                *(struct winsize *)data = tp->t_winsize;
        !           547:                break;
        !           548: 
        !           549:        case TIOCCONS:
        !           550:                if (*(int *)data) {
        !           551:                        if (constty && constty != tp &&
        !           552:                            (constty->t_state & (TS_CARR_ON|TS_ISOPEN)) ==
        !           553:                            (TS_CARR_ON|TS_ISOPEN))
        !           554:                                return (EBUSY);
        !           555: #ifndef        UCONSOLE
        !           556:                        if (error = suser(p->p_ucred, &p->p_acflag))
        !           557:                                return (error);
        !           558: #endif
        !           559:                        constty = tp;
        !           560:                } else if (tp == constty)
        !           561:                        constty = NULL;
        !           562:                break;
        !           563: 
        !           564:        case TIOCDRAIN:
        !           565:                if (error = ttywait(tp))
        !           566:                        return (error);
        !           567:                break;
        !           568: 
        !           569:        default:
        !           570: #ifdef COMPAT_43
        !           571:                return (ttcompat(tp, com, data, flag));
        !           572: #else
        !           573:                return (-1);
        !           574: #endif
        !           575:        }
        !           576:        return (0);
        !           577: }
        !           578: 
        !           579: ttnread(tp)
        !           580:        struct tty *tp;
        !           581: {
        !           582:        int nread = 0;
        !           583: 
        !           584:        if (tp->t_lflag & PENDIN)
        !           585:                ttypend(tp);
        !           586:        nread = tp->t_canq.c_cc;
        !           587:        if ((tp->t_lflag & ICANON) == 0)
        !           588:                nread += tp->t_rawq.c_cc;
        !           589:        return (nread);
        !           590: }
        !           591: 
        !           592: ttselect(dev, rw)
        !           593:        dev_t dev;
        !           594:        int rw;
        !           595: {
        !           596:        register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
        !           597:        int nread;
        !           598:        int s = spltty();
        !           599: 
        !           600:        switch (rw) {
        !           601: 
        !           602:        case FREAD:
        !           603:                nread = ttnread(tp);
        !           604:                if (nread > 0 || 
        !           605:                   ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
        !           606:                        goto win;
        !           607:                if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
        !           608:                        tp->t_state |= TS_RCOLL;
        !           609:                else
        !           610:                        tp->t_rsel = curproc;
        !           611:                break;
        !           612: 
        !           613:        case FWRITE:
        !           614:                if (tp->t_outq.c_cc <= tp->t_lowat)
        !           615:                        goto win;
        !           616:                if (tp->t_wsel && tp->t_wsel->p_wchan == (caddr_t)&selwait)
        !           617:                        tp->t_state |= TS_WCOLL;
        !           618:                else
        !           619:                        tp->t_wsel = curproc;
        !           620:                break;
        !           621:        }
        !           622:        splx(s);
        !           623:        return (0);
        !           624: win:
        !           625:        splx(s);
        !           626:        return (1);
        !           627: }
        !           628: 
        !           629: /*
        !           630:  * Initial open of tty, or (re)entry to standard tty line discipline.
        !           631:  */
        !           632: ttyopen(dev, tp)
        !           633:        dev_t dev;
        !           634:        register struct tty *tp;
        !           635: {
        !           636: 
        !           637:        tp->t_dev = dev;
        !           638: 
        !           639:        tp->t_state &= ~TS_WOPEN;
        !           640:        if ((tp->t_state & TS_ISOPEN) == 0) {
        !           641:                tp->t_state |= TS_ISOPEN;
        !           642:                bzero((caddr_t)&tp->t_winsize, sizeof(tp->t_winsize));
        !           643:        }
        !           644:        return (0);
        !           645: }
        !           646: 
        !           647: /*
        !           648:  * "close" a line discipline
        !           649:  */
        !           650: ttylclose(tp, flag)
        !           651:        struct tty *tp;
        !           652:        int flag;
        !           653: {
        !           654: 
        !           655:        if (flag&IO_NDELAY)
        !           656:                ttyflush(tp, FREAD|FWRITE);
        !           657:        else
        !           658:                ttywflush(tp);
        !           659: }
        !           660: 
        !           661: /*
        !           662:  * Handle close() on a tty line: flush and set to initial state,
        !           663:  * bumping generation number so that pending read/write calls
        !           664:  * can detect recycling of the tty.
        !           665:  */
        !           666: ttyclose(tp)
        !           667:        register struct tty *tp;
        !           668: {
        !           669:        if (constty == tp)
        !           670:                constty = NULL;
        !           671:        ttyflush(tp, FREAD|FWRITE);
        !           672:        tp->t_session = NULL;
        !           673:        tp->t_pgrp = NULL;
        !           674:        tp->t_state = 0;
        !           675:        tp->t_gen++;
        !           676:        return (0);
        !           677: }
        !           678: 
        !           679: /*
        !           680:  * Handle modem control transition on a tty.
        !           681:  * Flag indicates new state of carrier.
        !           682:  * Returns 0 if the line should be turned off, otherwise 1.
        !           683:  */
        !           684: ttymodem(tp, flag)
        !           685:        register struct tty *tp;
        !           686: {
        !           687: 
        !           688:        if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag&MDMBUF)) {
        !           689:                /*
        !           690:                 * MDMBUF: do flow control according to carrier flag
        !           691:                 */
        !           692:                if (flag) {
        !           693:                        tp->t_state &= ~TS_TTSTOP;
        !           694:                        ttstart(tp);
        !           695:                } else if ((tp->t_state&TS_TTSTOP) == 0) {
        !           696:                        tp->t_state |= TS_TTSTOP;
        !           697:                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
        !           698:                }
        !           699:        } else if (flag == 0) {
        !           700:                /*
        !           701:                 * Lost carrier.
        !           702:                 */
        !           703:                tp->t_state &= ~TS_CARR_ON;
        !           704:                if (tp->t_state&TS_ISOPEN && (tp->t_cflag&CLOCAL) == 0) {
        !           705:                        if (tp->t_session && tp->t_session->s_leader)
        !           706:                                psignal(tp->t_session->s_leader, SIGHUP);
        !           707:                        ttyflush(tp, FREAD|FWRITE);
        !           708:                        return (0);
        !           709:                }
        !           710:        } else {
        !           711:                /*
        !           712:                 * Carrier now on.
        !           713:                 */
        !           714:                tp->t_state |= TS_CARR_ON;
        !           715:                ttwakeup(tp);
        !           716:        }
        !           717:        return (1);
        !           718: }
        !           719: 
        !           720: /*
        !           721:  * Default modem control routine (for other line disciplines).
        !           722:  * Return argument flag, to turn off device on carrier drop.
        !           723:  */
        !           724: nullmodem(tp, flag)
        !           725:        register struct tty *tp;
        !           726:        int flag;
        !           727: {
        !           728:        
        !           729:        if (flag)
        !           730:                tp->t_state |= TS_CARR_ON;
        !           731:        else {
        !           732:                tp->t_state &= ~TS_CARR_ON;
        !           733:                if ((tp->t_cflag&CLOCAL) == 0) {
        !           734:                        if (tp->t_session && tp->t_session->s_leader)
        !           735:                                psignal(tp->t_session->s_leader, SIGHUP);
        !           736:                        return (0);
        !           737:                }
        !           738:        }
        !           739:        return (1);
        !           740: }
        !           741: 
        !           742: /*
        !           743:  * reinput pending characters after state switch
        !           744:  * call at spltty().
        !           745:  */
        !           746: ttypend(tp)
        !           747:        register struct tty *tp;
        !           748: {
        !           749:        struct clist tq;
        !           750:        register c;
        !           751: 
        !           752:        tp->t_lflag &= ~PENDIN;
        !           753:        tp->t_state |= TS_TYPEN;
        !           754:        tq = tp->t_rawq;
        !           755:        tp->t_rawq.c_cc = 0;
        !           756:        tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
        !           757:        while ((c = getc(&tq)) >= 0)
        !           758:                ttyinput(c, tp);
        !           759:        tp->t_state &= ~TS_TYPEN;
        !           760: }
        !           761: 
        !           762: /*
        !           763:  * Process input of a single character received on a tty.
        !           764:  */
        !           765: ttyinput(c, tp)
        !           766:        register c;
        !           767:        register struct tty *tp;
        !           768: {
        !           769:        register int iflag = tp->t_iflag;
        !           770:        register int lflag = tp->t_lflag;
        !           771:        register u_char *cc = tp->t_cc;
        !           772:        int i, err;
        !           773: 
        !           774:        /*
        !           775:         * If input is pending take it first.
        !           776:         */
        !           777:        if (lflag&PENDIN)
        !           778:                ttypend(tp);
        !           779:        /*
        !           780:         * Gather stats.
        !           781:         */
        !           782:        tk_nin++;
        !           783:        if (lflag&ICANON) {
        !           784:                tk_cancc++;
        !           785:                tp->t_cancc++;
        !           786:        } else {
        !           787:                tk_rawcc++;
        !           788:                tp->t_rawcc++;
        !           789:        }
        !           790:        /*
        !           791:         * Handle exceptional conditions (break, parity, framing).
        !           792:         */
        !           793:        if (err = (c&TTY_ERRORMASK)) {
        !           794:                c &= ~TTY_ERRORMASK;
        !           795:                if (err&TTY_FE && !c) {         /* break */
        !           796:                        if (iflag&IGNBRK)
        !           797:                                goto endcase;
        !           798:                        else if (iflag&BRKINT && lflag&ISIG && 
        !           799:                                (cc[VINTR] != _POSIX_VDISABLE))
        !           800:                                c = cc[VINTR];
        !           801:                        else if (iflag&PARMRK)
        !           802:                                goto parmrk;
        !           803:                } else if ((err&TTY_PE && iflag&INPCK) || err&TTY_FE) {
        !           804:                        if (iflag&IGNPAR)
        !           805:                                goto endcase;
        !           806:                        else if (iflag&PARMRK) {
        !           807: parmrk:
        !           808:                                putc(0377|TTY_QUOTE, &tp->t_rawq);
        !           809:                                putc(0|TTY_QUOTE, &tp->t_rawq);
        !           810:                                putc(c|TTY_QUOTE, &tp->t_rawq);
        !           811:                                goto endcase;
        !           812:                        } else
        !           813:                                c = 0;
        !           814:                }
        !           815:        }
        !           816:        /*
        !           817:         * In tandem mode, check high water mark.
        !           818:         */
        !           819:        if (iflag&IXOFF)
        !           820:                ttyblock(tp);
        !           821:        if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))
        !           822:                c &= ~0x80;
        !           823:        if ((tp->t_lflag&EXTPROC) == 0) {
        !           824:                /*
        !           825:                 * Check for literal nexting very first
        !           826:                 */
        !           827:                if (tp->t_state&TS_LNCH) {
        !           828:                        c |= TTY_QUOTE;
        !           829:                        tp->t_state &= ~TS_LNCH;
        !           830:                }
        !           831:                /*
        !           832:                 * Scan for special characters.  This code
        !           833:                 * is really just a big case statement with
        !           834:                 * non-constant cases.  The bottom of the
        !           835:                 * case statement is labeled ``endcase'', so goto
        !           836:                 * it after a case match, or similar.
        !           837:                 */
        !           838: 
        !           839:                /*
        !           840:                 * Control chars which aren't controlled
        !           841:                 * by ICANON, ISIG, or IXON.
        !           842:                 */
        !           843:                if (lflag&IEXTEN) {
        !           844:                        if (CCEQ(cc[VLNEXT], c)) {
        !           845:                                if (lflag&ECHO) {
        !           846:                                        if (lflag&ECHOE)
        !           847:                                                ttyoutstr("^\b", tp);
        !           848:                                        else
        !           849:                                                ttyecho(c, tp);
        !           850:                                }
        !           851:                                tp->t_state |= TS_LNCH;
        !           852:                                goto endcase;
        !           853:                        }
        !           854:                        if (CCEQ(cc[VDISCARD], c)) {
        !           855:                                if (lflag&FLUSHO)
        !           856:                                        tp->t_lflag &= ~FLUSHO;
        !           857:                                else {
        !           858:                                        ttyflush(tp, FWRITE);
        !           859:                                        ttyecho(c, tp);
        !           860:                                        if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
        !           861:                                                ttyretype(tp);
        !           862:                                        tp->t_lflag |= FLUSHO;
        !           863:                                }
        !           864:                                goto startoutput;
        !           865:                        }
        !           866:                }
        !           867:                /*
        !           868:                 * Signals.
        !           869:                 */
        !           870:                if (lflag&ISIG) {
        !           871:                        if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
        !           872:                                if ((lflag&NOFLSH) == 0)
        !           873:                                        ttyflush(tp, FREAD|FWRITE);
        !           874:                                ttyecho(c, tp);
        !           875:                                pgsignal(tp->t_pgrp,
        !           876:                                    CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
        !           877:                                goto endcase;
        !           878:                        }
        !           879:                        if (CCEQ(cc[VSUSP], c)) {
        !           880:                                if ((lflag&NOFLSH) == 0)
        !           881:                                        ttyflush(tp, FREAD);
        !           882:                                ttyecho(c, tp);
        !           883:                                pgsignal(tp->t_pgrp, SIGTSTP, 1);
        !           884:                                goto endcase;
        !           885:                        }
        !           886:                }
        !           887:                /*
        !           888:                 * Handle start/stop characters.
        !           889:                 */
        !           890:                if (iflag&IXON) {
        !           891:                        if (CCEQ(cc[VSTOP], c)) {
        !           892:                                if ((tp->t_state&TS_TTSTOP) == 0) {
        !           893:                                        tp->t_state |= TS_TTSTOP;
        !           894:                                        (*cdevsw[major(tp->t_dev)].d_stop)(tp,
        !           895:                                           0);
        !           896:                                        return;
        !           897:                                }
        !           898:                                if (!CCEQ(cc[VSTART], c))
        !           899:                                        return;
        !           900:                                /* 
        !           901:                                 * if VSTART == VSTOP then toggle 
        !           902:                                 */
        !           903:                                goto endcase;
        !           904:                        }
        !           905:                        if (CCEQ(cc[VSTART], c))
        !           906:                                goto restartoutput;
        !           907:                }
        !           908:                /*
        !           909:                 * IGNCR, ICRNL, & INLCR
        !           910:                 */
        !           911:                if (c == '\r') {
        !           912:                        if (iflag&IGNCR)
        !           913:                                goto endcase;
        !           914:                        else if (iflag&ICRNL)
        !           915:                                c = '\n';
        !           916:                } else if (c == '\n' && iflag&INLCR)
        !           917:                        c = '\r';
        !           918:        }
        !           919:        if ((tp->t_lflag&EXTPROC) == 0 && lflag&ICANON) {
        !           920:                /*
        !           921:                 * From here on down canonical mode character
        !           922:                 * processing takes place.
        !           923:                 */
        !           924:                /*
        !           925:                 * erase (^H / ^?)
        !           926:                 */
        !           927:                if (CCEQ(cc[VERASE], c)) {
        !           928:                        if (tp->t_rawq.c_cc)
        !           929:                                ttyrub(unputc(&tp->t_rawq), tp);
        !           930:                        goto endcase;
        !           931:                }
        !           932:                /*
        !           933:                 * kill (^U)
        !           934:                 */
        !           935:                if (CCEQ(cc[VKILL], c)) {
        !           936:                        if (lflag&ECHOKE && tp->t_rawq.c_cc == tp->t_rocount &&
        !           937:                            (lflag&ECHOPRT) == 0) {
        !           938:                                while (tp->t_rawq.c_cc)
        !           939:                                        ttyrub(unputc(&tp->t_rawq), tp);
        !           940:                        } else {
        !           941:                                ttyecho(c, tp);
        !           942:                                if (lflag&ECHOK || lflag&ECHOKE)
        !           943:                                        ttyecho('\n', tp);
        !           944:                                while (getc(&tp->t_rawq) > 0)
        !           945:                                        ;
        !           946:                                tp->t_rocount = 0;
        !           947:                        }
        !           948:                        tp->t_state &= ~TS_LOCAL;
        !           949:                        goto endcase;
        !           950:                }
        !           951:                /*
        !           952:                 * word erase (^W)
        !           953:                 */
        !           954:                if (CCEQ(cc[VWERASE], c)) {     
        !           955:                        int ctype;
        !           956:                        int alt = lflag&ALTWERASE;
        !           957: 
        !           958:                        /* 
        !           959:                         * erase whitespace 
        !           960:                         */
        !           961:                        while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
        !           962:                                ttyrub(c, tp);
        !           963:                        if (c == -1)
        !           964:                                goto endcase;
        !           965:                        /*
        !           966:                         * erase last char of word and remember the
        !           967:                         * next chars type (for ALTWERASE)
        !           968:                         */
        !           969:                        ttyrub(c, tp);
        !           970:                        c = unputc(&tp->t_rawq);
        !           971:                        if (c == -1)
        !           972:                                goto endcase;
        !           973:                        ctype = ISALPHA(c);
        !           974:                        /*
        !           975:                         * erase rest of word
        !           976:                         */
        !           977:                        do {
        !           978:                                ttyrub(c, tp);
        !           979:                                c = unputc(&tp->t_rawq);
        !           980:                                if (c == -1)
        !           981:                                        goto endcase;
        !           982:                        } while (c != ' ' && c != '\t' && 
        !           983:                                (alt == 0 || ISALPHA(c) == ctype));
        !           984:                        (void) putc(c, &tp->t_rawq);
        !           985:                        goto endcase;
        !           986:                }
        !           987:                /*
        !           988:                 * reprint line (^R)
        !           989:                 */
        !           990:                if (CCEQ(cc[VREPRINT], c)) {
        !           991:                        ttyretype(tp);
        !           992:                        goto endcase;
        !           993:                }
        !           994:                /*
        !           995:                 * ^T - kernel info and generate SIGINFO
        !           996:                 */
        !           997:                if (CCEQ(cc[VSTATUS], c)) {
        !           998:                        pgsignal(tp->t_pgrp, SIGINFO, 1);
        !           999:                        if ((lflag&NOKERNINFO) == 0)
        !          1000:                                ttyinfo(tp);
        !          1001:                        goto endcase;
        !          1002:                }
        !          1003:        }
        !          1004:        /*
        !          1005:         * Check for input buffer overflow
        !          1006:         */
        !          1007:        if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
        !          1008:                if (iflag&IMAXBEL) {
        !          1009:                        if (tp->t_outq.c_cc < tp->t_hiwat)
        !          1010:                                (void) ttyoutput(CTRL('g'), tp);
        !          1011:                } else
        !          1012:                        ttyflush(tp, FREAD | FWRITE);
        !          1013:                goto endcase;
        !          1014:        }
        !          1015:        /*
        !          1016:         * Put data char in q for user and
        !          1017:         * wakeup on seeing a line delimiter.
        !          1018:         */
        !          1019:        if (putc(c, &tp->t_rawq) >= 0) {
        !          1020:                if ((lflag&ICANON) == 0) {
        !          1021:                        ttwakeup(tp);
        !          1022:                        ttyecho(c, tp);
        !          1023:                        goto endcase;
        !          1024:                }
        !          1025:                if (ttbreakc(c)) {
        !          1026:                        tp->t_rocount = 0;
        !          1027:                        catq(&tp->t_rawq, &tp->t_canq);
        !          1028:                        ttwakeup(tp);
        !          1029:                } else if (tp->t_rocount++ == 0)
        !          1030:                        tp->t_rocol = tp->t_col;
        !          1031:                if (tp->t_state&TS_ERASE) {
        !          1032:                        /*
        !          1033:                         * end of prterase \.../
        !          1034:                         */
        !          1035:                        tp->t_state &= ~TS_ERASE;
        !          1036:                        (void) ttyoutput('/', tp);
        !          1037:                }
        !          1038:                i = tp->t_col;
        !          1039:                ttyecho(c, tp);
        !          1040:                if (CCEQ(cc[VEOF], c) && lflag&ECHO) {
        !          1041:                        /*
        !          1042:                         * Place the cursor over the '^' of the ^D.
        !          1043:                         */
        !          1044:                        i = MIN(2, tp->t_col - i);
        !          1045:                        while (i > 0) {
        !          1046:                                (void) ttyoutput('\b', tp);
        !          1047:                                i--;
        !          1048:                        }
        !          1049:                }
        !          1050:        }
        !          1051: endcase:
        !          1052:        /*
        !          1053:         * IXANY means allow any character to restart output.
        !          1054:         */
        !          1055:        if ((tp->t_state&TS_TTSTOP) && (iflag&IXANY) == 0 && 
        !          1056:            cc[VSTART] != cc[VSTOP])
        !          1057:                return;
        !          1058: restartoutput:
        !          1059:        tp->t_state &= ~TS_TTSTOP;
        !          1060:        tp->t_lflag &= ~FLUSHO;
        !          1061: startoutput:
        !          1062:        ttstart(tp);
        !          1063: }
        !          1064: 
        !          1065: /*
        !          1066:  * Output a single character on a tty, doing output processing
        !          1067:  * as needed (expanding tabs, newline processing, etc.).
        !          1068:  * Returns < 0 if putc succeeds, otherwise returns char to resend.
        !          1069:  * Must be recursive.
        !          1070:  */
        !          1071: ttyoutput(c, tp)
        !          1072:        register c;
        !          1073:        register struct tty *tp;
        !          1074: {
        !          1075:        register int col;
        !          1076:        register long oflag = tp->t_oflag;
        !          1077:        
        !          1078:        if ((oflag&OPOST) == 0) {
        !          1079:                if (tp->t_lflag&FLUSHO) 
        !          1080:                        return (-1);
        !          1081:                if (putc(c, &tp->t_outq))
        !          1082:                        return (c);
        !          1083:                tk_nout++;
        !          1084:                tp->t_outcc++;
        !          1085:                return (-1);
        !          1086:        }
        !          1087:        c &= TTY_CHARMASK;
        !          1088:        /*
        !          1089:         * Do tab expansion if OXTABS is set.
        !          1090:         * Special case if we have external processing, we don't
        !          1091:         * do the tab expansion because we'll probably get it
        !          1092:         * wrong.  If tab expansion needs to be done, let it
        !          1093:         * happen externally.
        !          1094:         */
        !          1095:        if (c == '\t' && oflag&OXTABS && (tp->t_lflag&EXTPROC) == 0) {
        !          1096:                register int s;
        !          1097: 
        !          1098:                c = 8 - (tp->t_col&7);
        !          1099:                if ((tp->t_lflag&FLUSHO) == 0) {
        !          1100:                        s = spltty();           /* don't interrupt tabs */
        !          1101:                        c -= b_to_q("        ", c, &tp->t_outq);
        !          1102:                        tk_nout += c;
        !          1103:                        tp->t_outcc += c;
        !          1104:                        splx(s);
        !          1105:                }
        !          1106:                tp->t_col += c;
        !          1107:                return (c ? -1 : '\t');
        !          1108:        }
        !          1109:        if (c == CEOT && oflag&ONOEOT)
        !          1110:                return (-1);
        !          1111:        tk_nout++;
        !          1112:        tp->t_outcc++;
        !          1113:        /*
        !          1114:         * Newline translation: if ONLCR is set,
        !          1115:         * translate newline into "\r\n".
        !          1116:         */
        !          1117:        if (c == '\n' && (tp->t_oflag&ONLCR) && ttyoutput('\r', tp) >= 0)
        !          1118:                return (c);
        !          1119:        if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
        !          1120:                return (c);
        !          1121: 
        !          1122:        col = tp->t_col;
        !          1123:        switch (CCLASS(c)) {
        !          1124: 
        !          1125:        case ORDINARY:
        !          1126:                col++;
        !          1127: 
        !          1128:        case CONTROL:
        !          1129:                break;
        !          1130: 
        !          1131:        case BACKSPACE:
        !          1132:                if (col > 0)
        !          1133:                        col--;
        !          1134:                break;
        !          1135: 
        !          1136:        case NEWLINE:
        !          1137:                col = 0;
        !          1138:                break;
        !          1139: 
        !          1140:        case TAB:
        !          1141:                col = (col + 8) &~ 0x7;
        !          1142:                break;
        !          1143: 
        !          1144:        case RETURN:
        !          1145:                col = 0;
        !          1146:        }
        !          1147:        tp->t_col = col;
        !          1148:        return (-1);
        !          1149: }
        !          1150: 
        !          1151: /*
        !          1152:  * Process a read call on a tty device.
        !          1153:  */
        !          1154: ttread(tp, uio, flag)
        !          1155:        register struct tty *tp;
        !          1156:        struct uio *uio;
        !          1157: {
        !          1158:        register struct clist *qp;
        !          1159:        register int c;
        !          1160:        register long lflag;
        !          1161:        register u_char *cc = tp->t_cc;
        !          1162:        register struct proc *p = curproc;
        !          1163:        int s, first, error = 0;
        !          1164: 
        !          1165: loop:
        !          1166:        lflag = tp->t_lflag;
        !          1167:        s = spltty();
        !          1168:        /*
        !          1169:         * take pending input first 
        !          1170:         */
        !          1171:        if (lflag&PENDIN)
        !          1172:                ttypend(tp);
        !          1173:        splx(s);
        !          1174: 
        !          1175:        /*
        !          1176:         * Hang process if it's in the background.
        !          1177:         */
        !          1178:        if (isbackground(p, tp)) {
        !          1179:                if ((p->p_sigignore & sigmask(SIGTTIN)) ||
        !          1180:                   (p->p_sigmask & sigmask(SIGTTIN)) ||
        !          1181:                    p->p_flag&SPPWAIT || p->p_pgrp->pg_jobc == 0)
        !          1182:                        return (EIO);
        !          1183:                pgsignal(p->p_pgrp, SIGTTIN, 1);
        !          1184:                if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH, 
        !          1185:                    ttybg, 0)) 
        !          1186:                        return (error);
        !          1187:                goto loop;
        !          1188:        }
        !          1189: 
        !          1190:        /*
        !          1191:         * If canonical, use the canonical queue,
        !          1192:         * else use the raw queue.
        !          1193:         *
        !          1194:         * (should get rid of clists...)
        !          1195:         */
        !          1196:        qp = lflag&ICANON ? &tp->t_canq : &tp->t_rawq;
        !          1197: 
        !          1198:        /*
        !          1199:         * If there is no input, sleep on rawq
        !          1200:         * awaiting hardware receipt and notification.
        !          1201:         * If we have data, we don't need to check for carrier.
        !          1202:         */
        !          1203:        s = spltty();
        !          1204:        if (qp->c_cc <= 0) {
        !          1205:                int carrier;
        !          1206: 
        !          1207:                carrier = (tp->t_state&TS_CARR_ON) || (tp->t_cflag&CLOCAL);
        !          1208:                if (!carrier && tp->t_state&TS_ISOPEN) {
        !          1209:                        splx(s);
        !          1210:                        return (0);     /* EOF */
        !          1211:                }
        !          1212:                if (flag & IO_NDELAY) {
        !          1213:                        splx(s);
        !          1214:                        return (EWOULDBLOCK);
        !          1215:                }
        !          1216:                error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
        !          1217:                    carrier ? ttyin : ttopen, 0);
        !          1218:                splx(s);
        !          1219:                if (error)
        !          1220:                        return (error);
        !          1221:                goto loop;
        !          1222:        }
        !          1223:        splx(s);
        !          1224: 
        !          1225:        /*
        !          1226:         * Input present, check for input mapping and processing.
        !          1227:         */
        !          1228:        first = 1;
        !          1229:        while ((c = getc(qp)) >= 0) {
        !          1230:                /*
        !          1231:                 * delayed suspend (^Y)
        !          1232:                 */
        !          1233:                if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
        !          1234:                        pgsignal(tp->t_pgrp, SIGTSTP, 1);
        !          1235:                        if (first) {
        !          1236:                                if (error = ttysleep(tp, (caddr_t)&lbolt,
        !          1237:                                    TTIPRI | PCATCH, ttybg, 0))
        !          1238:                                        break;
        !          1239:                                goto loop;
        !          1240:                        }
        !          1241:                        break;
        !          1242:                }
        !          1243:                /*
        !          1244:                 * Interpret EOF only in canonical mode.
        !          1245:                 */
        !          1246:                if (CCEQ(cc[VEOF], c) && lflag&ICANON)
        !          1247:                        break;
        !          1248:                /*
        !          1249:                 * Give user character.
        !          1250:                 */
        !          1251:                error = ureadc(c, uio);
        !          1252:                if (error)
        !          1253:                        break;
        !          1254:                if (uio->uio_resid == 0)
        !          1255:                        break;
        !          1256:                /*
        !          1257:                 * In canonical mode check for a "break character"
        !          1258:                 * marking the end of a "line of input".
        !          1259:                 */
        !          1260:                if (lflag&ICANON && ttbreakc(c))
        !          1261:                        break;
        !          1262:                first = 0;
        !          1263:        }
        !          1264:        /*
        !          1265:         * Look to unblock output now that (presumably)
        !          1266:         * the input queue has gone down.
        !          1267:         */
        !          1268:        if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
        !          1269:                if (cc[VSTART] != _POSIX_VDISABLE &&
        !          1270:                    putc(cc[VSTART], &tp->t_outq) == 0) {
        !          1271:                        tp->t_state &= ~TS_TBLOCK;
        !          1272:                        ttstart(tp);
        !          1273:                }
        !          1274:        }
        !          1275:        return (error);
        !          1276: }
        !          1277: 
        !          1278: /*
        !          1279:  * Check the output queue on tp for space for a kernel message
        !          1280:  * (from uprintf/tprintf).  Allow some space over the normal
        !          1281:  * hiwater mark so we don't lose messages due to normal flow
        !          1282:  * control, but don't let the tty run amok.
        !          1283:  * Sleeps here are not interruptible, but we return prematurely
        !          1284:  * if new signals come in.
        !          1285:  */
        !          1286: ttycheckoutq(tp, wait)
        !          1287:        register struct tty *tp;
        !          1288:        int wait;
        !          1289: {
        !          1290:        int hiwat, s, oldsig;
        !          1291:        extern int wakeup();
        !          1292: 
        !          1293:        hiwat = tp->t_hiwat;
        !          1294:        s = spltty();
        !          1295:        oldsig = curproc->p_sig;
        !          1296:        if (tp->t_outq.c_cc > hiwat + 200)
        !          1297:                while (tp->t_outq.c_cc > hiwat) {
        !          1298:                        ttstart(tp);
        !          1299:                        if (wait == 0 || curproc->p_sig != oldsig) {
        !          1300:                                splx(s);
        !          1301:                                return (0);
        !          1302:                        }
        !          1303:                        timeout(wakeup, (caddr_t)&tp->t_outq, hz);
        !          1304:                        tp->t_state |= TS_ASLEEP;
        !          1305:                        sleep((caddr_t)&tp->t_outq, PZERO - 1);
        !          1306:                }
        !          1307:        splx(s);
        !          1308:        return (1);
        !          1309: }
        !          1310: 
        !          1311: /*
        !          1312:  * Process a write call on a tty device.
        !          1313:  */
        !          1314: ttwrite(tp, uio, flag)
        !          1315:        register struct tty *tp;
        !          1316:        register struct uio *uio;
        !          1317: {
        !          1318:        register char *cp;
        !          1319:        register int cc = 0, ce;
        !          1320:        register struct proc *p = curproc;
        !          1321:        int i, hiwat, cnt, error, s;
        !          1322:        char obuf[OBUFSIZ];
        !          1323: 
        !          1324:        hiwat = tp->t_hiwat;
        !          1325:        cnt = uio->uio_resid;
        !          1326:        error = 0;
        !          1327: loop:
        !          1328:        s = spltty();
        !          1329:        if ((tp->t_state&TS_CARR_ON) == 0 && (tp->t_cflag&CLOCAL) == 0) {
        !          1330:                if (tp->t_state&TS_ISOPEN) {
        !          1331:                        splx(s);
        !          1332:                        return (EIO);
        !          1333:                } else if (flag & IO_NDELAY) {
        !          1334:                        splx(s);
        !          1335:                        error = EWOULDBLOCK;
        !          1336:                        goto out;
        !          1337:                } else {
        !          1338:                        /*
        !          1339:                         * sleep awaiting carrier
        !          1340:                         */
        !          1341:                        error = ttysleep(tp, (caddr_t)&tp->t_rawq, 
        !          1342:                                        TTIPRI | PCATCH,ttopen, 0);
        !          1343:                        splx(s);
        !          1344:                        if (error)
        !          1345:                                goto out;
        !          1346:                        goto loop;
        !          1347:                }
        !          1348:        }
        !          1349:        splx(s);
        !          1350:        /*
        !          1351:         * Hang the process if it's in the background.
        !          1352:         */
        !          1353:        if (isbackground(p, tp) && 
        !          1354:            tp->t_lflag&TOSTOP && (p->p_flag&SPPWAIT) == 0 &&
        !          1355:            (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
        !          1356:            (p->p_sigmask & sigmask(SIGTTOU)) == 0 &&
        !          1357:             p->p_pgrp->pg_jobc) {
        !          1358:                pgsignal(p->p_pgrp, SIGTTOU, 1);
        !          1359:                if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH, 
        !          1360:                    ttybg, 0))
        !          1361:                        goto out;
        !          1362:                goto loop;
        !          1363:        }
        !          1364:        /*
        !          1365:         * Process the user's data in at most OBUFSIZ
        !          1366:         * chunks.  Perform any output translation.
        !          1367:         * Keep track of high water mark, sleep on overflow
        !          1368:         * awaiting device aid in acquiring new space.
        !          1369:         */
        !          1370:        while (uio->uio_resid > 0 || cc > 0) {
        !          1371:                if (tp->t_lflag&FLUSHO) {
        !          1372:                        uio->uio_resid = 0;
        !          1373:                        return (0);
        !          1374:                }
        !          1375:                if (tp->t_outq.c_cc > hiwat)
        !          1376:                        goto ovhiwat;
        !          1377:                /*
        !          1378:                 * Grab a hunk of data from the user,
        !          1379:                 * unless we have some leftover from last time.
        !          1380:                 */
        !          1381:                if (cc == 0) {
        !          1382:                        cc = min(uio->uio_resid, OBUFSIZ);
        !          1383:                        cp = obuf;
        !          1384:                        error = uiomove(cp, cc, uio);
        !          1385:                        if (error) {
        !          1386:                                cc = 0;
        !          1387:                                break;
        !          1388:                        }
        !          1389:                }
        !          1390:                /*
        !          1391:                 * If nothing fancy need be done, grab those characters we
        !          1392:                 * can handle without any of ttyoutput's processing and
        !          1393:                 * just transfer them to the output q.  For those chars
        !          1394:                 * which require special processing (as indicated by the
        !          1395:                 * bits in partab), call ttyoutput.  After processing
        !          1396:                 * a hunk of data, look for FLUSHO so ^O's will take effect
        !          1397:                 * immediately.
        !          1398:                 */
        !          1399:                while (cc > 0) {
        !          1400:                        if ((tp->t_oflag&OPOST) == 0)
        !          1401:                                ce = cc;
        !          1402:                        else {
        !          1403:                                ce = cc - scanc((unsigned)cc, (u_char *)cp,
        !          1404:                                   (u_char *)partab, CCLASSMASK);
        !          1405:                                /*
        !          1406:                                 * If ce is zero, then we're processing
        !          1407:                                 * a special character through ttyoutput.
        !          1408:                                 */
        !          1409:                                if (ce == 0) {
        !          1410:                                        tp->t_rocount = 0;
        !          1411:                                        if (ttyoutput(*cp, tp) >= 0) {
        !          1412:                                            /* no c-lists, wait a bit */
        !          1413:                                            ttstart(tp);
        !          1414:                                            if (error = ttysleep(tp, 
        !          1415:                                                (caddr_t)&lbolt,
        !          1416:                                                 TTOPRI | PCATCH, ttybuf, 0))
        !          1417:                                                    break;
        !          1418:                                            goto loop;
        !          1419:                                        }
        !          1420:                                        cp++, cc--;
        !          1421:                                        if ((tp->t_lflag&FLUSHO) ||
        !          1422:                                            tp->t_outq.c_cc > hiwat)
        !          1423:                                                goto ovhiwat;
        !          1424:                                        continue;
        !          1425:                                }
        !          1426:                        }
        !          1427:                        /*
        !          1428:                         * A bunch of normal characters have been found,
        !          1429:                         * transfer them en masse to the output queue and
        !          1430:                         * continue processing at the top of the loop.
        !          1431:                         * If there are any further characters in this
        !          1432:                         * <= OBUFSIZ chunk, the first should be a character
        !          1433:                         * requiring special handling by ttyoutput.
        !          1434:                         */
        !          1435:                        tp->t_rocount = 0;
        !          1436:                        i = b_to_q(cp, ce, &tp->t_outq);
        !          1437:                        ce -= i;
        !          1438:                        tp->t_col += ce;
        !          1439:                        cp += ce, cc -= ce, tk_nout += ce;
        !          1440:                        tp->t_outcc += ce;
        !          1441:                        if (i > 0) {
        !          1442:                                /* out of c-lists, wait a bit */
        !          1443:                                ttstart(tp);
        !          1444:                                if (error = ttysleep(tp, (caddr_t)&lbolt,
        !          1445:                                            TTOPRI | PCATCH, ttybuf, 0))
        !          1446:                                        break;
        !          1447:                                goto loop;
        !          1448:                        }
        !          1449:                        if (tp->t_lflag&FLUSHO || tp->t_outq.c_cc > hiwat)
        !          1450:                                break;
        !          1451:                }
        !          1452:                ttstart(tp);
        !          1453:        }
        !          1454: out:
        !          1455:        /*
        !          1456:         * If cc is nonzero, we leave the uio structure inconsistent,
        !          1457:         * as the offset and iov pointers have moved forward,
        !          1458:         * but it doesn't matter (the call will either return short
        !          1459:         * or restart with a new uio).
        !          1460:         */
        !          1461:        uio->uio_resid += cc;
        !          1462:        return (error);
        !          1463: 
        !          1464: ovhiwat:
        !          1465:        ttstart(tp);
        !          1466:        s = spltty();
        !          1467:        /*
        !          1468:         * This can only occur if FLUSHO is set in t_lflag,
        !          1469:         * or if ttstart/oproc is synchronous (or very fast).
        !          1470:         */
        !          1471:        if (tp->t_outq.c_cc <= hiwat) {
        !          1472:                splx(s);
        !          1473:                goto loop;
        !          1474:        }
        !          1475:        if (flag & IO_NDELAY) {
        !          1476:                splx(s);
        !          1477:                uio->uio_resid += cc;
        !          1478:                if (uio->uio_resid == cnt)
        !          1479:                        return (EWOULDBLOCK);
        !          1480:                return (0);
        !          1481:        }
        !          1482:        tp->t_state |= TS_ASLEEP;
        !          1483:        error = ttysleep(tp, (caddr_t)&tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
        !          1484:        splx(s);
        !          1485:        if (error)
        !          1486:                goto out;
        !          1487:        goto loop;
        !          1488: }
        !          1489: 
        !          1490: /*
        !          1491:  * Rubout one character from the rawq of tp
        !          1492:  * as cleanly as possible.
        !          1493:  */
        !          1494: ttyrub(c, tp)
        !          1495:        register c;
        !          1496:        register struct tty *tp;
        !          1497: {
        !          1498:        register char *cp;
        !          1499:        register int savecol;
        !          1500:        int s;
        !          1501:        char *nextc();
        !          1502: 
        !          1503:        if ((tp->t_lflag&ECHO) == 0 || (tp->t_lflag&EXTPROC))
        !          1504:                return;
        !          1505:        tp->t_lflag &= ~FLUSHO; 
        !          1506:        if (tp->t_lflag&ECHOE) {
        !          1507:                if (tp->t_rocount == 0) {
        !          1508:                        /*
        !          1509:                         * Screwed by ttwrite; retype
        !          1510:                         */
        !          1511:                        ttyretype(tp);
        !          1512:                        return;
        !          1513:                }
        !          1514:                if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))
        !          1515:                        ttyrubo(tp, 2);
        !          1516:                else switch (CCLASS(c &= TTY_CHARMASK)) {
        !          1517: 
        !          1518:                case ORDINARY:
        !          1519:                        ttyrubo(tp, 1);
        !          1520:                        break;
        !          1521: 
        !          1522:                case VTAB:
        !          1523:                case BACKSPACE:
        !          1524:                case CONTROL:
        !          1525:                case RETURN:
        !          1526:                case NEWLINE:
        !          1527:                        if (tp->t_lflag&ECHOCTL)
        !          1528:                                ttyrubo(tp, 2);
        !          1529:                        break;
        !          1530: 
        !          1531:                case TAB: {
        !          1532:                        int c;
        !          1533: 
        !          1534:                        if (tp->t_rocount < tp->t_rawq.c_cc) {
        !          1535:                                ttyretype(tp);
        !          1536:                                return;
        !          1537:                        }
        !          1538:                        s = spltty();
        !          1539:                        savecol = tp->t_col;
        !          1540:                        tp->t_state |= TS_CNTTB;
        !          1541:                        tp->t_lflag |= FLUSHO;
        !          1542:                        tp->t_col = tp->t_rocol;
        !          1543:                        cp = tp->t_rawq.c_cf;
        !          1544:                        if (cp)
        !          1545:                                c = *cp;        /* XXX FIX NEXTC */
        !          1546:                        for (; cp; cp = nextc(&tp->t_rawq, cp, &c))
        !          1547:                                ttyecho(c, tp);
        !          1548:                        tp->t_lflag &= ~FLUSHO;
        !          1549:                        tp->t_state &= ~TS_CNTTB;
        !          1550:                        splx(s);
        !          1551:                        /*
        !          1552:                         * savecol will now be length of the tab
        !          1553:                         */
        !          1554:                        savecol -= tp->t_col;
        !          1555:                        tp->t_col += savecol;
        !          1556:                        if (savecol > 8)
        !          1557:                                savecol = 8;            /* overflow screw */
        !          1558:                        while (--savecol >= 0)
        !          1559:                                (void) ttyoutput('\b', tp);
        !          1560:                        break;
        !          1561:                }
        !          1562: 
        !          1563:                default:
        !          1564:                        /* XXX */
        !          1565:                        printf("ttyrub: would panic c = %d, val = %d\n",
        !          1566:                                c, CCLASS(c));
        !          1567:                        /*panic("ttyrub");*/
        !          1568:                }
        !          1569:        } else if (tp->t_lflag&ECHOPRT) {
        !          1570:                if ((tp->t_state&TS_ERASE) == 0) {
        !          1571:                        (void) ttyoutput('\\', tp);
        !          1572:                        tp->t_state |= TS_ERASE;
        !          1573:                }
        !          1574:                ttyecho(c, tp);
        !          1575:        } else
        !          1576:                ttyecho(tp->t_cc[VERASE], tp);
        !          1577:        tp->t_rocount--;
        !          1578: }
        !          1579: 
        !          1580: /*
        !          1581:  * Crt back over cnt chars perhaps
        !          1582:  * erasing them.
        !          1583:  */
        !          1584: ttyrubo(tp, cnt)
        !          1585:        register struct tty *tp;
        !          1586:        int cnt;
        !          1587: {
        !          1588: 
        !          1589:        while (--cnt >= 0)
        !          1590:                ttyoutstr("\b \b", tp);
        !          1591: }
        !          1592: 
        !          1593: /*
        !          1594:  * Reprint the rawq line.
        !          1595:  * We assume c_cc has already been checked.
        !          1596:  */
        !          1597: ttyretype(tp)
        !          1598:        register struct tty *tp;
        !          1599: {
        !          1600:        register char *cp;
        !          1601:        char *nextc();
        !          1602:        int s, c;
        !          1603: 
        !          1604:        if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
        !          1605:                ttyecho(tp->t_cc[VREPRINT], tp);
        !          1606:        (void) ttyoutput('\n', tp);
        !          1607:        s = spltty();
        !          1608:        /*** XXX *** FIX *** NEXTC IS BROKEN - DOESN'T CHECK QUOTE
        !          1609:          BIT OF FIRST CHAR ****/
        !          1610:        for (cp = tp->t_canq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_canq, cp, &c)) {
        !          1611:                ttyecho(c, tp);
        !          1612:        }
        !          1613:        for (cp = tp->t_rawq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_rawq, cp, &c)) {
        !          1614:                ttyecho(c, tp);
        !          1615:        }
        !          1616:        tp->t_state &= ~TS_ERASE;
        !          1617:        splx(s);
        !          1618:        tp->t_rocount = tp->t_rawq.c_cc;
        !          1619:        tp->t_rocol = 0;
        !          1620: }
        !          1621: 
        !          1622: /*
        !          1623:  * Echo a typed character to the terminal.
        !          1624:  */
        !          1625: ttyecho(c, tp)
        !          1626:        register c;
        !          1627:        register struct tty *tp;
        !          1628: {
        !          1629:        if ((tp->t_state&TS_CNTTB) == 0)
        !          1630:                tp->t_lflag &= ~FLUSHO;
        !          1631:        if (((tp->t_lflag&ECHO) == 0 &&
        !          1632:            ((tp->t_lflag&ECHONL) == 0 || c == '\n')) || (tp->t_lflag&EXTPROC))
        !          1633:                return;
        !          1634:        if (tp->t_lflag&ECHOCTL) {
        !          1635:                if ((c&TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
        !          1636:                    c == 0177) {
        !          1637:                        (void) ttyoutput('^', tp);
        !          1638:                        c &= TTY_CHARMASK;
        !          1639:                        if (c == 0177)
        !          1640:                                c = '?';
        !          1641:                        else
        !          1642:                                c += 'A' - 1;
        !          1643:                }
        !          1644:        }
        !          1645:        (void) ttyoutput(c, tp);
        !          1646: }
        !          1647: 
        !          1648: /*
        !          1649:  * send string cp to tp
        !          1650:  */
        !          1651: ttyoutstr(cp, tp)
        !          1652:        register char *cp;
        !          1653:        register struct tty *tp;
        !          1654: {
        !          1655:        register char c;
        !          1656: 
        !          1657:        while (c = *cp++)
        !          1658:                (void) ttyoutput(c, tp);
        !          1659: }
        !          1660: 
        !          1661: /*
        !          1662:  * Wake up any readers on a tty.
        !          1663:  */
        !          1664: ttwakeup(tp)
        !          1665:        register struct tty *tp;
        !          1666: {
        !          1667: 
        !          1668:        if (tp->t_rsel) {
        !          1669:                selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
        !          1670:                tp->t_state &= ~TS_RCOLL;
        !          1671:                tp->t_rsel = 0;
        !          1672:        }
        !          1673:        if (tp->t_state & TS_ASYNC)
        !          1674:                pgsignal(tp->t_pgrp, SIGIO, 1); 
        !          1675:        wakeup((caddr_t)&tp->t_rawq);
        !          1676: }
        !          1677: 
        !          1678: /*
        !          1679:  * Look up a code for a specified speed in a conversion table;
        !          1680:  * used by drivers to map software speed values to hardware parameters.
        !          1681:  */
        !          1682: ttspeedtab(speed, table)
        !          1683:        register struct speedtab *table;
        !          1684: {
        !          1685: 
        !          1686:        for ( ; table->sp_speed != -1; table++)
        !          1687:                if (table->sp_speed == speed)
        !          1688:                        return (table->sp_code);
        !          1689:        return (-1);
        !          1690: }
        !          1691: 
        !          1692: /*
        !          1693:  * set tty hi and low water marks
        !          1694:  *
        !          1695:  * Try to arrange the dynamics so there's about one second
        !          1696:  * from hi to low water.
        !          1697:  * 
        !          1698:  */
        !          1699: ttsetwater(tp)
        !          1700:        struct tty *tp;
        !          1701: {
        !          1702:        register cps = tp->t_ospeed / 10;
        !          1703:        register x;
        !          1704: 
        !          1705: #define clamp(x, h, l) ((x)>h ? h : ((x)<l) ? l : (x))
        !          1706:        tp->t_lowat = x = clamp(cps/2, TTMAXLOWAT, TTMINLOWAT);
        !          1707:        x += cps;
        !          1708:        x = clamp(x, TTMAXHIWAT, TTMINHIWAT);
        !          1709:        tp->t_hiwat = roundup(x, CBSIZE);
        !          1710: #undef clamp
        !          1711: }
        !          1712: 
        !          1713: /*
        !          1714:  * Report on state of foreground process group.
        !          1715:  */
        !          1716: ttyinfo(tp)
        !          1717:        register struct tty *tp;
        !          1718: {
        !          1719:        register struct proc *p, *pick;
        !          1720:        struct timeval utime, stime;
        !          1721:        int tmp;
        !          1722: 
        !          1723:        if (ttycheckoutq(tp,0) == 0) 
        !          1724:                return;
        !          1725: 
        !          1726:        /* Print load average. */
        !          1727:        tmp = (averunnable[0] * 100 + FSCALE / 2) >> FSHIFT;
        !          1728:        ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
        !          1729: 
        !          1730:        if (tp->t_session == NULL)
        !          1731:                ttyprintf(tp, "not a controlling terminal\n");
        !          1732:        else if (tp->t_pgrp == NULL)
        !          1733:                ttyprintf(tp, "no foreground process group\n");
        !          1734:        else if ((p = tp->t_pgrp->pg_mem) == NULL)
        !          1735:                ttyprintf(tp, "empty foreground process group\n");
        !          1736:        else {
        !          1737:                /* Pick interesting process. */
        !          1738:                for (pick = NULL; p != NULL; p = p->p_pgrpnxt)
        !          1739:                        if (proc_compare(pick, p))
        !          1740:                                pick = p;
        !          1741: 
        !          1742:                ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
        !          1743:                    pick->p_stat == SRUN ? "running" :
        !          1744:                    pick->p_wmesg ? pick->p_wmesg : "iowait");
        !          1745: 
        !          1746:                /*
        !          1747:                 * Lock out clock if process is running; get user/system
        !          1748:                 * cpu time.
        !          1749:                 */
        !          1750:                if (curproc == pick)
        !          1751:                        tmp = splclock();
        !          1752:                utime = pick->p_utime;
        !          1753:                stime = pick->p_stime;
        !          1754:                if (curproc == pick)
        !          1755:                        splx(tmp);
        !          1756: 
        !          1757:                /* Print user time. */
        !          1758:                ttyprintf(tp, "%d.%02du ",
        !          1759:                    utime.tv_sec, (utime.tv_usec + 5000) / 10000);
        !          1760: 
        !          1761:                /* Print system time. */
        !          1762:                ttyprintf(tp, "%d.%02ds ",
        !          1763:                    stime.tv_sec, (stime.tv_usec + 5000) / 10000);
        !          1764: 
        !          1765: #define        pgtok(a)        (((a) * NBPG) / 1024)
        !          1766:                /* Print percentage cpu, resident set size. */
        !          1767:                tmp = pick->p_pctcpu * 10000 + FSCALE / 2 >> FSHIFT;
        !          1768:                ttyprintf(tp, "%d%% %dk\n",
        !          1769:                   tmp / 100, pgtok(pick->p_vmspace->vm_rssize));
        !          1770:        }
        !          1771:        tp->t_rocount = 0;      /* so pending input will be retyped if BS */
        !          1772: }
        !          1773: 
        !          1774: /*
        !          1775:  * Returns 1 if p2 is "better" than p1
        !          1776:  *
        !          1777:  * The algorithm for picking the "interesting" process is thus:
        !          1778:  *
        !          1779:  *     1) (Only foreground processes are eligable - implied)
        !          1780:  *     2) Runnable processes are favored over anything
        !          1781:  *        else.  The runner with the highest cpu
        !          1782:  *        utilization is picked (p_cpu).  Ties are
        !          1783:  *        broken by picking the highest pid.
        !          1784:  *     3  Next, the sleeper with the shortest sleep
        !          1785:  *        time is favored.  With ties, we pick out
        !          1786:  *        just "short-term" sleepers (SSINTR == 0).
        !          1787:  *        Further ties are broken by picking the highest
        !          1788:  *        pid.
        !          1789:  *
        !          1790:  */
        !          1791: #define isrun(p)       (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
        !          1792: #define TESTAB(a, b)    ((a)<<1 | (b))
        !          1793: #define ONLYA   2
        !          1794: #define ONLYB   1
        !          1795: #define BOTH    3
        !          1796: 
        !          1797: static int
        !          1798: proc_compare(p1, p2)
        !          1799:        register struct proc *p1, *p2;
        !          1800: {
        !          1801: 
        !          1802:        if (p1 == NULL)
        !          1803:                return (1);
        !          1804:        /*
        !          1805:         * see if at least one of them is runnable
        !          1806:         */
        !          1807:        switch (TESTAB(isrun(p1), isrun(p2))) {
        !          1808:        case ONLYA:
        !          1809:                return (0);
        !          1810:        case ONLYB:
        !          1811:                return (1);
        !          1812:        case BOTH:
        !          1813:                /*
        !          1814:                 * tie - favor one with highest recent cpu utilization
        !          1815:                 */
        !          1816:                if (p2->p_cpu > p1->p_cpu)
        !          1817:                        return (1);
        !          1818:                if (p1->p_cpu > p2->p_cpu)
        !          1819:                        return (0);
        !          1820:                return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
        !          1821:        }
        !          1822:        /*
        !          1823:         * weed out zombies
        !          1824:         */
        !          1825:        switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
        !          1826:        case ONLYA:
        !          1827:                return (1);
        !          1828:        case ONLYB:
        !          1829:                return (0);
        !          1830:        case BOTH:
        !          1831:                return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
        !          1832:        }
        !          1833:        /* 
        !          1834:         * pick the one with the smallest sleep time
        !          1835:         */
        !          1836:        if (p2->p_slptime > p1->p_slptime)
        !          1837:                return (0);
        !          1838:        if (p1->p_slptime > p2->p_slptime)
        !          1839:                return (1);
        !          1840:        /*
        !          1841:         * favor one sleeping in a non-interruptible sleep
        !          1842:         */
        !          1843:        if (p1->p_flag&SSINTR && (p2->p_flag&SSINTR) == 0)
        !          1844:                return (1);
        !          1845:        if (p2->p_flag&SSINTR && (p1->p_flag&SSINTR) == 0)
        !          1846:                return (0);
        !          1847:        return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
        !          1848: }
        !          1849: 
        !          1850: /*
        !          1851:  * Output char to tty; console putchar style.
        !          1852:  */
        !          1853: tputchar(c, tp)
        !          1854:        int c;
        !          1855:        struct tty *tp;
        !          1856: {
        !          1857:        register s = spltty();
        !          1858: 
        !          1859:        if ((tp->t_state & (TS_CARR_ON|TS_ISOPEN)) == (TS_CARR_ON|TS_ISOPEN)) {
        !          1860:                if (c == '\n')
        !          1861:                        (void) ttyoutput('\r', tp);
        !          1862:                (void) ttyoutput(c, tp);
        !          1863:                ttstart(tp);
        !          1864:                splx(s);
        !          1865:                return (0);
        !          1866:        }
        !          1867:        splx(s);
        !          1868:        return (-1);
        !          1869: }
        !          1870: 
        !          1871: /*
        !          1872:  * Sleep on chan, returning ERESTART if tty changed
        !          1873:  * while we napped and returning any errors (e.g. EINTR/ETIMEDOUT)
        !          1874:  * reported by tsleep.  If the tty is revoked, restarting a pending
        !          1875:  * call will redo validation done at the start of the call.
        !          1876:  */
        !          1877: ttysleep(tp, chan, pri, wmesg, timo)
        !          1878:        struct tty *tp;
        !          1879:        caddr_t chan;
        !          1880:        int pri;
        !          1881:        char *wmesg;
        !          1882:        int timo;
        !          1883: {
        !          1884:        int error;
        !          1885:        short gen = tp->t_gen;
        !          1886: 
        !          1887:        if (error = tsleep(chan, pri, wmesg, timo))
        !          1888:                return (error);
        !          1889:        if (tp->t_gen != gen)
        !          1890:                return (ERESTART);
        !          1891:        return (0);
        !          1892: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.