6 * Copyright (c) 1996-1999 Whistle Communications, Inc.
9 * Subject to the following obligations and disclaimer of warranty, use and
10 * redistribution of this software, in source or object code forms, with or
11 * without modifications are expressly permitted by Whistle Communications;
12 * provided, however, that:
13 * 1. Any and all reproductions of the source or object code must include the
14 * copyright notice above and the following disclaimer of warranties; and
15 * 2. No rights are granted, in any manner or form, to use Whistle
16 * Communications, Inc. trademarks, including the mark "WHISTLE
17 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as
18 * such appears in the above copyright notice or in the software.
20 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
21 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
22 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
23 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
25 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
26 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
27 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
28 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
29 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
30 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
31 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
32 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
38 * Author: Archie Cobbs <archie@freebsd.org>
40 * $FreeBSD: src/sys/netgraph/ng_tty.c,v 1.37 2006/11/06 13:42:03 rwatson Exp $
41 * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
45 * This file implements a terminal line discipline that is also a
46 * netgraph node. Installing this line discipline on a terminal device
47 * instantiates a new netgraph node of this type, which allows access
48 * to the device via the "hook" hook of the node.
50 * Once the line discipline is installed, you can find out the name
51 * of the corresponding netgraph node via a NGIOCGINFO ioctl().
53 * Incoming characters are delievered to the hook one at a time, each
54 * in its own mbuf. You may optionally define a ``hotchar,'' which causes
55 * incoming characters to be buffered up until either the hotchar is
56 * seen or the mbuf is full (MHLEN bytes). Then all buffered characters
57 * are immediately delivered.
60 #include <sys/param.h>
61 #include <sys/systm.h>
63 #include <sys/errno.h>
64 #include <sys/fcntl.h>
65 #include <sys/kernel.h>
66 #include <sys/malloc.h>
69 #include <sys/socket.h>
70 #include <sys/syslog.h>
72 #include <sys/ttycom.h>
75 #include <net/if_var.h>
77 #include <netgraph7/netgraph.h>
78 #include <netgraph7/ng_message.h>
82 #define MAX_MBUFQ 3 /* Max number of queued mbufs */
83 #define NGT_HIWATER 400 /* High water mark on output */
85 /* Per-node private info */
87 struct tty
*tp
; /* Terminal device */
88 node_p node
; /* Netgraph node */
89 hook_p hook
; /* Netgraph hook */
90 struct ifqueue outq
; /* Queue of outgoing data */
91 struct mbuf
*m
; /* Incoming data buffer */
92 short hotchar
; /* Hotchar, or -1 if none */
93 u_int flags
; /* Flags */
94 struct callout chand
; /* See man timeout(9) */
96 typedef struct ngt_sc
*sc_p
;
99 #define FLG_DEBUG 0x0002
100 #define FLG_DIE 0x0004
102 /* Line discipline methods */
103 static int ngt_open(struct cdev
*dev
, struct tty
*tp
);
104 static int ngt_close(struct tty
*tp
, int flag
);
105 static int ngt_read(struct tty
*tp
, struct uio
*uio
, int flag
);
106 static int ngt_write(struct tty
*tp
, struct uio
*uio
, int flag
);
107 static int ngt_tioctl(struct tty
*tp
,
108 u_long cmd
, caddr_t data
, int flag
, struct ucred
*cred
);
109 static int ngt_input(int c
, struct tty
*tp
);
110 static int ngt_start(struct tty
*tp
);
112 /* Netgraph methods */
113 static ng_constructor_t ngt_constructor
;
114 static ng_rcvmsg_t ngt_rcvmsg
;
115 static ng_shutdown_t ngt_shutdown
;
116 static ng_newhook_t ngt_newhook
;
117 static ng_connect_t ngt_connect
;
118 static ng_rcvdata_t ngt_rcvdata
;
119 static ng_disconnect_t ngt_disconnect
;
120 static int ngt_mod_event(module_t mod
, int event
, void *data
);
123 static void ngt_timeout(node_p node
, hook_p hook
, void *arg1
, int arg2
);
125 #define ERROUT(x) do { error = (x); goto done; } while (0)
127 /* Line discipline descriptor */
128 static struct linesw ngt_disc
= {
130 .l_close
= ngt_close
,
132 .l_write
= ngt_write
,
133 .l_ioctl
= ngt_tioctl
,
135 .l_start
= ngt_start
,
139 /* Netgraph node type descriptor */
140 static struct ng_type typestruct
= {
141 .version
= NG_ABI_VERSION
,
142 .name
= NG_TTY_NODE_TYPE
,
143 .mod_event
= ngt_mod_event
,
144 .constructor
= ngt_constructor
,
145 .rcvmsg
= ngt_rcvmsg
,
146 .shutdown
= ngt_shutdown
,
147 .newhook
= ngt_newhook
,
148 .connect
= ngt_connect
,
149 .rcvdata
= ngt_rcvdata
,
150 .disconnect
= ngt_disconnect
,
152 NETGRAPH_INIT(tty
, &typestruct
);
157 * - node private data and tp->t_lsc is protected by mutex in struct
158 * ifqueue, locking is done using IF_XXX() macros.
159 * - in all tty methods we should acquire node ifqueue mutex, when accessing
161 * - in _rcvdata() we should use locked versions of IF_{EN,DE}QUEUE() since
162 * we may have multiple _rcvdata() threads.
163 * - when calling any of tty methods from netgraph methods, we should
164 * acquire tty locking (now Giant).
166 * - ngt_unit is incremented atomically.
170 static int ngt_ldisc
;
172 /******************************************************************
173 LINE DISCIPLINE METHODS
174 ******************************************************************/
177 * Set our line discipline on the tty.
178 * Called from device open routine or ttioctl()
181 ngt_open(struct cdev
*dev
, struct tty
*tp
)
183 struct thread
*const td
= curthread
; /* XXX */
184 char name
[sizeof(NG_TTY_NODE_TYPE
) + 8];
188 /* Super-user only */
189 error
= priv_check(td
, PRIV_NETGRAPH_TTY
);
193 /* Initialize private struct */
194 sc
= kmalloc(sizeof(*sc
), M_NETGRAPH
, M_WAITOK
| M_ZERO
);
197 lwkt_gettoken(&tty_token
);
199 sc
->hotchar
= NG_TTY_DFL_HOTCHAR
;
200 sc
->outq
.ifq_maxlen
= MAX_MBUFQ
;
202 /* Setup netgraph node */
203 error
= ng_make_node_common(&typestruct
, &sc
->node
);
205 kfree(sc
, M_NETGRAPH
);
206 lwkt_reltoken(&tty_token
);
211 atomic_add_int(&ngt_unit
, 1);
212 ksnprintf(name
, sizeof(name
), "%s%d", typestruct
.name
, ngt_unit
);
214 /* Assign node its name */
215 if ((error
= ng_name_node(sc
->node
, name
))) {
216 sc
->flags
|= FLG_DIE
;
217 NG_NODE_UNREF(sc
->node
);
218 log(LOG_ERR
, "%s: node name exists?\n", name
);
219 lwkt_reltoken(&tty_token
);
224 /* Set back pointers */
225 NG_NODE_SET_PRIVATE(sc
->node
, sc
);
228 callout_init_mp(&sc
->chand
);
231 * Pre-allocate cblocks to the an appropriate amount.
232 * I'm not sure what is appropriate.
234 ttyflush(tp
, FREAD
| FWRITE
);
235 clist_alloc_cblocks(&tp
->t_canq
, 0, 0);
236 clist_alloc_cblocks(&tp
->t_rawq
, 0, 0);
237 clist_alloc_cblocks(&tp
->t_outq
,
238 MLEN
+ NGT_HIWATER
, MLEN
+ NGT_HIWATER
);
240 lwkt_reltoken(&tty_token
);
246 * Line specific close routine, called from device close routine
247 * and from ttioctl. This causes the node to be destroyed as well.
250 ngt_close(struct tty
*tp
, int flag
)
252 const sc_p sc
= (sc_p
) tp
->t_sc
;
255 lwkt_gettoken(&tty_token
);
256 ttyflush(tp
, FREAD
| FWRITE
);
257 clist_free_cblocks(&tp
->t_outq
);
259 if (callout_pending(&sc
->chand
))
260 ng_uncallout(&sc
->chand
, sc
->node
);
262 sc
->flags
|= FLG_DIE
;
263 ng_rmnode_self(sc
->node
);
265 lwkt_reltoken(&tty_token
);
271 * Once the device has been turned into a node, we don't allow reading.
274 ngt_read(struct tty
*tp
, struct uio
*uio
, int flag
)
280 * Once the device has been turned into a node, we don't allow writing.
283 ngt_write(struct tty
*tp
, struct uio
*uio
, int flag
)
289 * We implement the NGIOCGINFO ioctl() defined in ng_message.h.
292 ngt_tioctl(struct tty
*tp
, u_long cmd
, caddr_t data
, int flag
, struct ucred
*cred
)
294 const sc_p sc
= (sc_p
) tp
->t_sc
;
297 /* No node attached */
302 lwkt_gettoken(&tty_token
);
306 struct nodeinfo
*const ni
= (struct nodeinfo
*) data
;
307 const node_p node
= sc
->node
;
309 bzero(ni
, sizeof(*ni
));
310 if (NG_NODE_HAS_NAME(node
))
311 strncpy(ni
->name
, NG_NODE_NAME(node
), sizeof(ni
->name
) - 1);
312 strncpy(ni
->type
, node
->nd_type
->name
, sizeof(ni
->type
) - 1);
313 ni
->id
= (u_int32_t
) ng_node2ID(node
);
314 ni
->hooks
= NG_NODE_NUMHOOKS(node
);
318 lwkt_reltoken(&tty_token
);
323 lwkt_reltoken(&tty_token
);
329 * Receive data coming from the device. We get one character at
330 * a time, which is kindof silly.
332 * Full locking of softc is not required, since we are the only
336 ngt_input(int c
, struct tty
*tp
)
344 lwkt_gettoken(&tty_token
);
345 sc
= (sc_p
) tp
->t_sc
;
347 /* No node attached */
348 lwkt_reltoken(&tty_token
);
358 /* Check for error conditions */
359 if ((tp
->t_state
& TS_CONNECTED
) == 0) {
360 if (sc
->flags
& FLG_DEBUG
)
361 log(LOG_DEBUG
, "%s: no carrier\n", NG_NODE_NAME(node
));
362 lwkt_reltoken(&tty_token
);
366 if (c
& TTY_ERRORMASK
) {
367 /* framing error or overrun on this char */
368 if (sc
->flags
& FLG_DEBUG
)
369 log(LOG_DEBUG
, "%s: line error %x\n",
370 NG_NODE_NAME(node
), c
& TTY_ERRORMASK
);
371 lwkt_reltoken(&tty_token
);
377 /* Get a new header mbuf if we need one */
379 MGETHDR(m
, M_NOWAIT
, MT_DATA
);
381 if (sc
->flags
& FLG_DEBUG
)
383 "%s: can't get mbuf\n", NG_NODE_NAME(node
));
384 lwkt_reltoken(&tty_token
);
388 m
->m_len
= m
->m_pkthdr
.len
= 0;
389 m
->m_pkthdr
.rcvif
= NULL
;
393 /* Add char to mbuf */
394 *mtod(m
, u_char
*) = c
;
399 /* Ship off mbuf if it's time */
400 if (sc
->hotchar
== -1 || c
== sc
->hotchar
|| m
->m_len
>= MHLEN
) {
401 m
->m_data
= m
->m_pktdat
;
405 * We have built our mbuf without checking that we actually
406 * have a hook to send it. This was done to avoid
407 * acquiring mutex on each character. Check now.
411 if (sc
->hook
== NULL
) {
413 lwkt_reltoken(&tty_token
);
415 return (0); /* XXX: original behavior */
417 NG_SEND_DATA_ONLY(error
, sc
->hook
, m
); /* Will queue */
420 lwkt_reltoken(&tty_token
);
426 * This is called when the device driver is ready for more output.
427 * Also called from ngt_rcv_data() when a new mbuf is available for output.
430 ngt_start(struct tty
*tp
)
432 const sc_p sc
= (sc_p
) tp
->t_sc
;
435 lwkt_gettoken(&tty_token
);
436 while (tp
->t_outq
.c_cc
< NGT_HIWATER
) { /* XXX 2.2 specific ? */
439 /* Remove first mbuf from queue */
440 IF_DEQUEUE(&sc
->outq
, m
);
444 /* Send as much of it as possible */
449 - b_to_q(mtod(m
, u_char
*), m
->m_len
, &tp
->t_outq
);
453 break; /* device can't take no more */
457 /* Put remainder of mbuf chain (if any) back on queue */
459 IF_PREPEND(&sc
->outq
, m
);
464 /* Call output process whether or not there is any output. We are
465 * being called in lieu of ttstart and must do what it would. */
466 if (tp
->t_oproc
!= NULL
)
469 /* This timeout is needed for operation on a pseudo-tty, because the
470 * pty code doesn't call pppstart after it has drained the t_outq. */
471 /* XXX: outq not locked */
472 if (!IF_QEMPTY(&sc
->outq
) && !callout_pending(&sc
->chand
))
473 ng_callout(&sc
->chand
, sc
->node
, NULL
, 1, ngt_timeout
, NULL
, 0);
475 lwkt_reltoken(&tty_token
);
481 * We still have data to output to the device, so try sending more.
484 ngt_timeout(node_p node
, hook_p hook
, void *arg1
, int arg2
)
486 const sc_p sc
= NG_NODE_PRIVATE(node
);
489 lwkt_gettoken(&tty_token
);
491 lwkt_reltoken(&tty_token
);
495 /******************************************************************
496 NETGRAPH NODE METHODS
497 ******************************************************************/
500 * Initialize a new node of this type.
502 * We only allow nodes to be created as a result of setting
503 * the line discipline on a tty, so always return an error if not.
506 ngt_constructor(node_p node
)
512 * Add a new hook. There can only be one.
515 ngt_newhook(node_p node
, hook_p hook
, const char *name
)
517 const sc_p sc
= NG_NODE_PRIVATE(node
);
519 if (strcmp(name
, NG_TTY_HOOK
))
522 lwkt_gettoken(&tty_token
);
524 lwkt_reltoken(&tty_token
);
529 lwkt_reltoken(&tty_token
);
535 * Set the hook into queueing mode (for outgoing packets),
536 * so that we wont deliver mbuf thru the whole graph holding
540 ngt_connect(hook_p hook
)
542 NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook
));
544 * XXX: While ngt_start() is Giant-locked, queue incoming
545 * packets, too. Otherwise we acquire Giant holding some
546 * IP stack locks, e.g. divinp, and this makes WITNESS scream.
548 NG_HOOK_FORCE_QUEUE(hook
);
553 * Disconnect the hook
556 ngt_disconnect(hook_p hook
)
558 const sc_p sc
= NG_NODE_PRIVATE(NG_HOOK_NODE(hook
));
561 lwkt_gettoken(&tty_token
);
562 if (hook
!= sc
->hook
)
565 lwkt_reltoken(&tty_token
);
571 * Remove this node. The does the netgraph portion of the shutdown.
572 * This should only be called indirectly from ngt_close().
574 * tp->t_lsc is already NULL, so we should be protected from
578 ngt_shutdown(node_p node
)
580 const sc_p sc
= NG_NODE_PRIVATE(node
);
583 lwkt_gettoken(&tty_token
);
584 if (!(sc
->flags
& FLG_DIE
)) {
585 lwkt_reltoken(&tty_token
);
593 kfree(sc
, M_NETGRAPH
);
594 lwkt_reltoken(&tty_token
);
600 * Receive incoming data from netgraph system. Put it on our
601 * output queue and start output if necessary.
604 ngt_rcvdata(hook_p hook
, item_p item
)
606 const sc_p sc
= NG_NODE_PRIVATE(NG_HOOK_NODE(hook
));
610 if (hook
!= sc
->hook
)
617 if (IF_QFULL(&sc
->outq
)) {
624 IF_ENQUEUE(&sc
->outq
, m
);
625 qlen
= sc
->outq
.ifq_len
;
629 * If qlen > 1, then we should already have a scheduled callout.
632 lwkt_gettoken(&tty_token
);
634 lwkt_reltoken(&tty_token
);
641 * Receive control message
644 ngt_rcvmsg(node_p node
, item_p item
, hook_p lasthook
)
646 const sc_p sc
= NG_NODE_PRIVATE(node
);
647 struct ng_mesg
*msg
, *resp
= NULL
;
650 NGI_GET_MSG(item
, msg
);
651 switch (msg
->header
.typecookie
) {
653 switch (msg
->header
.cmd
) {
654 case NGM_TTY_SET_HOTCHAR
:
658 if (msg
->header
.arglen
!= sizeof(int))
660 hotchar
= *((int *) msg
->data
);
661 if (hotchar
!= (u_char
) hotchar
&& hotchar
!= -1)
663 sc
->hotchar
= hotchar
; /* race condition is OK */
666 case NGM_TTY_GET_HOTCHAR
:
667 NG_MKRESPONSE(resp
, msg
, sizeof(int), M_WAITOK
| M_NULLOK
);
670 /* Race condition here is OK */
671 *((int *) resp
->data
) = sc
->hotchar
;
681 NG_RESPOND_MSG(error
, node
, item
, resp
);
686 /******************************************************************
688 ******************************************************************/
691 * Handle loading and unloading for this node type
694 ngt_mod_event(module_t mod
, int event
, void *data
)
700 /* Register line discipline */
702 if ((ngt_ldisc
= ldisc_register(NETGRAPHDISC
, &ngt_disc
)) < 0) {
704 log(LOG_ERR
, "%s: can't register line discipline",
713 /* Unregister line discipline */
715 ldisc_deregister(ngt_ldisc
);