projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Cleanups for 4.4BSD-Lite
[unix-history] / usr / src / sys / kern / tty.c
diff --git a/usr/src/sys/kern/tty.c b/usr/src/sys/kern/tty.c
index 9c07a05..4b12b5e 100644 (file)
--- a/usr/src/sys/kern/tty.c
+++ b/usr/src/sys/kern/tty.c
@@ -1,33 +1,36 @@
-/*
- * Copyright (c) 1982, 1986, 1990 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * Copyright (c) 1982, 1986, 1990, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
  *
  *
- *     @(#)tty.c       7.25 (Berkeley) %G%
+ *     @(#)tty.c       8.1 (Berkeley) %G%
  */
 
  */
 
-#include "param.h"
-#include "systm.h"
-#include "user.h"
-#include "ioctl.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/ioctl.h>
+#include <sys/proc.h>
 #define TTYDEFCHARS
 #define TTYDEFCHARS
-#include "tty.h"
+#include <sys/tty.h>
 #undef TTYDEFCHARS
 #define TTYDEFCHARS
 #include "ttydefaults.h"
 #undef TTYDEFCHARS
 #include "termios.h"
 #undef TTYDEFCHARS
 #define TTYDEFCHARS
 #include "ttydefaults.h"
 #undef TTYDEFCHARS
 #include "termios.h"
-#include "proc.h"
-#include "file.h"
-#include "conf.h"
-#include "dkstat.h"
-#include "uio.h"
-#include "kernel.h"
-#include "vnode.h"
+#include <sys/file.h>
+#include <sys/conf.h>
+#include <sys/dkstat.h>
+#include <sys/uio.h>
+#include <sys/kernel.h>
+#include <sys/vnode.h>
+#include <sys/syslog.h>
+
+#include <vm/vm.h>
 #include "syslog.h"
 
 #include "syslog.h"
 
-#include "machine/reg.h"
-#include "syslog.h"
+static int proc_compare __P((struct proc *p1, struct proc *p2));
 
 /* symbolic sleep message strings */
 char ttyin[] = "ttyin";
 
 /* symbolic sleep message strings */
 char ttyin[] = "ttyin";
@@ -43,49 +46,76 @@ char ttybuf[] = "ttybuf";
  * indicates parity, the 7th bit indicates the character
  * is an alphameric or underscore (for ALTWERASE), and the 
  * low 6 bits indicate delay type.  If the low 6 bits are 0
  * indicates parity, the 7th bit indicates the character
  * is an alphameric or underscore (for ALTWERASE), and the 
  * low 6 bits indicate delay type.  If the low 6 bits are 0
- * then the character needs no special processing on output.
+ * then the character needs no special processing on output;
+ * classes other than 0 might be translated or (not currently)
+ * require delays.
  */
  */
+#define        PARITY(c)       (partab[c] & 0x80)
+#define        ISALPHA(c)      (partab[(c)&TTY_CHARMASK] & 0x40)
+#define        CCLASSMASK      0x3f
+#define        CCLASS(c)       (partab[c] & CCLASSMASK)
+
+#define        E       0x00    /* even parity */
+#define        O       0x80    /* odd parity */
+#define        ALPHA   0x40    /* alpha or underscore */
+
+#define        NO      ORDINARY
+#define        NA      ORDINARY|ALPHA
+#define        CC      CONTROL
+#define        BS      BACKSPACE
+#define        NL      NEWLINE
+#define        TB      TAB
+#define        VT      VTAB
+#define        CR      RETURN
 
 char partab[] = {
 
 char partab[] = {
-       0001,0201,0201,0001,0201,0001,0001,0201,        /* nul - bel */
-       0202,0004,0003,0201,0005,0206,0201,0001,        /* bs - si */
-       0201,0001,0001,0201,0001,0201,0201,0001,        /* dle - etb */
-       0001,0201,0201,0001,0201,0001,0001,0201,        /* can - us */
-       0200,0000,0000,0200,0000,0200,0200,0000,        /* sp - ' */
-       0000,0200,0200,0000,0200,0000,0000,0200,        /* ( - / */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* 0 - 7 */
-       0300,0100,0000,0200,0000,0200,0200,0000,        /* 8 - ? */
-       0200,0100,0100,0300,0100,0300,0300,0100,        /* @ - G */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* H - O */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* P - W */
-       0300,0100,0100,0200,0000,0200,0200,0300,        /* X - _ */
-       0000,0300,0300,0100,0300,0100,0100,0300,        /* ` - g */
-       0300,0100,0100,0300,0100,0300,0300,0100,        /* h - o */
-       0300,0100,0100,0300,0100,0300,0300,0100,        /* p - w */
-       0100,0300,0300,0000,0200,0000,0000,0201,        /* x - del */
+       E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* nul - bel */
+       O|BS, E|TB, E|NL, O|CC, E|VT, O|CR, O|CC, E|CC, /* bs - si */
+       O|CC, E|CC, E|CC, O|CC, E|CC, O|CC, O|CC, E|CC, /* dle - etb */
+       E|CC, O|CC, O|CC, E|CC, O|CC, E|CC, E|CC, O|CC, /* can - us */
+       O|NO, E|NO, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* sp - ' */
+       E|NO, O|NO, O|NO, E|NO, O|NO, E|NO, E|NO, O|NO, /* ( - / */
+       E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* 0 - 7 */
+       O|NA, E|NA, E|NO, O|NO, E|NO, O|NO, O|NO, E|NO, /* 8 - ? */
+       O|NO, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* @ - G */
+       E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* H - O */
+       E|NA, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* P - W */
+       O|NA, E|NA, E|NA, O|NO, E|NO, O|NO, O|NO, O|NA, /* X - _ */
+       E|NO, O|NA, O|NA, E|NA, O|NA, E|NA, E|NA, O|NA, /* ` - g */
+       O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* h - o */
+       O|NA, E|NA, E|NA, O|NA, E|NA, O|NA, O|NA, E|NA, /* p - w */
+       E|NA, O|NA, O|NA, E|NO, O|NO, E|NO, E|NO, O|CC, /* x - del */
        /*
        /*
-        * meta chars
+        * "meta" chars; should be settable per charset.
+        * For now, treat all as normal characters.
         */
         */
-       0001,0201,0201,0001,0201,0001,0001,0201,        /* nul - bel */
-       0202,0004,0003,0201,0005,0206,0201,0001,        /* bs - si */
-       0201,0001,0001,0201,0001,0201,0201,0001,        /* dle - etb */
-       0001,0201,0201,0001,0201,0001,0001,0201,        /* can - us */
-       0200,0000,0000,0200,0000,0200,0200,0000,        /* sp - ' */
-       0000,0200,0200,0000,0200,0000,0000,0200,        /* ( - / */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* 0 - 7 */
-       0300,0100,0000,0200,0000,0200,0200,0000,        /* 8 - ? */
-       0200,0100,0100,0300,0100,0300,0300,0100,        /* @ - G */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* H - O */
-       0100,0300,0300,0100,0300,0100,0100,0300,        /* P - W */
-       0300,0100,0100,0200,0000,0200,0200,0300,        /* X - _ */
-       0000,0300,0300,0100,0300,0100,0100,0300,        /* ` - g */
-       0300,0100,0100,0300,0100,0300,0300,0100,        /* h - o */
-       0300,0100,0100,0300,0100,0300,0300,0100,        /* p - w */
-       0100,0300,0300,0000,0200,0000,0000,0201,        /* x - del */
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
+       NA,   NA,   NA,   NA,   NA,   NA,   NA,   NA,
 };
 };
+#undef NO
+#undef NA
+#undef CC
+#undef BS
+#undef NL
+#undef TB
+#undef VT
+#undef CR
 
 extern struct tty *constty;            /* temporary virtual console */
 
 extern struct tty *constty;            /* temporary virtual console */
-extern char partab[], maptab[];
 
 /*
  * Is 'c' a line delimiter ("break" character)?
 
 /*
  * Is 'c' a line delimiter ("break" character)?
@@ -107,12 +137,13 @@ extern char partab[], maptab[];
 ttychars(tp)
        struct tty *tp;
 {
 ttychars(tp)
        struct tty *tp;
 {
+
        bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
 }
 
 /*
  *
        bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
 }
 
 /*
  *
- * Wait for output to drain, then flush input waiting.
+ * Flush tty after output has drained.
  */
 ttywflush(tp)
        struct tty *tp;
  */
 ttywflush(tp)
        struct tty *tp;
