libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/components/lwp/terminal/freebsd/tty.c

1448 lines
39 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-11-13 Shell init ver.
*/
#include "../bsd_porting.h"
#include "../tty_config.h"
#include "../terminal.h"
#include "../tty_internal.h"
#include <rtdef.h>
#include <sys/ioctl.h>
/*-
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2008 Ed Schouten <ed@FreeBSD.org>
* All rights reserved.
*
* Portions of this software were developed under sponsorship from Snow
* B.V., the Netherlands.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
*/
static void tty_rel_free(struct lwp_tty *tp);
/* Character device of /dev/console. */
static struct rt_device *dev_console;
#ifdef USING_BSD_CONSOLE_NAME
static const char *dev_console_filename;
#endif
/*
* Flags that are supported and stored by this implementation.
*/
#ifndef ALTWERASE
#define ALTWERASE 0
#endif
#ifndef NOKERNINFO
#define NOKERNINFO 0
#endif
#define TTYSUP_IFLAG \
(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | \
ICRNL | IXON | IXOFF | IXANY | IMAXBEL | IUTF8)
#define TTYSUP_OFLAG (OPOST | ONLCR | TAB3 | ONOEOT | OCRNL | ONOCR | ONLRET)
#define TTYSUP_LFLAG \
(ECHOKE | ECHOE | ECHOK | ECHO | ECHONL | ECHOPRT | ECHOCTL | ISIG | \
ICANON | ALTWERASE | IEXTEN | TOSTOP | FLUSHO | NOKERNINFO | NOFLSH)
#define TTYSUP_CFLAG \
(CIGNORE | CSIZE | CSTOPB | CREAD | PARENB | PARODD | HUPCL | CLOCAL | \
CCTS_OFLOW | CRTS_IFLOW | CDTR_IFLOW | CDSR_OFLOW | CCAR_OFLOW | \
CNO_RTSDTR)
/*
* Set TTY buffer sizes.
*/
#define TTYBUF_MAX 65536
#ifdef PRINTF_BUFR_SIZE
#define TTY_PRBUF_SIZE PRINTF_BUFR_SIZE
#else
#define TTY_PRBUF_SIZE 256
#endif
/* Note: access to struct cdev:si_drv0.
Since pull-in, pull-out is not provided, this field
is constant value 0 in smart system */
#define dev2unit(d) (0)
#define TTY_CALLOUT(tp, d) (dev2unit(d) & TTYUNIT_CALLOUT)
/*
* Allocate buffer space if necessary, and set low watermarks, based on speed.
* Note that the ttyxxxq_setsize() functions may drop and then reacquire the tty
* lock during memory allocation. They will return ENXIO if the tty disappears
* while unlocked.
*/
static int tty_watermarks(struct lwp_tty *tp)
{
size_t bs = 0;
int error;
/* Provide an input buffer for 2 seconds of data. */
if (tp->t_termios.c_cflag & CREAD)
bs =
MIN(bsd_speed_to_integer(tp->t_termios.__c_ispeed) / 5, TTYBUF_MAX);
error = ttyinq_setsize(&tp->t_inq, tp, bs);
if (error != 0)
return error;
/* Set low watermark at 10% (when 90% is available). */
tp->t_inlow = (ttyinq_getallocatedsize(&tp->t_inq) * 9) / 10;
/* Provide an output buffer for 2 seconds of data. */
bs = MIN(bsd_speed_to_integer(tp->t_termios.__c_ospeed) / 5, TTYBUF_MAX);
error = ttyoutq_setsize(&tp->t_outq, tp, bs);
if (error != 0)
return error;
/* Set low watermark at 10% (when 90% is available). */
tp->t_outlow = (ttyoutq_getallocatedsize(&tp->t_outq) * 9) / 10;
return 0;
}
/**
* Drain outq
*/
static int tty_drain(struct lwp_tty *tp, int leaving)
{
rt_tick_t timeout_tick;
size_t bytes;
int error;
#ifdef USING_BSD_HOOK
if (ttyhook_hashook(tp, getc_inject))
/* buffer is inaccessible */
return 0;
#endif /* USING_BSD_HOOK */
/*
* For close(), use the recent historic timeout of "1 second without
* making progress". For tcdrain(), use t_drainwait as the timeout,
* with zero meaning "no timeout" which gives POSIX behavior.
*/
if (leaving)
timeout_tick = rt_tick_get() + RT_TICK_PER_SECOND;
else if (tp->t_drainwait != 0)
timeout_tick = rt_tick_get() + RT_TICK_PER_SECOND * tp->t_drainwait;
else
timeout_tick = 0;
/*
* Poll the output buffer and the hardware for completion, at 10 Hz.
* Polling is required for devices which are not able to signal an
* interrupt when the transmitter becomes idle (most USB serial devs).
* The unusual structure of this loop ensures we check for busy one more
* time after tty_timedwait() returns EWOULDBLOCK, so that success has
* higher priority than timeout if the IO completed in the last 100mS.
*/
error = 0;
bytes = ttyoutq_bytesused(&tp->t_outq);
for (;;)
{
if (ttyoutq_bytesused(&tp->t_outq) == 0 && !ttydevsw_busy(tp))
return 0;
if (error != 0)
return error;
ttydevsw_outwakeup(tp);
error = tty_timedwait(tp, &tp->t_outwait, RT_TICK_PER_SECOND / 10);
if (error != 0 && error != EWOULDBLOCK)
return error;
else if (timeout_tick == 0 || rt_tick_get() < timeout_tick)
error = 0;
else if (leaving && ttyoutq_bytesused(&tp->t_outq) < bytes)
{
/* In close, making progress, grant an extra second. */
error = 0;
timeout_tick += RT_TICK_PER_SECOND;
bytes = ttyoutq_bytesused(&tp->t_outq);
}
}
}
/*
* Though ttydev_enter() and ttydev_leave() seem to be related, they
* don't have to be used together. ttydev_enter() is used by the cdev
* operations to prevent an actual operation from being processed when
* the TTY has been abandoned. ttydev_leave() is used by ttydev_open()
* and ttydev_close() to determine whether per-TTY data should be
* deallocated.
*/
rt_inline int ttydev_enter(struct lwp_tty *tp)
{
rt_err_t error = tty_lock(tp);
if (error)
RT_ASSERT(0);
if (tty_gone(tp) || !tty_opened(tp))
{
/* Device is already gone. */
tty_unlock(tp);
return -ENXIO;
}
return 0;
}
static void ttydev_leave(struct lwp_tty *tp)
{
tty_assert_locked(tp);
if (tty_opened(tp) || tp->t_flags & TF_OPENCLOSE)
{
/* Device is still opened somewhere. */
tty_unlock(tp);
return;
}
tp->t_flags |= TF_OPENCLOSE;
/* Remove console TTY. */
constty_clear(tp);
/* Drain any output. */
if (!tty_gone(tp))
tty_drain(tp, 1);
ttydisc_close(tp);
/* Free i/o queues now since they might be large. */
ttyinq_free(&tp->t_inq);
tp->t_inlow = 0;
ttyoutq_free(&tp->t_outq);
tp->t_outlow = 0;
#ifdef USING_BSD_KNOTE
knlist_clear(&tp->t_inpoll.si_note, 1);
knlist_clear(&tp->t_outpoll.si_note, 1);
#endif
if (!tty_gone(tp))
ttydevsw_close(tp);
tp->t_flags &= ~TF_OPENCLOSE;
cv_broadcast(&tp->t_dcdwait);
tty_rel_free(tp);
}
/*
* Operations that are exposed through the character device in /dev.
*/
static int ttydev_open(struct lwp_tty *tp, int oflags, int devtype,
struct rt_thread *td)
{
rt_device_t dev = &tp->parent;
int error;
error = 0;
tty_lock(tp);
if (tty_gone(tp))
{
/* Device is already gone. */
tty_unlock(tp);
return -ENXIO;
}
/*
* Block when other processes are currently opening or closing
* the TTY.
*/
while (tp->t_flags & TF_OPENCLOSE)
{
error = tty_wait(tp, &tp->t_dcdwait);
if (error != 0)
{
tty_unlock(tp);
return error;
}
}
tp->t_flags |= TF_OPENCLOSE;
/*
* Make sure the "tty" and "cua" device cannot be opened at the
* same time. The console is a "tty" device.
*/
if (TTY_CALLOUT(tp, dev))
{
if (tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN))
{
error = EBUSY;
goto done;
}
}
else
{
if (tp->t_flags & TF_OPENED_OUT)
{
error = EBUSY;
goto done;
}
}
if (tp->t_flags & TF_EXCLUDE && priv_check(td, PRIV_TTY_EXCLUSIVE))
{
error = EBUSY;
goto done;
}
if (!tty_opened(tp))
{
/* Set proper termios flags. */
if (TTY_CALLOUT(tp, dev))
#ifdef USING_BSD_INIT_LOCK_DEVICE
tp->t_termios = tp->t_termios_init_out;
#else
;
#endif /* USING_BSD_INIT_LOCK_DEVICE */
else
tp->t_termios = tp->t_termios_init_in;
ttydevsw_param(tp, &tp->t_termios);
/* Prevent modem control on callout devices and /dev/console. */
if (TTY_CALLOUT(tp, dev) || dev == dev_console)
tp->t_termios.c_cflag |= CLOCAL;
if ((tp->t_termios.c_cflag & CNO_RTSDTR) == 0)
ttydevsw_modem(tp, SER_DTR | SER_RTS, 0);
error = ttydevsw_open(tp);
if (error != 0)
goto done;
ttydisc_open(tp);
error = tty_watermarks(tp);
if (error != 0)
goto done;
}
/* Wait for Carrier Detect. */
if ((oflags & O_NONBLOCK) == 0 && (tp->t_termios.c_cflag & CLOCAL) == 0)
{
while ((ttydevsw_modem(tp, 0, 0) & SER_DCD) == 0)
{
error = tty_wait(tp, &tp->t_dcdwait);
if (error != 0)
goto done;
}
}
if (dev == dev_console)
tp->t_flags |= TF_OPENED_CONS;
else if (TTY_CALLOUT(tp, dev))
tp->t_flags |= TF_OPENED_OUT;
else
tp->t_flags |= TF_OPENED_IN;
MPASS((tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN)) == 0 ||
(tp->t_flags & TF_OPENED_OUT) == 0);
done:
tp->t_flags &= ~TF_OPENCLOSE;
cv_broadcast(&tp->t_dcdwait);
ttydev_leave(tp);
return error;
}
static int ttydev_close(struct lwp_tty *tp, int fflag, int devtype __unused,
struct rt_thread *td __unused)
{
rt_device_t dev = &tp->parent;
tty_lock(tp);
/*
* Don't actually close the device if it is being used as the
* console.
*/
MPASS((tp->t_flags & (TF_OPENED_CONS | TF_OPENED_IN)) == 0 ||
(tp->t_flags & TF_OPENED_OUT) == 0);
if (dev == dev_console)
tp->t_flags &= ~TF_OPENED_CONS;
else
tp->t_flags &= ~(TF_OPENED_IN | TF_OPENED_OUT);
if (tp->t_flags & TF_OPENED)
{
tty_unlock(tp);
return 0;
}
/* If revoking, flush output now to avoid draining it later. */
if (fflag & FREVOKE)
tty_flush(tp, FWRITE);
tp->t_flags &= ~TF_EXCLUDE;
/* Properly wake up threads that are stuck - revoke(). */
tp->t_revokecnt++;
tty_wakeup(tp, FREAD | FWRITE);
cv_broadcast(&tp->t_bgwait);
cv_broadcast(&tp->t_dcdwait);
ttydev_leave(tp);
return 0;
}
int tty_wait_background(struct lwp_tty *tp, struct rt_thread *td, int sig)
{
struct rt_lwp *p;
struct rt_processgroup *pg;
int error;
MPASS(sig == SIGTTIN || sig == SIGTTOU);
tty_assert_locked(tp);
p = td->lwp;
for (;;)
{
pg = p->pgrp;
PGRP_LOCK(pg);
LWP_LOCK(p);
/*
* pg may no longer be our process group.
* Re-check after locking.
*/
if (p->pgrp != pg)
{
LWP_UNLOCK(p);
PGRP_UNLOCK(pg);
continue;
}
/*
* The process should only sleep, when:
* - This terminal is the controlling terminal
* - Its process group is not the foreground process
* group
* - The parent process isn't waiting for the child to
* exit
* - the signal to send to the process isn't masked
*/
if (!tty_is_ctty(tp, p) || pg == tp->t_pgrp)
{
/* Allow the action to happen. */
LWP_UNLOCK(p);
PGRP_UNLOCK(pg);
return 0;
}
/* Note: process itself don't have a sigmask in smart */
if (lwp_sigisign(p, sig) ||
lwp_sigismember(&td->signal.sigset_mask, sig))
{
/* Only allow them in write()/ioctl(). */
LWP_UNLOCK(p);
PGRP_UNLOCK(pg);
return (sig == SIGTTOU ? 0 : -EIO);
}
#ifdef USING_VFORK_FLAG
if ((p->p_flag & P_PPWAIT) != 0 || pg->is_orphaned)
#else
if (pg->is_orphaned)
#endif
{
/* Don't allow the action to happen. */
LWP_UNLOCK(p);
PGRP_UNLOCK(pg);
return -EIO;
}
LWP_UNLOCK(p);
/*
* Send the signal and sleep until we're the new
* foreground process group.
*/
if (sig != 0)
{
lwp_pgrp_signal_kill(pg, sig, SI_KERNEL, 0);
}
PGRP_UNLOCK(pg);
error = tty_wait(tp, &tp->t_bgwait);
if (error)
return error;
}
}
static int ttydev_read(struct lwp_tty *tp, struct uio *uio, int ioflag)
{
int error;
error = ttydev_enter(tp);
if (error)
goto done;
error = ttydisc_read(tp, uio, ioflag);
tty_unlock(tp);
/*
* The read() call should not throw an error when the device is
* being destroyed. Silently convert it to an EOF.
*/
done:
if (error == -ENXIO)
error = 0;
return error;
}
static int ttydev_write(struct lwp_tty *tp, struct uio *uio, int ioflag)
{
#ifdef USING_BSD_DEFER_STOP
int defer;
#endif
int error;
error = ttydev_enter(tp);
if (error)
return error;
if (tp->t_termios.c_lflag & TOSTOP)
{
error = tty_wait_background(tp, curthread, SIGTTOU);
if (error)
goto done;
}
if (ioflag & IO_NDELAY && tp->t_flags & TF_BUSY_OUT)
{
/* Allow non-blocking writes to bypass serialization. */
error = ttydisc_write(tp, uio, ioflag);
}
else
{
/* Serialize write() calls. */
while (tp->t_flags & TF_BUSY_OUT)
{
error = tty_wait(tp, &tp->t_outserwait);
if (error)
goto done;
}
tp->t_flags |= TF_BUSY_OUT;
#ifdef USING_BSD_DEFER_STOP
defer = sigdeferstop(SIGDEFERSTOP_ERESTART);
#endif
error = ttydisc_write(tp, uio, ioflag);
#ifdef USING_BSD_DEFER_STOP
sigallowstop(defer);
#endif
tp->t_flags &= ~TF_BUSY_OUT;
cv_signal(&tp->t_outserwait);
}
done:
tty_unlock(tp);
return error;
}
static int ttydev_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, rt_caddr_t data, int fflag,
struct rt_thread *td)
{
int error;
error = ttydev_enter(tp);
if (error)
return (error);
switch (cmd)
{
case TIOCCBRK:
case TIOCCONS:
case TIOCDRAIN:
case TIOCEXCL:
case TIOCFLUSH:
case TIOCNXCL:
case TIOCSBRK:
case TIOCSCTTY:
case TIOCSETA:
case TIOCSETAF:
case TIOCSETAW:
case TIOCSPGRP:
case TIOCSTART:
case TIOCSTAT:
case TIOCSTI:
case TIOCSTOP:
case TIOCSWINSZ:
#if USING_BSD_TIOCSDRAINWAIT
case TIOCSDRAINWAIT:
case TIOCSETD:
#endif /* USING_BSD_TIOCSDRAINWAIT */
#ifdef COMPAT_43TTY
case TIOCLBIC:
case TIOCLBIS:
case TIOCLSET:
case TIOCSETC:
case OTIOCSETD:
case TIOCSETN:
case TIOCSETP:
case TIOCSLTC:
#endif /* COMPAT_43TTY */
/*
* If the ioctl() causes the TTY to be modified, let it
* wait in the background.
*/
error = tty_wait_background(tp, curthread, SIGTTOU);
if (error)
goto done;
}
#ifdef USING_BSD_INIT_LOCK_DEVICE
if (cmd == TIOCSETA || cmd == TIOCSETAW || cmd == TIOCSETAF)
{
struct termios *old = &tp->t_termios;
struct termios *new = (struct termios *)data;
struct termios *lock = TTY_CALLOUT(tp, dev) ? &tp->t_termios_lock_out
: &tp->t_termios_lock_in;
int cc;
/*
* Lock state devices. Just overwrite the values of the
* commands that are currently in use.
*/
new->c_iflag =
(old->c_iflag & lock->c_iflag) | (new->c_iflag & ~lock->c_iflag);
new->c_oflag =
(old->c_oflag & lock->c_oflag) | (new->c_oflag & ~lock->c_oflag);
new->c_cflag =
(old->c_cflag & lock->c_cflag) | (new->c_cflag & ~lock->c_cflag);
new->c_lflag =
(old->c_lflag & lock->c_lflag) | (new->c_lflag & ~lock->c_lflag);
for (cc = 0; cc < NCCS; ++cc)
if (lock->c_cc[cc])
new->c_cc[cc] = old->c_cc[cc];
if (lock->__c_ispeed)
new->__c_ispeed = old->__c_ispeed;
if (lock->__c_ospeed)
new->__c_ospeed = old->__c_ospeed;
}
#endif /* USING_BSD_INIT_LOCK_DEVICE */
error = tty_ioctl(tp, cmd, data, fflag, td);
done:
tty_unlock(tp);
return (error);
}
static int ttydev_poll(struct lwp_tty *tp, rt_pollreq_t *req, struct rt_thread *td)
{
int events = req->_key;
int error, revents = 0;
error = ttydev_enter(tp);
if (error)
return ((events & (POLLIN | POLLRDNORM)) | POLLHUP);
if (events & (POLLIN | POLLRDNORM))
{
/* See if we can read something. */
if (ttydisc_read_poll(tp) > 0)
revents |= events & (POLLIN | POLLRDNORM);
}
if (tp->t_flags & TF_ZOMBIE)
{
/* Hangup flag on zombie state. */
revents |= POLLHUP;
}
else if (events & (POLLOUT | POLLWRNORM))
{
/* See if we can write something. */
if (ttydisc_write_poll(tp) > 0)
revents |= events & (POLLOUT | POLLWRNORM);
}
if (revents == 0)
{
if (events & (POLLIN | POLLRDNORM))
rt_poll_add(&tp->t_inpoll, req);
if (events & (POLLOUT | POLLWRNORM))
rt_poll_add(&tp->t_outpoll, req);
}
tty_unlock(tp);
return revents;
}
static struct cdevsw ttydev_cdevsw = {
.d_open = ttydev_open,
.d_close = ttydev_close,
.d_read = ttydev_read,
.d_write = ttydev_write,
.d_ioctl = ttydev_ioctl,
#if 0
.d_kqfilter = ttydev_kqfilter,
#endif
.d_poll = ttydev_poll,
#if 0
.d_mmap = ttydev_mmap,
#endif
#ifdef USING_BSD_RAW_CDEVSW
.d_version = D_VERSION.d_name = "ttydev",
.d_flags = D_TTY,
#endif /* USING_BSD_RAW_CDEVSW */
};
extern struct cdevsw bsd_ttydev_methods __attribute__((alias("ttydev_cdevsw")));
/*
* Standard device routine implementations, mostly meant for
* pseudo-terminal device drivers. When a driver creates a new terminal
* device class, missing routines are patched.
*/
#define panic(msg) RT_ASSERT(0 && msg)
static int ttydevsw_defopen(struct lwp_tty *tp __unused)
{
return 0;
}
static void ttydevsw_defclose(struct lwp_tty *tp __unused)
{
}
static void ttydevsw_defoutwakeup(struct lwp_tty *tp __unused)
{
panic("Terminal device has output, while not implemented");
}
static void ttydevsw_definwakeup(struct lwp_tty *tp __unused)
{
}
static int ttydevsw_defioctl(struct lwp_tty *tp __unused, rt_ubase_t cmd __unused,
rt_caddr_t data __unused,
struct rt_thread *td __unused)
{
return -ENOSYS;
}
static int ttydevsw_defcioctl(struct lwp_tty *tp __unused, int unit __unused,
rt_ubase_t cmd __unused, rt_caddr_t data __unused,
struct rt_thread *td __unused)
{
return -ENOSYS;
}
static int ttydevsw_defparam(struct lwp_tty *tp __unused, struct termios *t)
{
/*
* Allow the baud rate to be adjusted for pseudo-devices, but at
* least restrict it to 115200 to prevent excessive buffer
* usage. Also disallow 0, to prevent foot shooting.
*/
if (t->__c_ispeed < B50)
t->__c_ispeed = B50;
else if (t->__c_ispeed > B115200)
t->__c_ispeed = B115200;
if (t->__c_ospeed < B50)
t->__c_ospeed = B50;
else if (t->__c_ospeed > B115200)
t->__c_ospeed = B115200;
t->c_cflag |= CREAD;
return 0;
}
static int ttydevsw_defmodem(struct lwp_tty *tp __unused, int sigon __unused,
int sigoff __unused)
{
/* Simulate a carrier to make the TTY layer happy. */
return (SER_DCD);
}
static int ttydevsw_defmmap(struct lwp_tty *tp __unused,
vm_ooffset_t offset __unused,
vm_paddr_t *paddr __unused, int nprot __unused,
vm_memattr_t *memattr __unused)
{
return (-1);
}
static void ttydevsw_defpktnotify(struct lwp_tty *tp __unused,
char event __unused)
{
}
static void ttydevsw_deffree(void *softc __unused)
{
panic("Terminal device freed without a free-handler");
}
static rt_bool_t ttydevsw_defbusy(struct lwp_tty *tp __unused)
{
return (RT_FALSE);
}
void bsd_devsw_init(struct lwp_ttydevsw *tsw)
{
/* Make sure the driver defines all routines. */
#define PATCH_FUNC(x) \
do \
{ \
if (tsw->tsw_##x == NULL) \
tsw->tsw_##x = ttydevsw_def##x; \
} while (0)
PATCH_FUNC(open);
PATCH_FUNC(close);
PATCH_FUNC(outwakeup);
PATCH_FUNC(inwakeup);
PATCH_FUNC(ioctl);
PATCH_FUNC(cioctl);
PATCH_FUNC(param);
PATCH_FUNC(modem);
PATCH_FUNC(mmap);
PATCH_FUNC(pktnotify);
PATCH_FUNC(free);
PATCH_FUNC(busy);
#undef PATCH_FUNC
}
/* release tty, and free the cdev resource */
static void tty_rel_free(struct lwp_tty *tp)
{
#ifdef USING_BSD_CHAR_DEVICE
struct cdev *dev;
#endif
tty_assert_locked(tp);
#define TF_ACTIVITY (TF_GONE | TF_OPENED | TF_HOOK | TF_OPENCLOSE)
if (tp->t_sessioncnt != 0 || (tp->t_flags & TF_ACTIVITY) != TF_GONE)
{
/* TTY is still in use. */
tty_unlock(tp);
return;
}
#ifdef USING_BSD_AIO
/* Stop asynchronous I/O. */
funsetown(&tp->t_sigio);
#endif /* USING_BSD_AIO */
#ifdef USING_BSD_CHAR_DEVICE
/* TTY can be deallocated. */
dev = tp->t_dev;
tp->t_dev = NULL;
#endif /* USING_BSD_CHAR_DEVICE */
tty_unlock(tp);
#ifdef USING_BSD_CHAR_DEVICE
if (dev != NULL)
{
sx_xlock(&tty_list_sx);
TAILQ_REMOVE(&tty_list, tp, t_list);
tty_list_count--;
sx_xunlock(&tty_list_sx);
destroy_dev_sched_cb(dev, tty_dealloc, tp);
}
#else
lwp_tty_delete(tp);
#endif
}
void tty_rel_pgrp(struct lwp_tty *tp, struct rt_processgroup *pg)
{
MPASS(tp->t_sessioncnt > 0);
tty_assert_locked(tp);
if (tp->t_pgrp == pg)
tp->t_pgrp = NULL;
tty_unlock(tp);
}
void tty_rel_sess(struct lwp_tty *tp, struct rt_session *sess)
{
MPASS(tp->t_sessioncnt > 0);
/* Current session has left. */
if (tp->t_session == sess)
{
tp->t_session = NULL;
MPASS(tp->t_pgrp == NULL);
}
tp->t_sessioncnt--;
tty_rel_free(tp);
}
/* deallocate the tty */
void tty_rel_gone(struct lwp_tty *tp)
{
tty_assert_locked(tp);
MPASS(!tty_gone(tp));
/* Simulate carrier removal. */
ttydisc_modem(tp, 0);
/* Wake up all blocked threads. */
tty_wakeup(tp, FREAD | FWRITE);
cv_broadcast(&tp->t_bgwait);
cv_broadcast(&tp->t_dcdwait);
tp->t_flags |= TF_GONE;
tty_rel_free(tp);
}
static int tty_drop_ctty(struct lwp_tty *tp, struct rt_lwp *p)
{
struct rt_session *session;
#ifdef USING_BSD_VNODE
struct vnode *vp;
#endif
/*
* This looks terrible, but it's generally safe as long as the tty
* hasn't gone away while we had the lock dropped. All of our sanity
* checking that this operation is OK happens after we've picked it back
* up, so other state changes are generally not fatal and the potential
* for this particular operation to happen out-of-order in a
* multithreaded scenario is likely a non-issue.
*/
tty_unlock(tp);
LWP_LOCK(p);
tty_lock(tp);
if (tty_gone(tp))
{
LWP_UNLOCK(p);
return -ENODEV;
}
/*
* If the session doesn't have a controlling TTY, or if we weren't
* invoked on the controlling TTY, we'll return ENOIOCTL as we've
* historically done.
*/
session = p->pgrp->session;
if (session->ctty == NULL || session->ctty != tp)
{
LWP_UNLOCK(p);
return -ENOTTY;
}
if (!is_sess_leader(p))
{
LWP_UNLOCK(p);
return -EPERM;
}
SESS_LOCK(session);
#ifdef USING_BSD_VNODE
vp = session->s_ttyvp;
#endif
session->ctty = NULL;
#ifdef USING_BSD_VNODE
session->s_ttyvp = NULL;
session->s_ttydp = NULL;
#endif
SESS_UNLOCK(session);
tp->t_sessioncnt--;
p->term_ctrlterm = RT_FALSE;
LWP_UNLOCK(p);
#ifdef USING_BSD_VNODE
/*
* If we did have a vnode, release our reference. Ordinarily we manage
* these at the devfs layer, but we can't necessarily know that we were
* invoked on the vnode referenced in the session (i.e. the vnode we
* hold a reference to). We explicitly don't check VBAD/VIRF_DOOMED here
* to avoid a vnode leak -- in circumstances elsewhere where we'd hit a
* VIRF_DOOMED vnode, release has been deferred until the controlling TTY
* is either changed or released.
*/
if (vp != NULL)
devfs_ctty_unref(vp);
#endif
return 0;
}
void tty_wakeup(struct lwp_tty *tp, int flags)
{
#ifdef USING_BSD_AIO
if (tp->t_flags & TF_ASYNC && tp->t_sigio != NULL)
pgsigio(&tp->t_sigio, SIGIO, (tp->t_session != NULL));
#endif
if (flags & FWRITE)
{
cv_broadcast(&tp->t_outwait);
#ifdef USING_BSD_POLL
selwakeup(&tp->t_outpoll);
KNOTE_LOCKED(&tp->t_outpoll.si_note, 0);
#else
rt_wqueue_wakeup_all(&tp->t_outpoll, (void *)POLLOUT);
#endif
}
if (flags & FREAD)
{
cv_broadcast(&tp->t_inwait);
#ifdef USING_BSD_POLL
selwakeup(&tp->t_inpoll);
KNOTE_LOCKED(&tp->t_inpoll.si_note, 0);
#else
rt_wqueue_wakeup_all(&tp->t_inpoll, (void *)POLLIN);
#endif
}
}
int tty_wait(struct lwp_tty *tp, struct rt_condvar *cv)
{
int error;
int revokecnt = tp->t_revokecnt;
tty_lock_assert(tp, MA_OWNED | MA_NOTRECURSED);
MPASS(!tty_gone(tp));
error = cv_wait_sig(cv, tp->t_mtx);
/* Bail out when the device slipped away. */
if (tty_gone(tp))
return -ENXIO;
/* Restart the system call when we may have been revoked. */
if (tp->t_revokecnt != revokecnt)
return -ERESTART;
return error;
}
int tty_timedwait(struct lwp_tty *tp, struct rt_condvar *cv, rt_tick_t timeout)
{
int error;
int revokecnt = tp->t_revokecnt;
tty_lock_assert(tp, MA_OWNED | MA_NOTRECURSED);
MPASS(!tty_gone(tp));
error = cv_timedwait_sig(cv, tp->t_mtx, timeout);
/* Bail out when the device slipped away. */
if (tty_gone(tp))
return -ENXIO;
/* Restart the system call when we may have been revoked. */
if (tp->t_revokecnt != revokecnt)
return -ERESTART;
return error;
}
/* discard data in I/O buffers */
void tty_flush(struct lwp_tty *tp, int flags)
{
if (flags & FWRITE)
{
tp->t_flags &= ~TF_HIWAT_OUT;
ttyoutq_flush(&tp->t_outq);
tty_wakeup(tp, FWRITE);
if (!tty_gone(tp))
{
ttydevsw_outwakeup(tp);
ttydevsw_pktnotify(tp, TIOCPKT_FLUSHWRITE);
}
}
if (flags & FREAD)
{
tty_hiwat_in_unblock(tp);
ttyinq_flush(&tp->t_inq);
tty_wakeup(tp, FREAD);
if (!tty_gone(tp))
{
ttydevsw_inwakeup(tp);
ttydevsw_pktnotify(tp, TIOCPKT_FLUSHREAD);
}
}
}
void tty_set_winsize(struct lwp_tty *tp, const struct winsize *wsz)
{
if (memcmp(&tp->t_winsize, wsz, sizeof(*wsz)) == 0)
return;
tp->t_winsize = *wsz;
lwp_tty_signal_pgrp(tp, SIGWINCH);
}
static int tty_generic_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, void *data,
int fflag, struct rt_thread *td)
{
int error;
switch (cmd)
{
/*
* Modem commands.
* The SER_* and TIOCM_* flags are the same, but one bit
* shifted. I don't know why.
*/
case TIOCSDTR:
ttydevsw_modem(tp, SER_DTR, 0);
return 0;
case TIOCCDTR:
ttydevsw_modem(tp, 0, SER_DTR);
return 0;
case TIOCMSET: {
int bits = *(int *)data;
ttydevsw_modem(tp, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1,
((~bits) & (TIOCM_DTR | TIOCM_RTS)) >> 1);
return 0;
}
case TIOCMBIS: {
int bits = *(int *)data;
ttydevsw_modem(tp, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1, 0);
return 0;
}
case TIOCMBIC: {
int bits = *(int *)data;
ttydevsw_modem(tp, 0, (bits & (TIOCM_DTR | TIOCM_RTS)) >> 1);
return 0;
}
case TIOCMGET:
*(int *)data = TIOCM_LE + (ttydevsw_modem(tp, 0, 0) << 1);
return 0;
case FIOASYNC:
if (*(int *)data)
tp->t_flags |= TF_ASYNC;
else
tp->t_flags &= ~TF_ASYNC;
return 0;
case FIONBIO:
/* This device supports non-blocking operation. */
return 0;
case FIONREAD:
*(int *)data = ttyinq_bytescanonicalized(&tp->t_inq);
return 0;
case FIONWRITE:
case TIOCOUTQ:
*(int *)data = ttyoutq_bytesused(&tp->t_outq);
return 0;
#if BSD_USING_FIO_OWNERSHIP
case FIOSETOWN:
if (tp->t_session != NULL && !tty_is_ctty(tp, td->lwp))
/* Not allowed to set ownership. */
return -ENOTTY;
/* Temporarily unlock the TTY to set ownership. */
tty_unlock(tp);
error = fsetown(*(int *)data, &tp->t_sigio);
tty_lock(tp);
return (error);
case FIOGETOWN:
if (tp->t_session != NULL && !tty_is_ctty(tp, td->lwp))
/* Not allowed to set ownership. */
return -ENOTTY;
/* Get ownership. */
*(int *)data = fgetown(&tp->t_sigio);
return 0;
#endif
case TIOCGETA:
/* Obtain terminal flags through tcgetattr(). */
*(struct termios *)data = tp->t_termios;
return 0;
case TIOCSETA:
case TIOCSETAW:
case TIOCSETAF: {
struct termios *t = data;
/*
* Who makes up these funny rules? According to POSIX,
* input baud rate is set equal to the output baud rate
* when zero.
*/
if (t->__c_ispeed == 0)
t->__c_ispeed = t->__c_ospeed;
/* Discard any unsupported bits. */
t->c_iflag &= TTYSUP_IFLAG;
t->c_oflag &= TTYSUP_OFLAG;
t->c_lflag &= TTYSUP_LFLAG;
t->c_cflag &= TTYSUP_CFLAG;
/* Set terminal flags through tcsetattr(). */
if (cmd == TIOCSETAW || cmd == TIOCSETAF)
{
error = tty_drain(tp, 0);
if (error)
return (error);
if (cmd == TIOCSETAF)
tty_flush(tp, FREAD);
}
/*
* Only call param() when the flags really change.
*/
if ((t->c_cflag & CIGNORE) == 0 &&
(tp->t_termios.c_cflag != t->c_cflag ||
((tp->t_termios.c_iflag ^ t->c_iflag) &
(IXON | IXOFF | IXANY)) ||
tp->t_termios.__c_ispeed != t->__c_ispeed ||
tp->t_termios.__c_ospeed != t->__c_ospeed))
{
error = ttydevsw_param(tp, t);
if (error)
return (error);
/* XXX: CLOCAL? */
tp->t_termios.c_cflag = t->c_cflag & ~CIGNORE;
tp->t_termios.__c_ispeed = t->__c_ispeed;
tp->t_termios.__c_ospeed = t->__c_ospeed;
/* Baud rate has changed - update watermarks. */
error = tty_watermarks(tp);
if (error)
return (error);
}
/* Copy new non-device driver parameters. */
tp->t_termios.c_iflag = t->c_iflag;
tp->t_termios.c_oflag = t->c_oflag;
tp->t_termios.c_lflag = t->c_lflag;
memcpy(&tp->t_termios.c_cc, t->c_cc, sizeof t->c_cc);
ttydisc_optimize(tp);
if ((t->c_lflag & ICANON) == 0)
{
/*
* When in non-canonical mode, wake up all
* readers. Canonicalize any partial input. VMIN
* and VTIME could also be adjusted.
*/
ttyinq_canonicalize(&tp->t_inq);
tty_wakeup(tp, FREAD);
}
/**
* For packet mode: notify the PTY consumer that VSTOP
* and VSTART may have been changed.
*
* TODO: change the _CONTROL('S') to a CSTOP?
*/
if (tp->t_termios.c_iflag & IXON &&
tp->t_termios.c_cc[VSTOP] == _CONTROL('S') &&
tp->t_termios.c_cc[VSTART] == _CONTROL('Q'))
ttydevsw_pktnotify(tp, TIOCPKT_DOSTOP);
else
ttydevsw_pktnotify(tp, TIOCPKT_NOSTOP);
return 0;
}
case TIOCGETD:
/* For compatibility - we only support TTYDISC. */
*(int *)data = TTYDISC;
return 0;
case TIOCGPGRP:
if (!tty_is_ctty(tp, td->lwp))
return -ENOTTY;
if (tp->t_pgrp != NULL)
*(int *)data = tp->t_pgrp->pgid;
else
*(int *)data = NO_PID;
return 0;
case TIOCGSID:
if (!tty_is_ctty(tp, td->lwp))
return -ENOTTY;
MPASS(tp->t_session);
*(int *)data = tp->t_session->sid;
return 0;
case TIOCNOTTY:
return tty_drop_ctty(tp, td->lwp);
case TIOCSCTTY:
return lwp_tty_set_ctrl_proc(tp, td);
case TIOCSPGRP: {
int pgid;
if (lwp_in_user_space((void *)data))
{
if (lwp_get_from_user(&pgid, data, sizeof(int)) != sizeof(int))
return -EFAULT;
}
else
{
pgid = *(int *)data;
}
return lwp_tty_assign_foreground(tp, td, pgid);
}
case TIOCFLUSH: {
int flags = *(int *)data;
if (flags == 0)
flags = (FREAD | FWRITE);
else
flags &= (FREAD | FWRITE);
tty_flush(tp, flags);
return 0;
}
case TIOCDRAIN:
/* Drain TTY output. */
return tty_drain(tp, 0);
case TIOCGDRAINWAIT:
*(int *)data = tp->t_drainwait;
return 0;
case TIOCSDRAINWAIT:
error = priv_check(td, PRIV_TTY_DRAINWAIT);
if (error == 0)
tp->t_drainwait = *(int *)data;
return (error);
case TIOCCONS:
/* Set terminal as console TTY. */
if (*(int *)data)
{
error = priv_check(td, PRIV_TTY_CONSOLE);
if (error)
return (error);
error = constty_set(tp);
}
else
{
error = constty_clear(tp);
}
return (error);
case TIOCGWINSZ:
/* Obtain window size. */
*(struct winsize *)data = tp->t_winsize;
return 0;
case TIOCSWINSZ:
/* Set window size. */
tty_set_winsize(tp, data);
return 0;
case TIOCEXCL:
tp->t_flags |= TF_EXCLUDE;
return 0;
case TIOCNXCL:
tp->t_flags &= ~TF_EXCLUDE;
return 0;
case TIOCSTOP:
tp->t_flags |= TF_STOPPED;
ttydevsw_pktnotify(tp, TIOCPKT_STOP);
return 0;
case TIOCSTART:
tp->t_flags &= ~TF_STOPPED;
tp->t_termios.c_lflag &= ~FLUSHO;
ttydevsw_outwakeup(tp);
ttydevsw_pktnotify(tp, TIOCPKT_START);
return 0;
case TIOCSTAT:
tty_info(tp);
return 0;
case TIOCSTI:
if ((fflag & FREAD) == 0 && priv_check(td, PRIV_TTY_STI))
return -EPERM;
if (!tty_is_ctty(tp, td->lwp) && priv_check(td, PRIV_TTY_STI))
return -EACCES;
ttydisc_rint(tp, *(char *)data, 0);
ttydisc_rint_done(tp);
return 0;
}
#ifdef COMPAT_43TTY
return tty_ioctl_compat(tp, cmd, data, fflag, td);
#else /* !COMPAT_43TTY */
return -ENOIOCTL;
#endif /* COMPAT_43TTY */
}
int tty_ioctl(struct lwp_tty *tp, rt_ubase_t cmd, void *data, int fflag,
struct rt_thread *td)
{
int error;
tty_assert_locked(tp);
if (tty_gone(tp))
return -ENXIO;
error = ttydevsw_ioctl(tp, cmd, data, td);
if (error == -ENOIOCTL)
error = tty_generic_ioctl(tp, cmd, data, fflag, td);
return error;
}
int tty_checkoutq(struct lwp_tty *tp)
{
/* 256 bytes should be enough to print a log message. */
return (ttyoutq_bytesleft(&tp->t_outq) >= 256);
}
void tty_hiwat_in_block(struct lwp_tty *tp)
{
if ((tp->t_flags & TF_HIWAT_IN) == 0 && tp->t_termios.c_iflag & IXOFF &&
tp->t_termios.c_cc[VSTOP] != _POSIX_VDISABLE)
{
/*
* Input flow control. Only enter the high watermark when we
* can successfully store the VSTOP character.
*/
if (ttyoutq_write_nofrag(&tp->t_outq, &tp->t_termios.c_cc[VSTOP], 1) ==
0)
tp->t_flags |= TF_HIWAT_IN;
}
else
{
/* No input flow control. */
tp->t_flags |= TF_HIWAT_IN;
}
}
void tty_hiwat_in_unblock(struct lwp_tty *tp)
{
if (tp->t_flags & TF_HIWAT_IN && tp->t_termios.c_iflag & IXOFF &&
tp->t_termios.c_cc[VSTART] != _POSIX_VDISABLE)
{
/*
* Input flow control. Only leave the high watermark when we
* can successfully store the VSTART character.
*/
if (ttyoutq_write_nofrag(&tp->t_outq, &tp->t_termios.c_cc[VSTART], 1) ==
0)
tp->t_flags &= ~TF_HIWAT_IN;
}
else
{
/* No input flow control. */
tp->t_flags &= ~TF_HIWAT_IN;
}
if (!tty_gone(tp))
ttydevsw_inwakeup(tp);
}
View Git Blame Copy Permalink