/* * 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 #include /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2008 Ed Schouten * 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); }