@@ -140,41 +171,48 @@ ttywait(tp)
            tp->t_oproc) {
                (*tp->t_oproc)(tp);
                tp->t_state |= TS_ASLEEP;
            tp->t_oproc) {
                (*tp->t_oproc)(tp);
                tp->t_state |= TS_ASLEEP;
-               if (error = tsleep((caddr_t)&tp->t_outq, TTOPRI | PCATCH,
-                   ttyout, 0))
+               if (error = ttysleep(tp, (caddr_t)&tp->t_outq, 
+                   TTOPRI | PCATCH, ttyout, 0))
                        break;
        }
        splx(s);
        return (error);
 }
 
                        break;
        }
        splx(s);
        return (error);
 }
 
+#define        flushq(q) { \
+       if ((q)->c_cc) \
+               ndflush(q, (q)->c_cc); \
+}
+
 /*
 /*
- * Flush all TTY queues
+ * Flush TTY read and/or write queues,
+ * notifying anyone waiting.
  */
 ttyflush(tp, rw)
        register struct tty *tp;
  */
 ttyflush(tp, rw)
        register struct tty *tp;
+       int rw;
 {
 {
-       register s;
+       register int s;
 
        s = spltty();
        if (rw & FREAD) {
 
        s = spltty();
        if (rw & FREAD) {
-               while (getc(&tp->t_canq) >= 0)
-                       ;
+               flushq(&tp->t_canq);
+               flushq(&tp->t_rawq);
+               tp->t_rocount = 0;
+               tp->t_rocol = 0;
+               tp->t_state &= ~TS_LOCAL;
                ttwakeup(tp);
        }
        if (rw & FWRITE) {
                ttwakeup(tp);
        }
        if (rw & FWRITE) {
-               wakeup((caddr_t)&tp->t_outq); /* XXX? what about selwakeup? */
                tp->t_state &= ~TS_TTSTOP;
                tp->t_state &= ~TS_TTSTOP;
+#ifdef sun4c                                           /* XXX */
+               (*tp->t_stop)(tp, rw);
+#else
                (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
                (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
-               while (getc(&tp->t_outq) >= 0)
-                       ;
-       }
-       if (rw & FREAD) {
-               while (getc(&tp->t_rawq) >= 0)
-                       ;
-               tp->t_rocount = 0;
-               tp->t_rocol = 0;
-               tp->t_state &= ~TS_LOCAL;
+#endif
+               flushq(&tp->t_outq);
+               wakeup((caddr_t)&tp->t_outq);
+               selwakeup(&tp->t_wsel);
        }
        splx(s);
 }
        }
        splx(s);
 }
@@ -196,7 +234,7 @@ ttyblock(tp)
         * Block further input iff:
         * Current input > threshold AND input is available to user program
         */
         * Block further input iff:
         * Current input > threshold AND input is available to user program
         */
-       if (x >= TTYHOG/2 && 
+       if (x >= TTYHOG/2 && (tp->t_state & TS_TBLOCK) == 0 &&
            (!(tp->t_lflag&ICANON)) || (tp->t_canq.c_cc > 0) &&
            tp->t_cc[VSTOP] != POSIX_V_DISABLE) {
                if (putc(tp->t_cc[VSTOP], &tp->t_outq)==0) {
            (!(tp->t_lflag&ICANON)) || (tp->t_canq.c_cc > 0) &&
            tp->t_cc[VSTOP] != POSIX_V_DISABLE) {
                if (putc(tp->t_cc[VSTOP], &tp->t_outq)==0) {
@@ -206,46 +244,47 @@ ttyblock(tp)
        }
 }
 
        }
 }
 
-/*
- * Restart typewriter output following a delay
- * timeout.
- * The name of the routine is passed to the timeout
- * subroutine and it is called during a clock interrupt.
- */
-ttrstrt(tp)
+ttstart(tp)
        struct tty *tp;
 {
 
        struct tty *tp;
 {
 
+       if (tp->t_oproc)                /* kludge for pty */
+               (*tp->t_oproc)(tp);
+}
+
+void
+ttrstrt(tp0)
+       void *tp0;
+{
+       struct tty *tp;
+       int s;
+
+       tp = (struct tty *)tp0;
 #ifdef DIAGNOSTIC
        if (tp == 0)
                panic("ttrstrt");
 #endif
 #ifdef DIAGNOSTIC
        if (tp == 0)
                panic("ttrstrt");
 #endif
+       s = spltty();
        tp->t_state &= ~TS_TIMEOUT;
        ttstart(tp);
        tp->t_state &= ~TS_TIMEOUT;
        ttstart(tp);
+       splx(s);
 }
 
 }
 
-/*
- * Start output on the typewriter. It is used from the top half
- * after some characters have been put on the output queue,
- * from the interrupt routine to transmit the next
- * character, and after a timeout has finished.
- */
-ttstart(tp)
-       struct tty *tp;
-{
-
-       if (tp->t_oproc)                /* kludge for pty */
-               (*tp->t_oproc)(tp);
-}
 
 /*
 
 /*
- * Common code for tty ioctls.
+ * Common code for ioctls on tty devices.
+ * Called after line-discipline-specific ioctl
+ * has been called to do discipline-specific functions
+ * and/or reject any of these ioctl commands.
  */
 /*ARGSUSED*/
 ttioctl(tp, com, data, flag)
        register struct tty *tp;
  */
 /*ARGSUSED*/
 ttioctl(tp, com, data, flag)
        register struct tty *tp;
+       int com;
        caddr_t data;
        caddr_t data;
+       int flag;
 {
 {
+       register struct proc *p = curproc;              /* XXX */
        extern int nldisp;
        int soft;
        int s, error;
        extern int nldisp;
        int soft;
        int s, error;
@@ -263,12 +302,7 @@ ttioctl(tp, com, data, flag)
        case TIOCSETA:
        case TIOCSETAW:
        case TIOCSETAF:
        case TIOCSETA:
        case TIOCSETAW:
        case TIOCSETAF:
-/**** these get removed ****
-       case TIOCSETAS:
-       case TIOCSETAWS:
-       case TIOCSETAFS:
-/***************************/
-#ifdef COMPAT_43
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
        case TIOCSETP:
        case TIOCSETN:
        case TIOCSETC:
        case TIOCSETP:
        case TIOCSETN:
        case TIOCSETC:
@@ -278,14 +312,13 @@ ttioctl(tp, com, data, flag)
        case TIOCLSET:
        case OTIOCSETD:
 #endif
        case TIOCLSET:
        case OTIOCSETD:
 #endif
-               while (isbackground(u.u_procp, tp) && 
-                  u.u_procp->p_pgrp->pg_jobc &&
-                  (u.u_procp->p_flag&SVFORK) == 0 &&
-                  (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
-                  (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0) {
-                       pgsignal(u.u_procp->p_pgrp, SIGTTOU);
-                       if (error = tsleep((caddr_t)&lbolt, TTOPRI | PCATCH,
-                           ttybg, 0))
+               while (isbackground(curproc, tp) && 
+                  p->p_pgrp->pg_jobc && (p->p_flag&SPPWAIT) == 0 &&
+                  (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
+                  (p->p_sigmask & sigmask(SIGTTOU)) == 0) {
+                       pgsignal(p->p_pgrp, SIGTTOU, 1);
+                       if (error = ttysleep(tp, (caddr_t)&lbolt, 
+                           TTOPRI | PCATCH, ttybg, 0)) 
                                return (error);
                }
                break;
                                return (error);
                }
                break;
@@ -311,7 +344,7 @@ ttioctl(tp, com, data, flag)
                        return (ENXIO);
                if (t != tp->t_line) {
                        s = spltty();
                        return (ENXIO);
                if (t != tp->t_line) {
                        s = spltty();
-                       (*linesw[tp->t_line].l_close)(tp);
+                       (*linesw[tp->t_line].l_close)(tp, flag);
                        error = (*linesw[t].l_open)(dev, tp);
                        if (error) {
                                (void)(*linesw[tp->t_line].l_open)(dev, tp);
                        error = (*linesw[t].l_open)(dev, tp);
                        if (error) {
                                (void)(*linesw[tp->t_line].l_open)(dev, tp);
@@ -328,16 +361,23 @@ ttioctl(tp, com, data, flag)
 
        /* prevent more opens on channel */
        case TIOCEXCL:
 
        /* prevent more opens on channel */
        case TIOCEXCL:
+               s = spltty();
                tp->t_state |= TS_XCLUDE;
                tp->t_state |= TS_XCLUDE;
+               splx(s);
                break;
 
        case TIOCNXCL:
                break;
 
        case TIOCNXCL:
+               s = spltty();
                tp->t_state &= ~TS_XCLUDE;
                tp->t_state &= ~TS_XCLUDE;
+               splx(s);
                break;
 
                break;
 
+#ifdef TIOCHPCL
        case TIOCHPCL:
        case TIOCHPCL:
+               s = spltty();
                tp->t_cflag |= HUPCL;
                break;
                tp->t_cflag |= HUPCL;
                break;
+#endif
 
        case TIOCFLUSH: {
                register int flags = *(int *)data;
 
        case TIOCFLUSH: {
                register int flags = *(int *)data;
@@ -351,10 +391,12 @@ ttioctl(tp, com, data, flag)
        }
 
        case FIOASYNC:
        }
 
        case FIOASYNC:
+               s = spltty();
                if (*(int *)data)
                        tp->t_state |= TS_ASYNC;
                else
                        tp->t_state &= ~TS_ASYNC;
                if (*(int *)data)
                        tp->t_state |= TS_ASYNC;
                else
                        tp->t_state &= ~TS_ASYNC;
+               splx(s);
                break;
 
        case FIONBIO:
                break;
 
        case FIONBIO:
@@ -362,7 +404,7 @@ ttioctl(tp, com, data, flag)
 
        /* return number of characters immediately available */
        case FIONREAD:
 
        /* return number of characters immediately available */
        case FIONREAD:
-               *(off_t *)data = ttnread(tp);
+               *(int *)data = ttnread(tp);
                break;
 
        case TIOCOUTQ:
                break;
 
        case TIOCOUTQ:
@@ -373,7 +415,11 @@ ttioctl(tp, com, data, flag)
                s = spltty();
                if ((tp->t_state&TS_TTSTOP) == 0) {
                        tp->t_state |= TS_TTSTOP;
                s = spltty();
                if ((tp->t_state&TS_TTSTOP) == 0) {
                        tp->t_state |= TS_TTSTOP;
+#ifdef sun4c                                           /* XXX */
+                       (*tp->t_stop)(tp, 0);
+#else
                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+#endif
                }
                splx(s);
                break;
                }
                splx(s);
                break;
@@ -392,11 +438,11 @@ ttioctl(tp, com, data, flag)
         * Simulate typing of a character at the terminal.
         */
        case TIOCSTI:
         * Simulate typing of a character at the terminal.
         */
        case TIOCSTI:
-               if (u.u_uid && (flag & FREAD) == 0)
+               if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
                        return (EPERM);
                        return (EPERM);
-               if (u.u_uid && !isctty(u.u_procp, tp))
+               if (p->p_ucred->cr_uid && !isctty(p, tp))
                        return (EACCES);
                        return (EACCES);
-               (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
+               (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
                break;
 
        case TIOCGETA: {
                break;
 
        case TIOCGETA: {
@@ -437,6 +483,13 @@ ttioctl(tp, com, data, flag)
                }
                tp->t_iflag = t->c_iflag;
                tp->t_oflag = t->c_oflag;
                }
                tp->t_iflag = t->c_iflag;
                tp->t_oflag = t->c_oflag;
+               /*
+                * Make the EXTPROC bit read only.
+                */
+               if (tp->t_lflag&EXTPROC)
+                       t->c_lflag |= EXTPROC;
+               else
+                       t->c_lflag &= ~EXTPROC;
                tp->t_lflag = t->c_lflag;
                bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
                splx(s);
                tp->t_lflag = t->c_lflag;
                bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
                splx(s);
@@ -449,7 +502,6 @@ ttioctl(tp, com, data, flag)
         * Set terminal process group.
         */
        case TIOCSPGRP: {
         * Set terminal process group.
         */
        case TIOCSPGRP: {
-               register struct proc *p = u.u_procp;
                register struct pgrp *pgrp = pgfind(*(int *)data);
 
                if (!isctty(p, tp))
                register struct pgrp *pgrp = pgfind(*(int *)data);
 
                if (!isctty(p, tp))
@@ -461,16 +513,16 @@ ttioctl(tp, com, data, flag)
        }
 
        case TIOCGPGRP:
        }
 
        case TIOCGPGRP:
-               if (!isctty(u.u_procp, tp))
+               if (!isctty(p, tp))
                        return (ENOTTY);
                        return (ENOTTY);
-               *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0;
+               *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
                break;
 
        case TIOCSWINSZ:
                if (bcmp((caddr_t)&tp->t_winsize, data,
                    sizeof (struct winsize))) {
                        tp->t_winsize = *(struct winsize *)data;
                break;
 
        case TIOCSWINSZ:
                if (bcmp((caddr_t)&tp->t_winsize, data,
                    sizeof (struct winsize))) {
                        tp->t_winsize = *(struct winsize *)data;
-                       pgsignal(tp->t_pgrp, SIGWINCH);
+                       pgsignal(tp->t_pgrp, SIGWINCH, 1);
                }
                break;
 
                }
                break;
 
@@ -485,7 +537,7 @@ ttioctl(tp, com, data, flag)
                            (TS_CARR_ON|TS_ISOPEN))
                                return (EBUSY);
 #ifndef        UCONSOLE
                            (TS_CARR_ON|TS_ISOPEN))
                                return (EBUSY);
 #ifndef        UCONSOLE
-                       if (error = suser(u.u_cred, &u.u_acflag))
+                       if (error = suser(p->p_ucred, &p->p_acflag))
                                return (error);
 #endif
                        constty = tp;
                                return (error);
 #endif
                        constty = tp;
@@ -493,22 +545,10 @@ ttioctl(tp, com, data, flag)
                        constty = NULL;
                break;
 
                        constty = NULL;
                break;
 
-#ifdef COMPAT_43
-       case TIOCGETP:
-       case TIOCSETP:
-       case TIOCSETN:
-       case TIOCGETC:
-       case TIOCSETC:
-       case TIOCSLTC:
-       case TIOCGLTC:
-       case TIOCLBIS:
-       case TIOCLBIC:
-       case TIOCLSET:
-       case TIOCLGET:
-       case OTIOCGETD:
-       case OTIOCSETD:
-               return(ttcompat(tp, com, data, flag));
-#endif
+       case TIOCDRAIN:
+               if (error = ttywait(tp))
+                       return (error);
+               break;
 
        /* allow old ioctls for now */
        case TIOCGETP:
 
        /* allow old ioctls for now */
        case TIOCGETP:
@@ -525,7 +565,11 @@ ttioctl(tp, com, data, flag)
                return(ottioctl(tp, com, data, flag));
 
        default:
                return(ottioctl(tp, com, data, flag));
 
        default:
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+               return (ttcompat(tp, com, data, flag));
+#else
                return (-1);
                return (-1);
+#endif
        }
        return (0);
 }
        }
        return (0);
 }
@@ -583,9 +627,10 @@ ttnread(tp)
        return (nread);
 }
 
        return (nread);
 }
 
-ttselect(dev, rw)
+ttselect(dev, rw, p)
        dev_t dev;
        int rw;
        dev_t dev;
        int rw;
+       struct proc *p;
 {
        register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
        int nread;
 {
        register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
        int nread;
@@ -598,19 +643,13 @@ ttselect(dev, rw)
                if (nread > 0 || 
                   ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
                        goto win;
                if (nread > 0 || 
                   ((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
                        goto win;
-               if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
-                       tp->t_state |= TS_RCOLL;
-               else
-                       tp->t_rsel = u.u_procp;
+               selrecord(p, &tp->t_rsel);
                break;
 
        case FWRITE:
                if (tp->t_outq.c_cc <= tp->t_lowat)
                        goto win;
                break;
 
        case FWRITE:
                if (tp->t_outq.c_cc <= tp->t_lowat)
                        goto win;
-               if (tp->t_wsel && tp->t_wsel->p_wchan == (caddr_t)&selwait)
-                       tp->t_state |= TS_WCOLL;
-               else
-                       tp->t_wsel = u.u_procp;
+               selrecord(p, &tp->t_wsel);
                break;
        }
        splx(s);
                break;
        }
        splx(s);
@@ -621,12 +660,13 @@ win:
 }
 
 /*
 }
 
 /*
- * Initial open of tty, or (re)entry to line discipline.
+ * Initial open of tty, or (re)entry to standard tty line discipline.
  */
 ttyopen(dev, tp)
        dev_t dev;
        register struct tty *tp;
 {
  */
 ttyopen(dev, tp)
        dev_t dev;
        register struct tty *tp;
 {
+       int s = spltty();
 
        tp->t_dev = dev;
 
 
        tp->t_dev = dev;
 
@@ -639,21 +679,28 @@ ttyopen(dev, tp)
                 *  old (old) line discipline.
                 */
        }
                 *  old (old) line discipline.
                 */
        }
+       splx(s);
        return (0);
 }
 
 /*
  * "close" a line discipline
  */
        return (0);
 }
 
 /*
  * "close" a line discipline
  */
-ttylclose(tp)
-       register struct tty *tp;
+ttylclose(tp, flag)
+       struct tty *tp;
+       int flag;
 {
 
 {
 
-       ttywflush(tp);
+       if (flag&IO_NDELAY)
+               ttyflush(tp, FREAD|FWRITE);
+       else
+               ttywflush(tp);
 }
 
 /*
 }
 
 /*
- * clean tp on last close
+ * Handle close() on a tty line: flush and set to initial state,
+ * bumping generation number so that pending read/write calls
+ * can detect recycling of the tty.
  */
 ttyclose(tp)
        register struct tty *tp;
  */
 ttyclose(tp)
        register struct tty *tp;
@@ -664,6 +711,7 @@ ttyclose(tp)
        tp->t_session = NULL;
        tp->t_pgrp = NULL;
        tp->t_state = 0;
        tp->t_session = NULL;
        tp->t_pgrp = NULL;
        tp->t_state = 0;
+       tp->t_gen++;
        return (0);
 }
 
        return (0);
 }
 
@@ -674,6 +722,7 @@ ttyclose(tp)
  */
 ttymodem(tp, flag)
        register struct tty *tp;
  */
 ttymodem(tp, flag)
        register struct tty *tp;
+       int flag;
 {
 
        if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag & MDMBUF)) {
 {
 
        if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag & MDMBUF)) {
@@ -685,20 +734,22 @@ ttymodem(tp, flag)
                        ttstart(tp);
                } else if ((tp->t_state&TS_TTSTOP) == 0) {
                        tp->t_state |= TS_TTSTOP;
                        ttstart(tp);
                } else if ((tp->t_state&TS_TTSTOP) == 0) {
                        tp->t_state |= TS_TTSTOP;
+#ifdef sun4c                                           /* XXX */
+                       (*tp->t_stop)(tp, 0);
+#else
                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
                        (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+#endif
                }
        } else if (flag == 0) {
                /*
                 * Lost carrier.
                 */
                tp->t_state &= ~TS_CARR_ON;
                }
        } else if (flag == 0) {
                /*
                 * Lost carrier.
                 */
                tp->t_state &= ~TS_CARR_ON;
-               if (tp->t_state & TS_ISOPEN) {
-                       if ((tp->t_lflag & NOHANG) == 0) {
-                               pgsignal(tp->t_pgrp, SIGHUP);
-                               pgsignal(tp->t_pgrp, SIGCONT);
-                               ttyflush(tp, FREAD|FWRITE);
-                               return (0);
-                       }
+               if (tp->t_state&TS_ISOPEN && (tp->t_cflag&CLOCAL) == 0) {
+                       if (tp->t_session && tp->t_session->s_leader)
+                               psignal(tp->t_session->s_leader, SIGHUP);
+                       ttyflush(tp, FREAD|FWRITE);
+                       return (0);
                }
        } else {
                /*
                }
        } else {
                /*
@@ -723,10 +774,13 @@ nullmodem(tp, flag)
                tp->t_state |= TS_CARR_ON;
        else {
                tp->t_state &= ~TS_CARR_ON;
                tp->t_state |= TS_CARR_ON;
        else {
                tp->t_state &= ~TS_CARR_ON;
-               if ((tp->t_lflag & NOHANG) == 0)
-                       pgsignal(tp->t_pgrp, SIGHUP);
+               if ((tp->t_cflag&CLOCAL) == 0) {
+                       if (tp->t_session && tp->t_session->s_leader)
+                               psignal(tp->t_session->s_leader, SIGHUP);
+                       return (0);
+               }
        }
        }
-       return (flag);
+       return (1);
 }
 
 /*
 }
 
 /*
@@ -750,13 +804,7 @@ ttypend(tp)
 }
 
 /*
 }
 
 /*
- *
- *
- * Place a character on raw TTY input queue,
- * putting in delimiters and waking up top
- * half as needed.  Also echo if required.
- * The arguments are the character and the
- * appropriate tty structure.
+ * Process input of a single character received on a tty.
  */
 ttyinput(c, tp)
        register c;
  */
 ttyinput(c, tp)
        register c;
@@ -819,21 +867,7 @@ ttyinput(c, tp)
         * In tandem mode, check high water mark.
         */
        if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))
         * In tandem mode, check high water mark.
         */
        if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))
-               c &= 0177;
-       /*
-        * Check for literal nexting very first
-        */
-       if (tp->t_state&TS_LNCH) {
-               c |= TTY_QUOTE;
-               tp->t_state &= ~TS_LNCH;
-       }
-       /*
-        * Scan for special characters.  This code
-        * is really just a big case statement with
-        * non-constant cases.  The bottom of the
-        * case statement is labeled ``endcase'', so goto
-        * it after a case match, or similar.
-        */
+               c &= ~0x80;
 
        /*
         * Extensions to POSIX input modes which aren't controlled
 
        /*
         * Extensions to POSIX input modes which aren't controlled
@@ -843,46 +877,25 @@ ttyinput(c, tp)
                if (CCEQ(cc[VLNEXT],c) && (iflag&ISTRIP)) {
                        if (lflag&ECHO)
                                ttyout("^\b", tp); /*XXX - presumes too much */
                if (CCEQ(cc[VLNEXT],c) && (iflag&ISTRIP)) {
                        if (lflag&ECHO)
                                ttyout("^\b", tp); /*XXX - presumes too much */
-                       tp->t_state |= TS_LNCH;
-                       goto endcase;
                }
                }
