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.
|
|
|
|
*
|
2002-05-28 06:53:41 +00:00
|
|
|
* Copyright (c) 2002 Networks Associates Technologies, Inc.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Portions of this software were developed for the FreeBSD Project by
|
|
|
|
* ThinkSec AS and NAI Labs, the Security Research Division of Network
|
|
|
|
* Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
|
|
|
|
* ("CBOSS"), as part of the DARPA CHATS research program.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
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
|
|
|
*/
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.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>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
2002-04-03 10:56:59 +00:00
|
|
|
#include <sys/namei.h>
|
2002-02-23 11:12:57 +00:00
|
|
|
#include <sys/sx.h>
|
1997-03-24 12:03:06 +00:00
|
|
|
#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>
|
1999-08-08 19:47:32 +00:00
|
|
|
#include <sys/sysctl.h>
|
1995-02-14 21:21:26 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <vm/vm.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");
|
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
static int proc_compare(struct proc *p1, struct proc *p2);
|
|
|
|
static int ttnread(struct tty *tp);
|
|
|
|
static void ttyecho(int c, struct tty *tp);
|
2002-05-25 15:44:38 +00:00
|
|
|
static int ttyoutput(int c, struct tty *tp);
|
2002-03-19 21:25:46 +00:00
|
|
|
static void ttypend(struct tty *tp);
|
|
|
|
static void ttyretype(struct tty *tp);
|
|
|
|
static void ttyrub(int c, struct tty *tp);
|
|
|
|
static void ttyrubo(struct tty *tp, int cnt);
|
|
|
|
static void ttyunblock(struct tty *tp);
|
|
|
|
static int ttywflush(struct tty *tp);
|
|
|
|
static int filt_ttyread(struct knote *kn, long hint);
|
2002-05-25 15:43:06 +00:00
|
|
|
static void filt_ttyrdetach(struct knote *kn);
|
2002-03-19 21:25:46 +00:00
|
|
|
static int filt_ttywrite(struct knote *kn, long hint);
|
2002-05-25 15:43:06 +00:00
|
|
|
static void filt_ttywdetach(struct knote *kn);
|
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
|
|
|
|
1999-08-08 19:47:32 +00:00
|
|
|
/*
|
|
|
|
* list of struct tty where pstat(8) can pick it up with sysctl
|
|
|
|
*/
|
2000-05-26 02:09:24 +00:00
|
|
|
static SLIST_HEAD(, tty) tty_list;
|
1999-08-08 19:47:32 +00:00
|
|
|
|
2000-04-30 16:00:53 +00:00
|
|
|
static int drainwait = 5*60;
|
|
|
|
SYSCTL_INT(_kern, OID_AUTO, drainwait, CTLFLAG_RW, &drainwait,
|
|
|
|
0, "Output drain timeout in seconds");
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Initial open of tty, or (re)entry to standard tty line discipline.
|
|
|
|
*/
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyopen(dev_t device, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
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));
|
|
|
|
}
|
2000-04-27 20:14:21 +00:00
|
|
|
/* XXX don't hang forever on output */
|
2000-05-01 09:05:03 +00:00
|
|
|
if (tp->t_timeout < 0)
|
|
|
|
tp->t_timeout = drainwait*hz;
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyclose(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1994-11-26 19:24:13 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-05-06 19:31:28 +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
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyinput(int c, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
tcflag_t iflag, lflag;
|
|
|
|
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);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
pgsignal(tp->t_pgrp, SIGINT, 1);
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1996-11-29 15:23:42 +00:00
|
|
|
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);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
pgsignal(tp->t_pgrp,
|
|
|
|
CCEQ(cc[VINTR], c) ? SIGINT : SIGQUIT, 1);
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
goto endcase;
|
|
|
|
}
|
|
|
|
if (CCEQ(cc[VSUSP], c)) {
|
|
|
|
if (!ISSET(lflag, NOFLSH))
|
|
|
|
ttyflush(tp, FREAD);
|
|
|
|
ttyecho(c, tp);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
pgsignal(tp->t_pgrp, SIGTSTP, 1);
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
|
|
|
(*tp->t_stop)(tp, 0);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
/*
|
2000-11-28 20:03:23 +00:00
|
|
|
* erase or erase2 (^H / ^?)
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2000-11-28 20:03:23 +00:00
|
|
|
if (CCEQ(cc[VERASE], c) || CCEQ(cc[VERASE2], c) ) {
|
1994-05-24 10:09:53 +00:00
|
|
|
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)) {
|
2002-02-23 11:12:57 +00:00
|
|
|
if (ISSET(lflag, ISIG) && tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(tp->t_pgrp, SIGINFO, 1);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyoutput(int c, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
tcflag_t oflag;
|
|
|
|
int col, s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
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++;
|
2001-03-04 06:04:50 +00:00
|
|
|
if (!ISSET(tp->t_lflag, FLUSHO) && putc('\r', &tp->t_outq))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (c);
|
|
|
|
}
|
2001-03-04 06:04:50 +00:00
|
|
|
/* If OCRNL is set, translate "\r" into "\n". */
|
|
|
|
else if (c == '\r' && ISSET(tp->t_oflag, OCRNL))
|
|
|
|
c = '\n';
|
|
|
|
/* If ONOCR is set, don't transmit CRs when on column 0. */
|
|
|
|
else if (c == '\r' && ISSET(tp->t_oflag, ONOCR) && tp->t_column == 0)
|
|
|
|
return (-1);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
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:
|
2001-03-04 06:04:50 +00:00
|
|
|
if (ISSET(tp->t_oflag, ONLCR | ONLRET))
|
|
|
|
col = 0;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttioctl(struct tty *tp, u_long cmd, void *data, int flag)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
struct proc *p;
|
2002-04-01 21:31:13 +00:00
|
|
|
struct thread *td;
|
2002-04-16 17:09:22 +00:00
|
|
|
struct pgrp *pgrp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int s, error;
|
|
|
|
|
2002-04-01 21:31:13 +00:00
|
|
|
td = curthread; /* XXX */
|
|
|
|
p = td->td_proc;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* 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
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
1999-09-29 15:03:48 +00:00
|
|
|
while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) &&
|
|
|
|
!SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
|
|
|
|
!SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
|
2002-04-16 17:09:22 +00:00
|
|
|
pgrp = p->p_pgrp;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
if (pgrp->pg_jobc == 0) {
|
|
|
|
sx_sunlock(&proctree_lock);
|
1996-11-29 15:50:56 +00:00
|
|
|
return (EIO);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
2002-04-16 17:09:22 +00:00
|
|
|
PGRP_LOCK(pgrp);
|
|
|
|
sx_sunlock(&proctree_lock);
|
|
|
|
pgsignal(pgrp, SIGTTOU, 1);
|
|
|
|
PGRP_UNLOCK(pgrp);
|
1995-07-21 20:57:15 +00:00
|
|
|
error = ttysleep(tp, &lbolt, TTOPRI | PCATCH, "ttybg1",
|
|
|
|
0);
|
2002-03-02 12:42:24 +00:00
|
|
|
if (error)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
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:
|
|
|
|
/*
|
2002-05-25 15:43:06 +00:00
|
|
|
* Policy -- Don't allow FIOSETOWN on someone else's
|
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
|
|
|
* 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 */
|
2002-05-25 15:44:38 +00:00
|
|
|
int flags = *(int *)data;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
if (flags == 0)
|
|
|
|
flags = FREAD | FWRITE;
|
|
|
|
else
|
|
|
|
flags &= FREAD | FWRITE;
|
|
|
|
ttyflush(tp, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case TIOCCONS: /* become virtual console */
|
|
|
|
if (*(int *)data) {
|
2002-04-03 10:56:59 +00:00
|
|
|
struct nameidata nid;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
2002-04-03 10:56:59 +00:00
|
|
|
|
|
|
|
/* Ensure user can open the real console. */
|
|
|
|
NDINIT(&nid, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE,
|
|
|
|
"/dev/console", td);
|
|
|
|
if ((error = namei(&nid)) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
2002-04-03 10:56:59 +00:00
|
|
|
NDFREE(&nid, NDF_ONLY_PNBUF);
|
|
|
|
error = VOP_ACCESS(nid.ni_vp, VREAD, td->td_ucred, td);
|
|
|
|
vput(nid.ni_vp);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
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 */
|
2002-05-25 15:44:38 +00:00
|
|
|
struct termios *t = (struct termios *)data;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
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 */
|
2002-05-25 15:44:38 +00:00
|
|
|
int t = *(int *)data;
|
1994-05-24 10:09:53 +00:00
|
|
|
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 */
|
2002-04-01 21:31:13 +00:00
|
|
|
if ((flag & FREAD) == 0 && suser(td))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EPERM);
|
2002-04-01 21:31:13 +00:00
|
|
|
if (!isctty(p, tp) && suser(td))
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
|
|
|
(*tp->t_stop)(tp, 0);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
case TIOCSCTTY: /* become controlling tty */
|
|
|
|
/* Session ctty vnode pointer set in vnode layer. */
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (!SESS_LEADER(p) ||
|
1994-10-02 17:35:40 +00:00
|
|
|
((p->p_session->s_ttyvp || tp->t_session) &&
|
2002-02-23 11:12:57 +00:00
|
|
|
(tp->t_session != p->p_session))) {
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EPERM);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
tp->t_session = p->p_session;
|
|
|
|
tp->t_pgrp = p->p_pgrp;
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_LOCK(p->p_session);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_session->s_ttyp = tp;
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
PROC_LOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_flag |= P_CONTROLT;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
case TIOCSPGRP: { /* set pgrp of tty */
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
pgrp = pgfind(*(int *)data);
|
|
|
|
if (!isctty(p, tp)) {
|
|
|
|
if (pgrp != NULL)
|
|
|
|
PGRP_UNLOCK(pgrp);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (ENOTTY);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
|
|
|
if (pgrp == NULL) {
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EPERM);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
|
|
|
PGRP_UNLOCK(pgrp);
|
|
|
|
if (pgrp->pg_session != p->p_session) {
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
return (EPERM);
|
|
|
|
}
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
pgsignal(tp->t_pgrp, SIGWINCH, 1);
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
break;
|
1995-01-05 00:01:07 +00:00
|
|
|
case TIOCSDRAINWAIT:
|
2002-04-01 21:31:13 +00:00
|
|
|
error = suser(td);
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttypoll(dev_t dev, int events, struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1995-07-31 19:17:19 +00:00
|
|
|
int s;
|
1997-09-14 02:40:46 +00:00
|
|
|
int revents = 0;
|
1999-09-25 16:21:39 +00:00
|
|
|
struct tty *tp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-09-25 16:21:39 +00:00
|
|
|
tp = dev->si_tty;
|
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();
|
1999-05-06 18:13:11 +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
|
2001-09-12 08:38:13 +00:00
|
|
|
selrecord(td, &tp->t_rsel);
|
1999-05-06 18:13:11 +00:00
|
|
|
}
|
|
|
|
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
|
2001-09-12 08:38:13 +00:00
|
|
|
selrecord(td, &tp->t_wsel);
|
1999-05-06 18:13:11 +00:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2001-02-15 16:34:11 +00:00
|
|
|
static struct filterops ttyread_filtops =
|
|
|
|
{ 1, NULL, filt_ttyrdetach, filt_ttyread };
|
|
|
|
static struct filterops ttywrite_filtops =
|
|
|
|
{ 1, NULL, filt_ttywdetach, filt_ttywrite };
|
|
|
|
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
ttykqfilter(dev_t dev, struct knote *kn)
|
2001-02-15 16:34:11 +00:00
|
|
|
{
|
|
|
|
struct tty *tp = dev->si_tty;
|
|
|
|
struct klist *klist;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
switch (kn->kn_filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
klist = &tp->t_rsel.si_note;
|
|
|
|
kn->kn_fop = &ttyread_filtops;
|
|
|
|
break;
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
klist = &tp->t_wsel.si_note;
|
|
|
|
kn->kn_fop = &ttywrite_filtops;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
kn->kn_hook = (caddr_t)dev;
|
|
|
|
|
|
|
|
s = spltty();
|
|
|
|
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_ttyrdetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
|
|
|
|
int s = spltty();
|
|
|
|
|
|
|
|
SLIST_REMOVE(&tp->t_rsel.si_note, kn, knote, kn_selnext);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
filt_ttyread(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
|
|
|
|
|
|
|
|
kn->kn_data = ttnread(tp);
|
|
|
|
if (ISSET(tp->t_state, TS_ZOMBIE)) {
|
|
|
|
kn->kn_flags |= EV_EOF;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (kn->kn_data > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_ttywdetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
|
|
|
|
int s = spltty();
|
|
|
|
|
|
|
|
SLIST_REMOVE(&tp->t_wsel.si_note, kn, knote, kn_selnext);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-05-25 15:52:53 +00:00
|
|
|
filt_ttywrite(struct knote *kn, long hint)
|
2001-02-15 16:34:11 +00:00
|
|
|
{
|
|
|
|
struct tty *tp = ((dev_t)kn->kn_hook)->si_tty;
|
|
|
|
|
|
|
|
kn->kn_data = tp->t_outq.c_cc;
|
|
|
|
if (ISSET(tp->t_state, TS_ZOMBIE))
|
|
|
|
return (1);
|
|
|
|
return (kn->kn_data <= tp->t_olowat &&
|
|
|
|
ISSET(tp->t_state, TS_CONNECTED));
|
|
|
|
}
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttnread(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttywait(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttywflush(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyflush(struct tty *tp, int rw)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
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
|
|
|
(*tp->t_stop)(tp, rw);
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
termioschars(struct termios *t)
|
1995-07-21 22:52:01 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
bcopy(ttydefchars, t->c_cc, sizeof t->c_cc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Old interface.
|
|
|
|
*/
|
|
|
|
void
|
2002-05-25 15:52:53 +00:00
|
|
|
ttychars(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyblock(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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyunblock(struct tty *tp)
|
1995-07-31 18:29:51 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttrstrt(void *tp_arg)
|
1995-12-14 22:32:52 +00:00
|
|
|
{
|
|
|
|
struct tty *tp;
|
|
|
|
int s;
|
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(tp_arg != NULL, ("ttrstrt"));
|
|
|
|
|
1995-12-14 22:32:52 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttstart(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
if (tp->t_oproc != NULL) /* XXX: Kludge for pty. */
|
|
|
|
(*tp->t_oproc)(tp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "close" a line discipline
|
|
|
|
*/
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
ttylclose(struct tty *tp, int flag)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttymodem(struct tty *tp, int flag)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
(*tp->t_stop)(tp, 0);
|
|
|
|
}
|
|
|
|
} 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);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_session) {
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_session->s_leader) {
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = tp->t_session->s_leader;
|
|
|
|
PROC_LOCK(p);
|
|
|
|
psignal(p, SIGHUP);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
}
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
2001-03-07 03:37:06 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttypend(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
struct clist tq;
|
2002-05-25 15:44:38 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttread(struct tty *tp, struct uio *uio, int flag)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
struct clist *qp;
|
|
|
|
int c;
|
|
|
|
tcflag_t lflag;
|
|
|
|
cc_t *cc = tp->t_cc;
|
|
|
|
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;
|
2002-04-16 17:09:22 +00:00
|
|
|
struct pgrp *pg;
|
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);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
1999-09-29 15:03:48 +00:00
|
|
|
if (SIGISMEMBER(p->p_sigignore, SIGTTIN) ||
|
|
|
|
SIGISMEMBER(p->p_sigmask, SIGTTIN) ||
|
2002-02-23 11:12:57 +00:00
|
|
|
(p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) {
|
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EIO);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
2002-04-16 17:09:22 +00:00
|
|
|
pg = p->p_pgrp;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
PGRP_LOCK(pg);
|
|
|
|
sx_sunlock(&proctree_lock);
|
|
|
|
pgsignal(pg, SIGTTIN, 1);
|
|
|
|
PGRP_UNLOCK(pg);
|
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 (error)
|
|
|
|
break;
|
2002-05-25 15:43:06 +00:00
|
|
|
if (uio->uio_resid == 0)
|
1995-04-15 21:04:58 +00:00
|
|
|
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)) {
|
2002-02-23 11:12:57 +00:00
|
|
|
if (tp->t_pgrp != NULL) {
|
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
pgsignal(tp->t_pgrp, SIGTSTP, 1);
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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.
|
|
|
|
*/
|
2002-05-25 15:43:06 +00:00
|
|
|
error = ureadc(c, uio);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error)
|
1995-04-15 21:04:58 +00:00
|
|
|
/* XXX should ungetc(c, qp). */
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
2002-05-25 15:43:06 +00:00
|
|
|
if (uio->uio_resid == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttycheckoutq(struct tty *tp, int wait)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1999-09-29 15:03:48 +00:00
|
|
|
int hiwat, s;
|
|
|
|
sigset_t oldmask;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-03-07 15:36:29 +00:00
|
|
|
hiwat = tp->t_ohiwat;
|
1999-09-29 15:03:48 +00:00
|
|
|
SIGEMPTYSET(oldmask);
|
1994-05-24 10:09:53 +00:00
|
|
|
s = spltty();
|
1999-09-29 15:03:48 +00:00
|
|
|
if (wait)
|
|
|
|
oldmask = curproc->p_siglist;
|
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;
|
1999-09-29 15:03:48 +00:00
|
|
|
if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) {
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttwrite(struct tty *tp, struct uio *uio, int flag)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
char *cp = NULL;
|
|
|
|
int cc, ce;
|
|
|
|
struct proc *p;
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_slock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (isbackground(p, tp) &&
|
1999-09-29 15:03:48 +00:00
|
|
|
ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) &&
|
|
|
|
!SIGISMEMBER(p->p_sigignore, SIGTTOU) &&
|
|
|
|
!SIGISMEMBER(p->p_sigmask, SIGTTOU)) {
|
1996-11-29 15:50:56 +00:00
|
|
|
if (p->p_pgrp->pg_jobc == 0) {
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1996-11-29 15:50:56 +00:00
|
|
|
error = EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
|
|
|
PGRP_LOCK(p->p_pgrp);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(p->p_pgrp, SIGTTOU, 1);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(p->p_pgrp);
|
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;
|
2002-02-23 11:12:57 +00:00
|
|
|
} else {
|
|
|
|
PROC_UNLOCK(p);
|
2002-04-16 17:09:22 +00:00
|
|
|
sx_sunlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyrub(int c, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
char *cp;
|
|
|
|
int savecol;
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
2000-11-28 20:03:23 +00:00
|
|
|
} else {
|
1994-05-24 10:09:53 +00:00
|
|
|
ttyecho(tp->t_cc[VERASE], tp);
|
2000-11-28 20:03:23 +00:00
|
|
|
/*
|
|
|
|
* This code may be executed not only when an ERASE key
|
|
|
|
* is pressed, but also when ^U (KILL) or ^W (WERASE) are.
|
|
|
|
* So, I didn't think it was worthwhile to pass the extra
|
|
|
|
* information (which would need an extra parameter,
|
|
|
|
* changing every call) needed to distinguish the ERASE2
|
|
|
|
* case from the ERASE.
|
|
|
|
*/
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
--tp->t_rocount;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Back over cnt characters, erasing them.
|
|
|
|
*/
|
|
|
|
static void
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyrubo(struct tty *tp, int cnt)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyretype(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
char *cp;
|
1994-05-24 10:09:53 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyecho(int c, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttwakeup(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2002-03-14 01:32:30 +00:00
|
|
|
if (SEL_WAITING(&tp->t_rsel))
|
1995-07-31 21:02:00 +00:00
|
|
|
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)
|
2002-05-01 20:44:46 +00:00
|
|
|
pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
|
1995-07-31 21:02:00 +00:00
|
|
|
wakeup(TSA_HUP_OR_INPUT(tp));
|
2001-02-17 19:40:22 +00:00
|
|
|
KNOTE(&tp->t_rsel.si_note, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-07-22 01:30:45 +00:00
|
|
|
/*
|
|
|
|
* Wake up any writers on a tty.
|
|
|
|
*/
|
|
|
|
void
|
2002-05-25 15:52:53 +00:00
|
|
|
ttwwakeup(struct tty *tp)
|
1995-07-22 01:30:45 +00:00
|
|
|
{
|
|
|
|
|
2002-03-14 01:32:30 +00:00
|
|
|
if (SEL_WAITING(&tp->t_wsel) && tp->t_outq.c_cc <= tp->t_olowat)
|
1995-07-22 01:30:45 +00:00
|
|
|
selwakeup(&tp->t_wsel);
|
2000-04-05 18:38:21 +00:00
|
|
|
if (ISSET(tp->t_state, TS_ASYNC) && tp->t_sigio != NULL)
|
2002-05-01 20:44:46 +00:00
|
|
|
pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
|
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
|
|
|
}
|
2001-02-17 19:40:22 +00:00
|
|
|
KNOTE(&tp->t_wsel.si_note, 0);
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttspeedtab(int speed, struct speedtab *table)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttsetwater(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyinfo(struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
struct proc *p, *pick;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct timeval utime, stime;
|
2001-01-20 23:03:20 +00:00
|
|
|
const char *stmp;
|
|
|
|
long ltmp;
|
1994-05-24 10:09:53 +00:00
|
|
|
int tmp;
|
2002-02-07 20:58:47 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
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");
|
|
|
|
else {
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_LOCK(tp->t_pgrp);
|
|
|
|
if ((p = LIST_FIRST(&tp->t_pgrp->pg_members)) == 0) {
|
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
|
|
|
ttyprintf(tp, "empty foreground process group\n");
|
|
|
|
} else {
|
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
|
|
|
|
/* Pick interesting process. */
|
|
|
|
for (pick = NULL; p != 0; p = LIST_NEXT(p, p_pglist))
|
|
|
|
if (proc_compare(pick, p))
|
|
|
|
pick = p;
|
2002-04-02 17:12:06 +00:00
|
|
|
PGRP_UNLOCK(tp->t_pgrp);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
td = FIRST_THREAD_IN_PROC(pick);
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
if (pick->p_flag & P_KSES) {
|
|
|
|
stmp = "KSE" ; /* XXXKSE */
|
|
|
|
} else {
|
|
|
|
if (td) {
|
2002-09-11 08:13:56 +00:00
|
|
|
if (TD_ON_RUNQ(td) ||
|
|
|
|
(TD_IS_RUNNING(td))) {
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
stmp = "running";
|
2002-09-11 08:13:56 +00:00
|
|
|
} else if (TD_ON_MUTEX(td)) {
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
stmp = td->td_mtxname;
|
|
|
|
} else if (td->td_wmesg) {
|
|
|
|
stmp = td->td_wmesg;
|
|
|
|
} else {
|
|
|
|
stmp = "iowait";
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
stmp = "threadless";
|
|
|
|
panic("ttyinfo: no thread!?");
|
|
|
|
}
|
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
calcru(pick, &utime, &stime, NULL);
|
2002-07-18 21:19:56 +00:00
|
|
|
/* XXXKSE The TDS_IWAIT line is Dubious */
|
|
|
|
if (pick->p_state == PRS_NEW ||
|
2002-09-11 08:13:56 +00:00
|
|
|
(td && (TD_AWAITING_INTR(td))) ||
|
2002-07-18 21:19:56 +00:00
|
|
|
pick->p_state == PRS_ZOMBIE) {
|
|
|
|
ltmp = 0;
|
|
|
|
} else {
|
|
|
|
ltmp = pgtok(
|
|
|
|
vmspace_resident_count(pick->p_vmspace));
|
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
|
|
|
|
2002-06-20 14:03:36 +00:00
|
|
|
ttyprintf(tp, " cmd: %s %d [%s%s] ", pick->p_comm,
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
pick->p_pid,
|
2002-09-11 08:13:56 +00:00
|
|
|
TD_ON_MUTEX(td) ? "*" : "",
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
stmp);
|
2002-02-23 11:12:57 +00:00
|
|
|
|
|
|
|
/* Print user time. */
|
2002-02-24 19:56:41 +00:00
|
|
|
ttyprintf(tp, "%ld.%02ldu ",
|
2002-02-23 11:12:57 +00:00
|
|
|
utime.tv_sec, utime.tv_usec / 10000);
|
|
|
|
|
|
|
|
/* Print system time. */
|
|
|
|
ttyprintf(tp, "%ld.%02lds ",
|
|
|
|
(long)stime.tv_sec, stime.tv_usec / 10000);
|
|
|
|
|
|
|
|
/* Print percentage cpu, resident set size. */
|
|
|
|
ttyprintf(tp, "%d%% %ldk\n", tmp / 100, ltmp);
|
|
|
|
|
|
|
|
}
|
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.
|
|
|
|
*/
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
#define ISRUN(p, val) \
|
|
|
|
do { \
|
|
|
|
struct thread *td; \
|
|
|
|
val = 0; \
|
|
|
|
FOREACH_THREAD_IN_PROC(p, td) { \
|
2002-09-11 08:13:56 +00:00
|
|
|
if (TD_ON_RUNQ(td) || \
|
|
|
|
TD_IS_RUNNING(td)) { \
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
val = 1; \
|
|
|
|
break; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#define TESTAB(a, b) ((a)<<1 | (b))
|
|
|
|
#define ONLYA 2
|
|
|
|
#define ONLYB 1
|
|
|
|
#define BOTH 3
|
|
|
|
|
|
|
|
static int
|
2002-05-25 15:52:53 +00:00
|
|
|
proc_compare(struct proc *p1, struct proc *p2)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
int esta, estb;
|
|
|
|
struct ksegrp *kg;
|
2001-01-24 11:15:59 +00:00
|
|
|
mtx_assert(&sched_lock, MA_OWNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (p1 == NULL)
|
|
|
|
return (1);
|
2000-12-02 01:32:51 +00:00
|
|
|
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
ISRUN(p1, esta);
|
|
|
|
ISRUN(p2, estb);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* see if at least one of them is runnable
|
|
|
|
*/
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
switch (TESTAB(esta, estb)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case ONLYA:
|
|
|
|
return (0);
|
|
|
|
case ONLYB:
|
|
|
|
return (1);
|
|
|
|
case BOTH:
|
|
|
|
/*
|
|
|
|
* tie - favor one with highest recent cpu utilization
|
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
esta = estb = 0;
|
|
|
|
FOREACH_KSEGRP_IN_PROC(p1,kg) {
|
|
|
|
esta += kg->kg_estcpu;
|
|
|
|
}
|
|
|
|
FOREACH_KSEGRP_IN_PROC(p2,kg) {
|
|
|
|
estb += kg->kg_estcpu;
|
|
|
|
}
|
|
|
|
if (estb > esta)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (1);
|
2001-09-12 08:38:13 +00:00
|
|
|
if (esta > estb)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
|
|
|
|
}
|
|
|
|
/*
|
2002-05-25 15:43:06 +00:00
|
|
|
* weed out zombies
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
switch (TESTAB(p1->p_state == PRS_ZOMBIE, p2->p_state == PRS_ZOMBIE)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
case ONLYA:
|
|
|
|
return (1);
|
|
|
|
case ONLYB:
|
|
|
|
return (0);
|
|
|
|
case BOTH:
|
|
|
|
return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
|
|
|
|
}
|
2000-12-02 01:32:51 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
#if 0 /* XXXKSE */
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2001-01-24 11:15:59 +00:00
|
|
|
if (p1->p_sflag & PS_SINTR && (p2->p_sflag & PS_SINTR) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (1);
|
2001-01-24 11:15:59 +00:00
|
|
|
if (p2->p_sflag & PS_SINTR && (p1->p_sflag & PS_SINTR) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
2001-09-12 08:38:13 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
return (p2->p_pid > p1->p_pid); /* tie - return highest pid */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Output char to tty; console putchar style.
|
|
|
|
*/
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
tputchar(int c, struct tty *tp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-25 15:44:38 +00:00
|
|
|
int s;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttysleep(struct tty *tp, void *chan, int pri, char *wmesg, int timo)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
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-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 *
|
2002-05-25 15:52:53 +00:00
|
|
|
ttymalloc(struct tty *tp)
|
1995-02-09 11:13:30 +00:00
|
|
|
{
|
|
|
|
|
1999-08-08 20:24:58 +00:00
|
|
|
if (tp)
|
|
|
|
return(tp);
|
2002-05-25 15:43:06 +00:00
|
|
|
tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO);
|
1999-08-08 20:24:58 +00:00
|
|
|
ttyregister(tp);
|
2002-05-25 15:43:06 +00:00
|
|
|
return (tp);
|
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
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyfree(struct tty *tp)
|
1995-02-09 11:13:30 +00:00
|
|
|
{
|
2002-05-25 15:43:06 +00:00
|
|
|
free(tp, M_TTYS);
|
1995-02-09 11:13:30 +00:00
|
|
|
}
|
1995-02-15 22:25:51 +00:00
|
|
|
#endif /* 0 */
|
1999-08-08 19:47:32 +00:00
|
|
|
|
|
|
|
void
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyregister(struct tty *tp)
|
1999-08-08 19:47:32 +00:00
|
|
|
{
|
2000-05-01 10:51:54 +00:00
|
|
|
tp->t_timeout = -1;
|
1999-08-08 19:47:32 +00:00
|
|
|
SLIST_INSERT_HEAD(&tty_list, tp, t_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_kern_ttys(SYSCTL_HANDLER_ARGS)
|
1999-08-08 19:47:32 +00:00
|
|
|
{
|
2002-05-28 05:40:53 +00:00
|
|
|
struct tty *tp;
|
|
|
|
struct xtty xt;
|
1999-08-08 19:47:32 +00:00
|
|
|
int error;
|
2002-05-28 05:40:53 +00:00
|
|
|
|
1999-08-08 19:47:32 +00:00
|
|
|
SLIST_FOREACH(tp, &tty_list, t_list) {
|
2002-05-28 05:40:53 +00:00
|
|
|
bzero(&xt, sizeof xt);
|
|
|
|
xt.xt_size = sizeof xt;
|
|
|
|
#define XT_COPY(field) xt.xt_##field = tp->t_##field
|
|
|
|
xt.xt_rawcc = tp->t_rawq.c_cc;
|
|
|
|
xt.xt_cancc = tp->t_canq.c_cc;
|
|
|
|
xt.xt_outcc = tp->t_outq.c_cc;
|
|
|
|
XT_COPY(line);
|
2002-05-28 14:29:56 +00:00
|
|
|
if (tp->t_dev)
|
|
|
|
xt.xt_dev = dev2udev(tp->t_dev);
|
2002-05-28 05:40:53 +00:00
|
|
|
XT_COPY(state);
|
|
|
|
XT_COPY(flags);
|
|
|
|
XT_COPY(timeout);
|
2002-05-28 14:29:56 +00:00
|
|
|
if (tp->t_pgrp)
|
|
|
|
xt.xt_pgid = tp->t_pgrp->pg_id;
|
|
|
|
if (tp->t_session)
|
|
|
|
xt.xt_sid = tp->t_session->s_sid;
|
2002-05-28 05:40:53 +00:00
|
|
|
XT_COPY(termios);
|
|
|
|
XT_COPY(winsize);
|
|
|
|
XT_COPY(column);
|
|
|
|
XT_COPY(rocount);
|
|
|
|
XT_COPY(rocol);
|
|
|
|
XT_COPY(ififosize);
|
|
|
|
XT_COPY(ihiwat);
|
|
|
|
XT_COPY(ilowat);
|
|
|
|
XT_COPY(ispeedwat);
|
|
|
|
XT_COPY(ohiwat);
|
|
|
|
XT_COPY(olowat);
|
|
|
|
XT_COPY(ospeedwat);
|
|
|
|
#undef XT_COPY
|
|
|
|
error = SYSCTL_OUT(req, &xt, sizeof xt);
|
1999-08-08 19:47:32 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_kern, OID_AUTO, ttys, CTLTYPE_OPAQUE|CTLFLAG_RD,
|
2002-05-31 16:11:49 +00:00
|
|
|
0, 0, sysctl_kern_ttys, "S,xtty", "All ttys");
|
2001-08-04 18:09:24 +00:00
|
|
|
SYSCTL_LONG(_kern, OID_AUTO, tty_nin, CTLFLAG_RD,
|
|
|
|
&tk_nin, 0, "Total TTY in characters");
|
|
|
|
SYSCTL_LONG(_kern, OID_AUTO, tty_nout, CTLFLAG_RD,
|
|
|
|
&tk_nout, 0, "Total TTY out characters");
|
1999-09-25 18:24:47 +00:00
|
|
|
|
|
|
|
void
|
2002-05-25 15:52:53 +00:00
|
|
|
nottystop(struct tty *tp, int rw)
|
1999-09-25 18:24:47 +00:00
|
|
|
{
|
1999-09-28 11:45:31 +00:00
|
|
|
|
1999-09-25 18:24:47 +00:00
|
|
|
return;
|
|
|
|
}
|
1999-09-28 11:45:31 +00:00
|
|
|
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
ttyread(dev_t dev, struct uio *uio, int flag)
|
1999-09-28 11:45:31 +00:00
|
|
|
{
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
tp = dev->si_tty;
|
|
|
|
if (tp == NULL)
|
|
|
|
return (ENODEV);
|
|
|
|
return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2002-05-25 15:52:53 +00:00
|
|
|
ttywrite(dev_t dev, struct uio *uio, int flag)
|
1999-09-28 11:45:31 +00:00
|
|
|
{
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
tp = dev->si_tty;
|
|
|
|
if (tp == NULL)
|
|
|
|
return (ENODEV);
|
|
|
|
return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
|
|
|
|
}
|