1994-05-24 10:09:53 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 1982, 1986, 1990, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)tty.c 8.8 (Berkeley) 1/21/94
|
1998-12-08 10:22:07 +00:00
|
|
|
* $Id: tty.c,v 1.109 1998/12/07 07:59:20 ache Exp $
|
1995-07-21 14:15:09 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*-
|
|
|
|
* TODO:
|
|
|
|
* o Fix races for sending the start char in ttyflush().
|
|
|
|
* o Handle inter-byte timeout for "MIN > 0, TIME > 0" in ttyselect().
|
|
|
|
* With luck, there will be MIN chars before select() returns().
|
|
|
|
* o Handle CLOCAL consistently for ptys. Perhaps disallow setting it.
|
|
|
|
* o Don't allow input in TS_ZOMBIE case. It would be visible through
|
|
|
|
* FIONREAD.
|
|
|
|
* o Do the new sio locking stuff here and use it to avoid special
|
|
|
|
* case for EXTPROC?
|
|
|
|
* o Lock PENDIN too?
|
|
|
|
* o Move EXTPROC and/or PENDIN to t_state?
|
|
|
|
* o Wrap most of ttioctl in spltty/splx.
|
|
|
|
* o Implement TIOCNOTTY or remove it from <sys/ioctl.h>.
|
|
|
|
* o Send STOP if IXOFF is toggled off while TS_TBLOCK is set.
|
|
|
|
* o Don't allow certain termios flags to affect disciplines other
|
|
|
|
* than TTYDISC. Cancel their effects before switch disciplines
|
|
|
|
* and ignore them if they are set while we are in another
|
|
|
|
* discipline.
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
* o Now that historical speed conversions are handled here, don't
|
|
|
|
* do them in drivers.
|
1995-07-21 14:15:09 +00:00
|
|
|
* o Check for TS_CARR_ON being set while everything is closed and not
|
|
|
|
* waiting for carrier. TS_CARR_ON isn't cleared if nothing is open,
|
|
|
|
* so it would live until the next open even if carrier drops.
|
|
|
|
* o Restore TS_WOPEN since it is useful in pstat. It must be cleared
|
|
|
|
* only when _all_ openers leave open().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1995-02-14 21:21:26 +00:00
|
|
|
#include "snp.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
1996-03-02 18:24:13 +00:00
|
|
|
#include "opt_uconsole.h"
|
1995-02-14 21:21:26 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1997-03-24 12:03:06 +00:00
|
|
|
#include <sys/filio.h>
|
|
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
|
|
#include <sys/ioctl_compat.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#define TTYDEFCHARS
|
|
|
|
#include <sys/tty.h>
|
|
|
|
#undef TTYDEFCHARS
|
1997-03-23 03:37:54 +00:00
|
|
|
#include <sys/fcntl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/dkstat.h>
|
1997-09-14 02:40:46 +00:00
|
|
|
#include <sys/poll.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/vnode.h>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/signalvar.h>
|
|
|
|
#include <sys/resourcevar.h>
|
1995-02-09 11:13:30 +00:00
|
|
|
#include <sys/malloc.h>
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
#include <sys/filedesc.h>
|
1995-02-15 16:00:56 +00:00
|
|
|
#if NSNP > 0
|
1995-02-14 21:21:26 +00:00
|
|
|
#include <sys/snoop.h>
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <vm/vm.h>
|
1997-02-10 02:22:35 +00:00
|
|
|
#include <sys/lock.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_TTYS, "ttys", "tty data structures");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
static int proc_compare __P((struct proc *p1, struct proc *p2));
|
1995-07-31 19:17:19 +00:00
|
|
|
static int ttnread __P((struct tty *tp));
|
|
|
|
static void ttyecho __P((int c, struct tty *tp));
|
|
|
|
static int ttyoutput __P((int c, register struct tty *tp));
|
|
|
|
static void ttypend __P((struct tty *tp));
|
|
|
|
static void ttyretype __P((struct tty *tp));
|
|
|
|
static void ttyrub __P((int c, struct tty *tp));
|
|
|
|
static void ttyrubo __P((struct tty *tp, int cnt));
|
1995-07-31 18:29:51 +00:00
|
|
|
static void ttyunblock __P((struct tty *tp));
|
1995-12-14 08:32:45 +00:00
|
|
|
static int ttywflush __P((struct tty *tp));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
#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
|
|
|
|
|
1996-08-31 16:52:44 +00:00
|
|
|
static u_char const char_type[] = {
|
1994-05-24 10:09:53 +00:00
|
|
|
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; should be settable per character set;
|
|
|
|
* for now, treat them all as normal characters.
|
|
|
|
*/
|
|
|
|
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 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))
|
|
|
|
|
1995-07-21 14:41:43 +00:00
|
|
|
#undef MAX_INPUT /* XXX wrong in <sys/syslimits.h> */
|
1998-03-07 15:36:29 +00:00
|
|
|
#define MAX_INPUT TTYHOG /* XXX limit is usually larger for !ICANON */
|
1995-07-21 14:41:43 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Initial open of tty, or (re)entry to standard tty line discipline.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttyopen(device, tp)
|
|
|
|
dev_t device;
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = spltty();
|
|
|
|
tp->t_dev = device;
|
|
|
|
if (!ISSET(tp->t_state, TS_ISOPEN)) {
|
|
|
|
SET(tp->t_state, TS_ISOPEN);
|
1995-10-31 19:27:50 +00:00
|
|
|
if (ISSET(tp->t_cflag, CLOCAL))
|
|
|
|
SET(tp->t_state, TS_CONNECTED);
|
1994-05-24 10:09:53 +00:00
|
|
|
bzero(&tp->t_winsize, sizeof(tp->t_winsize));
|
|
|
|
}
|
1998-03-07 15:36:29 +00:00
|
|
|
ttsetwater(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
1995-07-21 17:30:12 +00:00
|
|
|
* XXX our caller should have done `spltty(); l_close(); ttyclose();'
|
|
|
|
* and l_close() should have flushed, but we repeat the spltty() and
|
|
|
|
* the flush in case there are buggy callers.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttyclose(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
1994-11-26 19:24:13 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
funsetown(tp->t_sigio);
|
1994-11-26 19:24:13 +00:00
|
|
|
s = spltty();
|
1994-05-24 10:09:53 +00:00
|
|
|
if (constty == tp)
|
|
|
|
constty = NULL;
|
|
|
|
|
|
|
|
ttyflush(tp, FREAD | FWRITE);
|
1994-11-26 19:24:13 +00:00
|
|
|
clist_free_cblocks(&tp->t_canq);
|
|
|
|
clist_free_cblocks(&tp->t_outq);
|
|
|
|
clist_free_cblocks(&tp->t_rawq);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-02-15 18:41:57 +00:00
|
|
|
#if NSNP > 0
|
1995-05-30 08:16:23 +00:00
|
|
|
if (ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
|
1995-02-15 18:41:57 +00:00
|
|
|
snpdown((struct snoop *)tp->t_sc);
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_gen++;
|
1995-10-31 19:27:50 +00:00
|
|
|
tp->t_line = TTYDISC;
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_pgrp = NULL;
|
|
|
|
tp->t_session = NULL;
|
|
|
|
tp->t_state = 0;
|
1994-11-26 19:24:13 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define FLUSHQ(q) { \
|
|
|
|
if ((q)->c_cc) \
|
|
|
|
ndflush(q, (q)->c_cc); \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is 'c' a line delimiter ("break" character)? */
|
1996-11-29 15:06:17 +00:00
|
|
|
#define TTBREAKC(c, lflag) \
|
1994-10-02 17:35:40 +00:00
|
|
|
((c) == '\n' || (((c) == cc[VEOF] || \
|
1996-11-29 15:06:17 +00:00
|
|
|
(c) == cc[VEOL] || ((c) == cc[VEOL2] && lflag & IEXTEN)) && \
|
|
|
|
(c) != _POSIX_VDISABLE))
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Process input of a single character received on a tty.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttyinput(c, tp)
|
|
|
|
register int c;
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
1995-07-31 19:17:19 +00:00
|
|
|
register tcflag_t iflag, lflag;
|
|
|
|
register cc_t *cc;
|
1994-05-24 10:09:53 +00:00
|
|
|
int i, err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If input is pending take it first.
|
|
|
|
*/
|
|
|
|
lflag = tp->t_lflag;
|
|
|
|
if (ISSET(lflag, PENDIN))
|
|
|
|
ttypend(tp);
|
|
|
|
/*
|
|
|
|
* Gather stats.
|
|
|
|
*/
|
|
|
|
if (ISSET(lflag, ICANON)) {
|
|
|
|
++tk_cancc;
|
|
|
|
++tp->t_cancc;
|
|
|
|
} else {
|
|
|
|
++tk_rawcc;
|
|
|
|
++tp->t_rawcc;
|
|
|
|
}
|
|
|
|
++tk_nin;
|
|
|
|
|
1995-07-31 18:29:51 +00:00
|
|
|
/*
|
|
|
|
* Block further input iff:
|
|
|
|
* current input > threshold AND input is available to user program
|
|
|
|
* AND input flow control is enabled and not yet invoked.
|
|
|
|
* The 3 is slop for PARMRK.
|
|
|
|
*/
|
|
|
|
iflag = tp->t_iflag;
|
1998-03-07 15:36:29 +00:00
|
|
|
if (tp->t_rawq.c_cc + tp->t_canq.c_cc > tp->t_ihiwat - 3 &&
|
1995-07-31 18:29:51 +00:00
|
|
|
(!ISSET(lflag, ICANON) || tp->t_canq.c_cc != 0) &&
|
|
|
|
(ISSET(tp->t_cflag, CRTS_IFLOW) || ISSET(iflag, IXOFF)) &&
|
|
|
|
!ISSET(tp->t_state, TS_TBLOCK))
|
|
|
|
ttyblock(tp);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Handle exceptional conditions (break, parity, framing). */
|
|
|
|
cc = tp->t_cc;
|
1994-10-02 17:35:40 +00:00
|
|
|
err = (ISSET(c, TTY_ERRORMASK));
|
|
|
|
if (err) {
|
1994-05-24 10:09:53 +00:00
|
|
|
CLR(c, TTY_ERRORMASK);
|
1996-11-29 15:23:42 +00:00
|
|
|
if (ISSET(err, TTY_BI)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ISSET(iflag, IGNBRK))
|
1995-03-28 11:09:35 +00:00
|
|
|
return (0);
|
1996-11-29 15:23:42 +00:00
|
|
|
if (ISSET(iflag, BRKINT)) {
|
|
|
|
ttyflush(tp, FREAD | FWRITE);
|
|
|
|
pgsignal(tp->t_pgrp, SIGINT, 1);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
if (ISSET(iflag, PARMRK))
|
1994-05-24 10:09:53 +00:00
|
|
|
goto parmrk;
|
1994-10-02 17:35:40 +00:00
|
|
|
} else if ((ISSET(err, TTY_PE) && ISSET(iflag, INPCK))
|
|
|
|
|| ISSET(err, TTY_FE)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ISSET(iflag, IGNPAR))
|
1995-03-28 11:09:35 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
else if (ISSET(iflag, PARMRK)) {
|
1995-07-21 14:41:43 +00:00
|
|
|
parmrk:
|
|
|
|
if (tp->t_rawq.c_cc + tp->t_canq.c_cc >
|
|
|
|
MAX_INPUT - 3)
|
|
|
|
goto input_overflow;
|
|
|
|
(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
|
1994-05-24 10:09:53 +00:00
|
|
|
(void)putc(0 | TTY_QUOTE, &tp->t_rawq);
|
|
|
|
(void)putc(c | TTY_QUOTE, &tp->t_rawq);
|
|
|
|
goto endcase;
|
|
|
|
} else
|
|
|
|
c = 0;
|
|
|
|
}
|
|
|
|
}
|
1995-07-31 18:29:51 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (!ISSET(tp->t_state, TS_TYPEN) && ISSET(iflag, ISTRIP))
|
|
|
|
CLR(c, 0x80);
|
|
|
|
if (!ISSET(lflag, EXTPROC)) {
|
|
|
|
/*
|
|
|
|
* Check for literal nexting very first
|
|
|
|
*/
|
|
|
|
if (ISSET(tp->t_state, TS_LNCH)) {
|
|
|
|
SET(c, TTY_QUOTE);
|
|
|
|
CLR(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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Control chars which aren't controlled
|
|
|
|
* by ICANON, ISIG, or IXON.
|
|
|
|
*/
|
|
|
|
if (ISSET(lflag, IEXTEN)) {
|
|
|
|
if (CCEQ(cc[VLNEXT], c)) {
|
|
|
|
if (ISSET(lflag, ECHO)) {
|
|
|
|
if (ISSET(lflag, ECHOE)) {
|
|
|
|
(void)ttyoutput('^', tp);
|
|
|
|
(void)ttyoutput('\b', tp);
|
|
|
|
} else
|
|
|
|
ttyecho(c, tp);
|
|
|
|
}
|
|
|
|
SET(tp->t_state, TS_LNCH);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
if (CCEQ(cc[VDISCARD], c)) {
|
|
|
|
if (ISSET(lflag, FLUSHO))
|
|
|
|
CLR(tp->t_lflag, FLUSHO);
|
|
|
|
else {
|
|
|
|
ttyflush(tp, FWRITE);
|
|
|
|
ttyecho(c, tp);
|
|
|
|
if (tp->t_rawq.c_cc + tp->t_canq.c_cc)
|
|
|
|
ttyretype(tp);
|
|
|
|
SET(tp->t_lflag, FLUSHO);
|
|
|
|
}
|
|
|
|
goto startoutput;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
pgsignal(tp->t_pgrp,
|
|
|
|
CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
if (CCEQ(cc[VSUSP], c)) {
|
|
|
|
if (!ISSET(lflag, NOFLSH))
|
|
|
|
ttyflush(tp, FREAD);
|
|
|
|
ttyecho(c, tp);
|
|
|
|
pgsignal(tp->t_pgrp, SIGTSTP, 1);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Handle start/stop characters.
|
|
|
|
*/
|
|
|
|
if (ISSET(iflag, IXON)) {
|
|
|
|
if (CCEQ(cc[VSTOP], c)) {
|
|
|
|
if (!ISSET(tp->t_state, TS_TTSTOP)) {
|
|
|
|
SET(tp->t_state, TS_TTSTOP);
|
|
|
|
#ifdef sun4c /* XXX */
|
|
|
|
(*tp->t_stop)(tp, 0);
|
|
|
|
#else
|
1995-12-13 15:13:57 +00:00
|
|
|
(*cdevsw[major(tp->t_dev)]->d_stop)(tp,
|
1994-05-24 10:09:53 +00:00
|
|
|
0);
|
|
|
|
#endif
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (!CCEQ(cc[VSTART], c))
|
|
|
|
return (0);
|
|
|
|
/*
|
|
|
|
* if VSTART == VSTOP then toggle
|
|
|
|
*/
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
if (CCEQ(cc[VSTART], c))
|
|
|
|
goto restartoutput;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* IGNCR, ICRNL, & INLCR
|
|
|
|
*/
|
|
|
|
if (c == '\r') {
|
|
|
|
if (ISSET(iflag, IGNCR))
|
1995-03-28 15:25:13 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
else if (ISSET(iflag, ICRNL))
|
|
|
|
c = '\n';
|
|
|
|
} else if (c == '\n' && ISSET(iflag, INLCR))
|
|
|
|
c = '\r';
|
|
|
|
}
|
|
|
|
if (!ISSET(tp->t_lflag, EXTPROC) && ISSET(lflag, ICANON)) {
|
|
|
|
/*
|
|
|
|
* From here on down canonical mode character
|
|
|
|
* processing takes place.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* erase (^H / ^?)
|
|
|
|
*/
|
|
|
|
if (CCEQ(cc[VERASE], c)) {
|
|
|
|
if (tp->t_rawq.c_cc)
|
|
|
|
ttyrub(unputc(&tp->t_rawq), tp);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* kill (^U)
|
|
|
|
*/
|
|
|
|
if (CCEQ(cc[VKILL], c)) {
|
|
|
|
if (ISSET(lflag, ECHOKE) &&
|
|
|
|
tp->t_rawq.c_cc == tp->t_rocount &&
|
|
|
|
!ISSET(lflag, ECHOPRT))
|
|
|
|
while (tp->t_rawq.c_cc)
|
|
|
|
ttyrub(unputc(&tp->t_rawq), tp);
|
|
|
|
else {
|
|
|
|
ttyecho(c, tp);
|
|
|
|
if (ISSET(lflag, ECHOK) ||
|
|
|
|
ISSET(lflag, ECHOKE))
|
|
|
|
ttyecho('\n', tp);
|
|
|
|
FLUSHQ(&tp->t_rawq);
|
|
|
|
tp->t_rocount = 0;
|
|
|
|
}
|
|
|
|
CLR(tp->t_state, TS_LOCAL);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* word erase (^W)
|
|
|
|
*/
|
1996-11-29 15:06:17 +00:00
|
|
|
if (CCEQ(cc[VWERASE], c) && ISSET(lflag, IEXTEN)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
int ctype;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* erase whitespace
|
|
|
|
*/
|
|
|
|
while ((c = unputc(&tp->t_rawq)) == ' ' || c == '\t')
|
|
|
|
ttyrub(c, tp);
|
|
|
|
if (c == -1)
|
|
|
|
goto endcase;
|
|
|
|
/*
|
|
|
|
* erase last char of word and remember the
|
|
|
|
* next chars type (for ALTWERASE)
|
|
|
|
*/
|
|
|
|
ttyrub(c, tp);
|
|
|
|
c = unputc(&tp->t_rawq);
|
|
|
|
if (c == -1)
|
|
|
|
goto endcase;
|
|
|
|
if (c == ' ' || c == '\t') {
|
|
|
|
(void)putc(c, &tp->t_rawq);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
ctype = ISALPHA(c);
|
|
|
|
/*
|
|
|
|
* erase rest of word
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
ttyrub(c, tp);
|
|
|
|
c = unputc(&tp->t_rawq);
|
|
|
|
if (c == -1)
|
|
|
|
goto endcase;
|
|
|
|
} while (c != ' ' && c != '\t' &&
|
1995-07-31 19:17:19 +00:00
|
|
|
(!ISSET(lflag, ALTWERASE) || ISALPHA(c) == ctype));
|
1994-05-24 10:09:53 +00:00
|
|
|
(void)putc(c, &tp->t_rawq);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* reprint line (^R)
|
|
|
|
*/
|
1996-11-29 15:06:17 +00:00
|
|
|
if (CCEQ(cc[VREPRINT], c) && ISSET(lflag, IEXTEN)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyretype(tp);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* ^T - kernel info and generate SIGINFO
|
|
|
|
*/
|
1996-11-29 15:06:17 +00:00
|
|
|
if (CCEQ(cc[VSTATUS], c) && ISSET(lflag, IEXTEN)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ISSET(lflag, ISIG))
|
|
|
|
pgsignal(tp->t_pgrp, SIGINFO, 1);
|
|
|
|
if (!ISSET(lflag, NOKERNINFO))
|
|
|
|
ttyinfo(tp);
|
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Check for input buffer overflow
|
|
|
|
*/
|
1995-07-21 14:41:43 +00:00
|
|
|
if (tp->t_rawq.c_cc + tp->t_canq.c_cc >= MAX_INPUT) {
|
|
|
|
input_overflow:
|
1994-05-24 10:09:53 +00:00
|
|
|
if (ISSET(iflag, IMAXBEL)) {
|
1998-03-07 15:36:29 +00:00
|
|
|
if (tp->t_outq.c_cc < tp->t_ohiwat)
|
1994-05-24 10:09:53 +00:00
|
|
|
(void)ttyoutput(CTRL('g'), tp);
|
1995-03-28 15:25:13 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
goto endcase;
|
|
|
|
}
|
1995-03-29 18:55:20 +00:00
|
|
|
|
|
|
|
if ( c == 0377 && ISSET(iflag, PARMRK) && !ISSET(iflag, ISTRIP)
|
|
|
|
&& ISSET(iflag, IGNBRK|IGNPAR) != (IGNBRK|IGNPAR))
|
|
|
|
(void)putc(0377 | TTY_QUOTE, &tp->t_rawq);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
1996-11-29 15:06:17 +00:00
|
|
|
if (TTBREAKC(c, lflag)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_rocount = 0;
|
|
|
|
catq(&tp->t_rawq, &tp->t_canq);
|
|
|
|
ttwakeup(tp);
|
|
|
|
} else if (tp->t_rocount++ == 0)
|
|
|
|
tp->t_rocol = tp->t_column;
|
|
|
|
if (ISSET(tp->t_state, TS_ERASE)) {
|
|
|
|
/*
|
|
|
|
* end of prterase \.../
|
|
|
|
*/
|
|
|
|
CLR(tp->t_state, TS_ERASE);
|
|
|
|
(void)ttyoutput('/', tp);
|
|
|
|
}
|
|
|
|
i = tp->t_column;
|
|
|
|
ttyecho(c, tp);
|
|
|
|
if (CCEQ(cc[VEOF], c) && ISSET(lflag, ECHO)) {
|
|
|
|
/*
|
|
|
|
* Place the cursor over the '^' of the ^D.
|
|
|
|
*/
|
1995-07-31 19:17:19 +00:00
|
|
|
i = imin(2, tp->t_column - i);
|
1994-05-24 10:09:53 +00:00
|
|
|
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:
|
|
|
|
CLR(tp->t_lflag, FLUSHO);
|
|
|
|
CLR(tp->t_state, TS_TTSTOP);
|
|
|
|
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.
|
|
|
|
*/
|
1995-07-31 19:17:19 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyoutput(c, tp)
|
|
|
|
register int c;
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
1995-07-31 19:17:19 +00:00
|
|
|
register tcflag_t oflag;
|
1994-05-24 10:09:53 +00:00
|
|
|
register int col, s;
|
|
|
|
|
|
|
|
oflag = tp->t_oflag;
|
|
|
|
if (!ISSET(oflag, OPOST)) {
|
|
|
|
if (ISSET(tp->t_lflag, FLUSHO))
|
|
|
|
return (-1);
|
|
|
|
if (putc(c, &tp->t_outq))
|
|
|
|
return (c);
|
|
|
|
tk_nout++;
|
|
|
|
tp->t_outcc++;
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
CLR(c, ~TTY_CHARMASK);
|
|
|
|
if (c == '\t' &&
|
|
|
|
ISSET(oflag, OXTABS) && !ISSET(tp->t_lflag, EXTPROC)) {
|
|
|
|
c = 8 - (tp->t_column & 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_column += c;
|
|
|
|
return (c ? -1 : '\t');
|
|
|
|
}
|
|
|
|
if (c == CEOT && ISSET(oflag, ONOEOT))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Newline translation: if ONLCR is set,
|
|
|
|
* translate newline into "\r\n".
|
|
|
|
*/
|
|
|
|
if (c == '\n' && ISSET(tp->t_oflag, ONLCR)) {
|
|
|
|
tk_nout++;
|
|
|
|
tp->t_outcc++;
|
|
|
|
if (putc('\r', &tp->t_outq))
|
|
|
|
return (c);
|
|
|
|
}
|
|
|
|
tk_nout++;
|
|
|
|
tp->t_outcc++;
|
|
|
|
if (!ISSET(tp->t_lflag, FLUSHO) && putc(c, &tp->t_outq))
|
|
|
|
return (c);
|
|
|
|
|
|
|
|
col = tp->t_column;
|
|
|
|
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_column = col;
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ioctls for 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, cmd, data, flag)
|
|
|
|
register struct tty *tp;
|
1998-06-07 17:13:14 +00:00
|
|
|
u_long cmd;
|
|
|
|
int flag;
|
1994-05-24 10:09:53 +00:00
|
|
|
void *data;
|
|
|
|
{
|
|
|
|
register struct proc *p;
|
|
|
|
int s, error;
|
|
|
|
|
|
|
|
p = curproc; /* XXX */
|
|
|
|
|
|
|
|
/* If the ioctl involves modification, hang if in the background. */
|
|
|
|
switch (cmd) {
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
case TIOCCBRK:
|
|
|
|
case TIOCCONS:
|
|
|
|
case TIOCDRAIN:
|
|
|
|
case TIOCEXCL:
|
1994-05-24 10:09:53 +00:00
|
|
|
case TIOCFLUSH:
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
#ifdef TIOCHPCL
|
|
|
|
case TIOCHPCL:
|
|
|
|
#endif
|
|
|
|
case TIOCNXCL:
|
|
|
|
case TIOCSBRK:
|
|
|
|
case TIOCSCTTY:
|
|
|
|
case TIOCSDRAINWAIT:
|
1994-05-24 10:09:53 +00:00
|
|
|
case TIOCSETA:
|
|
|
|
case TIOCSETAF:
|
|
|
|
case TIOCSETAW:
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
case TIOCSETD:
|
1994-05-24 10:09:53 +00:00
|
|
|
case TIOCSPGRP:
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
case TIOCSTART:
|
1994-08-18 09:16:37 +00:00
|
|
|
case TIOCSTAT:
|
1994-05-24 10:09:53 +00:00
|
|
|
case TIOCSTI:
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
case TIOCSTOP:
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
1996-11-29 15:50:56 +00:00
|
|
|
while (isbackground(p, tp) &&
|
|
|
|
(p->p_flag & P_PPWAIT) == 0 &&
|
1994-05-24 10:09:53 +00:00
|
|
|
(p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
|
|
|
|
(p->p_sigmask & sigmask(SIGTTOU)) == 0) {
|
1996-11-29 15:50:56 +00:00
|
|
|
if (p->p_pgrp->pg_jobc == 0)
|
|
|
|
return (EIO);
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(p->p_pgrp, SIGTTOU, 1);
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
|
|
|
|
0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (cmd) { /* 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 */
|
1995-07-21 17:30:12 +00:00
|
|
|
s = spltty();
|
1994-05-24 10:09:53 +00:00
|
|
|
*(int *)data = ttnread(tp);
|
1995-07-21 17:30:12 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
|
|
|
|
case FIOSETOWN:
|
|
|
|
/*
|
|
|
|
* Policy -- Don't allow FIOSETOWN on someone else's
|
|
|
|
* controlling tty
|
|
|
|
*/
|
|
|
|
if (tp->t_session != NULL && !isctty(p, tp))
|
|
|
|
return (ENOTTY);
|
|
|
|
|
|
|
|
error = fsetown(*(int *)data, &tp->t_sigio);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
break;
|
|
|
|
case FIOGETOWN:
|
|
|
|
if (tp->t_session != NULL && !isctty(p, tp))
|
|
|
|
return (ENOTTY);
|
|
|
|
*(int *)data = fgetown(tp->t_sigio);
|
|
|
|
break;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
if (flags == 0)
|
|
|
|
flags = FREAD | FWRITE;
|
|
|
|
else
|
|
|
|
flags &= FREAD | FWRITE;
|
|
|
|
ttyflush(tp, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TIOCCONS: /* become virtual console */
|
|
|
|
if (*(int *)data) {
|
|
|
|
if (constty && constty != tp &&
|
1995-07-31 21:02:00 +00:00
|
|
|
ISSET(constty->t_state, TS_CONNECTED))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EBUSY);
|
|
|
|
#ifndef UCONSOLE
|
|
|
|
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 */
|
1994-10-02 17:35:40 +00:00
|
|
|
error = ttywait(tp);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
break;
|
|
|
|
case TIOCGETA: { /* get termios struct */
|
|
|
|
struct termios *t = (struct termios *)data;
|
|
|
|
|
|
|
|
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();
|
|
|
|
SET(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;
|
|
|
|
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
if (t->c_ispeed == 0)
|
|
|
|
t->c_ispeed = t->c_ospeed;
|
|
|
|
if (t->c_ispeed == 0)
|
|
|
|
t->c_ispeed = tp->t_ospeed;
|
|
|
|
if (t->c_ispeed == 0)
|
1995-08-02 06:55:36 +00:00
|
|
|
return (EINVAL);
|
1994-05-24 10:09:53 +00:00
|
|
|
s = spltty();
|
|
|
|
if (cmd == TIOCSETAW || cmd == TIOCSETAF) {
|
1994-10-02 17:35:40 +00:00
|
|
|
error = ttywait(tp);
|
|
|
|
if (error) {
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (cmd == 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);
|
1995-07-31 21:02:00 +00:00
|
|
|
}
|
|
|
|
if (ISSET(t->c_cflag, CLOCAL) &&
|
|
|
|
!ISSET(tp->t_cflag, CLOCAL)) {
|
|
|
|
/*
|
|
|
|
* XXX disconnections would be too hard to
|
|
|
|
* get rid of without this kludge. The only
|
|
|
|
* way to get rid of controlling terminals
|
|
|
|
* is to exit from the session leader.
|
|
|
|
*/
|
|
|
|
CLR(tp->t_state, TS_ZOMBIE);
|
|
|
|
|
|
|
|
wakeup(TSA_CARR_ON(tp));
|
|
|
|
ttwakeup(tp);
|
1995-07-30 12:39:42 +00:00
|
|
|
ttwwakeup(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-07-31 21:02:00 +00:00
|
|
|
if ((ISSET(tp->t_state, TS_CARR_ON) ||
|
|
|
|
ISSET(t->c_cflag, CLOCAL)) &&
|
|
|
|
!ISSET(tp->t_state, TS_ZOMBIE))
|
|
|
|
SET(tp->t_state, TS_CONNECTED);
|
|
|
|
else
|
|
|
|
CLR(tp->t_state, TS_CONNECTED);
|
|
|
|
tp->t_cflag = t->c_cflag;
|
|
|
|
tp->t_ispeed = t->c_ispeed;
|
Fixed some missing cases in the check for ioctls that involve modification.
Many (mostly machine-dependent ones) are still missing. NIST-PCTS found
this bug for all the ioctls used to implement the POSIX tc* functions
(TIOCCBRK, TIOCDRAIN, TIOCSPGRP, TIOCSBRK, TIOCSTART and TIOCSTOP), and
I found FIOASYNC, TIOCCONS, TIOCEXCL, TIOCHPCL, TIOCNXCL, TIOCSCTTY and
TIOCSDRAINWAIT by inspection. TIOCSPGRP was ifdefed out for some reason.
Handle tcsetattr()'s historical speed conversions correctly and more
centrally:
- don't store speeds of 0 in the final termios struct. Drivers can now
depend on tp->t_ispeed and tp->t_ospeed giving the actual speed.
Applications can now depend on tcgetattr() being POSIX.1 conformant.
- convert from a proposed input speed of 0 to the proposed output speed
(except if that is 0, convert to the current output speed). Drivers
can now depend on the proposed input speed being nonzero.
- don't reject negative speeds. Negative speeds can't happen now that
speed_t is unsigned, and rejecting invalid speeds is a bug - tcsetattr()
is supposed to succeed if it can "perform any of the requested actions",
so it shouldn't fail in practice.
1998-11-22 09:04:09 +00:00
|
|
|
if (t->c_ospeed != 0)
|
|
|
|
tp->t_ospeed = t->c_ospeed;
|
1994-05-24 10:09:53 +00:00
|
|
|
ttsetwater(tp);
|
|
|
|
}
|
1995-07-30 13:52:56 +00:00
|
|
|
if (ISSET(t->c_lflag, ICANON) != ISSET(tp->t_lflag, ICANON) &&
|
|
|
|
cmd != TIOCSETAF) {
|
|
|
|
if (ISSET(t->c_lflag, ICANON))
|
|
|
|
SET(tp->t_lflag, PENDIN);
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* XXX we really shouldn't allow toggling
|
|
|
|
* ICANON while we're in a non-termios line
|
|
|
|
* discipline. Now we have to worry about
|
|
|
|
* panicing for a null queue.
|
|
|
|
*/
|
|
|
|
if (tp->t_canq.c_cbreserved > 0 &&
|
|
|
|
tp->t_rawq.c_cbreserved > 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
catq(&tp->t_rawq, &tp->t_canq);
|
1995-07-30 13:52:56 +00:00
|
|
|
/*
|
|
|
|
* XXX the queue limits may be
|
|
|
|
* different, so the old queue
|
|
|
|
* swapping method no longer works.
|
|
|
|
*/
|
|
|
|
catq(&tp->t_canq, &tp->t_rawq);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-07-30 13:52:56 +00:00
|
|
|
CLR(tp->t_lflag, PENDIN);
|
|
|
|
}
|
|
|
|
ttwakeup(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
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 | ISSET(tp->t_lflag, PENDIN);
|
1994-10-03 01:12:18 +00:00
|
|
|
if (t->c_cc[VMIN] != tp->t_cc[VMIN] ||
|
|
|
|
t->c_cc[VTIME] != tp->t_cc[VTIME])
|
|
|
|
ttwakeup(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
if ((u_int)t >= nlinesw)
|
|
|
|
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);
|
1995-07-21 17:30:12 +00:00
|
|
|
s = spltty();
|
1994-05-24 10:09:53 +00:00
|
|
|
(*linesw[tp->t_line].l_rint)(*(u_char *)data, tp);
|
1995-07-21 17:30:12 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
1995-12-13 15:13:57 +00:00
|
|
|
(*cdevsw[major(tp->t_dev)]->d_stop)(tp, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
case TIOCSCTTY: /* become controlling tty */
|
|
|
|
/* Session ctty vnode pointer set in vnode layer. */
|
|
|
|
if (!SESS_LEADER(p) ||
|
1994-10-02 17:35:40 +00:00
|
|
|
((p->p_session->s_ttyvp || tp->t_session) &&
|
|
|
|
(tp->t_session != p->p_session)))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EPERM);
|
|
|
|
tp->t_session = p->p_session;
|
|
|
|
tp->t_pgrp = p->p_pgrp;
|
|
|
|
p->p_session->s_ttyp = tp;
|
|
|
|
p->p_flag |= P_CONTROLT;
|
|
|
|
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;
|
|
|
|
}
|
1994-08-18 09:16:37 +00:00
|
|
|
case TIOCSTAT: /* simulate control-T */
|
1995-07-21 17:30:12 +00:00
|
|
|
s = spltty();
|
1994-08-18 09:16:37 +00:00
|
|
|
ttyinfo(tp);
|
1995-07-21 17:30:12 +00:00
|
|
|
splx(s);
|
1994-08-18 09:16:37 +00:00
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
1995-01-05 00:01:07 +00:00
|
|
|
case TIOCSDRAINWAIT:
|
|
|
|
error = suser(p->p_ucred, &p->p_acflag);
|
1995-01-06 14:56:42 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1995-01-05 00:01:07 +00:00
|
|
|
tp->t_timeout = *(int *)data * hz;
|
1995-09-10 11:48:13 +00:00
|
|
|
wakeup(TSA_OCOMPLETE(tp));
|
|
|
|
wakeup(TSA_OLOWAT(tp));
|
1995-01-05 00:01:07 +00:00
|
|
|
break;
|
|
|
|
case TIOCGDRAINWAIT:
|
|
|
|
*(int *)data = tp->t_timeout / hz;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
#if defined(COMPAT_43) || defined(COMPAT_SUNOS)
|
|
|
|
return (ttcompat(tp, cmd, data, flag));
|
|
|
|
#else
|
1997-12-06 13:25:01 +00:00
|
|
|
return (ENOIOCTL);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1997-09-14 02:40:46 +00:00
|
|
|
ttypoll(tp, events, p)
|
1995-02-25 20:09:44 +00:00
|
|
|
struct tty *tp;
|
1997-09-14 02:40:46 +00:00
|
|
|
int events;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct proc *p;
|
|
|
|
{
|
1995-07-31 19:17:19 +00:00
|
|
|
int s;
|
1997-09-14 02:40:46 +00:00
|
|
|
int revents = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-09-14 02:40:46 +00:00
|
|
|
if (tp == NULL) /* XXX used to return ENXIO, but that means true! */
|
|
|
|
return ((events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM))
|
|
|
|
| POLLHUP);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
s = spltty();
|
1997-09-14 02:40:46 +00:00
|
|
|
if (events & (POLLIN | POLLRDNORM))
|
1995-07-31 21:02:00 +00:00
|
|
|
if (ttnread(tp) > 0 || ISSET(tp->t_state, TS_ZOMBIE))
|
1997-09-14 02:40:46 +00:00
|
|
|
revents |= events & (POLLIN | POLLRDNORM);
|
|
|
|
else
|
|
|
|
selrecord(p, &tp->t_rsel);
|
|
|
|
|
|
|
|
if (events & (POLLOUT | POLLWRNORM))
|
1998-03-07 15:36:29 +00:00
|
|
|
if ((tp->t_outq.c_cc <= tp->t_olowat &&
|
1995-07-31 21:02:00 +00:00
|
|
|
ISSET(tp->t_state, TS_CONNECTED))
|
1997-09-14 02:40:46 +00:00
|
|
|
|| ISSET(tp->t_state, TS_ZOMBIE))
|
|
|
|
revents |= events & (POLLOUT | POLLWRNORM);
|
|
|
|
else
|
|
|
|
selrecord(p, &tp->t_wsel);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
1997-09-14 02:40:46 +00:00
|
|
|
return (revents);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-02-28 00:21:11 +00:00
|
|
|
/*
|
|
|
|
* This is a wrapper for compatibility with the select vector used by
|
|
|
|
* cdevsw. It relies on a proper xxxdevtotty routine.
|
|
|
|
*/
|
|
|
|
int
|
1997-09-14 02:40:46 +00:00
|
|
|
ttpoll(dev, events, p)
|
1995-02-28 00:21:11 +00:00
|
|
|
dev_t dev;
|
1997-09-14 02:40:46 +00:00
|
|
|
int events;
|
1995-02-28 00:21:11 +00:00
|
|
|
struct proc *p;
|
|
|
|
{
|
1997-09-14 02:40:46 +00:00
|
|
|
return ttypoll((*cdevsw[major(dev)]->d_devtotty)(dev), events, p);
|
1995-02-28 00:21:11 +00:00
|
|
|
}
|
|
|
|
|
1995-02-09 11:13:30 +00:00
|
|
|
/*
|
1995-07-21 17:30:12 +00:00
|
|
|
* Must be called at spltty().
|
1995-02-09 11:13:30 +00:00
|
|
|
*/
|
1995-04-15 21:04:58 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
ttnread(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
|
|
|
int nread;
|
|
|
|
|
|
|
|
if (ISSET(tp->t_lflag, PENDIN))
|
|
|
|
ttypend(tp);
|
|
|
|
nread = tp->t_canq.c_cc;
|
1994-10-03 01:12:18 +00:00
|
|
|
if (!ISSET(tp->t_lflag, ICANON)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
nread += tp->t_rawq.c_cc;
|
1994-10-03 01:12:18 +00:00
|
|
|
if (nread < tp->t_cc[VMIN] && tp->t_cc[VTIME] == 0)
|
|
|
|
nread = 0;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
return (nread);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for output to drain.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttywait(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
int error, s;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
s = spltty();
|
|
|
|
while ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
|
1995-07-31 21:02:00 +00:00
|
|
|
ISSET(tp->t_state, TS_CONNECTED) && tp->t_oproc) {
|
1995-07-30 12:39:42 +00:00
|
|
|
(*tp->t_oproc)(tp);
|
1994-10-15 17:59:02 +00:00
|
|
|
if ((tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)) &&
|
1995-07-31 21:02:00 +00:00
|
|
|
ISSET(tp->t_state, TS_CONNECTED)) {
|
1995-07-30 12:39:42 +00:00
|
|
|
SET(tp->t_state, TS_SO_OCOMPLETE);
|
|
|
|
error = ttysleep(tp, TSA_OCOMPLETE(tp),
|
|
|
|
TTOPRI | PCATCH, "ttywai",
|
|
|
|
tp->t_timeout);
|
1995-07-31 19:17:19 +00:00
|
|
|
if (error) {
|
|
|
|
if (error == EWOULDBLOCK)
|
|
|
|
error = EIO;
|
1994-10-15 17:59:02 +00:00
|
|
|
break;
|
1995-07-31 19:17:19 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-02-15 22:25:51 +00:00
|
|
|
if (!error && (tp->t_outq.c_cc || ISSET(tp->t_state, TS_BUSY)))
|
|
|
|
error = EIO;
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-02-13 02:03:57 +00:00
|
|
|
* Flush if successfully wait.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-12-14 08:32:45 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
ttywflush(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
1995-02-13 02:03:57 +00:00
|
|
|
if ((error = ttywait(tp)) == 0)
|
|
|
|
ttyflush(tp, FREAD);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush tty read and/or write queues, notifying anyone waiting.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttyflush(tp, rw)
|
|
|
|
register struct tty *tp;
|
|
|
|
int rw;
|
|
|
|
{
|
|
|
|
register int s;
|
|
|
|
|
|
|
|
s = spltty();
|
1996-06-12 05:11:41 +00:00
|
|
|
#if 0
|
1995-07-31 18:29:51 +00:00
|
|
|
again:
|
1996-06-12 05:11:41 +00:00
|
|
|
#endif
|
1996-11-29 16:16:47 +00:00
|
|
|
if (rw & FWRITE) {
|
|
|
|
FLUSHQ(&tp->t_outq);
|
1994-12-04 01:01:45 +00:00
|
|
|
CLR(tp->t_state, TS_TTSTOP);
|
1996-11-29 16:16:47 +00:00
|
|
|
}
|
1994-12-04 01:01:45 +00:00
|
|
|
#ifdef sun4c /* XXX */
|
|
|
|
(*tp->t_stop)(tp, rw);
|
|
|
|
#else
|
1995-12-13 15:13:57 +00:00
|
|
|
(*cdevsw[major(tp->t_dev)]->d_stop)(tp, rw);
|
1994-12-04 01:01:45 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rw & FREAD) {
|
|
|
|
FLUSHQ(&tp->t_canq);
|
|
|
|
FLUSHQ(&tp->t_rawq);
|
1995-07-31 21:43:37 +00:00
|
|
|
CLR(tp->t_lflag, PENDIN);
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_rocount = 0;
|
|
|
|
tp->t_rocol = 0;
|
|
|
|
CLR(tp->t_state, TS_LOCAL);
|
|
|
|
ttwakeup(tp);
|
1995-07-31 18:29:51 +00:00
|
|
|
if (ISSET(tp->t_state, TS_TBLOCK)) {
|
1995-12-15 01:01:00 +00:00
|
|
|
if (rw & FWRITE)
|
|
|
|
FLUSHQ(&tp->t_outq);
|
1995-07-31 18:29:51 +00:00
|
|
|
ttyunblock(tp);
|
1995-12-15 01:01:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't let leave any state that might clobber the
|
|
|
|
* next line discipline (although we should do more
|
|
|
|
* to send the START char). Not clearing the state
|
|
|
|
* may have caused the "putc to a clist with no
|
|
|
|
* reserved cblocks" panic/printf.
|
|
|
|
*/
|
|
|
|
CLR(tp->t_state, TS_TBLOCK);
|
|
|
|
|
|
|
|
#if 0 /* forget it, sleeping isn't always safe and we don't know when it is */
|
1995-07-31 18:29:51 +00:00
|
|
|
if (ISSET(tp->t_iflag, IXOFF)) {
|
|
|
|
/*
|
|
|
|
* XXX wait a bit in the hope that the stop
|
|
|
|
* character (if any) will go out. Waiting
|
|
|
|
* isn't good since it allows races. This
|
|
|
|
* will be fixed when the stop character is
|
|
|
|
* put in a special queue. Don't bother with
|
|
|
|
* the checks in ttywait() since the timeout
|
|
|
|
* will save us.
|
|
|
|
*/
|
|
|
|
SET(tp->t_state, TS_SO_OCOMPLETE);
|
|
|
|
ttysleep(tp, TSA_OCOMPLETE(tp), TTOPRI,
|
|
|
|
"ttyfls", hz / 10);
|
|
|
|
/*
|
|
|
|
* Don't try sending the stop character again.
|
|
|
|
*/
|
|
|
|
CLR(tp->t_state, TS_TBLOCK);
|
|
|
|
goto again;
|
|
|
|
}
|
1995-12-15 01:01:00 +00:00
|
|
|
#endif
|
1995-07-31 18:29:51 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
if (rw & FWRITE) {
|
|
|
|
FLUSHQ(&tp->t_outq);
|
1995-07-30 12:39:42 +00:00
|
|
|
ttwwakeup(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy in the default termios characters.
|
|
|
|
*/
|
|
|
|
void
|
1995-07-21 22:52:01 +00:00
|
|
|
termioschars(t)
|
|
|
|
struct termios *t;
|
|
|
|
{
|
|
|
|
|
|
|
|
bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Old interface.
|
|
|
|
*/
|
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
ttychars(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
|
|
|
|
1995-07-21 22:52:01 +00:00
|
|
|
termioschars(&tp->t_termios);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1995-07-31 18:29:51 +00:00
|
|
|
* Handle input high water. Send stop character for the IXOFF case. Turn
|
|
|
|
* on our input flow control bit and propagate the changes to the driver.
|
|
|
|
* XXX the stop character should be put in a special high priority queue.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-07-31 18:29:51 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyblock(tp)
|
1995-07-31 18:29:51 +00:00
|
|
|
struct tty *tp;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
1995-07-31 18:29:51 +00:00
|
|
|
SET(tp->t_state, TS_TBLOCK);
|
|
|
|
if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTOP] != _POSIX_VDISABLE &&
|
|
|
|
putc(tp->t_cc[VSTOP], &tp->t_outq) != 0)
|
|
|
|
CLR(tp->t_state, TS_TBLOCK); /* try again later */
|
|
|
|
ttstart(tp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle input low water. Send start character for the IXOFF case. Turn
|
|
|
|
* off our input flow control bit and propagate the changes to the driver.
|
|
|
|
* XXX the start character should be put in a special high priority queue.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ttyunblock(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
|
|
|
|
|
|
|
CLR(tp->t_state, TS_TBLOCK);
|
|
|
|
if (ISSET(tp->t_iflag, IXOFF) && tp->t_cc[VSTART] != _POSIX_VDISABLE &&
|
|
|
|
putc(tp->t_cc[VSTART], &tp->t_outq) != 0)
|
|
|
|
SET(tp->t_state, TS_TBLOCK); /* try again later */
|
|
|
|
ttstart(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-12-14 22:32:52 +00:00
|
|
|
#ifdef notyet
|
|
|
|
/* Not used by any current (i386) drivers. */
|
|
|
|
/*
|
|
|
|
* Restart after an inter-char delay.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttrstrt(tp_arg)
|
|
|
|
void *tp_arg;
|
|
|
|
{
|
|
|
|
struct tty *tp;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (tp_arg == NULL)
|
|
|
|
panic("ttrstrt");
|
|
|
|
#endif
|
|
|
|
tp = tp_arg;
|
|
|
|
s = spltty();
|
|
|
|
|
|
|
|
CLR(tp->t_state, TS_TIMEOUT);
|
|
|
|
ttstart(tp);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
int
|
|
|
|
ttstart(tp)
|
|
|
|
struct tty *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;
|
|
|
|
{
|
|
|
|
|
1995-05-07 06:32:28 +00:00
|
|
|
if (flag & FNONBLOCK || ttywflush(tp))
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyflush(tp, FREAD | FWRITE);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle modem control transition on a tty.
|
|
|
|
* Flag indicates new state of carrier.
|
|
|
|
* Returns 0 if the line should be turned off, otherwise 1.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttymodem(tp, flag)
|
|
|
|
register struct tty *tp;
|
|
|
|
int flag;
|
|
|
|
{
|
|
|
|
|
1995-07-21 16:30:59 +00:00
|
|
|
if (ISSET(tp->t_state, TS_CARR_ON) && ISSET(tp->t_cflag, MDMBUF)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* MDMBUF: do flow control according to carrier flag
|
1995-07-31 22:48:46 +00:00
|
|
|
* XXX TS_CAR_OFLOW doesn't do anything yet. TS_TTSTOP
|
|
|
|
* works if IXON and IXANY are clear.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
if (flag) {
|
1995-07-31 22:48:46 +00:00
|
|
|
CLR(tp->t_state, TS_CAR_OFLOW);
|
1994-05-24 10:09:53 +00:00
|
|
|
CLR(tp->t_state, TS_TTSTOP);
|
|
|
|
ttstart(tp);
|
1995-07-31 22:48:46 +00:00
|
|
|
} else if (!ISSET(tp->t_state, TS_CAR_OFLOW)) {
|
|
|
|
SET(tp->t_state, TS_CAR_OFLOW);
|
1994-05-24 10:09:53 +00:00
|
|
|
SET(tp->t_state, TS_TTSTOP);
|
|
|
|
#ifdef sun4c /* XXX */
|
|
|
|
(*tp->t_stop)(tp, 0);
|
|
|
|
#else
|
1995-12-13 15:13:57 +00:00
|
|
|
(*cdevsw[major(tp->t_dev)]->d_stop)(tp, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
} 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)) {
|
1995-07-31 21:02:00 +00:00
|
|
|
SET(tp->t_state, TS_ZOMBIE);
|
|
|
|
CLR(tp->t_state, TS_CONNECTED);
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
1995-07-31 21:02:00 +00:00
|
|
|
if (!ISSET(tp->t_state, TS_ZOMBIE))
|
|
|
|
SET(tp->t_state, TS_CONNECTED);
|
|
|
|
wakeup(TSA_CARR_ON(tp));
|
1994-05-24 10:09:53 +00:00
|
|
|
ttwakeup(tp);
|
1995-07-30 12:39:42 +00:00
|
|
|
ttwwakeup(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reinput pending characters after state switch
|
|
|
|
* call at spltty().
|
|
|
|
*/
|
1995-07-31 19:17:19 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
ttypend(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
struct clist tq;
|
1995-07-31 19:17:19 +00:00
|
|
|
register int c;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
CLR(tp->t_lflag, PENDIN);
|
|
|
|
SET(tp->t_state, TS_TYPEN);
|
1994-11-26 19:24:13 +00:00
|
|
|
/*
|
|
|
|
* XXX this assumes too much about clist internals. It may even
|
|
|
|
* fail if the cblock slush pool is empty. We can't allocate more
|
|
|
|
* cblocks here because we are called from an interrupt handler
|
|
|
|
* and clist_alloc_cblocks() can wait.
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
tq = tp->t_rawq;
|
1994-11-26 19:24:13 +00:00
|
|
|
bzero(&tp->t_rawq, sizeof tp->t_rawq);
|
|
|
|
tp->t_rawq.c_cbmax = tq.c_cbmax;
|
|
|
|
tp->t_rawq.c_cbreserved = tq.c_cbreserved;
|
1994-05-24 10:09:53 +00:00
|
|
|
while ((c = getc(&tq)) >= 0)
|
|
|
|
ttyinput(c, tp);
|
|
|
|
CLR(tp->t_state, TS_TYPEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
1994-10-03 01:12:18 +00:00
|
|
|
register tcflag_t lflag;
|
|
|
|
register cc_t *cc = tp->t_cc;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct proc *p = curproc;
|
1995-07-31 21:02:00 +00:00
|
|
|
int s, first, error = 0;
|
1994-10-03 01:12:18 +00:00
|
|
|
int has_stime = 0, last_cc = 0;
|
|
|
|
long slp = 0; /* XXX this should be renamed `timo'. */
|
1998-12-07 07:59:20 +00:00
|
|
|
struct timeval stime;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-10-03 01:12:18 +00:00
|
|
|
loop:
|
1994-05-24 10:09:53 +00:00
|
|
|
s = spltty();
|
1994-10-03 01:12:18 +00:00
|
|
|
lflag = tp->t_lflag;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* take pending input first
|
|
|
|
*/
|
1994-10-03 01:12:18 +00:00
|
|
|
if (ISSET(lflag, PENDIN)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
ttypend(tp);
|
1994-10-03 01:12:18 +00:00
|
|
|
splx(s); /* reduce latency */
|
|
|
|
s = spltty();
|
|
|
|
lflag = tp->t_lflag; /* XXX ttypend() clobbers it */
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hang process if it's in the background.
|
|
|
|
*/
|
|
|
|
if (isbackground(p, tp)) {
|
1994-10-03 01:12:18 +00:00
|
|
|
splx(s);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((p->p_sigignore & sigmask(SIGTTIN)) ||
|
|
|
|
(p->p_sigmask & sigmask(SIGTTIN)) ||
|
|
|
|
p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0)
|
|
|
|
return (EIO);
|
|
|
|
pgsignal(p->p_pgrp, SIGTTIN, 1);
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
1995-07-31 21:02:00 +00:00
|
|
|
if (ISSET(tp->t_state, TS_ZOMBIE)) {
|
|
|
|
splx(s);
|
|
|
|
return (0); /* EOF */
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If canonical, use the canonical queue,
|
|
|
|
* else use the raw queue.
|
|
|
|
*
|
|
|
|
* (should get rid of clists...)
|
|
|
|
*/
|
|
|
|
qp = ISSET(lflag, ICANON) ? &tp->t_canq : &tp->t_rawq;
|
|
|
|
|
1994-10-03 01:12:18 +00:00
|
|
|
if (flag & IO_NDELAY) {
|
|
|
|
if (qp->c_cc > 0)
|
|
|
|
goto read;
|
1995-07-31 21:02:00 +00:00
|
|
|
if (!ISSET(lflag, ICANON) && cc[VMIN] == 0) {
|
1994-10-03 01:12:18 +00:00
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
return (EWOULDBLOCK);
|
|
|
|
}
|
|
|
|
if (!ISSET(lflag, ICANON)) {
|
|
|
|
int m = cc[VMIN];
|
|
|
|
long t = cc[VTIME];
|
1998-12-07 07:59:20 +00:00
|
|
|
struct timeval timecopy;
|
1994-10-03 01:12:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check each of the four combinations.
|
|
|
|
* (m > 0 && t == 0) is the normal read case.
|
|
|
|
* It should be fairly efficient, so we check that and its
|
|
|
|
* companion case (m == 0 && t == 0) first.
|
|
|
|
* For the other two cases, we compute the target sleep time
|
|
|
|
* into slp.
|
|
|
|
*/
|
|
|
|
if (t == 0) {
|
|
|
|
if (qp->c_cc < m)
|
|
|
|
goto sleep;
|
|
|
|
if (qp->c_cc > 0)
|
|
|
|
goto read;
|
|
|
|
|
|
|
|
/* m, t and qp->c_cc are all 0. 0 is enough input. */
|
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
t *= 100000; /* time in us */
|
|
|
|
#define diff(t1, t2) (((t1).tv_sec - (t2).tv_sec) * 1000000 + \
|
|
|
|
((t1).tv_usec - (t2).tv_usec))
|
|
|
|
if (m > 0) {
|
|
|
|
if (qp->c_cc <= 0)
|
|
|
|
goto sleep;
|
|
|
|
if (qp->c_cc >= m)
|
|
|
|
goto read;
|
1998-03-30 09:56:58 +00:00
|
|
|
getmicrotime(&timecopy);
|
1994-10-03 01:12:18 +00:00
|
|
|
if (!has_stime) {
|
|
|
|
/* first character, start timer */
|
|
|
|
has_stime = 1;
|
|
|
|
stime = timecopy;
|
|
|
|
slp = t;
|
|
|
|
} else if (qp->c_cc > last_cc) {
|
|
|
|
/* got a character, restart timer */
|
|
|
|
stime = timecopy;
|
|
|
|
slp = t;
|
|
|
|
} else {
|
|
|
|
/* nothing, check expiration */
|
|
|
|
slp = t - diff(timecopy, stime);
|
|
|
|
if (slp <= 0)
|
|
|
|
goto read;
|
|
|
|
}
|
|
|
|
last_cc = qp->c_cc;
|
|
|
|
} else { /* m == 0 */
|
|
|
|
if (qp->c_cc > 0)
|
|
|
|
goto read;
|
1998-03-30 09:56:58 +00:00
|
|
|
getmicrotime(&timecopy);
|
1994-10-03 01:12:18 +00:00
|
|
|
if (!has_stime) {
|
|
|
|
has_stime = 1;
|
|
|
|
stime = timecopy;
|
|
|
|
slp = t;
|
|
|
|
} else {
|
|
|
|
slp = t - diff(timecopy, stime);
|
|
|
|
if (slp <= 0) {
|
|
|
|
/* Timed out, but 0 is enough input. */
|
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#undef diff
|
|
|
|
/*
|
|
|
|
* Rounding down may make us wake up just short
|
|
|
|
* of the target, so we round up.
|
|
|
|
* The formula is ceiling(slp * hz/1000000).
|
|
|
|
* 32-bit arithmetic is enough for hz < 169.
|
1998-05-17 20:08:05 +00:00
|
|
|
* XXX see tvtohz() for how to avoid overflow if hz
|
1994-10-03 01:12:18 +00:00
|
|
|
* is large (divide by `tick' and/or arrange to
|
1998-05-17 20:08:05 +00:00
|
|
|
* use tvtohz() if hz is large).
|
1994-10-03 01:12:18 +00:00
|
|
|
*/
|
|
|
|
slp = (long) (((u_long)slp * hz) + 999999) / 1000000;
|
|
|
|
goto sleep;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (qp->c_cc <= 0) {
|
1994-10-03 01:12:18 +00:00
|
|
|
sleep:
|
1995-07-31 21:02:00 +00:00
|
|
|
/*
|
|
|
|
* There is no input, or not enough input and we can block.
|
|
|
|
*/
|
|
|
|
error = ttysleep(tp, TSA_HUP_OR_INPUT(tp), TTIPRI | PCATCH,
|
|
|
|
ISSET(tp->t_state, TS_CONNECTED) ?
|
1995-07-21 20:57:15 +00:00
|
|
|
"ttyin" : "ttyhup", (int)slp);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
1994-10-03 01:12:18 +00:00
|
|
|
if (error == EWOULDBLOCK)
|
|
|
|
error = 0;
|
|
|
|
else if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
1994-10-03 01:12:18 +00:00
|
|
|
/*
|
|
|
|
* XXX what happens if another process eats some input
|
|
|
|
* while we are asleep (not just here)? It would be
|
|
|
|
* safest to detect changes and reset our state variables
|
|
|
|
* (has_stime and last_cc).
|
|
|
|
*/
|
|
|
|
slp = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
1994-10-03 01:12:18 +00:00
|
|
|
read:
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
/*
|
|
|
|
* Input present, check for input mapping and processing.
|
|
|
|
*/
|
|
|
|
first = 1;
|
1995-04-15 21:04:58 +00:00
|
|
|
if (ISSET(lflag, ICANON | ISIG))
|
|
|
|
goto slowcase;
|
|
|
|
for (;;) {
|
|
|
|
char ibuf[IBUFSIZ];
|
|
|
|
int icc;
|
|
|
|
|
1995-07-31 19:17:19 +00:00
|
|
|
icc = imin(uio->uio_resid, IBUFSIZ);
|
1995-04-15 21:04:58 +00:00
|
|
|
icc = q_to_b(qp, ibuf, icc);
|
|
|
|
if (icc <= 0) {
|
|
|
|
if (first)
|
|
|
|
goto loop;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
error = uiomove(ibuf, icc, uio);
|
|
|
|
/*
|
|
|
|
* XXX if there was an error then we should ungetc() the
|
|
|
|
* unmoved chars and reduce icc here.
|
|
|
|
*/
|
|
|
|
#if NSNP > 0
|
|
|
|
if (ISSET(tp->t_lflag, ECHO) &&
|
|
|
|
ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
|
|
|
|
snpin((struct snoop *)tp->t_sc, ibuf, icc);
|
|
|
|
#endif
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (uio->uio_resid == 0)
|
|
|
|
break;
|
|
|
|
first = 0;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
slowcase:
|
|
|
|
for (;;) {
|
|
|
|
c = getc(qp);
|
|
|
|
if (c < 0) {
|
|
|
|
if (first)
|
|
|
|
goto loop;
|
|
|
|
break;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* delayed suspend (^Y)
|
|
|
|
*/
|
1996-11-29 15:06:17 +00:00
|
|
|
if (CCEQ(cc[VDSUSP], c) &&
|
|
|
|
ISSET(lflag, IEXTEN | ISIG) == (IEXTEN | ISIG)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(tp->t_pgrp, SIGTSTP, 1);
|
|
|
|
if (first) {
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH,
|
|
|
|
"ttybg3", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Interpret EOF only in canonical mode.
|
|
|
|
*/
|
|
|
|
if (CCEQ(cc[VEOF], c) && ISSET(lflag, ICANON))
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* Give user character.
|
|
|
|
*/
|
|
|
|
error = ureadc(c, uio);
|
|
|
|
if (error)
|
1995-04-15 21:04:58 +00:00
|
|
|
/* XXX should ungetc(c, qp). */
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1995-04-15 21:04:58 +00:00
|
|
|
#if NSNP > 0
|
|
|
|
/*
|
|
|
|
* Only snoop directly on input in echo mode. Non-echoed
|
|
|
|
* input will be snooped later iff the application echoes it.
|
|
|
|
*/
|
|
|
|
if (ISSET(tp->t_lflag, ECHO) &&
|
|
|
|
ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
|
|
|
|
snpinc((struct snoop *)tp->t_sc, (char)c);
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (uio->uio_resid == 0)
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* In canonical mode check for a "break character"
|
|
|
|
* marking the end of a "line of input".
|
|
|
|
*/
|
1996-11-29 15:06:17 +00:00
|
|
|
if (ISSET(lflag, ICANON) && TTBREAKC(c, lflag))
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
first = 0;
|
|
|
|
}
|
1995-07-31 18:29:51 +00:00
|
|
|
|
|
|
|
out:
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-04-15 21:04:58 +00:00
|
|
|
* Look to unblock input now that (presumably)
|
1994-05-24 10:09:53 +00:00
|
|
|
* the input queue has gone down.
|
|
|
|
*/
|
|
|
|
s = spltty();
|
1995-07-31 18:29:51 +00:00
|
|
|
if (ISSET(tp->t_state, TS_TBLOCK) &&
|
1998-03-07 15:36:29 +00:00
|
|
|
tp->t_rawq.c_cc + tp->t_canq.c_cc <= tp->t_ilowat)
|
1995-07-31 18:29:51 +00:00
|
|
|
ttyunblock(tp);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
1995-07-31 18:29:51 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
{
|
|
|
|
int hiwat, s, oldsig;
|
|
|
|
|
1998-03-07 15:36:29 +00:00
|
|
|
hiwat = tp->t_ohiwat;
|
1994-05-24 10:09:53 +00:00
|
|
|
s = spltty();
|
|
|
|
oldsig = wait ? curproc->p_siglist : 0;
|
1995-12-16 21:45:02 +00:00
|
|
|
if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100)
|
1994-05-24 10:09:53 +00:00
|
|
|
while (tp->t_outq.c_cc > hiwat) {
|
|
|
|
ttstart(tp);
|
1995-07-30 12:39:42 +00:00
|
|
|
if (tp->t_outq.c_cc <= hiwat)
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (wait == 0 || curproc->p_siglist != oldsig) {
|
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
1995-07-30 12:39:42 +00:00
|
|
|
SET(tp->t_state, TS_SO_OLOWAT);
|
|
|
|
tsleep(TSA_OLOWAT(tp), PZERO - 1, "ttoutq", hz);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a write call on a tty device.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ttwrite(tp, uio, flag)
|
|
|
|
register struct tty *tp;
|
|
|
|
register struct uio *uio;
|
|
|
|
int flag;
|
|
|
|
{
|
1995-07-31 19:17:19 +00:00
|
|
|
register char *cp = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
register int cc, ce;
|
|
|
|
register struct proc *p;
|
|
|
|
int i, hiwat, cnt, error, s;
|
|
|
|
char obuf[OBUFSIZ];
|
|
|
|
|
1998-03-07 15:36:29 +00:00
|
|
|
hiwat = tp->t_ohiwat;
|
1994-05-24 10:09:53 +00:00
|
|
|
cnt = uio->uio_resid;
|
|
|
|
error = 0;
|
|
|
|
cc = 0;
|
|
|
|
loop:
|
|
|
|
s = spltty();
|
1995-07-31 21:02:00 +00:00
|
|
|
if (ISSET(tp->t_state, TS_ZOMBIE)) {
|
|
|
|
splx(s);
|
|
|
|
if (uio->uio_resid == cnt)
|
|
|
|
error = EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!ISSET(tp->t_state, TS_CONNECTED)) {
|
|
|
|
if (flag & IO_NDELAY) {
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
error = EWOULDBLOCK;
|
|
|
|
goto out;
|
|
|
|
}
|
1995-07-31 21:02:00 +00:00
|
|
|
error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH,
|
|
|
|
"ttydcd", 0);
|
|
|
|
splx(s);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
goto loop;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
/*
|
|
|
|
* Hang the process if it's in the background.
|
|
|
|
*/
|
|
|
|
p = curproc;
|
|
|
|
if (isbackground(p, tp) &&
|
|
|
|
ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 &&
|
|
|
|
(p->p_sigignore & sigmask(SIGTTOU)) == 0 &&
|
1996-11-29 15:50:56 +00:00
|
|
|
(p->p_sigmask & sigmask(SIGTTOU)) == 0) {
|
|
|
|
if (p->p_pgrp->pg_jobc == 0) {
|
|
|
|
error = EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(p->p_pgrp, SIGTTOU, 1);
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg4", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
goto out;
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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 || 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, unless we have some
|
|
|
|
* leftover from last time.
|
|
|
|
*/
|
|
|
|
if (cc == 0) {
|
1995-07-31 19:17:19 +00:00
|
|
|
cc = imin(uio->uio_resid, OBUFSIZ);
|
1994-05-24 10:09:53 +00:00
|
|
|
cp = obuf;
|
|
|
|
error = uiomove(cp, cc, uio);
|
|
|
|
if (error) {
|
|
|
|
cc = 0;
|
|
|
|
break;
|
|
|
|
}
|
1995-02-15 16:00:56 +00:00
|
|
|
#if NSNP > 0
|
|
|
|
if (ISSET(tp->t_state, TS_SNOOP) && tp->t_sc != NULL)
|
|
|
|
snpin((struct snoop *)tp->t_sc, cp, cc);
|
1995-02-14 21:21:26 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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 char_type), call ttyoutput. After processing
|
|
|
|
* a hunk of data, look for FLUSHO so ^O's will take effect
|
|
|
|
* immediately.
|
|
|
|
*/
|
|
|
|
while (cc > 0) {
|
|
|
|
if (!ISSET(tp->t_oflag, OPOST))
|
|
|
|
ce = cc;
|
|
|
|
else {
|
|
|
|
ce = cc - scanc((u_int)cc, (u_char *)cp,
|
1996-08-31 16:52:44 +00:00
|
|
|
char_type, CCLASSMASK);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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 Clists, wait a bit. */
|
|
|
|
ttstart(tp);
|
1994-11-26 18:54:25 +00:00
|
|
|
if (flag & IO_NDELAY) {
|
|
|
|
error = EWOULDBLOCK;
|
|
|
|
goto out;
|
|
|
|
}
|
1994-10-02 17:35:40 +00:00
|
|
|
error = ttysleep(tp, &lbolt,
|
1995-07-21 20:57:15 +00:00
|
|
|
TTOPRI|PCATCH,
|
|
|
|
"ttybf1", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-11-01 22:23:29 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
cp++;
|
|
|
|
cc--;
|
|
|
|
if (ISSET(tp->t_lflag, FLUSHO) ||
|
|
|
|
tp->t_outq.c_cc > hiwat)
|
|
|
|
goto ovhiwat;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
* requiring special handling by ttyoutput.
|
|
|
|
*/
|
|
|
|
tp->t_rocount = 0;
|
|
|
|
i = b_to_q(cp, ce, &tp->t_outq);
|
|
|
|
ce -= i;
|
|
|
|
tp->t_column += ce;
|
|
|
|
cp += ce, cc -= ce, tk_nout += ce;
|
|
|
|
tp->t_outcc += ce;
|
|
|
|
if (i > 0) {
|
|
|
|
/* No Clists, wait a bit. */
|
|
|
|
ttstart(tp);
|
1994-11-26 18:54:25 +00:00
|
|
|
if (flag & IO_NDELAY) {
|
|
|
|
error = EWOULDBLOCK;
|
|
|
|
goto out;
|
|
|
|
}
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTOPRI | PCATCH,
|
|
|
|
"ttybf2", 0);
|
1994-10-02 17:35:40 +00:00
|
|
|
if (error)
|
1994-11-01 22:23:29 +00:00
|
|
|
goto out;
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
if (ISSET(tp->t_lflag, FLUSHO) ||
|
|
|
|
tp->t_outq.c_cc > hiwat)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
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:
|
|
|
|
ttstart(tp);
|
|
|
|
s = spltty();
|
|
|
|
/*
|
|
|
|
* This can only occur if FLUSHO is set in t_lflag,
|
|
|
|
* or if ttstart/oproc is synchronous (or very fast).
|
|
|
|
*/
|
|
|
|
if (tp->t_outq.c_cc <= hiwat) {
|
|
|
|
splx(s);
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
if (flag & IO_NDELAY) {
|
|
|
|
splx(s);
|
|
|
|
uio->uio_resid += cc;
|
|
|
|
return (uio->uio_resid == cnt ? EWOULDBLOCK : 0);
|
|
|
|
}
|
1995-07-30 12:39:42 +00:00
|
|
|
SET(tp->t_state, TS_SO_OLOWAT);
|
1995-07-22 16:45:22 +00:00
|
|
|
error = ttysleep(tp, TSA_OLOWAT(tp), TTOPRI | PCATCH, "ttywri",
|
|
|
|
tp->t_timeout);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
1995-06-23 21:20:10 +00:00
|
|
|
if (error == EWOULDBLOCK)
|
|
|
|
error = EIO;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rubout one character from the rawq of tp
|
|
|
|
* as cleanly as possible.
|
|
|
|
*/
|
1995-07-31 19:17:19 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyrub(c, tp)
|
|
|
|
register int c;
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
register char *cp;
|
|
|
|
register int savecol;
|
|
|
|
int tabc, s;
|
|
|
|
|
|
|
|
if (!ISSET(tp->t_lflag, ECHO) || ISSET(tp->t_lflag, EXTPROC))
|
|
|
|
return;
|
|
|
|
CLR(tp->t_lflag, FLUSHO);
|
|
|
|
if (ISSET(tp->t_lflag, ECHOE)) {
|
|
|
|
if (tp->t_rocount == 0) {
|
|
|
|
/*
|
|
|
|
* Screwed by ttwrite; retype
|
|
|
|
*/
|
|
|
|
ttyretype(tp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (c == ('\t' | TTY_QUOTE) || c == ('\n' | TTY_QUOTE))
|
|
|
|
ttyrubo(tp, 2);
|
|
|
|
else {
|
|
|
|
CLR(c, ~TTY_CHARMASK);
|
|
|
|
switch (CCLASS(c)) {
|
|
|
|
case ORDINARY:
|
|
|
|
ttyrubo(tp, 1);
|
|
|
|
break;
|
|
|
|
case BACKSPACE:
|
|
|
|
case CONTROL:
|
|
|
|
case NEWLINE:
|
|
|
|
case RETURN:
|
|
|
|
case VTAB:
|
|
|
|
if (ISSET(tp->t_lflag, ECHOCTL))
|
|
|
|
ttyrubo(tp, 2);
|
|
|
|
break;
|
|
|
|
case TAB:
|
|
|
|
if (tp->t_rocount < tp->t_rawq.c_cc) {
|
|
|
|
ttyretype(tp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
s = spltty();
|
|
|
|
savecol = tp->t_column;
|
|
|
|
SET(tp->t_state, TS_CNTTB);
|
|
|
|
SET(tp->t_lflag, FLUSHO);
|
|
|
|
tp->t_column = tp->t_rocol;
|
|
|
|
cp = tp->t_rawq.c_cf;
|
|
|
|
if (cp)
|
|
|
|
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 -= tp->t_column;
|
|
|
|
tp->t_column += savecol;
|
|
|
|
if (savecol > 8)
|
|
|
|
savecol = 8; /* overflow screw */
|
|
|
|
while (--savecol >= 0)
|
|
|
|
(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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Back over cnt characters, erasing them.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ttyrubo(tp, cnt)
|
|
|
|
register struct tty *tp;
|
|
|
|
int cnt;
|
|
|
|
{
|
|
|
|
|
|
|
|
while (cnt-- > 0) {
|
|
|
|
(void)ttyoutput('\b', tp);
|
|
|
|
(void)ttyoutput(' ', tp);
|
|
|
|
(void)ttyoutput('\b', tp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ttyretype --
|
|
|
|
* Reprint the rawq line. Note, it is assumed that c_cc has already
|
|
|
|
* been checked.
|
|
|
|
*/
|
1995-07-31 19:17:19 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyretype(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
register char *cp;
|
|
|
|
int s, c;
|
|
|
|
|
|
|
|
/* Echo the reprint character. */
|
|
|
|
if (tp->t_cc[VREPRINT] != _POSIX_VDISABLE)
|
|
|
|
ttyecho(tp->t_cc[VREPRINT], tp);
|
|
|
|
|
|
|
|
(void)ttyoutput('\n', tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* FIX: NEXTC IS BROKEN - DOESN'T CHECK QUOTE
|
|
|
|
* BIT OF FIRST CHAR.
|
|
|
|
*/
|
|
|
|
s = spltty();
|
|
|
|
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 != NULL ? *cp : 0);
|
|
|
|
cp != NULL; cp = nextc(&tp->t_rawq, cp, &c))
|
|
|
|
ttyecho(c, tp);
|
|
|
|
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 int c;
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!ISSET(tp->t_state, TS_CNTTB))
|
|
|
|
CLR(tp->t_lflag, FLUSHO);
|
|
|
|
if ((!ISSET(tp->t_lflag, ECHO) &&
|
1995-07-21 13:56:29 +00:00
|
|
|
(c != '\n' || !ISSET(tp->t_lflag, ECHONL))) ||
|
1994-05-24 10:09:53 +00:00
|
|
|
ISSET(tp->t_lflag, EXTPROC))
|
|
|
|
return;
|
|
|
|
if (ISSET(tp->t_lflag, ECHOCTL) &&
|
1994-10-02 17:35:40 +00:00
|
|
|
((ISSET(c, TTY_CHARMASK) <= 037 && c != '\t' && c != '\n') ||
|
1994-05-24 10:09:53 +00:00
|
|
|
ISSET(c, TTY_CHARMASK) == 0177)) {
|
|
|
|
(void)ttyoutput('^', tp);
|
|
|
|
CLR(c, ~TTY_CHARMASK);
|
|
|
|
if (c == 0177)
|
|
|
|
c = '?';
|
|
|
|
else
|
|
|
|
c += 'A' - 1;
|
|
|
|
}
|
|
|
|
(void)ttyoutput(c, tp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wake up any readers on a tty.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttwakeup(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
|
1995-07-31 21:02:00 +00:00
|
|
|
if (tp->t_rsel.si_pid != 0)
|
|
|
|
selwakeup(&tp->t_rsel);
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
|
|
|
|
pgsigio(tp->t_sigio, SIGIO, (tp->t_session != NULL));
|
1995-07-31 21:02:00 +00:00
|
|
|
wakeup(TSA_HUP_OR_INPUT(tp));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-07-22 01:30:45 +00:00
|
|
|
/*
|
|
|
|
* Wake up any writers on a tty.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttwwakeup(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
|
1998-03-07 15:36:29 +00:00
|
|
|
if (tp->t_wsel.si_pid != 0 && tp->t_outq.c_cc <= tp->t_olowat)
|
1995-07-22 01:30:45 +00:00
|
|
|
selwakeup(&tp->t_wsel);
|
1995-07-30 12:39:42 +00:00
|
|
|
if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
|
|
|
|
TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
|
|
|
|
CLR(tp->t_state, TS_SO_OCOMPLETE);
|
|
|
|
wakeup(TSA_OCOMPLETE(tp));
|
|
|
|
}
|
|
|
|
if (ISSET(tp->t_state, TS_SO_OLOWAT) &&
|
1998-03-07 15:36:29 +00:00
|
|
|
tp->t_outq.c_cc <= tp->t_olowat) {
|
1995-07-30 12:39:42 +00:00
|
|
|
CLR(tp->t_state, TS_SO_OLOWAT);
|
|
|
|
wakeup(TSA_OLOWAT(tp));
|
1995-07-22 01:30:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
{
|
|
|
|
|
|
|
|
for ( ; table->sp_speed != -1; table++)
|
|
|
|
if (table->sp_speed == speed)
|
|
|
|
return (table->sp_code);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1998-03-07 15:36:29 +00:00
|
|
|
* Set input and output watermarks and buffer sizes. For input, the
|
|
|
|
* high watermark is about one second's worth of input above empty, the
|
|
|
|
* low watermark is slightly below high water, and the buffer size is a
|
|
|
|
* driver-dependent amount above high water. For output, the watermarks
|
|
|
|
* are near the ends of the buffer, with about 1 second's worth of input
|
|
|
|
* between them. All this only applies to the standard line discipline.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttsetwater(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
1998-03-07 15:36:29 +00:00
|
|
|
register int cps, ttmaxhiwat, x;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-03-07 15:36:29 +00:00
|
|
|
/* Input. */
|
|
|
|
clist_alloc_cblocks(&tp->t_canq, TTYHOG, 512);
|
|
|
|
switch (tp->t_ispeedwat) {
|
|
|
|
case (speed_t)-1:
|
|
|
|
cps = tp->t_ispeed / 10;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
/*
|
|
|
|
* This case is for old drivers that don't know about
|
|
|
|
* t_ispeedwat. Arrange for them to get the old buffer
|
|
|
|
* sizes and watermarks.
|
|
|
|
*/
|
|
|
|
cps = TTYHOG - 2 * 256;
|
|
|
|
tp->t_ififosize = 2 * 256;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cps = tp->t_ispeedwat / 10;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
tp->t_ihiwat = cps;
|
|
|
|
tp->t_ilowat = 7 * cps / 8;
|
|
|
|
x = cps + tp->t_ififosize;
|
|
|
|
clist_alloc_cblocks(&tp->t_rawq, x, x);
|
|
|
|
|
|
|
|
/* Output. */
|
|
|
|
switch (tp->t_ospeedwat) {
|
|
|
|
case (speed_t)-1:
|
|
|
|
cps = tp->t_ospeed / 10;
|
1998-08-19 04:01:00 +00:00
|
|
|
ttmaxhiwat = 2 * TTMAXHIWAT;
|
1998-03-07 15:36:29 +00:00
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
cps = tp->t_ospeed / 10;
|
|
|
|
ttmaxhiwat = TTMAXHIWAT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cps = tp->t_ospeedwat / 10;
|
1998-08-19 04:01:00 +00:00
|
|
|
ttmaxhiwat = 8 * TTMAXHIWAT;
|
1998-03-07 15:36:29 +00:00
|
|
|
break;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
#define CLAMP(x, h, l) ((x) > h ? h : ((x) < l) ? l : (x))
|
1998-03-07 15:36:29 +00:00
|
|
|
tp->t_olowat = x = CLAMP(cps / 2, TTMAXLOWAT, TTMINLOWAT);
|
1994-05-24 10:09:53 +00:00
|
|
|
x += cps;
|
1998-03-07 15:36:29 +00:00
|
|
|
x = CLAMP(x, ttmaxhiwat, TTMINHIWAT); /* XXX clamps are too magic */
|
|
|
|
tp->t_ohiwat = roundup(x, CBSIZE); /* XXX for compat */
|
|
|
|
x = imax(tp->t_ohiwat, TTMAXHIWAT); /* XXX for compat/safety */
|
|
|
|
x += OBUFSIZ + 100;
|
|
|
|
clist_alloc_cblocks(&tp->t_outq, x, x);
|
1994-05-24 10:09:53 +00:00
|
|
|
#undef CLAMP
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Report on state of foreground process group.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttyinfo(tp)
|
|
|
|
register struct tty *tp;
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
|
|
|
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");
|
1996-03-11 06:05:03 +00:00
|
|
|
else if ((p = tp->t_pgrp->pg_members.lh_first) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyprintf(tp, "empty foreground process group\n");
|
|
|
|
else {
|
|
|
|
/* Pick interesting process. */
|
1996-03-11 06:05:03 +00:00
|
|
|
for (pick = NULL; p != 0; p = p->p_pglist.le_next)
|
1994-05-24 10:09:53 +00:00
|
|
|
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. */
|
1998-07-11 10:45:45 +00:00
|
|
|
ttyprintf(tp, "%ld.%02ldu ",
|
1994-10-23 06:18:13 +00:00
|
|
|
utime.tv_sec, utime.tv_usec / 10000);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* Print system time. */
|
1998-07-11 10:45:45 +00:00
|
|
|
ttyprintf(tp, "%ld.%02lds ",
|
1994-10-23 06:18:13 +00:00
|
|
|
stime.tv_sec, stime.tv_usec / 10000);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-05-02 14:21:14 +00:00
|
|
|
#define pgtok(a) (((a) * PAGE_SIZE) / 1024)
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Print percentage cpu, resident set size. */
|
1994-10-02 17:35:40 +00:00
|
|
|
tmp = (pick->p_pctcpu * 10000 + FSCALE / 2) >> FSHIFT;
|
1998-07-11 10:45:45 +00:00
|
|
|
ttyprintf(tp, "%d%% %ldk\n",
|
1994-05-24 10:09:53 +00:00
|
|
|
tmp / 100,
|
|
|
|
pick->p_stat == SIDL || pick->p_stat == SZOMB ? 0 :
|
|
|
|
#ifdef pmap_resident_count
|
1998-07-11 10:45:45 +00:00
|
|
|
(long)pgtok(pmap_resident_count(&pick->p_vmspace->vm_pmap))
|
1994-05-24 10:09:53 +00:00
|
|
|
#else
|
1998-07-11 10:45:45 +00:00
|
|
|
(long)pgtok(pick->p_vmspace->vm_rssize)
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
1998-07-11 10:45:45 +00:00
|
|
|
);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
tp->t_rocount = 0; /* so pending input will be retyped if BS */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns 1 if p2 is "better" than p1
|
|
|
|
*
|
|
|
|
* The algorithm for picking the "interesting" process is thus:
|
|
|
|
*
|
|
|
|
* 1) Only foreground processes are eligible - implied.
|
|
|
|
* 2) Runnable processes are favored over anything else. The runner
|
|
|
|
* with the highest cpu utilization is picked (p_estcpu). Ties are
|
|
|
|
* broken by picking the highest pid.
|
|
|
|
* 3) The sleeper with the shortest sleep time is next. With ties,
|
|
|
|
* we pick out just "short-term" sleepers (P_SINTR == 0).
|
|
|
|
* 4) Further ties are broken by picking the highest pid.
|
|
|
|
*/
|
|
|
|
#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_estcpu > p1->p_estcpu)
|
|
|
|
return (1);
|
|
|
|
if (p1->p_estcpu > p2->p_estcpu)
|
|
|
|
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 & P_SINTR && (p2->p_flag & P_SINTR) == 0)
|
|
|
|
return (1);
|
|
|
|
if (p2->p_flag & P_SINTR && (p1->p_flag & P_SINTR) == 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 int s;
|
|
|
|
|
|
|
|
s = spltty();
|
1995-07-31 21:02:00 +00:00
|
|
|
if (!ISSET(tp->t_state, TS_CONNECTED)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
if (c == '\n')
|
|
|
|
(void)ttyoutput('\r', tp);
|
|
|
|
(void)ttyoutput(c, tp);
|
|
|
|
ttstart(tp);
|
|
|
|
splx(s);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sleep on chan, returning ERESTART if tty changed while we napped and
|
1996-08-28 18:45:09 +00:00
|
|
|
* returning any errors (e.g. EINTR/EWOULDBLOCK) reported by tsleep. If
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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;
|
|
|
|
{
|
|
|
|
int error;
|
1995-07-31 22:50:08 +00:00
|
|
|
int gen;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
gen = tp->t_gen;
|
1994-10-02 17:35:40 +00:00
|
|
|
error = tsleep(chan, pri, wmesg, timo);
|
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
return (tp->t_gen == gen ? 0 : ERESTART);
|
|
|
|
}
|
1995-02-09 11:13:30 +00:00
|
|
|
|
1995-12-14 08:32:45 +00:00
|
|
|
#ifdef notyet
|
1995-02-09 11:13:30 +00:00
|
|
|
/*
|
1995-02-25 20:09:44 +00:00
|
|
|
* XXX this is usable not useful or used. Most tty drivers have
|
|
|
|
* ifdefs for using ttymalloc() but assume a different interface.
|
1995-02-15 22:25:51 +00:00
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Allocate a tty struct. Clists in the struct will be allocated by
|
|
|
|
* ttyopen().
|
1995-02-09 11:13:30 +00:00
|
|
|
*/
|
|
|
|
struct tty *
|
|
|
|
ttymalloc()
|
|
|
|
{
|
|
|
|
struct tty *tp;
|
|
|
|
|
1995-02-15 22:25:51 +00:00
|
|
|
tp = malloc(sizeof *tp, M_TTYS, M_WAITOK);
|
1995-02-09 11:13:30 +00:00
|
|
|
bzero(tp, sizeof *tp);
|
1995-02-15 22:25:51 +00:00
|
|
|
return (tp);
|
1995-02-09 11:13:30 +00:00
|
|
|
}
|
1995-12-14 08:32:45 +00:00
|
|
|
#endif
|
1995-02-09 11:13:30 +00:00
|
|
|
|
1995-02-15 22:25:51 +00:00
|
|
|
#if 0 /* XXX not yet usable: session leader holds a ref (see kern_exit.c). */
|
1995-02-09 11:13:30 +00:00
|
|
|
/*
|
1995-02-15 22:25:51 +00:00
|
|
|
* Free a tty struct. Clists in the struct should have been freed by
|
|
|
|
* ttyclose().
|
1995-02-09 11:13:30 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
ttyfree(tp)
|
1995-02-15 22:25:51 +00:00
|
|
|
struct tty *tp;
|
1995-02-09 11:13:30 +00:00
|
|
|
{
|
1995-02-15 22:25:51 +00:00
|
|
|
free(tp, M_TTYS);
|
1995-02-09 11:13:30 +00:00
|
|
|
}
|
1995-02-15 22:25:51 +00:00
|
|
|
#endif /* 0 */
|