xref: /freebsd/sys/netgraph/ng_tty.c (revision daf1cffce2e07931f27c6c6998652e90df6ba87e) 
1 
2 /*
3  * ng_tty.c
4  *
5  * Copyright (c) 1996-1999 Whistle Communications, Inc.
6  * All rights reserved.
7  *
8  * Subject to the following obligations and disclaimer of warranty, use and
9  * redistribution of this software, in source or object code forms, with or
10  * without modifications are expressly permitted by Whistle Communications;
11  * provided, however, that:
12  * 1. Any and all reproductions of the source or object code must include the
13  *    copyright notice above and the following disclaimer of warranties; and
14  * 2. No rights are granted, in any manner or form, to use Whistle
15  *    Communications, Inc. trademarks, including the mark "WHISTLE
16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17  *    such appears in the above copyright notice or in the software.
18  *
19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
35  * OF SUCH DAMAGE.
36  *
37  * Author: Archie Cobbs <archie@whistle.com>
38  *
39  * $FreeBSD$
40  * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
41  */
42 
43 /*
44  * This file implements a terminal line discipline that is also a
45  * netgraph node. Installing this line discipline on a terminal device
46  * instantiates a new netgraph node of this type, which allows access
47  * to the device via the "hook" hook of the node.
48  *
49  * Once the line discipline is installed, you can find out the name
50  * of the corresponding netgraph node via a NGIOCGINFO ioctl().
51  *
52  * Incoming characters are delievered to the hook one at a time, each
53  * in its own mbuf. You may optionally define a ``hotchar,'' which causes
54  * incoming characters to be buffered up until either the hotchar is
55  * seen or the mbuf is full (MHLEN bytes). Then all buffered characters
56  * are immediately delivered.
57  *
58  * NOTE: This node operates at spltty().
59  */
60 
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/kernel.h>
64 #include <sys/conf.h>
65 #include <sys/proc.h>
66 #include <sys/mbuf.h>
67 #include <sys/malloc.h>
68 #include <sys/fcntl.h>
69 #include <sys/tty.h>
70 #include <sys/ttycom.h>
71 #include <sys/syslog.h>
72 #include <sys/errno.h>
73 #include <sys/ioccom.h>
74 
75 #include <netgraph/ng_message.h>
76 #include <netgraph/netgraph.h>
77 #include <netgraph/ng_tty.h>
78 
79 #ifdef __i386__			/* fiddle with the spl locking */
80 #include <machine/ipl.h>
81 #include <i386/isa/intr_machdep.h>
82 #endif
83 
84 /* Misc defs */
85 #define MAX_MBUFQ		3	/* Max number of queued mbufs */
86 #define NGT_HIWATER		400	/* High water mark on output */
87 
88 /* Per-node private info */
89 struct ngt_sc {
90 	struct	tty *tp;		/* Terminal device */
91 	node_p	node;			/* Netgraph node */
92 	hook_p	hook;			/* Netgraph hook */
93 	struct	mbuf *m;		/* Incoming data buffer */
94 	struct	mbuf *qhead, **qtail;	/* Queue of outgoing mbuf's */
95 	short	qlen;			/* Length of queue */
96 	short	hotchar;		/* Hotchar, or -1 if none */
97 	u_int	flags;			/* Flags */
98 	struct	callout_handle chand;	/* See man timeout(9) */
99 };
100 typedef struct ngt_sc *sc_p;
101 
102 /* Flags */
103 #define FLG_TIMEOUT		0x0001	/* A timeout is pending */
104 #define FLG_DEBUG		0x0002
105 
106 /* Debugging */
107 #ifdef INVARIANTS
108 #define QUEUECHECK(sc)							\
109     do {								\
110       struct mbuf	**mp;						\
111       int		k;						\
112 									\
113       for (k = 0, mp = &sc->qhead;					\
114 	k <= MAX_MBUFQ && *mp;						\
115 	k++, mp = &(*mp)->m_nextpkt);					\
116       if (k != sc->qlen || k > MAX_MBUFQ || *mp || mp != sc->qtail)	\
117 	panic(__FUNCTION__ ": queue");					\
118     } while (0)
119 #else
120 #define QUEUECHECK(sc)	do {} while (0)
121 #endif
122 
123 /* Line discipline methods */
124 static int	ngt_open(dev_t dev, struct tty *tp);
125 static int	ngt_close(struct tty *tp, int flag);
126 static int	ngt_read(struct tty *tp, struct uio *uio, int flag);
127 static int	ngt_write(struct tty *tp, struct uio *uio, int flag);
128 static int	ngt_tioctl(struct tty *tp,
129 		    u_long cmd, caddr_t data, int flag, struct proc *);
130 static int	ngt_input(int c, struct tty *tp);
131 static int	ngt_start(struct tty *tp);
132 
133 /* Netgraph methods */
134 static ng_constructor_t	ngt_constructor;
135 static ng_rcvmsg_t	ngt_rcvmsg;
136 static ng_shutdown_t	ngt_shutdown;
137 static ng_newhook_t	ngt_newhook;
138 static ng_rcvdata_t	ngt_rcvdata;
139 static ng_disconnect_t	ngt_disconnect;
140 static int	ngt_mod_event(module_t mod, int event, void *data);
141 
142 /* Other stuff */
143 static void	ngt_timeout(void *arg);
144 
145 #define ERROUT(x)		do { error = (x); goto done; } while (0)
146 
147 /* Line discipline descriptor */
148 static struct linesw ngt_disc = {
149 	ngt_open,
150 	ngt_close,
151 	ngt_read,
152 	ngt_write,
153 	ngt_tioctl,
154 	ngt_input,
155 	ngt_start,
156 	ttymodem,
157 	NG_TTY_DFL_HOTCHAR	/* XXX can't change this in serial driver */
158 };
159 
160 /* Netgraph node type descriptor */
161 static struct ng_type typestruct = {
162 	NG_VERSION,
163 	NG_TTY_NODE_TYPE,
164 	ngt_mod_event,
165 	ngt_constructor,
166 	ngt_rcvmsg,
167 	ngt_shutdown,
168 	ngt_newhook,
169 	NULL,
170 	NULL,
171 	ngt_rcvdata,
172 	ngt_rcvdata,
173 	ngt_disconnect,
174 	NULL
175 };
176 NETGRAPH_INIT(tty, &typestruct);
177 
178 static int ngt_unit;
179 static int ngt_nodeop_ok;	/* OK to create/remove node */
180 static int ngt_ldisc;
181 
182 /******************************************************************
183 		    LINE DISCIPLINE METHODS
184 ******************************************************************/
185 
186 /*
187  * Set our line discipline on the tty.
188  * Called from device open routine or ttioctl() at >= splsofttty()
189  */
190 static int
191 ngt_open(dev_t dev, struct tty *tp)
192 {
193 	struct proc *const p = curproc;	/* XXX */
194 	char name[sizeof(NG_TTY_NODE_TYPE) + 8];
195 	sc_p sc;
196 	int s, error;
197 
198 	/* Super-user only */
199 	if ((error = suser(p)))
200 		return (error);
201 	s = splnet();
202 	(void) spltty();	/* XXX is this necessary? */
203 
204 	/* Already installed? */
205 	if (tp->t_line == NETGRAPHDISC) {
206 		sc = (sc_p) tp->t_sc;
207 		if (sc != NULL && sc->tp == tp)
208 			goto done;
209 	}
210 
211 	/* Initialize private struct */
212 	MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK);
213 	if (sc == NULL) {
214 		error = ENOMEM;
215 		goto done;
216 	}
217 	bzero(sc, sizeof(*sc));
218 	sc->tp = tp;
219 	sc->hotchar = NG_TTY_DFL_HOTCHAR;
220 	sc->qtail = &sc->qhead;
221 	QUEUECHECK(sc);
222 	callout_handle_init(&sc->chand);
223 
224 	/* Setup netgraph node */
225 	ngt_nodeop_ok = 1;
226 	error = ng_make_node_common(&typestruct, &sc->node);
227 	ngt_nodeop_ok = 0;
228 	if (error) {
229 		FREE(sc, M_NETGRAPH);
230 		goto done;
231 	}
232 	sprintf(name, "%s%d", typestruct.name, ngt_unit++);
233 
234 	/* Set back pointers */
235 	sc->node->private = sc;
236 	tp->t_sc = (caddr_t) sc;
237 
238 	/* Assign node its name */
239 	if ((error = ng_name_node(sc->node, name))) {
240 		log(LOG_ERR, "%s: node name exists?\n", name);
241 		ngt_nodeop_ok = 1;
242 		ng_rmnode(sc->node);
243 		ngt_nodeop_ok = 0;
244 		goto done;
245 	}
246 
247 	/*
248 	 * Pre-allocate cblocks to the an appropriate amount.
249 	 * I'm not sure what is appropriate.
250 	 */
251 	ttyflush(tp, FREAD | FWRITE);
252 	clist_alloc_cblocks(&tp->t_canq, 0, 0);
253 	clist_alloc_cblocks(&tp->t_rawq, 0, 0);
254 	clist_alloc_cblocks(&tp->t_outq,
255 	    MLEN + NGT_HIWATER, MLEN + NGT_HIWATER);
256 
257 done:
258 	/* Done */
259 	splx(s);
260 	return (error);
261 }
262 
263 /*
264  * Line specific close routine, called from device close routine
265  * and from ttioctl at >= splsofttty(). This causes the node to
266  * be destroyed as well.
267  */
268 static int
269 ngt_close(struct tty *tp, int flag)
270 {
271 	const sc_p sc = (sc_p) tp->t_sc;
272 	int s;
273 
274 	s = spltty();
275 	ttyflush(tp, FREAD | FWRITE);
276 	clist_free_cblocks(&tp->t_outq);
277 	tp->t_line = 0;
278 	if (sc != NULL) {
279 		if (sc->flags & FLG_TIMEOUT) {
280 			untimeout(ngt_timeout, sc, sc->chand);
281 			sc->flags &= ~FLG_TIMEOUT;
282 		}
283 		ngt_nodeop_ok = 1;
284 		ng_rmnode(sc->node);
285 		ngt_nodeop_ok = 0;
286 		tp->t_sc = NULL;
287 	}
288 	splx(s);
289 	return (0);
290 }
291 
292 /*
293  * Once the device has been turned into a node, we don't allow reading.
294  */
295 static int
296 ngt_read(struct tty *tp, struct uio *uio, int flag)
297 {
298 	return (EIO);
299 }
300 
301 /*
302  * Once the device has been turned into a node, we don't allow writing.
303  */
304 static int
305 ngt_write(struct tty *tp, struct uio *uio, int flag)
306 {
307 	return (EIO);
308 }
309 
310 /*
311  * We implement the NGIOCGINFO ioctl() defined in ng_message.h.
312  */
313 static int
314 ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct proc *p)
315 {
316 	const sc_p sc = (sc_p) tp->t_sc;
317 	int s, error = 0;
318 
319 	s = spltty();
320 	switch (cmd) {
321 	case NGIOCGINFO:
322 	    {
323 		struct nodeinfo *const ni = (struct nodeinfo *) data;
324 		const node_p node = sc->node;
325 
326 		bzero(ni, sizeof(*ni));
327 		if (node->name)
328 			strncpy(ni->name, node->name, sizeof(ni->name) - 1);
329 		strncpy(ni->type, node->type->name, sizeof(ni->type) - 1);
330 		ni->id = (u_int32_t) node;
331 		ni->hooks = node->numhooks;
332 		break;
333 	    }
334 	default:
335 		ERROUT(ENOIOCTL);
336 	}
337 done:
338 	splx(s);
339 	return (error);
340 }
341 
342 /*
343  * Receive data coming from the device. We get one character at
344  * a time, which is kindof silly.
345  * Only guaranteed to be at splsofttty() or spltty().
346  */
347 static int
348 ngt_input(int c, struct tty *tp)
349 {
350 	const sc_p sc = (sc_p) tp->t_sc;
351 	const node_p node = sc->node;
352 	struct mbuf *m;
353 	int s, error = 0;
354 
355 	if (!sc || tp != sc->tp)
356 		return (0);
357 	s = spltty();
358 	if (!sc->hook)
359 		ERROUT(0);
360 
361 	/* Check for error conditions */
362 	if ((tp->t_state & TS_CONNECTED) == 0) {
363 		if (sc->flags & FLG_DEBUG)
364 			log(LOG_DEBUG, "%s: no carrier\n", node->name);
365 		ERROUT(0);
366 	}
367 	if (c & TTY_ERRORMASK) {
368 		/* framing error or overrun on this char */
369 		if (sc->flags & FLG_DEBUG)
370 			log(LOG_DEBUG, "%s: line error %x\n",
371 			    node->name, c & TTY_ERRORMASK);
372 		ERROUT(0);
373 	}
374 	c &= TTY_CHARMASK;
375 
376 	/* Get a new header mbuf if we need one */
377 	if (!(m = sc->m)) {
378 		MGETHDR(m, M_DONTWAIT, MT_DATA);
379 		if (!m) {
380 			if (sc->flags & FLG_DEBUG)
381 				log(LOG_ERR,
382 				    "%s: can't get mbuf\n", node->name);
383 			ERROUT(ENOBUFS);
384 		}
385 		m->m_len = m->m_pkthdr.len = 0;
386 		m->m_pkthdr.rcvif = NULL;
387 		sc->m = m;
388 	}
389 
390 	/* Add char to mbuf */
391 	*mtod(m, u_char *) = c;
392 	m->m_data++;
393 	m->m_len++;
394 	m->m_pkthdr.len++;
395 
396 	/* Ship off mbuf if it's time */
397 	if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
398 		m->m_data = m->m_pktdat;
399 		error = ng_queue_data(sc->hook, m, NULL);
400 		sc->m = NULL;
401 	}
402 done:
403 	splx(s);
404 	return (error);
405 }
406 
407 /*
408  * This is called when the device driver is ready for more output.
409  * Called from tty system at splsofttty() or spltty().
410  * Also call from ngt_rcv_data() when a new mbuf is available for output.
411  */
412 static int
413 ngt_start(struct tty *tp)
414 {
415 	const sc_p sc = (sc_p) tp->t_sc;
416 	int s;
417 
418 	s = spltty();
419 	while (tp->t_outq.c_cc < NGT_HIWATER) {	/* XXX 2.2 specific ? */
420 		struct mbuf *m = sc->qhead;
421 
422 		/* Remove first mbuf from queue */
423 		if (!m)
424 			break;
425 		if ((sc->qhead = m->m_nextpkt) == NULL)
426 			sc->qtail = &sc->qhead;
427 		sc->qlen--;
428 		QUEUECHECK(sc);
429 
430 		/* Send as much of it as possible */
431 		while (m) {
432 			struct mbuf *m2;
433 			int     sent;
434 
435 			sent = m->m_len
436 			    - b_to_q(mtod(m, u_char *), m->m_len, &tp->t_outq);
437 			m->m_data += sent;
438 			m->m_len -= sent;
439 			if (m->m_len > 0)
440 				break;	/* device can't take no more */
441 			MFREE(m, m2);
442 			m = m2;
443 		}
444 
445 		/* Put remainder of mbuf chain (if any) back on queue */
446 		if (m) {
447 			m->m_nextpkt = sc->qhead;
448 			sc->qhead = m;
449 			if (sc->qtail == &sc->qhead)
450 				sc->qtail = &m->m_nextpkt;
451 			sc->qlen++;
452 			QUEUECHECK(sc);
453 			break;
454 		}
455 	}
456 
457 	/* Call output process whether or not there is any output. We are
458 	 * being called in lieu of ttstart and must do what it would. */
459 	if (tp->t_oproc != NULL)
460 		(*tp->t_oproc) (tp);
461 
462 	/* This timeout is needed for operation on a pseudo-tty, because the
463 	 * pty code doesn't call pppstart after it has drained the t_outq. */
464 	if (sc->qhead && (sc->flags & FLG_TIMEOUT) == 0) {
465 		sc->chand = timeout(ngt_timeout, sc, 1);
466 		sc->flags |= FLG_TIMEOUT;
467 	}
468 	splx(s);
469 	return (0);
470 }
471 
472 /*
473  * We still have data to output to the device, so try sending more.
474  */
475 static void
476 ngt_timeout(void *arg)
477 {
478 	const sc_p sc = (sc_p) arg;
479 	int s;
480 
481 	s = spltty();
482 	sc->flags &= ~FLG_TIMEOUT;
483 	ngt_start(sc->tp);
484 	splx(s);
485 }
486 
487 /******************************************************************
488 		    NETGRAPH NODE METHODS
489 ******************************************************************/
490 
491 /*
492  * Initialize a new node of this type.
493  *
494  * We only allow nodes to be created as a result of setting
495  * the line discipline on a tty, so always return an error if not.
496  */
497 static int
498 ngt_constructor(node_p *nodep)
499 {
500 	if (!ngt_nodeop_ok)
501 		return (EOPNOTSUPP);
502 	return (ng_make_node_common(&typestruct, nodep));
503 }
504 
505 /*
506  * Add a new hook. There can only be one.
507  */
508 static int
509 ngt_newhook(node_p node, hook_p hook, const char *name)
510 {
511 	const sc_p sc = node->private;
512 	int s, error = 0;
513 
514 	if (strcmp(name, NG_TTY_HOOK))
515 		return (EINVAL);
516 	s = spltty();
517 	if (sc->hook)
518 		ERROUT(EISCONN);
519 	sc->hook = hook;
520 done:
521 	splx(s);
522 	return (error);
523 }
524 
525 /*
526  * Disconnect the hook
527  */
528 static int
529 ngt_disconnect(hook_p hook)
530 {
531 	const sc_p sc = hook->node->private;
532 	int s;
533 
534 	s = spltty();
535 	if (hook != sc->hook)
536 		panic(__FUNCTION__);
537 	sc->hook = NULL;
538 	m_freem(sc->m);
539 	sc->m = NULL;
540 	splx(s);
541 	return (0);
542 }
543 
544 /*
545  * Remove this node. The does the netgraph portion of the shutdown.
546  * This should only be called indirectly from ngt_close().
547  */
548 static int
549 ngt_shutdown(node_p node)
550 {
551 	const sc_p sc = node->private;
552 
553 	if (!ngt_nodeop_ok)
554 		return (EOPNOTSUPP);
555 	ng_unname(node);
556 	ng_cutlinks(node);
557 	node->private = NULL;
558 	ng_unref(sc->node);
559 	m_freem(sc->qhead);
560 	m_freem(sc->m);
561 	bzero(sc, sizeof(*sc));
562 	FREE(sc, M_NETGRAPH);
563 	return (0);
564 }
565 
566 /*
567  * Receive incoming data from netgraph system. Put it on our
568  * output queue and start output if necessary.
569  */
570 static int
571 ngt_rcvdata(hook_p hook, struct mbuf *m, meta_p meta)
572 {
573 	const sc_p sc = hook->node->private;
574 	int s, error = 0;
575 
576 	if (hook != sc->hook)
577 		panic(__FUNCTION__);
578 	NG_FREE_META(meta);
579 	s = spltty();
580 	if (sc->qlen >= MAX_MBUFQ)
581 		ERROUT(ENOBUFS);
582 	m->m_nextpkt = NULL;
583 	*sc->qtail = m;
584 	sc->qtail = &m->m_nextpkt;
585 	sc->qlen++;
586 	QUEUECHECK(sc);
587 	m = NULL;
588 	if (sc->qlen == 1)
589 		ngt_start(sc->tp);
590 done:
591 	splx(s);
592 	if (m)
593 		m_freem(m);
594 	return (error);
595 }
596 
597 /*
598  * Receive control message
599  */
600 static int
601 ngt_rcvmsg(node_p node, struct ng_mesg *msg, const char *retaddr,
602 	   struct ng_mesg **rptr)
603 {
604 	const sc_p sc = (sc_p) node->private;
605 	struct ng_mesg *resp = NULL;
606 	int error = 0;
607 
608 	switch (msg->header.typecookie) {
609 	case NGM_TTY_COOKIE:
610 		switch (msg->header.cmd) {
611 		case NGM_TTY_SET_HOTCHAR:
612 		    {
613 			int     hotchar;
614 
615 			if (msg->header.arglen != sizeof(int))
616 				ERROUT(EINVAL);
617 			hotchar = *((int *) msg->data);
618 			if (hotchar != (u_char) hotchar && hotchar != -1)
619 				ERROUT(EINVAL);
620 			sc->hotchar = hotchar;	/* race condition is OK */
621 			break;
622 		    }
623 		case NGM_TTY_GET_HOTCHAR:
624 			NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
625 			if (!resp)
626 				ERROUT(ENOMEM);
627 			/* Race condition here is OK */
628 			*((int *) resp->data) = sc->hotchar;
629 			break;
630 		default:
631 			ERROUT(EINVAL);
632 		}
633 		break;
634 	default:
635 		ERROUT(EINVAL);
636 	}
637 	if (rptr)
638 		*rptr = resp;
639 	else if (resp)
640 		FREE(resp, M_NETGRAPH);
641 
642 done:
643 	FREE(msg, M_NETGRAPH);
644 	return (error);
645 }
646 
647 /******************************************************************
648 		    	INITIALIZATION
649 ******************************************************************/
650 
651 /*
652  * Handle loading and unloading for this node type
653  */
654 static int
655 ngt_mod_event(module_t mod, int event, void *data)
656 {
657 	/* struct ng_type *const type = data;*/
658 	int s, error = 0;
659 
660 	switch (event) {
661 	case MOD_LOAD:
662 #ifdef __i386__
663 		/* Insure the soft net "engine" can't run during spltty code */
664 		s = splhigh();
665 		tty_imask |= softnet_imask; /* spltty() block spl[soft]net() */
666 		net_imask |= softtty_imask; /* splimp() block splsofttty() */
667 		net_imask |= tty_imask;	    /* splimp() block spltty() */
668 		update_intr_masks();
669 		splx(s);
670 
671 		if (bootverbose)
672 			log(LOG_DEBUG, "new masks: bio %x, tty %x, net %x\n",
673 			    bio_imask, tty_imask, net_imask);
674 #endif
675 
676 		/* Register line discipline */
677 		s = spltty();
678 		if ((ngt_ldisc = ldisc_register(NETGRAPHDISC, &ngt_disc)) < 0) {
679 			splx(s);
680 			log(LOG_ERR, "%s: can't register line discipline",
681 			    __FUNCTION__);
682 			return (EIO);
683 		}
684 		splx(s);
685 		break;
686 
687 	case MOD_UNLOAD:
688 
689 		/* Unregister line discipline */
690 		s = spltty();
691 		ldisc_deregister(ngt_ldisc);
692 		splx(s);
693 		break;
694 
695 	default:
696 		error = EOPNOTSUPP;
697 		break;
698 	}
699 	return (error);
700 }
701 
702