A later change, currently being iterated on in D24459, will in-fact change the lock type to an sx so that TTY drivers can sleep on it if they need to. Committing this ahead of time to make the review in question a little more palatable. tty_lock_assert() is unfortunately still needed for now in two places to make sure that the tty lock has not been recursed upon, for those scenarios where it's supplied by the TTY driver and possibly a mutex that is allowed to recurse. Suggested by: markj
511 lines
12 KiB
C
511 lines
12 KiB
C
/*
|
|
* ng_tty.c
|
|
*/
|
|
|
|
/*-
|
|
* Copyright (c) 1996-1999 Whistle Communications, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Subject to the following obligations and disclaimer of warranty, use and
|
|
* redistribution of this software, in source or object code forms, with or
|
|
* without modifications are expressly permitted by Whistle Communications;
|
|
* provided, however, that:
|
|
* 1. Any and all reproductions of the source or object code must include the
|
|
* copyright notice above and the following disclaimer of warranties; and
|
|
* 2. No rights are granted, in any manner or form, to use Whistle
|
|
* Communications, Inc. trademarks, including the mark "WHISTLE
|
|
* COMMUNICATIONS" on advertising, endorsements, or otherwise except as
|
|
* such appears in the above copyright notice or in the software.
|
|
*
|
|
* THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
|
|
* TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
|
|
* REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
|
|
* INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
|
|
* WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
|
|
* REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
|
|
* SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
|
|
* IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
|
|
* RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
|
|
* WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
|
|
* PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER 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 WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
|
|
* OF SUCH DAMAGE.
|
|
*
|
|
* Author: Archie Cobbs <archie@freebsd.org>
|
|
*
|
|
* Updated by Andrew Thompson <thompsa@FreeBSD.org> for MPSAFE TTY.
|
|
*
|
|
* $FreeBSD$
|
|
* $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
|
|
*/
|
|
|
|
/*
|
|
* This file implements TTY hooks to link in to the netgraph system. The node
|
|
* is created and then passed the callers opened TTY file descriptor number to
|
|
* NGM_TTY_SET_TTY, this will hook the tty via ttyhook_register().
|
|
*
|
|
* Incoming data is delivered directly to ng_tty via the TTY bypass hook as a
|
|
* buffer pointer and length, this is converted to a mbuf and passed to the
|
|
* peer.
|
|
*
|
|
* If the TTY device does not support bypass then incoming characters are
|
|
* delivered to the hook one at a time, each in its own mbuf. You may
|
|
* optionally define a ``hotchar,'' which causes incoming characters to be
|
|
* buffered up until either the hotchar is seen or the mbuf is full (MHLEN
|
|
* bytes). Then all buffered characters are immediately delivered.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/ioccom.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/priv.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/tty.h>
|
|
#include <sys/ttycom.h>
|
|
#include <sys/proc.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_var.h>
|
|
|
|
#include <netgraph/ng_message.h>
|
|
#include <netgraph/netgraph.h>
|
|
#include <netgraph/ng_tty.h>
|
|
|
|
/* Per-node private info */
|
|
struct ngt_softc {
|
|
struct tty *tp; /* Terminal device */
|
|
node_p node; /* Netgraph node */
|
|
hook_p hook; /* Netgraph hook */
|
|
struct ifqueue outq; /* Queue of outgoing data */
|
|
size_t outqlen; /* Number of bytes in outq */
|
|
struct mbuf *m; /* Incoming non-bypass data buffer */
|
|
short hotchar; /* Hotchar, or -1 if none */
|
|
u_int flags; /* Flags */
|
|
};
|
|
typedef struct ngt_softc *sc_p;
|
|
|
|
/* Flags */
|
|
#define FLG_DEBUG 0x0002
|
|
|
|
/* Netgraph methods */
|
|
static ng_constructor_t ngt_constructor;
|
|
static ng_rcvmsg_t ngt_rcvmsg;
|
|
static ng_shutdown_t ngt_shutdown;
|
|
static ng_newhook_t ngt_newhook;
|
|
static ng_connect_t ngt_connect;
|
|
static ng_rcvdata_t ngt_rcvdata;
|
|
static ng_disconnect_t ngt_disconnect;
|
|
|
|
#define ERROUT(x) do { error = (x); goto done; } while (0)
|
|
|
|
static th_getc_inject_t ngt_getc_inject;
|
|
static th_getc_poll_t ngt_getc_poll;
|
|
static th_rint_t ngt_rint;
|
|
static th_rint_bypass_t ngt_rint_bypass;
|
|
static th_rint_poll_t ngt_rint_poll;
|
|
|
|
static struct ttyhook ngt_hook = {
|
|
.th_getc_inject = ngt_getc_inject,
|
|
.th_getc_poll = ngt_getc_poll,
|
|
.th_rint = ngt_rint,
|
|
.th_rint_bypass = ngt_rint_bypass,
|
|
.th_rint_poll = ngt_rint_poll,
|
|
};
|
|
|
|
/* Netgraph node type descriptor */
|
|
static struct ng_type typestruct = {
|
|
.version = NG_ABI_VERSION,
|
|
.name = NG_TTY_NODE_TYPE,
|
|
.constructor = ngt_constructor,
|
|
.rcvmsg = ngt_rcvmsg,
|
|
.shutdown = ngt_shutdown,
|
|
.newhook = ngt_newhook,
|
|
.connect = ngt_connect,
|
|
.rcvdata = ngt_rcvdata,
|
|
.disconnect = ngt_disconnect,
|
|
};
|
|
NETGRAPH_INIT(tty, &typestruct);
|
|
|
|
#define NGTLOCK(sc) IF_LOCK(&sc->outq)
|
|
#define NGTUNLOCK(sc) IF_UNLOCK(&sc->outq)
|
|
|
|
/******************************************************************
|
|
NETGRAPH NODE METHODS
|
|
******************************************************************/
|
|
|
|
/*
|
|
* Initialize a new node of this type.
|
|
*
|
|
* We only allow nodes to be created as a result of setting
|
|
* the line discipline on a tty, so always return an error if not.
|
|
*/
|
|
static int
|
|
ngt_constructor(node_p node)
|
|
{
|
|
sc_p sc;
|
|
|
|
/* Allocate private structure */
|
|
sc = malloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO);
|
|
|
|
NG_NODE_SET_PRIVATE(node, sc);
|
|
sc->node = node;
|
|
|
|
mtx_init(&sc->outq.ifq_mtx, "ng_tty node+queue", NULL, MTX_DEF);
|
|
IFQ_SET_MAXLEN(&sc->outq, ifqmaxlen);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Add a new hook. There can only be one.
|
|
*/
|
|
static int
|
|
ngt_newhook(node_p node, hook_p hook, const char *name)
|
|
{
|
|
const sc_p sc = NG_NODE_PRIVATE(node);
|
|
|
|
if (strcmp(name, NG_TTY_HOOK))
|
|
return (EINVAL);
|
|
|
|
if (sc->hook)
|
|
return (EISCONN);
|
|
|
|
NGTLOCK(sc);
|
|
sc->hook = hook;
|
|
NGTUNLOCK(sc);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Set the hook into queueing mode (for outgoing packets),
|
|
* so that we wont deliver mbuf through the whole graph holding
|
|
* tty locks.
|
|
*/
|
|
static int
|
|
ngt_connect(hook_p hook)
|
|
{
|
|
NG_HOOK_FORCE_QUEUE(hook);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Disconnect the hook
|
|
*/
|
|
static int
|
|
ngt_disconnect(hook_p hook)
|
|
{
|
|
const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
|
|
|
|
if (hook != sc->hook)
|
|
panic("%s", __func__);
|
|
|
|
NGTLOCK(sc);
|
|
sc->hook = NULL;
|
|
NGTUNLOCK(sc);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Remove this node. The does the netgraph portion of the shutdown.
|
|
*/
|
|
static int
|
|
ngt_shutdown(node_p node)
|
|
{
|
|
const sc_p sc = NG_NODE_PRIVATE(node);
|
|
struct tty *tp;
|
|
|
|
tp = sc->tp;
|
|
if (tp != NULL) {
|
|
tty_lock(tp);
|
|
ttyhook_unregister(tp);
|
|
}
|
|
/* Free resources */
|
|
IF_DRAIN(&sc->outq);
|
|
mtx_destroy(&(sc)->outq.ifq_mtx);
|
|
NG_NODE_UNREF(sc->node);
|
|
free(sc, M_NETGRAPH);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Receive control message
|
|
*/
|
|
static int
|
|
ngt_rcvmsg(node_p node, item_p item, hook_p lasthook)
|
|
{
|
|
struct proc *p;
|
|
const sc_p sc = NG_NODE_PRIVATE(node);
|
|
struct ng_mesg *msg, *resp = NULL;
|
|
int error = 0;
|
|
|
|
NGI_GET_MSG(item, msg);
|
|
switch (msg->header.typecookie) {
|
|
case NGM_TTY_COOKIE:
|
|
switch (msg->header.cmd) {
|
|
case NGM_TTY_SET_TTY:
|
|
if (sc->tp != NULL)
|
|
return (EBUSY);
|
|
|
|
p = pfind(((int *)msg->data)[0]);
|
|
if (p == NULL || (p->p_flag & P_WEXIT))
|
|
return (ESRCH);
|
|
_PHOLD(p);
|
|
PROC_UNLOCK(p);
|
|
error = ttyhook_register(&sc->tp, p, ((int *)msg->data)[1],
|
|
&ngt_hook, sc);
|
|
PRELE(p);
|
|
if (error != 0)
|
|
return (error);
|
|
break;
|
|
case NGM_TTY_SET_HOTCHAR:
|
|
{
|
|
int hotchar;
|
|
|
|
if (msg->header.arglen != sizeof(int))
|
|
ERROUT(EINVAL);
|
|
hotchar = *((int *) msg->data);
|
|
if (hotchar != (u_char) hotchar && hotchar != -1)
|
|
ERROUT(EINVAL);
|
|
sc->hotchar = hotchar; /* race condition is OK */
|
|
break;
|
|
}
|
|
case NGM_TTY_GET_HOTCHAR:
|
|
NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
|
|
if (!resp)
|
|
ERROUT(ENOMEM);
|
|
/* Race condition here is OK */
|
|
*((int *) resp->data) = sc->hotchar;
|
|
break;
|
|
default:
|
|
ERROUT(EINVAL);
|
|
}
|
|
break;
|
|
default:
|
|
ERROUT(EINVAL);
|
|
}
|
|
done:
|
|
NG_RESPOND_MSG(error, node, item, resp);
|
|
NG_FREE_MSG(msg);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Receive incoming data from netgraph system. Put it on our
|
|
* output queue and start output if necessary.
|
|
*/
|
|
static int
|
|
ngt_rcvdata(hook_p hook, item_p item)
|
|
{
|
|
const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
|
|
struct tty *tp = sc->tp;
|
|
struct mbuf *m;
|
|
|
|
if (hook != sc->hook)
|
|
panic("%s", __func__);
|
|
|
|
NGI_GET_M(item, m);
|
|
NG_FREE_ITEM(item);
|
|
|
|
if (tp == NULL) {
|
|
NG_FREE_M(m);
|
|
return (ENXIO);
|
|
}
|
|
|
|
IF_LOCK(&sc->outq);
|
|
if (_IF_QFULL(&sc->outq)) {
|
|
IF_UNLOCK(&sc->outq);
|
|
NG_FREE_M(m);
|
|
return (ENOBUFS);
|
|
}
|
|
|
|
_IF_ENQUEUE(&sc->outq, m);
|
|
sc->outqlen += m->m_pkthdr.len;
|
|
IF_UNLOCK(&sc->outq);
|
|
|
|
/* notify the TTY that data is ready */
|
|
tty_lock(tp);
|
|
if (!tty_gone(tp))
|
|
ttydevsw_outwakeup(tp);
|
|
tty_unlock(tp);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static size_t
|
|
ngt_getc_inject(struct tty *tp, void *buf, size_t len)
|
|
{
|
|
sc_p sc = ttyhook_softc(tp);
|
|
size_t total = 0;
|
|
int length;
|
|
|
|
while (len) {
|
|
struct mbuf *m;
|
|
|
|
/* Remove first mbuf from queue */
|
|
IF_DEQUEUE(&sc->outq, m);
|
|
if (m == NULL)
|
|
break;
|
|
|
|
/* Send as much of it as possible */
|
|
while (m != NULL) {
|
|
length = min(m->m_len, len);
|
|
memcpy((char *)buf + total, mtod(m, char *), length);
|
|
|
|
m->m_data += length;
|
|
m->m_len -= length;
|
|
total += length;
|
|
len -= length;
|
|
|
|
if (m->m_len > 0)
|
|
break; /* device can't take any more */
|
|
m = m_free(m);
|
|
}
|
|
|
|
/* Put remainder of mbuf chain (if any) back on queue */
|
|
if (m != NULL) {
|
|
IF_PREPEND(&sc->outq, m);
|
|
break;
|
|
}
|
|
}
|
|
IF_LOCK(&sc->outq);
|
|
sc->outqlen -= total;
|
|
IF_UNLOCK(&sc->outq);
|
|
MPASS(sc->outqlen >= 0);
|
|
|
|
return (total);
|
|
}
|
|
|
|
static size_t
|
|
ngt_getc_poll(struct tty *tp)
|
|
{
|
|
sc_p sc = ttyhook_softc(tp);
|
|
|
|
return (sc->outqlen);
|
|
}
|
|
|
|
/*
|
|
* Optimised TTY input.
|
|
*
|
|
* We get a buffer pointer to hopefully a complete data frame. Do not check for
|
|
* the hotchar, just pass it on.
|
|
*/
|
|
static size_t
|
|
ngt_rint_bypass(struct tty *tp, const void *buf, size_t len)
|
|
{
|
|
sc_p sc = ttyhook_softc(tp);
|
|
node_p node = sc->node;
|
|
struct mbuf *m, *mb;
|
|
size_t total = 0;
|
|
int error = 0, length;
|
|
|
|
tty_assert_locked(tp);
|
|
|
|
if (sc->hook == NULL)
|
|
return (0);
|
|
|
|
m = m_getm2(NULL, len, M_NOWAIT, MT_DATA, M_PKTHDR);
|
|
if (m == NULL) {
|
|
if (sc->flags & FLG_DEBUG)
|
|
log(LOG_ERR,
|
|
"%s: can't get mbuf\n", NG_NODE_NAME(node));
|
|
return (0);
|
|
}
|
|
m->m_pkthdr.rcvif = NULL;
|
|
|
|
for (mb = m; mb != NULL; mb = mb->m_next) {
|
|
length = min(M_TRAILINGSPACE(mb), len - total);
|
|
|
|
memcpy(mtod(m, char *), (const char *)buf + total, length);
|
|
mb->m_len = length;
|
|
total += length;
|
|
m->m_pkthdr.len += length;
|
|
}
|
|
if (sc->m != NULL) {
|
|
/*
|
|
* Odd, we have changed from non-bypass to bypass. It is
|
|
* unlikely but not impossible, flush the data first.
|
|
*/
|
|
NG_SEND_DATA_ONLY(error, sc->hook, sc->m);
|
|
sc->m = NULL;
|
|
}
|
|
NG_SEND_DATA_ONLY(error, sc->hook, m);
|
|
|
|
return (total);
|
|
}
|
|
|
|
/*
|
|
* Receive data coming from the device one char at a time, when it is not in
|
|
* bypass mode.
|
|
*/
|
|
static int
|
|
ngt_rint(struct tty *tp, char c, int flags)
|
|
{
|
|
sc_p sc = ttyhook_softc(tp);
|
|
node_p node = sc->node;
|
|
struct mbuf *m;
|
|
int error = 0;
|
|
|
|
tty_assert_locked(tp);
|
|
|
|
if (sc->hook == NULL)
|
|
return (0);
|
|
|
|
if (flags != 0) {
|
|
/* framing error or overrun on this char */
|
|
if (sc->flags & FLG_DEBUG)
|
|
log(LOG_DEBUG, "%s: line error %x\n",
|
|
NG_NODE_NAME(node), flags);
|
|
return (0);
|
|
}
|
|
|
|
/* Get a new header mbuf if we need one */
|
|
if (!(m = sc->m)) {
|
|
MGETHDR(m, M_NOWAIT, MT_DATA);
|
|
if (!m) {
|
|
if (sc->flags & FLG_DEBUG)
|
|
log(LOG_ERR,
|
|
"%s: can't get mbuf\n", NG_NODE_NAME(node));
|
|
return (ENOBUFS);
|
|
}
|
|
m->m_len = m->m_pkthdr.len = 0;
|
|
m->m_pkthdr.rcvif = NULL;
|
|
sc->m = m;
|
|
}
|
|
|
|
/* Add char to mbuf */
|
|
*mtod(m, u_char *) = c;
|
|
m->m_data++;
|
|
m->m_len++;
|
|
m->m_pkthdr.len++;
|
|
|
|
/* Ship off mbuf if it's time */
|
|
if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
|
|
sc->m = NULL;
|
|
NG_SEND_DATA_ONLY(error, sc->hook, m); /* Will queue */
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
static size_t
|
|
ngt_rint_poll(struct tty *tp)
|
|
{
|
|
/* We can always accept input */
|
|
return (1);
|
|
}
|
|
|