-               if (CCEQ(cc[VFLUSHO],c)) {
-                       if (lflag&FLUSHO)
-                               tp->t_lflag &= ~FLUSHO;
-                       else {
-                               ttyflush(tp, FWRITE);
+               /*
+                * Signals.
+                */
+               if (lflag&ISIG) {
+                       if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
+                               if ((lflag&NOFLSH) == 0)
+                                       ttyflush(tp, FREAD|FWRITE);
                                ttyecho(c, tp);
                                ttyecho(c, tp);
-                               if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
-                                       ttyretype(tp);
                                tp->t_lflag |= FLUSHO;
                        }
                                tp->t_lflag |= FLUSHO;
                        }
-                       goto startoutput;
-               }
-       }
-
-       /*
-        * Signals.
-        */
-       if (lflag&ISIG) {
-               if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
-                       if ((lflag&NOFLSH) == 0)
-                               ttyflush(tp, FREAD|FWRITE);
-                       ttyecho(c, tp);
-                       gsignal(tp->t_pgrp, CCEQ(cc[VINTR],c) ? 
-                               SIGINT : SIGQUIT);
-                       goto endcase;
-               }
-               if (CCEQ(cc[VSUSP],c)) {
-                       if ((lflag&NOFLSH) == 0)
-                               ttyflush(tp, FREAD);
-                       ttyecho(c, tp);
-                       pgsignal(tp->t_pgrp, SIGTSTP);
-                       goto endcase;
+                       if (CCEQ(cc[VSUSP], c)) {
+                               if ((lflag&NOFLSH) == 0)
+                                       ttyflush(tp, FREAD);
+                               ttyecho(c, tp);
+                               pgsignal(tp->t_pgrp, SIGTSTP, 1);
+                               goto endcase;
+                       }
                }
                }
