-/*
- * Copyright (c) 1982, 1986 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.18 (Berkeley) %G%
+ * @(#)tty.c 8.2 (Berkeley) %G%
*/
-#include "param.h"
-#include "systm.h"
-#include "user.h"
-#include "ioctl.h"
-#define TTYDEFCHARS
-#include "tty.h"
-#undef TTYDEFCHARS
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/ioctl.h>
+#include <sys/proc.h>
+#define TTYDEFCHARS
+#include <sys/tty.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 "machine/reg.h"
-#include "syslog.h"
+static int proc_compare __P((struct proc *p1, struct proc *p2));
+static int ttnread __P((struct tty *));
+static void ttyblock __P((struct tty *tp));
+static void ttyecho __P((int, struct tty *tp));
+static void ttyrubo __P((struct tty *, int));
+
+/* Symbolic sleep message strings. */
+char ttclos[] = "ttycls";
+char ttopen[] = "ttyopn";
+char ttybg[] = "ttybg";
+char ttybuf[] = "ttybuf";
+char ttyin[] = "ttyin";
+char ttyout[] = "ttyout";
/*
- * Table giving parity for characters and indicating
- * character classes to tty driver. The 8th bit
- * 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.
+ * Table with character classes and parity. The 8th bit 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; classes
+ * other than 0 might be translated or (not currently) require delays.
*/
-
-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 */
+#define E 0x00 /* Even parity. */
+#define O 0x80 /* Odd parity. */
+#define PARITY(c) (char_type[c] & O)
+
+#define ALPHA 0x40 /* Alpha or underscore. */
+#define ISALPHA(c) (char_type[(c) & TTY_CHARMASK] & ALPHA)
+
+#define CCLASSMASK 0x3f
+#define CCLASS(c) (char_type[c] & CCLASSMASK)
+
+#define BS BACKSPACE
+#define CC CONTROL
+#define CR RETURN
+#define NA ORDINARY | ALPHA
+#define NL NEWLINE
+#define NO ORDINARY
+#define TB TAB
+#define VT VTAB
+
+char const char_type[] = {
+ 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 character set;
+ * for now, treat them 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,
};
-
-extern struct tty *constty; /* temporary virtual console */
-extern char partab[], maptab[];
-
-/*
- * Is 'c' a line delimiter ("break" character)?
- */
-#define ttbreakc(c) (c == '\n' || CCEQ(cc[VEOF], c) || \
- CCEQ(cc[VEOL], c) || CCEQ(cc[VEOL2], c))
-
-/*
- * Debugging aids
- */
-#define dprintf if (tp->t_trace & TTRACE_IO)printf
-
-/*
- * Is 'c' a line delimiter ("break" character)?
- */
-#define ttbreakc(c) (c == '\n' || CCEQ(cc[VEOF], c) || \
- CCEQ(cc[VEOL], c) || CCEQ(cc[VEOL2], c))
-
-ttychars(tp)
- struct tty *tp;
-{
- bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
-}
-
-/*
- *
- * Wait for output to drain, then flush input waiting.
- */
-ttywflush(tp)
- struct tty *tp;
-{
-
- ttywait(tp);
- ttyflush(tp, FREAD);
-}
+#undef BS
+#undef CC
+#undef CR
+#undef NA
+#undef NL
+#undef NO
+#undef TB
+#undef VT
+
+/* Macros to clear/set/test flags. */
+#define SET(t, f) (t) |= (f)
+#define CLR(t, f) (t) &= ~(f)
+#define ISSET(t, f) ((t) & (f))
/*
- * Wait for output to drain.
- */
-/*
- * Wait for output to drain.
+ * Initial open of tty, or (re)entry to standard tty line discipline.
*/
-ttywait(tp)
+int
+ttyopen(device, tp)
+ dev_t device;
register struct tty *tp;
{
- int s = spltty();
+ int s;
- while ((tp->t_outq.c_cc || tp->t_state&TS_BUSY) &&
- (tp->t_state&TS_CARR_ON || tp->t_cflag&CLOCAL) &&
- tp->t_oproc) {
- (*tp->t_oproc)(tp);
- tp->t_state |= TS_ASLEEP;
- sleep((caddr_t)&tp->t_outq, TTOPRI);
+ s = spltty();
+ tp->t_dev = device;
+ if (!ISSET(tp->t_state, TS_ISOPEN)) {
+ SET(tp->t_state, TS_ISOPEN);
+ bzero(&tp->t_winsize, sizeof(tp->t_winsize));
}
+ CLR(tp->t_state, TS_WOPEN);
splx(s);
+ return (0);
}
/*
- * Flush all TTY queues
+ * 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.
*/
-ttyflush(tp, rw)
+int
+ttyclose(tp)
register struct tty *tp;
{
- register s;
+ extern struct tty *constty; /* Temporary virtual console. */
- s = spltty();
- if (rw & FREAD) {
- while (getc(&tp->t_canq) >= 0)
- ;
- ttwakeup(tp);
- }
- if (rw & FWRITE) {
- wakeup((caddr_t)&tp->t_outq); /* XXX? what about selwakeup? */
- tp->t_state &= ~TS_TTSTOP;
- (*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;
- }
- splx(s);
-}
+ if (constty == tp)
+ constty = NULL;
-/*
- * Send stop character on input overflow.
- */
-ttyblock(tp)
- register struct tty *tp;
-{
- register x;
+ ttyflush(tp, FREAD | FWRITE);
- x = tp->t_rawq.c_cc + tp->t_canq.c_cc;
- if (tp->t_rawq.c_cc > TTYHOG) {
- ttyflush(tp, FREAD|FWRITE);
- tp->t_state &= ~TS_TBLOCK;
- }
- /*
- * Block further input iff:
- * Current input > threshold AND input is available to user program
- */
- if (x >= TTYHOG/2 &&
- (!(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_state |= TS_TBLOCK;
- ttstart(tp);
- }
- }
+ tp->t_gen++;
+ tp->t_pgrp = NULL;
+ tp->t_session = NULL;
+ tp->t_state = 0;
+ return (0);
}
-/*
- * 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)
- struct tty *tp;
-{
-
- if (tp == 0)
- panic("ttrstrt");
- tp->t_state &= ~TS_TIMEOUT;
- ttstart(tp);
+#define FLUSHQ(q) { \
+ if ((q)->c_cc) \
+ ndflush(q, (q)->c_cc); \
}
-/*
- * 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;
-{
+/* Is 'c' a line delimiter ("break" character)? */
+#define TTBREAKC(c) \
+ ((c) == '\n' || ((c) == cc[VEOF] || \
+ (c) == cc[VEOL] || (c) == cc[VEOL2]) && (c) != _POSIX_VDISABLE)
- if (tp->t_oproc) /* kludge for pty */
- (*tp->t_oproc)(tp);
-}
/*
- * Common code for tty ioctls.
+ * Process input of a single character received on a tty.
*/
-/*ARGSUSED*/
-ttioctl(tp, com, data, flag)
+int
+ttyinput(c, tp)
+ register int c;
register struct tty *tp;
- caddr_t data;
{
- extern int nldisp;
- int soft;
- int s, error;
+ register int iflag = tp->t_iflag;
+ register int lflag = tp->t_lflag;
+ register u_char *cc = tp->t_cc;
+ int i, err;
/*
- * If the ioctl involves modification,
- * hang if in the background.
+ * If input is pending take it first.
+ */
+ if (lflag&PENDIN)
+ ttypend(tp);
+ /*
+ * Gather stats.
*/
- switch (com) {
- case TIOCSETD:
- case TIOCFLUSH:
- case TIOCSTI:
- case TIOCSWINSZ:
- case TIOCSETA:
- case TIOCSETAW:
- case TIOCSETAF:
-/**** these get removed ****
- case TIOCSETAS:
- case TIOCSETAWS:
- case TIOCSETAFS:
-/***************************/
- while (u.u_procp->p_pgid != tp->t_pgid &&
- tp == u.u_ttyp &&
- u.u_procp->p_pgrp->pg_jobc &&
- (u.u_procp->p_flag&SVFORK) == 0 &&
- !(u.u_procp->p_sigignore & sigmask(SIGTTOU)) &&
- !(u.u_procp->p_sigmask & sigmask(SIGTTOU))) {
- pgsignal(u.u_procp->p_pgrp, SIGTTOU);
- sleep((caddr_t)&lbolt, TTOPRI);
+ if (ISSET(lflag, ICANON)) {
+ ++tk_cancc;
+ ++tp->t_cancc;
+ } else {
+ ++tk_rawcc;
+ ++tp->t_rawcc;
+ }
+ if (err = (c&TTY_ERRORMASK)) {
+ c &= TTY_CHARMASK;
+ if (err&TTY_FE && !c) { /* break */
+ if (iflag&IGNBRK)
+ goto endcase;
+ else if (iflag&BRKINT && lflag&ISIG &&
+ (cc[VINTR] != POSIX_V_DISABLE))
+ c = cc[VINTR];
+ else
+ c = 0;
+ } else if ((err&TTY_PE && iflag&INPCK) || err&TTY_FE) {
+ if (iflag&IGNPAR)
+ goto endcase;
+ else if (iflag&PARMRK) {
+ ttyinput(0377, tp);
+ ttyinput(0, tp);
+ } else
+ c = 0;
}
- break;
}
+ dprintf("<%o>\n", c);
/*
- * Process the ioctl.
+ * In tandem mode, check high water mark.
*/
- switch (com) {
-
- /* get discipline number */
- case TIOCGETD:
- *(int *)data = tp->t_line;
- break;
+ if (iflag&IXOFF)
+ ttyblock(tp);
- /* set line discipline */
- case TIOCSETD: {
- register int t = *(int *)data;
- dev_t dev = tp->t_dev;
- dev_t dev = tp->t_dev;
- int error = 0;
+ /*
+ * In tandem mode, check high water mark.
+ */
+ if ((tp->t_state&TS_TYPEN) == 0 && (iflag&ISTRIP))
+ c &= ~0x80;
- if ((unsigned)t >= nldisp)
- return (ENXIO);
- if (t != tp->t_line) {
- s = spltty();
- (*linesw[tp->t_line].l_close)(tp);
- error = (*linesw[t].l_open)(dev, tp);
- if (error) {
- (void)(*linesw[tp->t_line].l_open)(dev, tp);
- splx(s);
- return (error);
+ /*
+ * Extensions to POSIX input modes which aren't controlled
+ * by ICANON, ISIG, or IXON.
+ */
+ if (iflag&IEXTEN) {
+ if (CCEQ(cc[VLNEXT],c) && (iflag&ISTRIP)) {
+ if (lflag&ECHO)
+ ttyout("^\b", tp); /*XXX - presumes too much */
+ }
+ /*
+ * Signals.
+ */
+ if (ISSET(lflag, ISIG)) {
+ if (CCEQ(cc[VINTR], c) || CCEQ(cc[VQUIT], c)) {
+ if (!ISSET(lflag, NOFLSH))
+ ttyflush(tp, FREAD | FWRITE);
+ ttyecho(c, tp);
+ tp->t_lflag |= FLUSHO;
+ }
+ if (CCEQ(cc[VSUSP], c)) {
+ if (!ISSET(lflag, NOFLSH))
+ ttyflush(tp, FREAD);
+ ttyecho(c, tp);
+ pgsignal(tp->t_pgrp, SIGTSTP, 1);
+ goto endcase;
}
- tp->t_line = t;
- splx(s);
}
- if (tp->t_trace & TTRACE_STATE)
- ttytrace(com, tp);
- break;
+ if (iflag&IXON) {
+ if (CCEQ(cc[VSTOP],c)) {
+ if ((tp->t_state&TS_TTSTOP) == 0) {
+ tp->t_state |= TS_TTSTOP;
+ (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+ return;
+ }
+ if (!CCEQ(cc[VSTART], c))
+ return;
+ /*
+ * if VSTART == VSTOP we toggle
+ */
+ goto endcase;
+ }
+ if (CCEQ(cc[VSTART], c))
+ goto restartoutput;
}
-
- /* prevent more opens on channel */
- case TIOCEXCL:
- tp->t_state |= TS_XCLUDE;
- break;
-
- case TIOCNXCL:
- tp->t_state &= ~TS_XCLUDE;
- break;
-
- case TIOCHPCL:
- tp->t_cflag |= HUPCL;
- break;
-
- case TIOCFLUSH: {
- register int flags = *(int *)data;
-
- if (flags == 0)
- flags = FREAD|FWRITE;
- else
- flags &= FREAD|FWRITE;
- ttyflush(tp, flags);
- break;
+ c = unputc(&tp->t_rawq);
+ } while (c != ' ' && c != '\t');
+ (void) putc(c, &tp->t_rawq);
+ goto endcase;
}
-
- case FIOASYNC:
- if (*(int *)data)
- tp->t_state |= TS_ASYNC;
- else
- tp->t_state &= ~TS_ASYNC;
- break;
-
- case FIONBIO:
- break; /* XXX remove */
-
- /* return number of characters immediately available */
- case FIONREAD:
- *(off_t *)data = ttnread(tp);
- break;
-
- case TIOCOUTQ:
- *(int *)data = tp->t_outq.c_cc;
- break;
-
- case TIOCSTOP:
- s = spltty();
- if ((tp->t_state&TS_TTSTOP) == 0) {
- tp->t_state |= TS_TTSTOP;
- (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
- }
- splx(s);
- break;
-
- case TIOCSTART:
- s = spltty();
- if ((tp->t_state&TS_TTSTOP) || (tp->t_lflag&FLUSHO)) {
- tp->t_state &= ~TS_TTSTOP;
- tp->t_lflag &= ~FLUSHO;
- ttstart(tp);
- }
- splx(s);
- break;
-
/*
- * Simulate typing of a character at the terminal.
+ * reprint line (^R)
*/
- case TIOCSTI:
- if (u.u_uid && (flag & FREAD) == 0)
- return (EPERM);
- if (u.u_uid && u.u_ttyp != tp)
- return (EACCES);
- (*linesw[tp->t_line].l_rint)(*(char *)data, tp);
- break;
-
- case TIOCGETA: {
- struct termios *t = (struct termios *)data;
- bcopy(&tp->t_termio, t, sizeof(struct termios));
- if (tp->t_trace & TTRACE_STATE)
- ttytrace(com, tp);
- break;
- }
-
- if (com == TIOCSETAF || com == TIOCSETAFS)
- ttywflush(tp);
- else {
- if (com == TIOCSETAW || com == TIOCSETAWS)
- ttywait(tp);
- if ((t->c_lflag&ICANON) != (tp->t_lflag&ICANON))
- if (t->c_lflag&ICANON) {
- tp->t_lflag |= PENDIN;
- ttwakeup(tp);
- }
- else {
- struct clist tq;
-
- catq(&tp->t_rawq, &tp->t_canq);
- tq = tp->t_rawq;
- tp->t_rawq = tp->t_canq;
- tp->t_canq = tq;
- }
- }
- tp->t_iflag = t->c_iflag;
- tp->t_oflag = t->c_oflag;
- tp->t_lflag = t->c_lflag;
- bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
- if (!soft) {
- tp->t_cflag = t->c_cflag;
- tp->t_ispeed = t->c_ispeed;
- tp->t_ospeed = t->c_ospeed;
- }
- tp->t_iflag = t->c_iflag;
- tp->t_oflag = t->c_oflag;
- tp->t_lflag = t->c_lflag;
- bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
- splx(s);
- if (tp->t_trace & TTRACE_STATE)
- ttytrace(com, tp);
- break;
+ if (CCEQ(cc[VREPRINT], c)) {
+ ttyretype(tp);
+ goto endcase;
}
-
/*
- * Set terminal process group.
+ * Check for input buffer overflow
*/
- case TIOCSPGRP: {
- register struct proc *p = u.u_procp;
- register struct pgrp *pgrp = pgfind(*(int *)data);
-
- if (u.u_uid &&
- (tp != u.u_ttyp ||
- (pgrp && pgrp->pg_session != p->p_session))) {
- if (u.u_ttyp == NULL)
- return (ENOTTY);
- else
- return (EPERM);
+ 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);
+ } else
+ ttyflush(tp, FREAD | FWRITE);
+ goto endcase;
+ }
+ /*
+ * Put data char in q for user and
+ * wakeup on seeing a line delimiter.
+ */
+ if (putc(c, &tp->t_rawq) >= 0) {
+ if (!ISSET(lflag, ICANON)) {
+ ttwakeup(tp);
+ ttyecho(c, tp);
+ goto endcase;
}
- tp->t_pgid = *(int *)data;
- break;
+ if (ttbreakc(c)) {
+ tp->t_rocount = 0;
+ catq(&tp->t_rawq, &tp->t_canq);
+ ttwakeup(tp);
+ } else if (tp->t_rocount++ == 0)
+ tp->t_rocol = tp->t_col;
+ if (CCEQ(cc[VQUOTE], c) && (iflag&ISTRIP))
+ tp->t_state |= TS_QUOT; /* '\' escape */
+ if (ISSET(tp->t_state, TS_ERASE)) {
+ /*
+ * end of prterase \.../
+ */
+ /*
+ * end of prterase \.../
+ */
+ CLR(tp->t_state, TS_ERASE);
+ (void)ttyoutput('/', tp);
+ }
+ i = tp->t_col;
+ ttyecho(c, tp);
+ if (CCEQ(cc[VEOF], c) && lflag&ECHO) {
+ /*
+ * Place the cursor over the '^' of the ^D.
+ */
+ i = min(2, tp->t_col - i);
+ while (i > 0) {
+ (void)ttyoutput('\b', tp);
+ i--;
+ }
+ }
+ }
+endcase:
+ /*
+ * IXANY means allow any character to restart output.
+ */
+ if (ISSET(tp->t_state, TS_TTSTOP) &&
+ !ISSET(iflag, IXANY) && cc[VSTART] != cc[VSTOP])
+ return (0);
+
+restartoutput:
+ tp->t_lflag &= ~FLUSHO;
+startoutput:
+ return (ttstart(tp));
+}
+
+/*
+ * Output a single character on a tty, doing output processing
+ * as needed (expanding tabs, newline processing, etc.).
+ * Returns < 0 if succeeds, otherwise returns char to resend.
+ * Must be recursive.
+ */
+int
+ttyoutput(c, tp)
+ register int c;
+ register struct tty *tp;
+{
+ if (!(tp->t_oflag&OPOST)) {
+ if (tp->t_lflag&FLUSHO)
+ return (-1);
+ if (putc(c, &tp->t_outq))
+ return (c);
+ tk_nout++;
+ tp->t_outcc++;
+ return (-1);
+ }
+ c &= 0377;
+ /*
+ * Do tab expansion if OXTABS is set. Special case if we 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.
+ */
+ c &= TTY_CHARMASK;
+ if (c == '\t' &&
+ ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
+ c = 8 - (tp->t_col & 7);
+ if (!ISSET(tp->t_lflag, FLUSHO)) {
+ s = spltty(); /* Don't interrupt tabs. */
+ c -= b_to_q(" ", c, &tp->t_outq);
+ tk_nout += c;
+ tp->t_outcc += c;
+ splx(s);
+ }
+ tp->t_col += c;
+ return (c ? -1 : '\t');
}
+ if (c == CEOT && ISSET(oflag, ONOEOT))
+ return (-1);
+ tk_nout++;
+ tp->t_outcc++;
+#ifdef notdef
+ /*
+ * 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 (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
+ return (c);
- case TIOCGPGRP:
- *(int *)data = tp->t_pgid;
+ col = tp->t_col;
+ switch (CCLASS(c)) {
+ case BACKSPACE:
+ if (col > 0)
+ --col;
+ break;
+ case CONTROL:
+ break;
+ case NEWLINE:
+ case RETURN:
+ col = 0;
+ break;
+ case ORDINARY:
+ ++col;
+ break;
+ case TAB:
+ col = (col + 8) & ~7;
break;
+ }
+ tp->t_col = col;
+ return (-1);
+}
- case TIOCSWINSZ:
- if (bcmp((caddr_t)&tp->t_winsize, data,
- sizeof (struct winsize))) {
- tp->t_winsize = *(struct winsize *)data;
- gsignal(tp->t_pgid, SIGWINCH);
+/*
+ * Common code for ioctls on all 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 */
+int
+ttioctl(tp, com, data, flag)
+ register struct tty *tp;
+ int com, flag;
+ void *data;
+{
+ extern struct tty *constty; /* Temporary virtual console. */
+ extern int nldisp;
+ register struct proc *p;
+ int s, error;
+
+ p = curproc; /* XXX */
+
+ /* If the ioctl involves modification, hang if in the background. */
+ switch (com) {
+ case TIOCFLUSH:
+ case TIOCSETA:
+ case TIOCSETD:
+ case TIOCSETAF:
+ case TIOCSETAW:
+#ifdef notdef
+ case TIOCSPGRP:
+#endif
+ case TIOCSTI:
+ case TIOCSWINSZ:
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+ case TIOCLBIC:
+ case TIOCLBIS:
+ case TIOCLSET:
+ case TIOCSETC:
+ case OTIOCSETD:
+ case TIOCSETN:
+ case TIOCSETP:
+ case TIOCSLTC:
+#endif
+ 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,
+ &lbolt, TTOPRI | PCATCH, ttybg, 0))
+ return (error);
}
break;
+ }
- case TIOCGWINSZ:
- *(struct winsize *)data = tp->t_winsize;
+ switch (com) { /* Process the ioctl. */
+ case FIOASYNC: /* set/clear async i/o */
+ s = spltty();
+ if (*(int *)data)
+ SET(tp->t_state, TS_ASYNC);
+ else
+ CLR(tp->t_state, TS_ASYNC);
+ splx(s);
+ break;
+ case FIONBIO: /* set/clear non-blocking i/o */
+ break; /* XXX: delete. */
+ case FIONREAD: /* get # bytes to read */
+ *(int *)data = ttnread(tp);
break;
+ case TIOCEXCL: /* set exclusive use of tty */
+ s = spltty();
+ SET(tp->t_state, TS_XCLUDE);
+ splx(s);
+ break;
+ case TIOCFLUSH: { /* flush buffers */
+ register int flags = *(int *)data;
- case TIOCCONS:
+ if (flags == 0)
+ flags = FREAD | FWRITE;
+ else
+ flags &= FREAD | FWRITE;
+ ttyflush(tp, flags);
+ break;
+ }
+ case TIOCCONS: /* become virtual console */
if (*(int *)data) {
- if (constty != NULL)
+ if (constty && constty != tp &&
+ ISSET(constty->t_state, TS_CARR_ON | TS_ISOPEN) ==
+ (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;
} else if (tp == constty)
constty = NULL;
break;
+ case TIOCDRAIN: /* wait till output drained */
+ if (error = ttywait(tp))
+ return (error);
+ break;
+ case TIOCGETA: { /* get termios struct */
+ struct termios *t = (struct termios *)data;
-#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));
+ bcopy(&tp->t_termios, t, sizeof(struct termios));
+ break;
+ }
+ case TIOCGETD: /* get line discipline */
+ *(int *)data = tp->t_line;
+ break;
+ case TIOCGWINSZ: /* get window size */
+ *(struct winsize *)data = tp->t_winsize;
+ break;
+ case TIOCGPGRP: /* get pgrp of tty */
+ if (!isctty(p, tp))
+ return (ENOTTY);
+ *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
+ break;
+#ifdef TIOCHPCL
+ case TIOCHPCL: /* hang up on last close */
+ s = spltty();
+ tp->t_cflag |= HUPCL;
+ splx(s);
+ break;
#endif
+ case TIOCNXCL: /* reset exclusive use of tty */
+ s = spltty();
+ CLR(tp->t_state, TS_XCLUDE);
+ splx(s);
+ break;
+ case TIOCOUTQ: /* output queue size */
+ *(int *)data = tp->t_outq.c_cc;
+ break;
+ case TIOCSETA: /* set termios struct */
+ case TIOCSETAW: /* drain output, set */
+ case TIOCSETAF: { /* drn out, fls in, set */
+ register struct termios *t = (struct termios *)data;
+
+ s = spltty();
+ if (com == TIOCSETAW || com == TIOCSETAF) {
+ if (error = ttywait(tp)) {
+ splx(s);
+ return (error);
+ }
+ if (com == TIOCSETAF)
+ ttyflush(tp, FREAD);
+ }
+ if (!ISSET(t->c_cflag, CIGNORE)) {
+ /*
+ * Set device hardware.
+ */
+ if (tp->t_param && (error = (*tp->t_param)(tp, t))) {
+ splx(s);
+ return (error);
+ } else {
+ if (!ISSET(tp->t_state, TS_CARR_ON) &&
+ ISSET(tp->t_cflag, CLOCAL) &&
+ !ISSET(t->c_cflag, CLOCAL)) {
+ CLR(tp->t_state, TS_ISOPEN);
+ SET(tp->t_state, TS_WOPEN);
+ ttwakeup(tp);
+ }
+ tp->t_cflag = t->c_cflag;
+ tp->t_ispeed = t->c_ispeed;
+ tp->t_ospeed = t->c_ospeed;
+ }
+ ttsetwater(tp);
+ }
+ if (com != TIOCSETAF) {
+ if (ISSET(t->c_lflag, ICANON) !=
+ ISSET(tp->t_lflag, ICANON))
+ if (ISSET(t->c_lflag, ICANON)) {
+ tp->t_lflag |= PENDIN;
+ ttwakeup(tp);
+ } else {
+ struct clist tq;
+
+ catq(&tp->t_rawq, &tp->t_canq);
+ tq = tp->t_rawq;
+ tp->t_rawq = tp->t_canq;
+ tp->t_canq = tq;
+ }
+ }
+ tp->t_iflag = t->c_iflag;
+ tp->t_oflag = t->c_oflag;
+ /*
+ * Make the EXTPROC bit read only.
+ */
+ if (ISSET(tp->t_lflag, EXTPROC))
+ SET(t->c_lflag, EXTPROC);
+ else
+ CLR(t->c_lflag, EXTPROC);
+ tp->t_lflag = t->c_lflag;
+ bcopy(t->c_cc, tp->t_cc, sizeof(t->c_cc));
+ splx(s);
+ break;
+ }
+ case TIOCSETD: { /* set line discipline */
+ register int t = *(int *)data;
+ dev_t device = tp->t_dev;
- /* allow old ioctls for now */
- case TIOCGETP:
- case TIOCSETP:
- case TIOCSETN:
- case TIOCGETC:
- case TIOCSETC:
- case TIOCSLTC:
- case TIOCGLTC:
- case TIOCLBIS:
- case TIOCLBIC:
- case TIOCLSET:
- case TIOCLGET:
- return(ottioctl(tp, com, data, flag));
+ if ((u_int)t >= nldisp)
+ return (ENXIO);
+ if (t != tp->t_line) {
+ s = spltty();
+ (*linesw[tp->t_line].l_close)(tp, flag);
+ error = (*linesw[t].l_open)(device, tp);
+ if (error) {
+ (void)(*linesw[tp->t_line].l_open)(device, tp);
+ splx(s);
+ return (error);
+ }
+ tp->t_line = t;
+ splx(s);
+ }
+ break;
+ }
+ case TIOCSTART: /* start output, like ^Q */
+ s = spltty();
+ if (ISSET(tp->t_state, TS_TTSTOP) ||
+ ISSET(tp->t_lflag, FLUSHO)) {
+ CLR(tp->t_lflag, FLUSHO);
+ CLR(tp->t_state, TS_TTSTOP);
+ ttstart(tp);
+ }
+ splx(s);
+ break;
+ case TIOCSTI: /* simulate terminal input */
+ if (p->p_ucred->cr_uid && (flag & FREAD) == 0)
+ return (EPERM);
+ if (p->p_ucred->cr_uid && !isctty(p, tp))
+ return (EACCES);
+ (*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
+ break;
+ case TIOCSTOP: /* stop output, like ^S */
+ s = spltty();
+ if (!ISSET(tp->t_state, TS_TTSTOP)) {
+ SET(tp->t_state, TS_TTSTOP);
+#ifdef sun4c /* XXX */
+ (*tp->t_stop)(tp, 0);
+#else
+ (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+#endif
+ }
+ splx(s);
+ break;
+ case TIOCSCTTY: /* become controlling tty */
+ /* Session ctty vnode pointer set in vnode layer. */
+ if (!SESS_LEADER(p) ||
+ (p->p_session->s_ttyvp || tp->t_session) &&
+ (tp->t_session != p->p_session))
+ return (EPERM);
+ tp->t_session = p->p_session;
+ tp->t_pgrp = p->p_pgrp;
+ p->p_session->s_ttyp = tp;
+ p->p_flag |= SCTTY;
+ break;
+ case TIOCSPGRP: { /* set pgrp of tty */
+ register struct pgrp *pgrp = pgfind(*(int *)data);
+ if (!isctty(p, tp))
+ return (ENOTTY);
+ else if (pgrp == NULL || pgrp->pg_session != p->p_session)
+ return (EPERM);
+ tp->t_pgrp = pgrp;
+ break;
+ }
+ case TIOCSWINSZ: /* set window size */
+ if (bcmp((caddr_t)&tp->t_winsize, data,
+ sizeof (struct winsize))) {
+ tp->t_winsize = *(struct winsize *)data;
+ pgsignal(tp->t_pgrp, SIGWINCH, 1);
+ }
+ break;
default:
+#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
+ return (ttcompat(tp, com, data, flag));
+#else
return (-1);
+#endif
}
return (0);
}
-/*
- * DEBUG - to be removed
- */
-ttytrace(ioc, tp)
- struct tty *tp;
+int
+ttselect(device, rw, p)
+ dev_t device;
+ int rw;
+ struct proc *p;
{
- register u_char *cc = tp->t_cc;
- char comm[MAXCOMLEN+1];
- static int seq = 0;
-
- bcopy(u.u_comm, comm, MAXCOMLEN+1);
- comm[MAXCOMLEN] = '\0';
+ register struct tty *tp;
+ int nread, s;
- /* trace changes to line disciplines */
- if (ioc == TIOCSETD) {
- log(LOG_LOCAL4|LOG_DEBUG, "%s:%x:%x:%x:%x\n",
- comm, ioc, u.u_procp->p_pid, tp->t_dev, tp->t_line);
- return;
- }
+ tp = &cdevsw[major(device)].d_ttys[minor(device)];
- /*
- * format for the trace record is:
- *
- * u_comm:ioctl:pid:dev_t:ldisc:iflag:oflag:lflag:cflag:ispeed:
- * ospeed:cc's...:seq
- *
- * u_comm is a string and all other values are hex. "cc's..."
- * stands for control chars 0 through NCC-1. seq is a sequence #
- * to force syslogd to log every entry (rather than hold them to
- * print "last message repeated...".
- */
- log(LOG_LOCAL4|LOG_DEBUG, "%s:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x\n",
- comm, ioc, u.u_procp->p_pid, tp->t_dev, tp->t_line,
- tp->t_iflag, tp->t_oflag, tp->t_lflag, tp->t_cflag,
- tp->t_ispeed, tp->t_ospeed, cc[0], cc[1], cc[2], cc[3],
- cc[4], cc[5], cc[6], cc[7], cc[8], cc[9], cc[10], cc[11],
- cc[12], cc[13], cc[14], cc[15], cc[16], cc[17], cc[18],
- cc[19], seq++);
+ s = spltty();
+ switch (rw) {
+ case FREAD:
+ nread = ttnread(tp);
+ if (nread > 0 || !ISSET(tp->t_cflag, CLOCAL) &&
+ !ISSET(tp->t_state, TS_CARR_ON))
+ goto win;
+ selrecord(p, &tp->t_rsel);
+ break;
+ case FWRITE:
+ if (tp->t_outq.c_cc <= tp->t_lowat) {
+win: splx(s);
+ return (1);
+ }
+ selrecord(p, &tp->t_wsel);
+ break;
+ }
+ splx(s);
+ return (0);
}
+static int
ttnread(tp)
struct tty *tp;
{
- int nread = 0;
+ int nread;
- if (tp->t_lflag & PENDIN)
+ if (ISSET(tp->t_lflag, PENDIN))
ttypend(tp);
nread = tp->t_canq.c_cc;
- if (tp->t_lflag & ICANON == 0)
+ if (!ISSET(tp->t_lflag, ICANON))
nread += tp->t_rawq.c_cc;
return (nread);
}
-ttselect(dev, rw)
- dev_t dev;
- int rw;
-{
- register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
- int nread;
- int s = spltty();
-
- switch (rw) {
-
- case FREAD:
- nread = ttnread(tp);
- if (nread > 0 ||
- (!(tp->t_cflag&CLOCAL) && !(tp->t_state&TS_CARR_ON)))
- 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;
- 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;
- break;
- }
- splx(s);
- return (0);
-win:
- splx(s);
- return (1);
-}
-
/*
- * Initial open of tty, or (re)entry to line discipline.
+ * Wait for output to drain.
*/
-ttyopen(dev, tp)
- dev_t dev;
+int
+ttywait(tp)
register struct tty *tp;
{
+ int error, s;
- tp->t_dev = dev;
-
- tp->t_state &= ~TS_WOPEN;
- if ((tp->t_state & TS_ISOPEN) == 0) {
- tp->t_state |= TS_ISOPEN;
- bzero((caddr_t)&tp->t_winsize, sizeof(tp->t_winsize));
- /*
- * CHANGE: used to do a ttywflush() if it was the
- * old (old) line discipline.
- */
+ error = 0;
+ s = spltty();
+ while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
+ (ISSET(tp->t_state, TS_CARR_ON) || ISSET(tp->t_cflag, CLOCAL))
+ && tp->t_oproc) {
+ (*tp->t_oproc)(tp);
+ SET(tp->t_state, TS_ASLEEP);
+ if (error = ttysleep(tp,
+ &tp->t_outq, TTOPRI | PCATCH, ttyout, 0))
+ break;
}
- return (0);
+ splx(s);
+ return (error);
}
/*
- * "close" a line discipline
+ * Flush if successfully wait.
*/
-ttylclose(tp)
- register struct tty *tp;
+int
+ttywflush(tp)
+ struct tty *tp;
{
+ int error;
- ttywflush(tp);
-}
-
-/*
- * clean tp on last close
- */
-ttyclose(tp)
- register struct tty *tp;
-{
- if (constty == tp)
- constty = NULL;
- ttyflush(tp, FREAD|FWRITE);
- tp->t_pgid = 0;
- tp->t_state = 0;
+ if ((error = ttywait(tp)) == 0)
+ ttyflush(tp, FREAD);
+ return (error);
}
/*
- * Handle modem control transition on a tty.
- * Flag indicates new state of carrier.
- * Returns 0 if the line should be turned off, otherwise 1.
+ * Flush tty read and/or write queues, notifying anyone waiting.
*/
-ttymodem(tp, flag)
+void
+ttyflush(tp, rw)
register struct tty *tp;
+ int rw;
{
+ register int s;
- if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_lflag & MDMBUF)) {
- /*
- * MDMBUF: do flow control according to carrier flag
- */
- if (flag) {
- tp->t_state &= ~TS_TTSTOP;
- ttstart(tp);
- } else if ((tp->t_state&TS_TTSTOP) == 0) {
- tp->t_state |= TS_TTSTOP;
- (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
- }
- } else if (flag == 0) {
- /*
- * Lost carrier.
- */
- tp->t_state &= ~TS_CARR_ON;
- if (tp->t_state & TS_ISOPEN) {
- if ((tp->t_lflag & NOHANG) == 0) {
- gsignal(tp->t_pgid, SIGHUP);
- gsignal(tp->t_pgid, SIGCONT);
- ttyflush(tp, FREAD|FWRITE);
- return (0);
- }
- }
- } else {
- /*
- * Carrier now on.
- */
- tp->t_state |= TS_CARR_ON;
+ s = spltty();
+ if (rw & FREAD) {
+ FLUSHQ(&tp->t_canq);
+ FLUSHQ(&tp->t_rawq);
+ tp->t_rocount = 0;
+ tp->t_rocol = 0;
+ CLR(tp->t_state, TS_LOCAL);
ttwakeup(tp);
}
- return (1);
-}
-
-/*
- * Default modem control routine (for other line disciplines).
- * Return argument flag, to turn off device on carrier drop.
- */
-nullmodem(tp, flag)
- register struct tty *tp;
- int flag;
-{
-
- if (flag)
- tp->t_state |= TS_CARR_ON;
- else {
- tp->t_state &= ~TS_CARR_ON;
- if ((tp->t_lflag & NOHANG) == 0)
- gsignal(tp->t_pgid, SIGHUP);
+ if (rw & FWRITE) {
+ CLR(tp->t_state, TS_TTSTOP);
+#ifdef sun4c /* XXX */
+ (*tp->t_stop)(tp, rw);
+#else
+ (*cdevsw[major(tp->t_dev)].d_stop)(tp, rw);
+#endif
+ FLUSHQ(&tp->t_outq);
+ wakeup((caddr_t)&tp->t_outq);
+ selwakeup(&tp->t_wsel);
}
- return (flag);
+ splx(s);
}
/*
- * reinput pending characters after state switch
- * call at spltty().
+ * Copy in the default termios characters.
*/
-ttypend(tp)
- register struct tty *tp;
+void
+ttychars(tp)
+ struct tty *tp;
{
- struct clist tq;
- register c;
- tp->t_lflag &= ~PENDIN;
- tp->t_state |= TS_TYPEN;
- tq = tp->t_rawq;
- tp->t_rawq.c_cc = 0;
- tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
- while ((c = getc(&tq)) >= 0)
- ttyinput(c, tp);
- tp->t_state &= ~TS_TYPEN;
+ bcopy(ttydefchars, tp->t_cc, sizeof(ttydefchars));
}
/*
- *
- *
- * 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.
+ * Send stop character on input overflow.
*/
-ttyinput(c, tp)
- register c;
+static void
+ttyblock(tp)
register struct tty *tp;
{
- register int iflag = tp->t_iflag;
- register int lflag = tp->t_lflag;
- register u_char *cc = tp->t_cc;
- int i, err;
+ register int total;
- /*
- * If input is pending take it first.
- */
- if (lflag&PENDIN)
- ttypend(tp);
- /*
- * Gather stats.
- */
-
- tk_nin++;
- if (lflag&ICANON) {
- tk_cancc++;
- tp->t_cancc++;
- } else {
- tk_rawcc++;
- tp->t_rawcc++;
+ total = tp->t_rawq.c_cc + tp->t_canq.c_cc;
+ if (tp->t_rawq.c_cc > TTYHOG) {
+ ttyflush(tp, FREAD | FWRITE);
+ CLR(tp->t_state, TS_TBLOCK);
}
/*
- * Handle exceptional conditions (break, parity, framing).
+ * Block further input iff: current input > threshold
+ * AND input is available to user program.
*/
- if (err = (c&TTY_ERRORMASK)) {
- c &= TTY_CHARMASK;
- if (err&TTY_FE && !c) { /* break */
- if (iflag&IGNBRK)
- goto endcase;
- else if (iflag&BRKINT && lflag&ISIG &&
- (cc[VINTR] != POSIX_V_DISABLE))
- c = cc[VINTR];
- else
- c = 0;
- } else if ((err&TTY_PE && iflag&INPCK) || err&TTY_FE) {
- if (iflag&IGNPAR)
- goto endcase;
- else if (iflag&PARMRK) {
- ttyinput(0377, tp);
- ttyinput(0, tp);
- } else
- c = 0;
+ if (total >= TTYHOG / 2 &&
+ !ISSET(tp->t_state, TS_TBLOCK) &&
+ !ISSET(tp->t_lflag, ICANON) || tp->t_canq.c_cc > 0 &&
+ tp->t_cc[VSTOP] != _POSIX_VDISABLE) {
+ if (putc(tp->t_cc[VSTOP], &tp->t_outq) == 0) {
+ SET(tp->t_state, TS_TBLOCK);
+ ttstart(tp);
}
}
- dprintf("<%o>\n", c);
+}
- /*
- * In tandem mode, check high water mark.
- */
- if (iflag&IXOFF)
- ttyblock(tp);
+void
+ttrstrt(tp_arg)
+ void *tp_arg;
+{
+ struct tty *tp;
+ int s;
- /*
- * 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.
- */
+#ifdef DIAGNOSTIC
+ if (tp_arg == NULL)
+ panic("ttrstrt");
+#endif
+ tp = tp_arg;
+ s = spltty();
- /*
- * Extensions to POSIX input modes which aren't controlled
- * by ICANON, ISIG, or IXON.
- */
- if (iflag&IEXTEN) {
- 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);
- ttyecho(c, tp);
- if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
- ttyretype(tp);
- tp->t_lflag |= FLUSHO;
- }
- goto startoutput;
- }
- }
+ CLR(tp->t_state, TS_TIMEOUT);
+ ttstart(tp);
- /*
- * 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);
- gsignal(tp->t_pgid, SIGTSTP);
- goto endcase;
- }
- if (CCEQ(cc[VINFO],c)) {
- ttyinfo(tp);
- goto endcase;
- }
- }
- /*
- * Handle start/stop characters.
- */
- if (iflag&IXON) {
- if (CCEQ(cc[VSTOP],c)) {
- if ((tp->t_state&TS_TTSTOP) == 0) {
- tp->t_state |= TS_TTSTOP;
- (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
- return;
- }
- if (!CCEQ(cc[VSTART], c))
- return;
- /*
- * if VSTART == VSTOP we toggle
- */
- goto endcase;
- }
- 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.
- */
+ splx(s);
+}
- /*
- * Oldstyle quoting of erase, kill, and eof chars.
- *
- * Historically is '\' , but can be changed (read: disabled)
- * with the VQUOTE subscript.
- */
+int
+ttstart(tp)
+ struct tty *tp;
+{
- /*
- * 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)) {
- 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);
- goto endcase;
- }
- /*
- * reprint line (^R)
- */
- if (CCEQ(cc[VREPRINT], c)) {
- ttyretype(tp);
- goto endcase;
- }
- /*
- * reprint line (^R)
- */
- if (CCEQ(cc[VREPRINT], c)) {
- ttyretype(tp);
- goto endcase;
- }
- /*
- * Check for input buffer overflow
- */
- 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);
- } else
- ttyflush(tp, FREAD | FWRITE);
- goto endcase;
- }
- /*
- * Put data char in q for user and
- * wakeup on seeing a line delimiter.
- */
- if (putc(c, &tp->t_rawq) >= 0) {
- if (ttbreakc(c)) {
- tp->t_rocount = 0;
- catq(&tp->t_rawq, &tp->t_canq);
- ttwakeup(tp);
- } else if (tp->t_rocount++ == 0)
- tp->t_rocol = tp->t_col;
- if (CCEQ(cc[VQUOTE], c) && (iflag&ISTRIP))
- tp->t_state |= TS_QUOT; /* '\' escape */
- if (tp->t_state&TS_ERASE) {
- /*
- * end of prterase \.../
- */
- /*
- * end of prterase \.../
- */
- tp->t_state &= ~TS_ERASE;
- (void) ttyoutput('/', tp);
- }
- i = tp->t_col;
- ttyecho(c, tp);
- if (CCEQ(cc[VEOF], c) && lflag&ECHO) {
- /*
- * Place the cursor over the '^' of the ^D.
- */
- i = MIN(2, tp->t_col - i);
- while (i > 0) {
- (void) ttyoutput('\b', tp);
- i--;
- }
- }
- }
-endcase:
- /*
- * IXANY means allow any character to restart output.
- */
- if (tp->t_state&TS_TTSTOP && (iflag&IXANY == 0)
- && cc[VSTART] != cc[VSTOP])
- return;
-
-restartoutput:
- tp->t_state &= ~TS_TTSTOP;
- tp->t_lflag &= ~FLUSHO;
-startoutput:
- ttstart(tp);
+ if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
+ (*tp->t_oproc)(tp);
+ return (0);
+}
+
+/*
+ * "close" a line discipline
+ */
+int
+ttylclose(tp, flag)
+ struct tty *tp;
+ int flag;
+{
+
+ if (flag & IO_NDELAY)
+ ttyflush(tp, FREAD | FWRITE);
+ else
+ ttywflush(tp);
+ return (0);
}
/*
- * 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
- * Must be recursive.
+ * Handle modem control transition on a tty.
+ * Flag indicates new state of carrier.
+ * Returns 0 if the line should be turned off, otherwise 1.
*/
-ttyoutput(c, tp)
- register c;
+int
+ttymodem(tp, flag)
register struct tty *tp;
+ int flag;
{
- register char *colp;
- register ctype;
- if (!(tp->t_oflag&OPOST)) {
- if (tp->t_lflag&FLUSHO)
- return (-1);
- if (putc(c, &tp->t_outq))
- return (c);
- tk_nout++;
- tp->t_outcc++;
- return (-1);
- }
- c &= 0377;
- /*
- * Turn tabs to spaces as required
- */
- if (c == '\t' && tp->t_oflag&OXTABS ) {
- register int s;
- c = 8 - (tp->t_col&7);
- if ((tp->t_lflag&FLUSHO) == 0) {
- s = spltty(); /* don't interrupt tabs */
- c -= b_to_q(" ", c, &tp->t_outq);
- tk_nout += c;
- tp->t_outcc += c;
- splx(s);
+ if (!ISSET(tp->t_state, TS_WOPEN) && ISSET(tp->t_cflag, MDMBUF)) {
+ /*
+ * MDMBUF: do flow control according to carrier flag
+ */
+ if (flag) {
+ CLR(tp->t_state, TS_TTSTOP);
+ ttstart(tp);
+ } else if (!ISSET(tp->t_state, TS_TTSTOP)) {
+ SET(tp->t_state, TS_TTSTOP);
+#ifdef sun4c /* XXX */
+ (*tp->t_stop)(tp, 0);
+#else
+ (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
+#endif
}
- tp->t_col += c;
- return (c ? -1 : '\t');
+ } else if (flag == 0) {
+ /*
+ * Lost carrier.
+ */
+ CLR(tp->t_state, TS_CARR_ON);
+ if (ISSET(tp->t_state, TS_ISOPEN) &&
+ !ISSET(tp->t_cflag, CLOCAL)) {
+ if (tp->t_session && tp->t_session->s_leader)
+ psignal(tp->t_session->s_leader, SIGHUP);
+ ttyflush(tp, FREAD | FWRITE);
+ return (0);
+ }
+ } else {
+ /*
+ * Carrier now on.
+ */
+ SET(tp->t_state, TS_CARR_ON);
+ ttwakeup(tp);
}
- if (c == CEOT && oflag&ONOEOT)
- return(-1);
- tk_nout++;
- tp->t_outcc++;
-#ifdef notdef
- /*
- * turn <nl> to <cr><lf> if desired.
- */
-#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) {
-
- case ORDINARY:
- (*colp)++;
-
- case CONTROL:
- break;
-
- case BACKSPACE:
- if (*colp)
- (*colp)--;
- break;
+ return (1);
+}
- /*
- * 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:
- 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;
- break;
+/*
+ * Default modem control routine (for other line disciplines).
+ * Return argument flag, to turn off device on carrier drop.
+ */
+int
+nullmodem(tp, flag)
+ register struct tty *tp;
+ int flag;
+{
- case TAB:
- ctype = (tp->t_flags >> 10) & 03;
- if (ctype == 1) { /* tty 37 */
- c = 1 - (*colp | ~07);
- if (c < 5)
- c = 0;
+ if (flag)
+ SET(tp->t_state, TS_CARR_ON);
+ else {
+ CLR(tp->t_state, TS_CARR_ON);
+ if (!ISSET(tp->t_cflag, CLOCAL)) {
+ if (tp->t_session && tp->t_session->s_leader)
+ psignal(tp->t_session->s_leader, SIGHUP);
+ return (0);
}
- *colp |= 07;
- (*colp)++;
- break;
+ }
+ return (1);
+}
- case VTAB:
- if (tp->t_flags&VTDELAY) /* tty 37 */
- c = 0177;
- break;
+/*
+ * Reinput pending characters after state switch
+ * call at spltty().
+ */
+void
+ttypend(tp)
+ register struct tty *tp;
+{
+ struct clist tq;
+ register c;
- 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;
- }
- if (c && (tp->t_lflag&FLUSHO) == 0)
- (void) putc(c|TTY_QUOTE, &tp->t_outq);
- return (-1);
+ CLR(tp->t_lflag, PENDIN);
+ SET(tp->t_state, TS_TYPEN);
+ tq = tp->t_rawq;
+ tp->t_rawq.c_cc = 0;
+ tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
+ while ((c = getc(&tq)) >= 0)
+ ttyinput(c, tp);
+ CLR(tp->t_state, TS_TYPEN);
}
-#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.
*/
+int
ttread(tp, uio, flag)
register struct tty *tp;
struct uio *uio;
+ int flag;
{
register struct clist *qp;
register int c, t_flags;
int s, first, error = 0;
-loop:
+loop: lflag = tp->t_lflag;
s = spltty();
/*
- * take pending input first
+ * take pending input first
*/
if (tp->t_lflag&PENDIN)
ttypend(tp);
- /*
- * Handle carrier.
- */
- if (!(tp->t_state&TS_CARR_ON) && !(tp->t_cflag&CLOCAL)) {
- if (tp->t_state&TS_ISOPEN) {
- splx(s);
- return (0); /* EOF */
- } else if (flag & IO_NDELAY) {
- splx(s);
- return (EWOULDBLOCK);
- } else {
- /*
- * sleep awaiting carrier
- */
- sleep((caddr_t)&tp->t_rawq, TTIPRI);
- splx(s);
- goto loop;
- }
- }
splx(s);
+
/*
* Hang process if it's in the background.
*/
- if (u.u_ttyp == tp && u.u_procp->p_pgid != tp->t_pgid) {
- 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);
- pgsignal(u.u_procp->p_pgrp, SIGTTIN);
- sleep((caddr_t)&lbolt, TTIPRI);
+ pgsignal(p->p_pgrp, SIGTTIN, 1);
+ if (error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg, 0))
+ return (error);
goto loop;
}
+
/*
* If canonical, use the canonical queue,
* else use the raw queue.
*/
- qp = lflag&ICANON ? &tp->t_canq : &tp->t_rawq;
+ qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
+
/*
- * No input, sleep on rawq awaiting hardware
- * receipt and notification.
+ * If there is no input, sleep on rawq
+ * awaiting hardware receipt and notification.
+ * If we have data, we don't need to check for carrier.
*/
s = spltty();
if (qp->c_cc <= 0) {
- /** XXX ??? ask mike why TS_CARR_ON was (once) necessary here
- if ((tp->t_state&TS_CARR_ON) == 0 ||
- (tp->t_state&TS_NBIO)) {
+ int carrier;
+
+ carrier = ISSET(tp->t_state, TS_CARR_ON) ||
+ ISSET(tp->t_cflag, CLOCAL);
+ if (!carrier && ISSET(tp->t_state, TS_ISOPEN)) {
splx(s);
- return (EWOULDBLOCK);
+ return (0); /* EOF */
}
- **/
if (flag & IO_NDELAY) {
splx(s);
return (EWOULDBLOCK);
}
- sleep((caddr_t)&tp->t_rawq, TTIPRI);
+ error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH,
+ carrier ? ttyin : ttopen, 0);
splx(s);
+ if (error)
+ return (error);
goto loop;
}
splx(s);
+
/*
* Input present, check for input mapping and processing.
*/
/*
* delayed suspend (^Y)
*/
- if (CCEQ(cc[VDSUSP], c) && lflag&ISIG) {
- gsignal(tp->t_pgid, SIGTSTP);
+ if (CCEQ(cc[VDSUSP], c) && ISSET(lflag, ISIG)) {
+ pgsignal(tp->t_pgrp, SIGTSTP, 1);
if (first) {
- sleep((caddr_t)&lbolt, TTIPRI);
+ if (error = ttysleep(tp,
+ &lbolt, TTIPRI | PCATCH, ttybg, 0))
+ break;
goto loop;
}
break;
if (lflag&ICANON && ttbreakc(c)) {
break;
}
- }
first = 0;
}
/*
* 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) {
- tp->t_state &= ~TS_TBLOCK;
+ CLR(tp->t_state, TS_TBLOCK);
ttstart(tp);
}
}
+ splx(s);
}
return (error);
}
/*
- * Check the output queue on tp for space for a kernel message
- * (from uprintf/tprintf). Allow some space over the normal
- * hiwater mark so we don't lose messages due to normal flow
- * control, but don't let the tty run amok.
- * Sleeps here are not interruptible, but we return prematurely
- * if new signals come in.
+ * Check the output queue on tp for space for a kernel message (from uprintf
+ * or tprintf). Allow some space over the normal hiwater mark so we don't
+ * lose messages due to normal flow control, but don't let the tty run amok.
+ * Sleeps here are not interruptible, but we return prematurely if new signals
+ * arrive.
*/
+int
ttycheckoutq(tp, wait)
register struct tty *tp;
int wait;
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 (wait == 0 || u.u_procp->p_sig != oldsig) {
+ if (wait == 0 || curproc->p_sig != oldsig) {
splx(s);
return (0);
}
- timeout(wakeup, (caddr_t)&tp->t_outq, hz);
- tp->t_state |= TS_ASLEEP;
+ timeout((void (*)__P((void *)))wakeup,
+ (void *)&tp->t_outq, hz);
+ SET(tp->t_state, TS_ASLEEP);
sleep((caddr_t)&tp->t_outq, PZERO - 1);
}
splx(s);
}
/*
- * 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.
*/
+int
ttwrite(tp, uio, flag)
register struct tty *tp;
register struct uio *uio;
+ int flag;
{
register char *cp;
register int cc, ce;
+ register struct proc *p;
int i, hiwat, cnt, error, s;
char obuf[OBUFSIZ];
error = 0;
loop:
s = spltty();
- if (!(tp->t_state&TS_CARR_ON) && !(tp->t_cflag&CLOCAL)) {
- if (tp->t_state&TS_ISOPEN) {
+ if (!ISSET(tp->t_state, TS_CARR_ON) &&
+ !ISSET(tp->t_cflag, CLOCAL)) {
+ if (ISSET(tp->t_state, TS_ISOPEN)) {
splx(s);
return (EIO);
} else if (flag & IO_NDELAY) {
splx(s);
- return (EWOULDBLOCK);
+ error = EWOULDBLOCK;
+ goto out;
} else {
- /*
- * sleep awaiting carrier
- */
- sleep((caddr_t)&tp->t_rawq, TTIPRI);
+ /* Sleep awaiting carrier. */
+ error = ttysleep(tp,
+ &tp->t_rawq, TTIPRI | PCATCH,ttopen, 0);
splx(s);
+ if (error)
+ goto out;
goto loop;
}
}
/*
* 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)) &&
- !(u.u_procp->p_sigmask & sigmask(SIGTTOU)) &&
- u.u_procp->p_pgrp->pg_jobc) {
- pgsignal(u.u_procp->p_pgrp, SIGTTOU);
- sleep((caddr_t)&lbolt, TTIPRI);
+ p = curproc;
+ if (isbackground(p, tp) &&
+ ISSET(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, &lbolt, TTIPRI | PCATCH, ttybg, 0))
+ goto out;
goto loop;
}
/*
- * Process the user's data in at most OBUFSIZ
- * chunks. Perform lower case simulation and
- * similar hacks. Keep track of high water
- * mark, sleep on overflow awaiting device aid
- * in acquiring new space.
+ * Process the user's data in at most OBUFSIZ chunks. Perform any
+ * output translation. Keep track of high water mark, sleep on
+ * overflow awaiting device aid in acquiring new space.
*/
- while (uio->uio_resid > 0) {
- if (tp->t_outq.c_cc > hiwat) {
- cc = 0;
- goto ovhiwat;
+ for (cc = 0; uio->uio_resid > 0 || cc > 0;) {
+ if (ISSET(tp->t_lflag, FLUSHO)) {
+ uio->uio_resid = 0;
+ return (0);
}
+ if (tp->t_outq.c_cc > hiwat)
+ goto ovhiwat;
/*
- * Grab a hunk of data from the user.
+ * Grab a hunk of data from the user, unless we have some
+ * leftover from last time.
*/
- cc = uio->uio_iov->iov_len;
if (cc == 0) {
- uio->uio_iovcnt--;
- uio->uio_iov++;
- if (uio->uio_iovcnt <= 0)
- panic("ttwrite");
- continue;
+ cc = min(uio->uio_resid, OBUFSIZ);
+ cp = obuf;
+ error = uiomove(cp, cc, uio);
+ if (error) {
+ cc = 0;
+ break;
+ }
}
- if (cc > OBUFSIZ)
- cc = OBUFSIZ;
- cp = obuf;
- error = uiomove(cp, cc, uio);
- if (error)
- break;
- if (tp->t_lflag&FLUSHO)
- continue;
#ifdef notdef
/*
* If nothing fancy need be done, grab those characters we
* can handle without any of ttyoutput's processing and
* just transfer them to the output q. For those chars
* which require special processing (as indicated by the
- * bits in partab), call ttyoutput. After processing
+ * bits in char_type), call ttyoutput. After processing
* a hunk of data, look for FLUSHO so ^O's will take effect
* immediately.
*/
if (!(tp->t_oflag&OPOST))
ce = cc;
else {
- ce = cc - scanc((unsigned)cc, (u_char *)cp,
- (u_char *)partab, 077);
+ ce = cc - scanc((u_int)cc, (u_char *)cp,
+ (u_char *)char_type, CCLASSMASK);
/*
* If ce is zero, then we're processing
* a special character through ttyoutput.
if (ce == 0) {
tp->t_rocount = 0;
if (ttyoutput(*cp, tp) >= 0) {
- /* no c-lists, wait a bit */
- ttstart(tp);
- sleep((caddr_t)&lbolt, TTOPRI);
- if (cc != 0) {
- uio->uio_iov->iov_base -= cc;
- uio->uio_iov->iov_len += cc;
- uio->uio_resid += cc;
- uio->uio_offset -= cc;
- }
- goto loop;
+ /* No Clists, wait a bit. */
+ ttstart(tp);
+ if (error = ttysleep(tp, &lbolt,
+ TTOPRI | PCATCH, ttybuf, 0))
+ break;
+ goto loop;
}
- cp++, cc--;
if (tp->t_lflag&FLUSHO ||
tp->t_outq.c_cc > hiwat)
goto ovhiwat;
}
}
/*
- * A bunch of normal characters have been found,
- * transfer them en masse to the output queue and
+ * A bunch of normal characters have been found.
+ * Transfer them en masse to the output queue and
* continue processing at the top of the loop.
* If there are any further characters in this
* <= OBUFSIZ chunk, the first should be a character
cp += ce, cc -= ce, tk_nout += ce;
tp->t_outcc += ce;
if (i > 0) {
- /* out of c-lists, wait a bit */
+ /* No Clists, wait a bit. */
ttstart(tp);
- sleep((caddr_t)&lbolt, TTOPRI);
- uio->uio_iov->iov_base -= cc;
- uio->uio_iov->iov_len += cc;
- uio->uio_resid += cc;
- uio->uio_offset -= cc;
+ if (error = ttysleep(tp,
+ &lbolt, TTOPRI | PCATCH, ttybuf, 0))
+ break;
goto loop;
}
if (tp->t_lflag&FLUSHO || tp->t_outq.c_cc > hiwat)
- goto ovhiwat;
+ break;
}
ttstart(tp);
ttstart(tp);
}
+out:
+ /*
+ * If cc is nonzero, we leave the uio structure inconsistent, as the
+ * offset and iov pointers have moved forward, but it doesn't matter
+ * (the call will either return short or restart with a new uio).
+ */
+ uio->uio_resid += cc;
return (error);
+
ovhiwat:
- if (cc != 0) {
- uio->uio_iov->iov_base -= cc;
- uio->uio_iov->iov_len += cc;
- uio->uio_resid += cc;
- uio->uio_offset -= cc;
- }
ttstart(tp);
s = spltty();
/*
}
if (flag & IO_NDELAY) {
splx(s);
- if (uio->uio_resid == cnt)
- return (EWOULDBLOCK);
- return (0);
+ uio->uio_resid += cc;
+ return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
}
- tp->t_state |= TS_ASLEEP;
- sleep((caddr_t)&tp->t_outq, TTOPRI);
+ SET(tp->t_state, TS_ASLEEP);
+ error = ttysleep(tp, &tp->t_outq, TTOPRI | PCATCH, ttyout, 0);
splx(s);
+ if (error)
+ goto out;
goto loop;
}
* Rubout one character from the rawq of tp
* as cleanly as possible.
*/
+void
ttyrub(c, tp)
- register c;
+ register int c;
register struct tty *tp;
{
register char *cp;
register int savecol;
- int s;
- char *nextc();
+ int tabc, s;
if ((tp->t_lflag&ECHO) == 0)
return;
return;
}
/* if tab or newline was escaped - XXX - not 8bit */
- if (c == ('\t'|TTY_QUOTE) || c == ('\n'|TTY_QUOTE))
+ 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
ttyrubo(tp, 1);
break;
-
- case VTAB:
case BACKSPACE:
case CONTROL:
- case RETURN:
+ case NEWLINE:
if (tp->t_lflag&ECHOCTL)
ttyrubo(tp, 2);
break;
-
- case TAB: {
- int c;
-
+ case TAB:
if (tp->t_rocount < tp->t_rawq.c_cc) {
ttyretype(tp);
return;
}
s = spltty();
savecol = tp->t_col;
- tp->t_state |= TS_CNTTB;
tp->t_lflag |= FLUSHO;
tp->t_col = tp->t_rocol;
cp = tp->t_rawq.c_cf;
- tp->t_lflag &= ~FLUSHO;
- tp->t_state &= ~TS_CNTTB;
+ tabc = *cp; /* XXX FIX NEXTC */
+ for (; cp; cp = nextc(&tp->t_rawq, cp, &tabc))
+ ttyecho(tabc, tp);
+ CLR(tp->t_lflag, FLUSHO);
+ CLR(tp->t_state, TS_CNTTB);
splx(s);
- /*
- * savecol will now be length of the tab
- */
+
+ /* savecol will now be length of the tab. */
savecol -= tp->t_col;
tp->t_col += savecol;
if (savecol > 8)
savecol = 8; /* overflow screw */
while (--savecol >= 0)
- (void) ttyoutput('\b', tp);
+ (void)ttyoutput('\b', tp);
break;
+ default: /* XXX */
+#define PANICSTR "ttyrub: would panic c = %d, val = %d\n"
+ (void)printf(PANICSTR, c, CCLASS(c));
+#ifdef notdef
+ panic(PANICSTR, c, CCLASS(c));
+#endif
}
-
- default:
- /* XXX */
- printf("ttyrub: would panic c = %d, val = %d\n",
- c, partab[c&=0377]&077);
- /*panic("ttyrub");*/
- }
- } else if (tp->t_lflag&ECHOPRT) {
- if ((tp->t_state&TS_ERASE) == 0) {
- (void) ttyoutput('\\', tp);
- tp->t_state |= TS_ERASE;
+ } else if (ISSET(tp->t_lflag, ECHOPRT)) {
+ if (!ISSET(tp->t_state, TS_ERASE)) {
+ SET(tp->t_state, TS_ERASE);
+ (void)ttyoutput('\\', tp);
}
ttyecho(c, tp);
} else
ttyecho(tp->t_cc[VERASE], tp);
- tp->t_rocount--;
+ --tp->t_rocount;
}
/*
- * Crt back over cnt chars perhaps
- * erasing them.
+ * Back over cnt characters, erasing them.
*/
+static void
ttyrubo(tp, cnt)
register struct tty *tp;
int cnt;
{
register char *rubostring = tp->t_lflag&ECHOE ? "\b \b" : "\b";
- while (--cnt >= 0)
- ttyout("\b \b", tp);
+ while (cnt-- > 0) {
+ (void)ttyoutput('\b', tp);
+ (void)ttyoutput(' ', tp);
+ (void)ttyoutput('\b', tp);
+ }
}
/*
- * Reprint the rawq line.
- * We assume c_cc has already been checked.
+ * ttyretype --
+ * Reprint the rawq line. Note, it is assumed that c_cc has already
+ * been checked.
*/
+void
ttyretype(tp)
register struct tty *tp;
{
register char *cp;
- char *nextc();
int s, c;
+ /* Echo the reprint character. */
if (tp->t_cc[VREPRINT] != POSIX_V_DISABLE)
ttyecho(tp->t_cc[VREPRINT], tp);
- (void) ttyoutput('\n', tp);
+
+ (void)ttyoutput('\n', tp);
+
+ /*
+ * XXX
+ * FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
+ * BIT OF FIRST CHAR.
+ */
s = spltty();
- /*** XXX *** FIX *** NEXTC IS BROKEN - DOESN'T CHECK QUOTE
- BIT OF FIRST CHAR ****/
- for (cp = tp->t_canq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_canq, cp, &c)) {
+ for (cp = tp->t_canq.c_cf, c = (cp != NULL ? *cp : 0);
+ cp != NULL; cp = nextc(&tp->t_canq, cp, &c))
ttyecho(c, tp);
- }
- for (cp = tp->t_rawq.c_cf, c=(cp?*cp:0); cp; cp = nextc(&tp->t_rawq, cp, &c)) {
+ for (cp = tp->t_rawq.c_cf, c = (cp != NULL ? *cp : 0);
+ cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
ttyecho(c, tp);
- }
- tp->t_state &= ~TS_ERASE;
+ CLR(tp->t_state, TS_ERASE);
splx(s);
+
tp->t_rocount = tp->t_rawq.c_cc;
tp->t_rocol = 0;
}
/*
* Echo a typed character to the terminal.
*/
+static void
ttyecho(c, tp)
- register c;
+ register int c;
register struct tty *tp;
{
c &= 0377;
- if ((tp->t_state&TS_CNTTB) == 0)
tp->t_lflag &= ~FLUSHO;
if ((tp->t_lflag&ECHO) == 0 && !(tp->t_lflag&ECHONL && c == '\n'))
return;
- if (tp->t_lflag&ECHOCTL) {
- if ((c&TTY_CHARMASK)<=037 && c!='\t' && c!='\n' || c==0177) {
- (void) ttyoutput('^', tp);
- c &= TTY_CHARMASK;
- if (c == 0177)
- c = '?';
-#ifdef notdef
-#endif
- else
- c += 'A' - 1;
- }
+ if (ISSET(tp->t_lflag, ECHOCTL) &&
+ ((c & TTY_CHARMASK) <= 037 && c != '\t' && c != '\n' ||
+ (c & TTY_CHARMASK) == 0177)) {
+ (void)ttyoutput('^', tp);
+ c &= TTY_CHARMASK;
+ if (c == 0177)
+ c = '?';
+ else
+ c += 'A' - 1;
}
- (void) ttyoutput(c, tp);
- * send string cp to tp
+ (void)ttyoutput(c, tp);
+ * Wake up any readers on a tty.
*/
-ttyout(cp, tp)
- register char *cp;
+void
+ttwakeup(tp)
register struct tty *tp;
{
- register char c;
- while (c = *cp++)
- (void) ttyoutput(c, tp);
+ selwakeup(&tp->t_rsel);
+ if (ISSET(tp->t_state, TS_ASYNC))
+ pgsignal(tp->t_pgrp, SIGIO, 1);
+ wakeup((caddr_t)&tp->t_rawq);
}
-ttwakeup(tp)
- struct tty *tp;
+/*
+ * Look up a code for a specified speed in a conversion table;
+ * used by drivers to map software speed values to hardware parameters.
+ */
+int
+ttspeedtab(speed, table)
+ int speed;
+ register struct speedtab *table;
{
- if (tp->t_rsel) {
- selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
- tp->t_state &= ~TS_RCOLL;
- tp->t_rsel = 0;
- }
- if (tp->t_state & TS_ASYNC)
- gsignal(tp->t_pgid, SIGIO);
- wakeup((caddr_t)&tp->t_rawq);
+ 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.
*
* Try to arrange the dynamics so there's about one second
* from hi to low water.
- *
+ *
*/
+void
ttsetwater(tp)
struct tty *tp;
{
- register cps = tp->t_ospeed / 10;
- register x;
+ register int cps, x;
-#define clamp(x, h, l) ((x)>h ? h : ((x)<l) ? l : (x))
- tp->t_lowat = x = clamp(cps/2, TTMAXLOWAT, TTMINLOWAT);
+#define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
+
+ cps = tp->t_ospeed / 10;
+ tp->t_lowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
x += cps;
- x = clamp(x, TTMAXHIWAT, TTMINHIWAT);
+ x = CLAMP(x, TTMAXHIWAT, TTMINHIWAT);
tp->t_hiwat = roundup(x, CBSIZE);
-#undef clamp
+#undef CLAMP
}
-ttspeedtab(speed, table)
- struct speedtab table[];
+/*
+ * Report on state of foreground process group.
+ */
+void
+ttyinfo(tp)
+ register struct tty *tp;
{
- register int i;
+ register struct proc *p, *pick;
+ struct timeval utime, stime;
+ int tmp;
+
+ if (ttycheckoutq(tp,0) == 0)
+ return;
+
+ /* Print load average. */
+ tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2) >> FSHIFT;
+ ttyprintf(tp, "load: %d.%02d ", tmp / 100, tmp % 100);
- for (i = 0; table[i].sp_speed != -1; i++)
- if (table[i].sp_speed == speed)
- return(table[i].sp_code);
- return(-1);
+ if (tp->t_session == NULL)
+ ttyprintf(tp, "not a controlling terminal\n");
+ else if (tp->t_pgrp == NULL)
+ ttyprintf(tp, "no foreground process group\n");
+ else if ((p = tp->t_pgrp->pg_mem) == NULL)
+ ttyprintf(tp, "empty foreground process group\n");
+ else {
+ /* Pick interesting process. */
+ for (pick = NULL; p != NULL; p = p->p_pgrpnxt)
+ if (proc_compare(pick, p))
+ pick = p;
+
+ 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);
+
+#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));
+ }
+ tp->t_rocount = 0; /* so pending input will be retyped if BS */
}
/*
- * (^T)
- * Report on state of foreground process group.
+ * Returns 1 if p2 is "better" than p1
+ *
+ * The algorithm for picking the "interesting" process is thus:
+ *
+ * 1) (Only foreground processes are eligable - implied)
+ * 2) Runnable processes are favored over anything
+ * else. The runner with the highest cpu
+ * utilization is picked (p_cpu). Ties are
+ * broken by picking the highest pid.
+ * 3 Next, the sleeper with the shortest sleep
+ * time is favored. With ties, we pick out
+ * just "short-term" sleepers (SSINTR == 0).
+ * Further ties are broken by picking the highest
+ * pid.
+ *
*/
-ttyinfo(tp)
+#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;
+{
+
+ if (p1 == NULL)
+ return (1);
+ /*
+ * see if at least one of them is runnable
+ */
+ switch (TESTAB(isrun(p1), isrun(p2))) {
+ case ONLYA:
+ return (0);
+ case ONLYB:
+ return (1);
+ case BOTH:
+ /*
+ * tie - favor one with highest recent cpu utilization
+ */
+ if (p2->p_cpu > p1->p_cpu)
+ return (1);
+ if (p1->p_cpu > p2->p_cpu)
+ 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
+ */
+ if (p2->p_slptime > p1->p_slptime)
+ return (0);
+ if (p1->p_slptime > p2->p_slptime)
+ return (1);
+ /*
+ * favor one sleeping in a non-interruptible sleep
+ */
+ if (p1->p_flag & SSINTR && (p2->p_flag & SSINTR) == 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 */
+}
+
+/*
+ * Output char to tty; console putchar style.
+ */
+int
+tputchar(c, tp)
+ int c;
struct tty *tp;
{
- register struct proc *p;
- struct pgrp *pg = pgfind(tp->t_pgid);
+ register int s;
- if (ttycheckoutq(tp,0) == 0)
- return;
- if (pg == NULL)
- ttyprintf(tp, "kernel: no foreground process group\n");
- else if ((p = pg->pg_mem) == NULL)
- ttyprintf(tp, "kernel: empty process group: %d\n",
- tp->t_pgid);
- else {
- int i = 0;
- for (; p != NULL; p = p->p_pgrpnxt) {
- ttyprintf(tp,
- "kernel: pid: %d state: %x wchan: %x ticks: %d\n",
- p->p_pid, p->p_stat, p->p_wchan, p->p_cpticks);
- if (++i > 6) {
- ttyprintf(tp, "kernel: more...\n");
- break;
- }
- }
+ s = spltty();
+ if (ISSET(tp->t_state,
+ TS_CARR_ON | TS_ISOPEN) != (TS_CARR_ON | TS_ISOPEN)) {
+ splx(s);
+ return (-1);
}
+ if (c == '\n')
+ (void)ttyoutput('\r', tp);
+ (void)ttyoutput(c, tp);
+ ttstart(tp);
+ splx(s);
+ return (0);
}
-#define TOTTY 0x2 /* XXX should be in header */
-/*VARARGS2*/
-ttyprintf(tp, fmt, x1)
- register struct tty *tp;
- char *fmt;
- unsigned x1;
+/*
+ * 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.
+ */
+int
+ttysleep(tp, chan, pri, wmesg, timo)
+ struct tty *tp;
+ void *chan;
+ int pri, timo;
+ char *wmesg;
{
- prf(fmt, &x1, TOTTY, tp);
+ int error;
+ short gen;
+
+ gen = tp->t_gen;
+ if (error = tsleep(chan, pri, wmesg, timo))
+ return (error);
+ return (tp->t_gen == gen ? 0 : ERESTART);
}