-       }
-       /*
-        * Handle start/stop characters.
-        */
        if (iflag&IXON) {
                if (CCEQ(cc[VSTOP],c)) {
                        if ((tp->t_state&TS_TTSTOP) == 0) {
        if (iflag&IXON) {
                if (CCEQ(cc[VSTOP],c)) {
                        if ((tp->t_state&TS_TTSTOP) == 0) {
@@ -900,78 +913,6 @@ ttyinput(c, tp)
                if (CCEQ(cc[VSTART], c))
                        goto restartoutput;
        }
                if (CCEQ(cc[VSTART], c))
                        goto restartoutput;
        }
-       /*
-        * IGNCR, ICRNL, & INLCR
-        */
-       if (c == '\r') {
-               if (iflag&IGNCR)
-                       goto endcase;
-               else if (iflag&ICRNL)
-                       c = '\n';
-       }
-       else if (c == '\n' && iflag&INLCR)
-               c = '\r';
-       else if (c == '\n' && iflag&INLCR)
-               c = '\r';
-       /*
-        * Non canonical mode, don't process line editing
-        * characters; check high water mark for wakeup.
-        * 
-        * 
-        */
-       if (!(lflag&ICANON)) {
-               if (tp->t_rawq.c_cc > TTYHOG) {
-                       if (iflag&IMAXBEL) {
-                               if (tp->t_outq.c_cc < tp->t_hiwat)
-                                       (void) ttyoutput(CTRL('g'), tp);
-                       } else
-                               ttyflush(tp, FREAD | FWRITE);
-               } else {
-                       if (putc(c, &tp->t_rawq) >= 0) {
-                               ttwakeup(tp);
-                               ttyecho(c, tp);
-                       }
-               }
-               goto endcase;
-       }
-       /*
-        * From here on down canonical mode character
-        * processing takes place.
-        */
-
-       /* 
-        * Oldstyle quoting of erase, kill, and eof chars.
-        *
-        * Historically is '\' , but can be changed (read: disabled)
-        * with the VQUOTE subscript.
-        */
-
-       /*
-        * erase (^H / ^?)
-        */
-       if (CCEQ(cc[VERASE], c)) {
-               if (tp->t_rawq.c_cc)
-                       ttyrub(unputc(&tp->t_rawq), tp);
-               goto endcase;
-       }
-               if (lflag&ECHOKE && tp->t_rawq.c_cc == tp->t_rocount &&
-                   (lflag&ECHOPRT) == 0) {
-                       while (tp->t_rawq.c_cc)
-                               ttyrub(unputc(&tp->t_rawq), tp);
-               } else {
-                       ttyecho(c, tp);
-                       if (lflag&ECHOK || lflag&ECHOKE)
-                               ttyecho('\n', tp);
-                       while (getc(&tp->t_rawq) > 0)
-                               ;
-                       tp->t_rocount = 0;
-               }
-               tp->t_state &= ~TS_LOCAL;
-               goto endcase;
-       }
-       /*
-        * word erase (^W)
-        */
                        c = unputc(&tp->t_rawq);
                } while (c != ' ' && c != '\t');
                (void) putc(c, &tp->t_rawq);
                        c = unputc(&tp->t_rawq);
                } while (c != ' ' && c != '\t');
                (void) putc(c, &tp->t_rawq);
@@ -984,23 +925,10 @@ ttyinput(c, tp)
                ttyretype(tp);
                goto endcase;
        }
                ttyretype(tp);
                goto endcase;
        }
-       /*
-        * reprint line (^R)
-        */
-       if (CCEQ(cc[VREPRINT], c)) {
-               ttyretype(tp);
-               goto endcase;
-       }
-       if (CCEQ(cc[VINFO], c)) {
-               pgsignal(tp->t_pgrp, SIGINFO);
-               if ((lflag&NOKERNINFO) == 0)
-                       ttyinfo(tp);
-               goto endcase;
-       }
        /*
         * Check for input buffer overflow
         */
        /*
         * Check for input buffer overflow
         */
-       if (tp->t_rawq.c_cc+tp->t_canq.c_cc >= TTYHOG) {
+       if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= TTYHOG) {
                if (iflag&IMAXBEL) {
                        if (tp->t_outq.c_cc < TTHIWAT(tp))
                                (void) ttyoutput(CTRL('g'), tp);
                if (iflag&IMAXBEL) {
                        if (tp->t_outq.c_cc < TTHIWAT(tp))
                                (void) ttyoutput(CTRL('g'), tp);
@@ -1013,6 +941,11 @@ ttyinput(c, tp)
         * wakeup on seeing a line delimiter.
         */
        if (putc(c, &tp->t_rawq) >= 0) {
         * wakeup on seeing a line delimiter.
         */
        if (putc(c, &tp->t_rawq) >= 0) {
+               if ((lflag&ICANON) == 0) {
+                       ttwakeup(tp);
+                       ttyecho(c, tp);
+                       goto endcase;
+               }
                if (ttbreakc(c)) {
                        tp->t_rocount = 0;
                        catq(&tp->t_rawq, &tp->t_canq);
                if (ttbreakc(c)) {
                        tp->t_rocount = 0;
                        catq(&tp->t_rawq, &tp->t_canq);
@@ -1037,7 +970,7 @@ ttyinput(c, tp)
                        /*
                         * Place the cursor over the '^' of the ^D.
                         */
                        /*
                         * Place the cursor over the '^' of the ^D.
                         */
-                       i = MIN(2, tp->t_col - i);
+                       i = min(2, tp->t_col - i);
                        while (i > 0) {
                                (void) ttyoutput('\b', tp);
                                i--;
                        while (i > 0) {
                                (void) ttyoutput('\b', tp);
                                i--;
@@ -1060,20 +993,16 @@ startoutput:
 }
 
 /*
 }
 
 /*
- * Put character on TTY output queue, adding delays,
- * expanding tabs, and handling the CR/NL bit.
- * This is called both from the top half for output,
- * and from interrupt level for echoing.
- * The arguments are the character and the tty structure.
- * Returns < 0 if putc succeeds, otherwise returns char to resend
+ * Output a single character on a tty, doing output processing
+ * as needed (expanding tabs, newline processing, etc.).
+ * Returns < 0 if putc succeeds, otherwise returns char to resend.
  * Must be recursive.
  */
 ttyoutput(c, tp)
        register c;
        register struct tty *tp;
 {
  * Must be recursive.
  */
 ttyoutput(c, tp)
        register c;
        register struct tty *tp;
 {
-       register char *colp;
-       register ctype;
+       register int col;
        if (!(tp->t_oflag&OPOST)) {
                if (tp->t_lflag&FLUSHO) 
                        return (-1);
        if (!(tp->t_oflag&OPOST)) {
                if (tp->t_lflag&FLUSHO) 
                        return (-1);
@@ -1085,7 +1014,11 @@ ttyoutput(c, tp)
        }
        c &= 0377;
        /*
        }
        c &= 0377;
        /*
-        * Turn tabs to spaces as required
+        * Do tab expansion if OXTABS is set.
+        * Special case if we have external processing, we don't
+        * do the tab expansion because we'll probably get it
+        * wrong.  If tab expansion needs to be done, let it
+        * happen externally.
         */
        if (c == '\t' && tp->t_oflag&OXTABS ) {
                register int s;
         */
        if (c == '\t' && tp->t_oflag&OXTABS ) {
                register int s;
@@ -1102,106 +1035,56 @@ ttyoutput(c, tp)
                return (c ? -1 : '\t');
        }
        if (c == CEOT && oflag&ONOEOT)
                return (c ? -1 : '\t');
        }
        if (c == CEOT && oflag&ONOEOT)
-               return(-1);
+               return (-1);
        tk_nout++;
        tp->t_outcc++;
 #ifdef notdef
        /*
        tk_nout++;
        tp->t_outcc++;
 #ifdef notdef
        /*
-        * turn <nl> to <cr><lf> if desired.
+        * Newline translation: if ONLCR is set,
+        * translate newline into "\r\n".
         */
 #endif
        if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
                return (c);
        if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
                return (c);
         */
 #endif
        if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
                return (c);
        if ((tp->t_lflag&FLUSHO) == 0 && putc(c, &tp->t_outq))
                return (c);
-       /*
-        * Calculate delays.
-        * The numbers here represent clock ticks
-        * and are not necessarily optimal for all terminals.
-        *
-        * SHOULD JUST ALLOW USER TO SPECIFY DELAYS
-        *
-        * (actually, should THROW AWAY terminals which need delays)
-        */
-       colp = &tp->t_col;
-       ctype = partab[c];
-       c = 0;
-       switch (ctype&077) {
+
+       col = tp->t_col;
+       switch (CCLASS(c)) {
 
        case ORDINARY:
 
        case ORDINARY:
-               (*colp)++;
+               col++;
 
        case CONTROL:
                break;
 
        case BACKSPACE:
 
        case CONTROL:
                break;
 
        case BACKSPACE:
-               if (*colp)
-                       (*colp)--;
+               if (col > 0)
+                       col--;
                break;
 
                break;
 
-       /*
-        * This macro is close enough to the correct thing;
-        * it should be replaced by real user settable delays
-        * in any event...
-        */
-#define        mstohz(ms)      (((ms) * hz) >> 10)
        case NEWLINE:
        case NEWLINE:
-               ctype = (tp->t_flags >> 8) & 03;
-               if (ctype == 1) { /* tty 37 */
-                       if (*colp > 0) {
-                               c = (((unsigned)*colp) >> 4) + 3;
-                               if ((unsigned)c > 6)
-                                       c = 6;
-                       }
-               } else if (ctype == 2) /* vt05 */
-                       c = mstohz(100);
-               *colp = 0;
+               col = 0;
                break;
 
        case TAB:
                break;
 
        case TAB:
-               ctype = (tp->t_flags >> 10) & 03;
-               if (ctype == 1) { /* tty 37 */
-                       c = 1 - (*colp | ~07);
-                       if (c < 5)
-                               c = 0;
-               }
-               *colp |= 07;
-               (*colp)++;
-               break;
-
-       case VTAB:
-               if (tp->t_flags&VTDELAY) /* tty 37 */
-                       c = 0177;
+               col = (col + 8) &~ 0x7;
                break;
 
        case RETURN:
                break;
 
        case RETURN:
-               ctype = (tp->t_flags >> 12) & 03;
-               if (ctype == 1) /* tn 300 */
-                       c = mstohz(83);
-               else if (ctype == 2) /* ti 700 */
-                       c = mstohz(166);
-               else if (ctype == 3) { /* concept 100 */
-                       int i;
-
-                       if ((i = *colp) >= 0)
-                               for (; i < 9; i++)
-                                       (void) putc(0177, &tp->t_outq);
-               }
-               *colp = 0;
+               col = 0;
        }
        }
-       if (c && (tp->t_lflag&FLUSHO) == 0)
-               (void) putc(c|TTY_QUOTE, &tp->t_outq);
+       tp->t_col = col;
        return (-1);
 }
        return (-1);
 }
-#undef mstohz
 
 /*
 
 /*
- * Called from device's read routine after it has
- * calculated the tty-structure given as argument.
+ * Process a read call on a tty device.
  */
 ttread(tp, uio, flag)
        register struct tty *tp;
        struct uio *uio;
  */
 ttread(tp, uio, flag)
        register struct tty *tp;
        struct uio *uio;
+       int flag;
 {
        register struct clist *qp;
        register int c, t_flags;
 {
        register struct clist *qp;
        register int c, t_flags;
@@ -1224,13 +1107,14 @@ loop:
        /*
         * Hang process if it's in the background.
         */
        /*
         * Hang process if it's in the background.
         */
-       if (isbackground(u.u_procp, tp)) {
-               if ((u.u_procp->p_sigignore & sigmask(SIGTTIN)) ||
-                  (u.u_procp->p_sigmask & sigmask(SIGTTIN)) ||
-                   u.u_procp->p_flag&SVFORK || u.u_procp->p_pgrp->pg_jobc == 0)
+       if (isbackground(p, tp)) {
+               if ((p->p_sigignore & sigmask(SIGTTIN)) ||
+                  (p->p_sigmask & sigmask(SIGTTIN)) ||
+                   p->p_flag&SPPWAIT || p->p_pgrp->pg_jobc == 0)
                        return (EIO);
                        return (EIO);
-               pgsignal(u.u_procp->p_pgrp, SIGTTIN);
-               if (error = tsleep((caddr_t)&lbolt, TTIPRI | PCATCH, ttybg, 0))
+               pgsignal(p->p_pgrp, SIGTTIN, 1);
+               if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH, 
+                   ttybg, 0)) 
                        return (error);
                goto loop;
        }
                        return (error);
                goto loop;
        }
@@ -1259,7 +1143,7 @@ loop:
                        splx(s);
                        return (EWOULDBLOCK);
                }
                        splx(s);
                        return (EWOULDBLOCK);
                }
-               error = tsleep((caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
+               error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
                    carrier ? ttyin : ttopen, 0);
                splx(s);
                if (error)
                    carrier ? ttyin : ttopen, 0);
                splx(s);
                if (error)
@@ -1277,9 +1161,9 @@ loop:
                 * delayed suspend (^Y)
                 */
                if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
                 * delayed suspend (^Y)
                 */
                if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
-                       pgsignal(tp->t_pgrp, SIGTSTP);
+                       pgsignal(tp->t_pgrp, SIGTSTP, 1);
                        if (first) {
                        if (first) {
-                               if (error = tsleep((caddr_t)&lbolt,
+                               if (error = ttysleep(tp, (caddr_t)&lbolt,
                                    TTIPRI | PCATCH, ttybg, 0))
                                        break;
                                goto loop;
                                    TTIPRI | PCATCH, ttybg, 0))
                                        break;
                                goto loop;
@@ -1312,6 +1196,7 @@ loop:
         * Look to unblock output now that (presumably)
         * the input queue has gone down.
         */
         * Look to unblock output now that (presumably)
         * the input queue has gone down.
         */
+       s = spltty();
        if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
                if (cc[VSTART] != POSIX_V_DISABLE 
                   && putc(cc[VSTART], &tp->t_outq) == 0) {
        if (tp->t_state&TS_TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
                if (cc[VSTART] != POSIX_V_DISABLE 
                   && putc(cc[VSTART], &tp->t_outq) == 0) {
@@ -1319,6 +1204,7 @@ loop:
                        ttstart(tp);
                }
        }
                        ttstart(tp);
                }
        }
+       splx(s);
        }
        return (error);
 }
        }
        return (error);
 }
@@ -1339,15 +1225,16 @@ ttycheckoutq(tp, wait)
 
        hiwat = tp->t_hiwat;
        s = spltty();
 
        hiwat = tp->t_hiwat;
        s = spltty();
-       oldsig = u.u_procp->p_sig;
+       oldsig = wait ? curproc->p_sig : 0;
        if (tp->t_outq.c_cc > hiwat + 200)
                while (tp->t_outq.c_cc > hiwat) {
                        ttstart(tp);
        if (tp->t_outq.c_cc > hiwat + 200)
                while (tp->t_outq.c_cc > hiwat) {
                        ttstart(tp);
-                       if (wait == 0 || u.u_procp->p_sig != oldsig) {
+                       if (wait == 0 || curproc->p_sig != oldsig) {
                                splx(s);
                                return (0);
                        }
                                splx(s);
                                return (0);
                        }
-                       timeout(wakeup, (caddr_t)&tp->t_outq, hz);
+                       timeout((void (*)__P((void *)))wakeup,
+                           (void *)&tp->t_outq, hz);
                        tp->t_state |= TS_ASLEEP;
                        sleep((caddr_t)&tp->t_outq, PZERO - 1);
                }
                        tp->t_state |= TS_ASLEEP;
                        sleep((caddr_t)&tp->t_outq, PZERO - 1);
                }
@@ -1356,15 +1243,16 @@ ttycheckoutq(tp, wait)
 }
 
 /*
 }
 
 /*
- * Called from the device's write routine after it has
- * calculated the tty-structure given as argument.
+ * Process a write call on a tty device.
  */
 ttwrite(tp, uio, flag)
        register struct tty *tp;
        register struct uio *uio;
  */
 ttwrite(tp, uio, flag)
        register struct tty *tp;
        register struct uio *uio;
+       int flag;
 {
        register char *cp;
        register int cc = 0, ce;
 {
        register char *cp;
        register int cc = 0, ce;
+       register struct proc *p = curproc;
        int i, hiwat, cnt, error, s;
        char obuf[OBUFSIZ];
 
        int i, hiwat, cnt, error, s;
        char obuf[OBUFSIZ];
 
@@ -1385,8 +1273,8 @@ loop:
                        /*
                         * sleep awaiting carrier
                         */
                        /*
                         * sleep awaiting carrier
                         */
-                       error = tsleep((caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
-                           ttopen, 0);
+                       error = ttysleep(tp, (caddr_t)&tp->t_rawq, 
+                                       TTIPRI | PCATCH,ttopen, 0);
                        splx(s);
                        if (error)
                                goto out;
                        splx(s);
                        if (error)
                                goto out;
@@ -1397,12 +1285,14 @@ loop:
        /*
         * Hang the process if it's in the background.
         */
        /*
         * Hang the process if it's in the background.
         */
-           (tp->t_lflag&TOSTOP) && (u.u_procp->p_flag&SVFORK)==0 &&
-           (u.u_procp->p_sigignore & sigmask(SIGTTOU)) == 0 &&
-           (u.u_procp->p_sigmask & sigmask(SIGTTOU)) == 0 &&
-            u.u_procp->p_pgrp->pg_jobc) {
-               pgsignal(u.u_procp->p_pgrp, SIGTTOU);
-               if (error = tsleep((caddr_t)&lbolt, TTIPRI | PCATCH, ttybg, 0))
+       if (isbackground(p, tp) && 
+           tp->t_lflag&TOSTOP && (p->p_flag&SPPWAIT) == 0 &&
+           (p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
+           (p->p_sigmask & sigmask(SIGTTOU)) == 0 &&
+            p->p_pgrp->pg_jobc) {
+               pgsignal(p->p_pgrp, SIGTTOU, 1);
+               if (error = ttysleep(tp, (caddr_t)&lbolt, TTIPRI | PCATCH, 
+                   ttybg, 0))
                        goto out;
                goto loop;
        }
                        goto out;
                goto loop;
        }
@@ -1447,7 +1337,7 @@ loop:
                                ce = cc;
                        else {
                                ce = cc - scanc((unsigned)cc, (u_char *)cp,
                                ce = cc;
                        else {
                                ce = cc - scanc((unsigned)cc, (u_char *)cp,
-                                  (u_char *)partab, 077);
+                                  (u_char *)partab, CCLASSMASK);
                                /*
                                 * If ce is zero, then we're processing
                                 * a special character through ttyoutput.
                                /*
                                 * If ce is zero, then we're processing
                                 * a special character through ttyoutput.
@@ -1457,8 +1347,9 @@ loop:
                                        if (ttyoutput(*cp, tp) >= 0) {
                                            /* no c-lists, wait a bit */
                                            ttstart(tp);
                                        if (ttyoutput(*cp, tp) >= 0) {
                                            /* no c-lists, wait a bit */
                                            ttstart(tp);
-                                           if (error = tsleep((caddr_t)&lbolt,
-                                               TTOPRI | PCATCH, ttybuf, 0))
+                                           if (error = ttysleep(tp, 
+                                               (caddr_t)&lbolt,
+                                                TTOPRI | PCATCH, ttybuf, 0))
                                                    break;
                                            goto loop;
                                        }
                                                    break;
                                            goto loop;
                                        }
@@ -1486,8 +1377,8 @@ loop:
                        if (i > 0) {
                                /* out of c-lists, wait a bit */
                                ttstart(tp);
                        if (i > 0) {
                                /* out of c-lists, wait a bit */
                                ttstart(tp);
-                               if (error = tsleep((caddr_t)&lbolt,
-                                   TTOPRI | PCATCH, ttybuf, 0))
+                               if (error = ttysleep(tp, (caddr_t)&lbolt,
+                                           TTOPRI | PCATCH, ttybuf, 0))
                                        break;
                                goto loop;
                        }
                                        break;
                                goto loop;
                        }
@@ -1526,7 +1417,7 @@ ovhiwat:
                return (0);
        }
        tp->t_state |= TS_ASLEEP;
                return (0);
        }
        tp->t_state |= TS_ASLEEP;
-       error = tsleep((caddr_t)&tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
+       error = ttysleep(tp, (caddr_t)&tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
        splx(s);
        if (error)
                goto out;
        splx(s);
        if (error)
                goto out;
@@ -1559,7 +1450,7 @@ ttyrub(c, tp)
                /* if tab or newline was escaped  - XXX - not 8bit */
                if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))
                        ttyrubo(tp, 2);
                /* if tab or newline was escaped  - XXX - not 8bit */
                if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))
                        ttyrubo(tp, 2);
-               else switch (partab[c&=0377]&077) {
+               else switch (CCLASS(c &= TTY_CHARMASK)) {
 
                case ORDINARY:
 #ifdef notdef
 
                case ORDINARY:
 #ifdef notdef
@@ -1570,6 +1461,7 @@ ttyrub(c, tp)
                case BACKSPACE:
                case CONTROL:
                case RETURN:
                case BACKSPACE:
                case CONTROL:
                case RETURN:
+               case NEWLINE:
                        if (tp->t_lflag&ECHOCTL)
                                ttyrubo(tp, 2);
                        break;
                        if (tp->t_lflag&ECHOCTL)
                                ttyrubo(tp, 2);
                        break;
@@ -1605,7 +1497,7 @@ ttyrub(c, tp)
                default:
                        /* XXX */
                        printf("ttyrub: would panic c = %d, val = %d\n",
                default:
                        /* XXX */
                        printf("ttyrub: would panic c = %d, val = %d\n",
-                               c, partab[c&=0377]&077);
+                               c, CCLASS(c));
                        /*panic("ttyrub");*/
                }
        } else if (tp->t_lflag&ECHOPRT) {
                        /*panic("ttyrub");*/
                }
        } else if (tp->t_lflag&ECHOPRT) {
@@ -1676,7 +1568,7 @@ ttyecho(c, tp)
                return;
        if (tp->t_lflag&ECHOCTL) {
                if ((c&TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
                return;
        if (tp->t_lflag&ECHOCTL) {
                if ((c&TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
-                   c == 0177) {
+                   (c&TTY_CHARMASK) == 0177) {
                        (void) ttyoutput('^', tp);
                        c &= TTY_CHARMASK;
                        if (c == 0177)
                        (void) ttyoutput('^', tp);
                        c &= TTY_CHARMASK;
                        if (c == 0177)
@@ -1700,20 +1592,34 @@ ttyoutstr(cp, tp)
                (void) ttyoutput(c, tp);
 }
 
                (void) ttyoutput(c, tp);
 }
 
+/*
+ * Wake up any readers on a tty.
+ */
 ttwakeup(tp)
 ttwakeup(tp)
-       struct tty *tp;
+       register struct tty *tp;
 {
 
 {
 
-       if (tp->t_rsel) {
-               selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
-               tp->t_state &= ~TS_RCOLL;
-               tp->t_rsel = 0;
-       }
+       selwakeup(&tp->t_rsel);
        if (tp->t_state & TS_ASYNC)
        if (tp->t_state & TS_ASYNC)
-               pgsignal(tp->t_pgrp, SIGIO); 
+               pgsignal(tp->t_pgrp, SIGIO, 1); 
        wakeup((caddr_t)&tp->t_rawq);
 }
 
        wakeup((caddr_t)&tp->t_rawq);
 }
 
+/*
+ * Look up a code for a specified speed in a conversion table;
+ * used by drivers to map software speed values to hardware parameters.
+ */
+ttspeedtab(speed, table)
+       int speed;
+       register struct speedtab *table;
+{
+
+       for ( ; table->sp_speed != -1; table++)
+               if (table->sp_speed == speed)
+                       return (table->sp_code);
+       return (-1);
+}
+
 /*
  * set tty hi and low water marks
  *
 /*
  * set tty hi and low water marks
  *
@@ -1735,115 +1641,58 @@ ttsetwater(tp)
 #undef clamp
 }
 
 #undef clamp
 }
 
-ttspeedtab(speed, table)
-       struct speedtab table[];
-{
-       register int i;
-
-       for (i = 0; table[i].sp_speed != -1; i++)
-               if (table[i].sp_speed == speed)
-                       return(table[i].sp_code);
-       return(-1);
-}
-
-int ttyhostname = 0;
 /*
 /*
- * (^T)
  * Report on state of foreground process group.
  */
 ttyinfo(tp)
  * Report on state of foreground process group.
  */
 ttyinfo(tp)
-       struct tty *tp;
+       register struct tty *tp;
 {
 {
-       register struct proc *p, *pick = NULL;
-       register char *cp = hostname;
-       int x, s;
+       register struct proc *p, *pick;
        struct timeval utime, stime;
        struct timeval utime, stime;
-#define        pgtok(a)        ((a)/(1024/NBPG))
+       int tmp;
 
        if (ttycheckoutq(tp,0) == 0) 
                return;
 
        if (ttycheckoutq(tp,0) == 0) 
                return;
-       /* 
-        * hostname 
-        */
-       if (ttyhostname) {
-               if (*cp == '\0')
-                       ttyprintf(tp, "amnesia");
-               else
-                       while (*cp && *cp != '.')
-                               tputchar(*cp++, tp);
-               tputchar(' ');
-       }
-       /* 
-        * load average 
-        */
-       x = (averunnable[0] * 100 + FSCALE/2) >> FSHIFT;
-       ttyprintf(tp, "load: %d.", x/100);
-       ttyoutint(x%100, 10, 2, tp);
+
+       /* Print load average. */
+       tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
+       ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
+
        if (tp->t_session == NULL)
        if (tp->t_session == NULL)
-               ttyprintf(tp, " not a controlling terminal\n");
+               ttyprintf(tp, "not a controlling terminal\n");
        else if (tp->t_pgrp == NULL)
        else if (tp->t_pgrp == NULL)
-               ttyprintf(tp, " no foreground process group\n");
+               ttyprintf(tp, "no foreground process group\n");
        else if ((p = tp->t_pgrp->pg_mem) == NULL)
        else if ((p = tp->t_pgrp->pg_mem) == NULL)
-               ttyprintf(tp, " empty foreground process group\n");
+               ttyprintf(tp, "empty foreground process group\n");
        else {
        else {
-               /* pick interesting process */
-               for (; p != NULL; p = p->p_pgrpnxt) {
+               /* Pick interesting process. */
+               for (pick = NULL; p != NULL; p = p->p_pgrpnxt)
                        if (proc_compare(pick, p))
                                pick = p;
                        if (proc_compare(pick, p))
                                pick = p;
-               }
-               ttyprintf(tp, "  cmd: %s %d [%s] ",
-                       pick->p_comm, pick->p_pid,
-                       pick->p_wmesg ? pick->p_wmesg : "running");
-               /* 
-                * cpu time 
-                */
-               if (u.u_procp == pick)
-                       s = splclock();
-               utime = pick->p_utime;
-               stime = pick->p_stime;
-               if (u.u_procp == pick)
-                       splx(s);
-               /* user time */
-               x = (utime.tv_usec + 5000) / 10000; /* scale to 100's */
-               ttyoutint(utime.tv_sec, 10, 1, tp);
-               tputchar('.', tp);
-               ttyoutint(x, 10, 2, tp);
-               tputchar('u', tp);
-               tputchar(' ', tp);
-               /* system time */
-               x = (stime.tv_usec + 5000) / 10000; /* scale to 100's */
-               ttyoutint(stime.tv_sec, 10, 1, tp);
-               tputchar('.', tp);
-               ttyoutint(x, 10, 2, tp);
-               tputchar('s', tp);
-               tputchar(' ', tp);
-               /* 
-                * pctcpu 
-                */
-               x = pick->p_pctcpu * 10000 + FSCALE/2 >> FSHIFT;
-               ttyoutint(x/100, 10, 1, tp);
-#ifdef notdef  /* do we really want this ??? */
-               tputchar('.', tp);
-               ttyoutint(x%100, 10, 2, tp);
-#endif
-               ttyprintf(tp, "%% %dk\n", pgtok(pick->p_ssize + pick->p_dsize));
-       }
-       tp->t_rocount = 0;      /* so pending input will be retyped if BS */
-}
 
 
-ttyoutint(n, base, min, tp)
-       register int n, base, min;
-       register struct tty *tp;
-{
-       char info[16];
-       register char *p = info;
+               ttyprintf(tp, " cmd: %s %d [%s] ", pick->p_comm, pick->p_pid,
+                   pick->p_stat == SRUN ? "running" :
+                   pick->p_wmesg ? pick->p_wmesg : "iowait");
+
+               calcru(pick, &utime, &stime, NULL);
+
+               /* Print user time. */
+               ttyprintf(tp, "%d.%02du ",
+                   utime.tv_sec, (utime.tv_usec + 5000) / 10000);
+
+               /* Print system time. */
+               ttyprintf(tp, "%d.%02ds ",
+                   stime.tv_sec, (stime.tv_usec + 5000) / 10000);
 
 
-       while (--min >= 0 || n) {
-               *p++ = "0123456789abcdef"[n%base];
-               n /= base;
+#define        pgtok(a)        (((a) * NBPG) / 1024)
+               /* Print percentage cpu, resident set size. */
+               tmp = pick->p_pctcpu * 10000 + FSCALE / 2 >> FSHIFT;
+               ttyprintf(tp, "%d%% %dk\n",
+                   tmp / 100,
+                   pick->p_stat == SIDL || pick->p_stat == SZOMB ? 0 :
+                       pgtok(pick->p_vmspace->vm_rssize));
        }
        }
-       while (p > info)
-               ttyoutput(*--p, tp);
+       tp->t_rocount = 0;      /* so pending input will be retyped if BS */
 }
 
 /*
 }
 
 /*
@@ -1864,6 +1713,12 @@ ttyoutint(n, base, min, tp)
  *
  */
 #define isrun(p)       (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
  *
  */
 #define isrun(p)       (((p)->p_stat == SRUN) || ((p)->p_stat == SIDL))
+#define TESTAB(a, b)    ((a)<<1 | (b))
+#define ONLYA   2
+#define ONLYB   1
+#define BOTH    3
+
+static int
 proc_compare(p1, p2)
        register struct proc *p1, *p2;
 {
 proc_compare(p1, p2)
        register struct proc *p1, *p2;
 {
@@ -1873,12 +1728,12 @@ proc_compare(p1, p2)
        /*
         * see if at least one of them is runnable
         */
        /*
         * see if at least one of them is runnable
         */
-       switch (isrun(p1)<<1 | isrun(p2)) {
-       case 0x01:
-               return (1);
-       case 0x10:
+       switch (TESTAB(isrun(p1), isrun(p2))) {
+       case ONLYA:
                return (0);
                return (0);
-       case 0x11:
+       case ONLYB:
+               return (1);
+       case BOTH:
                /*
                 * tie - favor one with highest recent cpu utilization
                 */
                /*
                 * tie - favor one with highest recent cpu utilization
                 */
@@ -1888,6 +1743,17 @@ proc_compare(p1, p2)
                        return (0);
                return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
        }
                        return (0);
                return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
        }
+       /*
+        * weed out zombies
+        */
+       switch (TESTAB(p1->p_stat == SZOMB, p2->p_stat == SZOMB)) {
+       case ONLYA:
+               return (1);
+       case ONLYB:
+               return (0);
+       case BOTH:
+               return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
+       }
        /* 
         * pick the one with the smallest sleep time
         */
        /* 
         * pick the one with the smallest sleep time
         */
@@ -1902,16 +1768,7 @@ proc_compare(p1, p2)
                return (1);
        if (p2->p_flag&SSINTR && (p1->p_flag&SSINTR) == 0)
                return (0);
                return (1);
        if (p2->p_flag&SSINTR && (p1->p_flag&SSINTR) == 0)
                return (0);
-       return(p2->p_pid > p1->p_pid);          /* tie - return highest pid */
-}
-#define TOTTY  0x2     /* XXX should be in header */
-/*VARARGS2*/
-ttyprintf(tp, fmt, x1)
-       struct tty *tp;
-       char *fmt;
-       unsigned x1;
-{
-       prf(fmt, &x1, TOTTY, (caddr_t)tp);
+       return (p2->p_pid > p1->p_pid);         /* tie - return highest pid */
 }
 
 /*
 }
 
 /*
@@ -1923,8 +1780,7 @@ tputchar(c, tp)
 {
        register s = spltty();
 
 {
        register s = spltty();
 
-       if ((tp->t_state & (TS_CARR_ON | TS_ISOPEN)) 
-           == (TS_CARR_ON | TS_ISOPEN)) {
+       if ((tp->t_state & (TS_CARR_ON|TS_ISOPEN)) == (TS_CARR_ON|TS_ISOPEN)) {
                if (c == '\n')
                        (void) ttyoutput('\r', tp);
                (void) ttyoutput(c, tp);
                if (c == '\n')
                        (void) ttyoutput('\r', tp);
                (void) ttyoutput(c, tp);
@@ -1935,3 +1791,26 @@ tputchar(c, tp)
        splx(s);
        return (-1);
 }
        splx(s);
        return (-1);
 }
+
+/*
+ * Sleep on chan, returning ERESTART if tty changed
+ * while we napped and returning any errors (e.g. EINTR/ETIMEDOUT)
+ * reported by tsleep.  If the tty is revoked, restarting a pending
+ * call will redo validation done at the start of the call.
+ */
+ttysleep(tp, chan, pri, wmesg, timo)
+       struct tty *tp;
+       caddr_t chan;
+       int pri;
+       char *wmesg;
+       int timo;
+{
+       int error;
+       short gen = tp->t_gen;
+
+       if (error = tsleep(chan, pri, wmesg, timo))
+               return (error);
+       if (tp->t_gen != gen)
+               return (ERESTART);
+       return (0);
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.