xref: /freebsd/sys/netgraph/ng_tty.c (revision 6990ffd8a95caaba6858ad44ff1b3157d1efba8f)
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@freebsd.org>
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/mbuf.h>
66 #include <sys/malloc.h>
67 #include <sys/fcntl.h>
68 #include <sys/tty.h>
69 #include <sys/ttycom.h>
70 #include <sys/syslog.h>
71 #include <sys/errno.h>
72 #include <sys/ioccom.h>
73 
74 #include <netgraph/ng_message.h>
75 #include <netgraph/netgraph.h>
76 #include <netgraph/ng_tty.h>
77 
78 /* Misc defs */
79 #define MAX_MBUFQ		3	/* Max number of queued mbufs */
80 #define NGT_HIWATER		400	/* High water mark on output */
81 
82 /* Per-node private info */
83 struct ngt_sc {
84 	struct	tty *tp;		/* Terminal device */
85 	node_p	node;			/* Netgraph node */
86 	hook_p	hook;			/* Netgraph hook */
87 	struct	mbuf *m;		/* Incoming data buffer */
88 	struct	mbuf *qhead, **qtail;	/* Queue of outgoing mbuf's */
89 	short	qlen;			/* Length of queue */
90 	short	hotchar;		/* Hotchar, or -1 if none */
91 	u_int	flags;			/* Flags */
92 	struct	callout_handle chand;	/* See man timeout(9) */
93 };
94 typedef struct ngt_sc *sc_p;
95 
96 /* Flags */
97 #define FLG_TIMEOUT		0x0001	/* A timeout is pending */
98 #define FLG_DEBUG		0x0002
99 
100 /* Debugging */
101 #ifdef INVARIANTS
102 #define QUEUECHECK(sc)							\
103     do {								\
104       struct mbuf	**mp;						\
105       int		k;						\
106 									\
107       for (k = 0, mp = &sc->qhead;					\
108 	k <= MAX_MBUFQ && *mp;						\
109 	k++, mp = &(*mp)->m_nextpkt);					\
110       if (k != sc->qlen || k > MAX_MBUFQ || *mp || mp != sc->qtail)	\
111 	panic(__FUNCTION__ ": queue");					\
112     } while (0)
113 #else
114 #define QUEUECHECK(sc)	do {} while (0)
115 #endif
116 
117 /* Line discipline methods */
118 static int	ngt_open(dev_t dev, struct tty *tp);
119 static int	ngt_close(struct tty *tp, int flag);
120 static int	ngt_read(struct tty *tp, struct uio *uio, int flag);
121 static int	ngt_write(struct tty *tp, struct uio *uio, int flag);
122 static int	ngt_tioctl(struct tty *tp,
123 		    u_long cmd, caddr_t data, int flag, struct thread *);
124 static int	ngt_input(int c, struct tty *tp);
125 static int	ngt_start(struct tty *tp);
126 
127 /* Netgraph methods */
128 static ng_constructor_t	ngt_constructor;
129 static ng_rcvmsg_t	ngt_rcvmsg;
130 static ng_shutdown_t	ngt_shutdown;
131 static ng_newhook_t	ngt_newhook;
132 static ng_connect_t	ngt_connect;
133 static ng_rcvdata_t	ngt_rcvdata;
134 static ng_disconnect_t	ngt_disconnect;
135 static int	ngt_mod_event(module_t mod, int event, void *data);
136 
137 /* Other stuff */
138 static void	ngt_timeout(void *arg);
139 
140 #define ERROUT(x)		do { error = (x); goto done; } while (0)
141 
142 /* Line discipline descriptor */
143 static struct linesw ngt_disc = {
144 	ngt_open,
145 	ngt_close,
146 	ngt_read,
147 	ngt_write,
148 	ngt_tioctl,
149 	ngt_input,
150 	ngt_start,
151 	ttymodem,
152 	NG_TTY_DFL_HOTCHAR	/* XXX can't change this in serial driver */
153 };
154 
155 /* Netgraph node type descriptor */
156 static struct ng_type typestruct = {
157 	NG_ABI_VERSION,
158 	NG_TTY_NODE_TYPE,
159 	ngt_mod_event,
160 	ngt_constructor,
161 	ngt_rcvmsg,
162 	ngt_shutdown,
163 	ngt_newhook,
164 	NULL,
165 	ngt_connect,
166 	ngt_rcvdata,
167 	ngt_disconnect,
168 	NULL
169 };
170 NETGRAPH_INIT(tty, &typestruct);
171 
172 static int ngt_unit;
173 static int ngt_nodeop_ok;	/* OK to create/remove node */
174 static int ngt_ldisc;
175 
176 /******************************************************************
177 		    LINE DISCIPLINE METHODS
178 ******************************************************************/
179 
180 /*
181  * Set our line discipline on the tty.
182  * Called from device open routine or ttioctl() at >= splsofttty()
183  */
184 static int
185 ngt_open(dev_t dev, struct tty *tp)
186 {
187 	struct thread *const td = curthread;	/* XXX */
188 	char name[sizeof(NG_TTY_NODE_TYPE) + 8];
189 	sc_p sc;
190 	int s, error;
191 
192 	/* Super-user only */
193 	if ((error = suser_td(td)))
194 		return (error);
195 	s = splnet();
196 	(void) spltty();	/* XXX is this necessary? */
197 
198 	/* Already installed? */
199 	if (tp->t_line == NETGRAPHDISC) {
200 		sc = (sc_p) tp->t_sc;
201 		if (sc != NULL && sc->tp == tp)
202 			goto done;
203 	}
204 
205 	/* Initialize private struct */
206 	MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO);
207 	if (sc == NULL) {
208 		error = ENOMEM;
209 		goto done;
210 	}
211 	sc->tp = tp;
212 	sc->hotchar = NG_TTY_DFL_HOTCHAR;
213 	sc->qtail = &sc->qhead;
214 	QUEUECHECK(sc);
215 	callout_handle_init(&sc->chand);
216 
217 	/* Setup netgraph node */
218 	ngt_nodeop_ok = 1;
219 	error = ng_make_node_common(&typestruct, &sc->node);
220 	ngt_nodeop_ok = 0;
221 	if (error) {
222 		FREE(sc, M_NETGRAPH);
223 		goto done;
224 	}
225 	snprintf(name, sizeof(name), "%s%d", typestruct.name, ngt_unit++);
226 
227 	/* Assign node its name */
228 	if ((error = ng_name_node(sc->node, name))) {
229 		log(LOG_ERR, "%s: node name exists?\n", name);
230 		ngt_nodeop_ok = 1;
231 		NG_NODE_UNREF(sc->node);
232 		ngt_nodeop_ok = 0;
233 		goto done;
234 	}
235 
236 	/* Set back pointers */
237 	NG_NODE_SET_PRIVATE(sc->node, sc);
238 	tp->t_sc = (caddr_t) sc;
239 
240 	/*
241 	 * Pre-allocate cblocks to the an appropriate amount.
242 	 * I'm not sure what is appropriate.
243 	 */
244 	ttyflush(tp, FREAD | FWRITE);
245 	clist_alloc_cblocks(&tp->t_canq, 0, 0);
246 	clist_alloc_cblocks(&tp->t_rawq, 0, 0);
247 	clist_alloc_cblocks(&tp->t_outq,
248 	    MLEN + NGT_HIWATER, MLEN + NGT_HIWATER);
249 
250 done:
251 	/* Done */
252 	splx(s);
253 	return (error);
254 }
255 
256 /*
257  * Line specific close routine, called from device close routine
258  * and from ttioctl at >= splsofttty(). This causes the node to
259  * be destroyed as well.
260  */
261 static int
262 ngt_close(struct tty *tp, int flag)
263 {
264 	const sc_p sc = (sc_p) tp->t_sc;
265 	int s;
266 
267 	s = spltty();
268 	ttyflush(tp, FREAD | FWRITE);
269 	clist_free_cblocks(&tp->t_outq);
270 	tp->t_line = 0;
271 	if (sc != NULL) {
272 		if (sc->flags & FLG_TIMEOUT) {
273 			untimeout(ngt_timeout, sc, sc->chand);
274 			sc->flags &= ~FLG_TIMEOUT;
275 		}
276 		ngt_nodeop_ok = 1;
277 		ng_rmnode_self(sc->node);
278 		ngt_nodeop_ok = 0;
279 		tp->t_sc = NULL;
280 	}
281 	splx(s);
282 	return (0);
283 }
284 
285 /*
286  * Once the device has been turned into a node, we don't allow reading.
287  */
288 static int
289 ngt_read(struct tty *tp, struct uio *uio, int flag)
290 {
291 	return (EIO);
292 }
293 
294 /*
295  * Once the device has been turned into a node, we don't allow writing.
296  */
297 static int
298 ngt_write(struct tty *tp, struct uio *uio, int flag)
299 {
300 	return (EIO);
301 }
302 
303 /*
304  * We implement the NGIOCGINFO ioctl() defined in ng_message.h.
305  */
306 static int
307 ngt_tioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, struct thread *td)
308 {
309 	const sc_p sc = (sc_p) tp->t_sc;
310 	int s, error = 0;
311 
312 	s = spltty();
313 	switch (cmd) {
314 	case NGIOCGINFO:
315 	    {
316 		struct nodeinfo *const ni = (struct nodeinfo *) data;
317 		const node_p node = sc->node;
318 
319 		bzero(ni, sizeof(*ni));
320 		if (NG_NODE_HAS_NAME(node))
321 			strncpy(ni->name, NG_NODE_NAME(node), sizeof(ni->name) - 1);
322 		strncpy(ni->type, node->nd_type->name, sizeof(ni->type) - 1);
323 		ni->id = (u_int32_t) ng_node2ID(node);
324 		ni->hooks = NG_NODE_NUMHOOKS(node);
325 		break;
326 	    }
327 	default:
328 		ERROUT(ENOIOCTL);
329 	}
330 done:
331 	splx(s);
332 	return (error);
333 }
334 
335 /*
336  * Receive data coming from the device. We get one character at
337  * a time, which is kindof silly.
338  * Only guaranteed to be at splsofttty() or spltty().
339  */
340 static int
341 ngt_input(int c, struct tty *tp)
342 {
343 	const sc_p sc = (sc_p) tp->t_sc;
344 	const node_p node = sc->node;
345 	struct mbuf *m;
346 	int s, error = 0;
347 
348 	if (!sc || tp != sc->tp)
349 		return (0);
350 	s = spltty();
351 	if (!sc->hook)
352 		ERROUT(0);
353 
354 	/* Check for error conditions */
355 	if ((tp->t_state & TS_CONNECTED) == 0) {
356 		if (sc->flags & FLG_DEBUG)
357 			log(LOG_DEBUG, "%s: no carrier\n", NG_NODE_NAME(node));
358 		ERROUT(0);
359 	}
360 	if (c & TTY_ERRORMASK) {
361 		/* framing error or overrun on this char */
362 		if (sc->flags & FLG_DEBUG)
363 			log(LOG_DEBUG, "%s: line error %x\n",
364 			    NG_NODE_NAME(node), c & TTY_ERRORMASK);
365 		ERROUT(0);
366 	}
367 	c &= TTY_CHARMASK;
368 
369 	/* Get a new header mbuf if we need one */
370 	if (!(m = sc->m)) {
371 		MGETHDR(m, M_DONTWAIT, MT_DATA);
372 		if (!m) {
373 			if (sc->flags & FLG_DEBUG)
374 				log(LOG_ERR,
375 				    "%s: can't get mbuf\n", NG_NODE_NAME(node));
376 			ERROUT(ENOBUFS);
377 		}
378 		m->m_len = m->m_pkthdr.len = 0;
379 		m->m_pkthdr.rcvif = NULL;
380 		sc->m = m;
381 	}
382 
383 	/* Add char to mbuf */
384 	*mtod(m, u_char *) = c;
385 	m->m_data++;
386 	m->m_len++;
387 	m->m_pkthdr.len++;
388 
389 	/* Ship off mbuf if it's time */
390 	if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
391 		m->m_data = m->m_pktdat;
392 		NG_SEND_DATA_ONLY(error, sc->hook, m);
393 		sc->m = NULL;
394 	}
395 done:
396 	splx(s);
397 	return (error);
398 }
399 
400 /*
401  * This is called when the device driver is ready for more output.
402  * Called from tty system at splsofttty() or spltty().
403  * Also call from ngt_rcv_data() when a new mbuf is available for output.
404  */
405 static int
406 ngt_start(struct tty *tp)
407 {
408 	const sc_p sc = (sc_p) tp->t_sc;
409 	int s;
410 
411 	s = spltty();
412 	while (tp->t_outq.c_cc < NGT_HIWATER) {	/* XXX 2.2 specific ? */
413 		struct mbuf *m = sc->qhead;
414 
415 		/* Remove first mbuf from queue */
416 		if (!m)
417 			break;
418 		if ((sc->qhead = m->m_nextpkt) == NULL)
419 			sc->qtail = &sc->qhead;
420 		sc->qlen--;
421 		QUEUECHECK(sc);
422 
423 		/* Send as much of it as possible */
424 		while (m) {
425 			struct mbuf *m2;
426 			int     sent;
427 
428 			sent = m->m_len
429 			    - b_to_q(mtod(m, u_char *), m->m_len, &tp->t_outq);
430 			m->m_data += sent;
431 			m->m_len -= sent;
432 			if (m->m_len > 0)
433 				break;	/* device can't take no more */
434 			MFREE(m, m2);
435 			m = m2;
436 		}
437 
438 		/* Put remainder of mbuf chain (if any) back on queue */
439 		if (m) {
440 			m->m_nextpkt = sc->qhead;
441 			sc->qhead = m;
442 			if (sc->qtail == &sc->qhead)
443 				sc->qtail = &m->m_nextpkt;
444 			sc->qlen++;
445 			QUEUECHECK(sc);
446 			break;
447 		}
448 	}
449 
450 	/* Call output process whether or not there is any output. We are
451 	 * being called in lieu of ttstart and must do what it would. */
452 	if (tp->t_oproc != NULL)
453 		(*tp->t_oproc) (tp);
454 
455 	/* This timeout is needed for operation on a pseudo-tty, because the
456 	 * pty code doesn't call pppstart after it has drained the t_outq. */
457 	if (sc->qhead && (sc->flags & FLG_TIMEOUT) == 0) {
458 		sc->chand = timeout(ngt_timeout, sc, 1);
459 		sc->flags |= FLG_TIMEOUT;
460 	}
461 	splx(s);
462 	return (0);
463 }
464 
465 /*
466  * We still have data to output to the device, so try sending more.
467  */
468 static void
469 ngt_timeout(void *arg)
470 {
471 	const sc_p sc = (sc_p) arg;
472 	int s;
473 
474 	s = spltty();
475 	sc->flags &= ~FLG_TIMEOUT;
476 	ngt_start(sc->tp);
477 	splx(s);
478 }
479 
480 /******************************************************************
481 		    NETGRAPH NODE METHODS
482 ******************************************************************/
483 
484 /*
485  * Initialize a new node of this type.
486  *
487  * We only allow nodes to be created as a result of setting
488  * the line discipline on a tty, so always return an error if not.
489  */
490 static int
491 ngt_constructor(node_p node)
492 {
493 	return (EOPNOTSUPP);
494 }
495 
496 /*
497  * Add a new hook. There can only be one.
498  */
499 static int
500 ngt_newhook(node_p node, hook_p hook, const char *name)
501 {
502 	const sc_p sc = NG_NODE_PRIVATE(node);
503 	int s, error = 0;
504 
505 	if (strcmp(name, NG_TTY_HOOK))
506 		return (EINVAL);
507 	s = spltty();
508 	if (sc->hook)
509 		ERROUT(EISCONN);
510 	sc->hook = hook;
511 done:
512 	splx(s);
513 	return (error);
514 }
515 
516 /*
517  * Set the hooks into queueing mode (for outgoing packets)
518  * Force single client at a time.
519  */
520 static int
521 ngt_connect(hook_p hook)
522 {
523 	/*NG_HOOK_FORCE_WRITER(hook);
524 	NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook));*/
525 	return (0);
526 }
527 
528 /*
529  * Disconnect the hook
530  */
531 static int
532 ngt_disconnect(hook_p hook)
533 {
534 	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
535 	int s;
536 
537 	s = spltty();
538 	if (hook != sc->hook)
539 		panic(__FUNCTION__);
540 	sc->hook = NULL;
541 	m_freem(sc->m);
542 	sc->m = NULL;
543 	splx(s);
544 	return (0);
545 }
546 
547 /*
548  * Remove this node. The does the netgraph portion of the shutdown.
549  * This should only be called indirectly from ngt_close().
550  */
551 static int
552 ngt_shutdown(node_p node)
553 {
554 	const sc_p sc = NG_NODE_PRIVATE(node);
555 
556 	if (!ngt_nodeop_ok)
557 		return (EOPNOTSUPP);
558 	NG_NODE_SET_PRIVATE(node, NULL);
559 	NG_NODE_UNREF(sc->node);
560 	m_freem(sc->qhead);
561 	m_freem(sc->m);
562 	bzero(sc, sizeof(*sc));
563 	FREE(sc, M_NETGRAPH);
564 	return (0);
565 }
566 
567 /*
568  * Receive incoming data from netgraph system. Put it on our
569  * output queue and start output if necessary.
570  */
571 static int
572 ngt_rcvdata(hook_p hook, item_p item)
573 {
574 	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
575 	int s, error = 0;
576 	struct mbuf *m;
577 
578 	if (hook != sc->hook)
579 		panic(__FUNCTION__);
580 
581 	NGI_GET_M(item, m);
582 	NG_FREE_ITEM(item);
583 	s = spltty();
584 	if (sc->qlen >= MAX_MBUFQ)
585 		ERROUT(ENOBUFS);
586 	m->m_nextpkt = NULL;
587 	*sc->qtail = m;
588 	sc->qtail = &m->m_nextpkt;
589 	sc->qlen++;
590 	QUEUECHECK(sc);
591 	m = NULL;
592 	if (sc->qlen == 1)
593 		ngt_start(sc->tp);
594 done:
595 	splx(s);
596 	if (m)
597 		m_freem(m);
598 	return (error);
599 }
600 
601 /*
602  * Receive control message
603  */
604 static int
605 ngt_rcvmsg(node_p node, item_p item, hook_p lasthook)
606 {
607 	const sc_p sc = NG_NODE_PRIVATE(node);
608 	struct ng_mesg *resp = NULL;
609 	int error = 0;
610 	struct ng_mesg *msg;
611 
612 	NGI_GET_MSG(item, msg);
613 	switch (msg->header.typecookie) {
614 	case NGM_TTY_COOKIE:
615 		switch (msg->header.cmd) {
616 		case NGM_TTY_SET_HOTCHAR:
617 		    {
618 			int     hotchar;
619 
620 			if (msg->header.arglen != sizeof(int))
621 				ERROUT(EINVAL);
622 			hotchar = *((int *) msg->data);
623 			if (hotchar != (u_char) hotchar && hotchar != -1)
624 				ERROUT(EINVAL);
625 			sc->hotchar = hotchar;	/* race condition is OK */
626 			break;
627 		    }
628 		case NGM_TTY_GET_HOTCHAR:
629 			NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
630 			if (!resp)
631 				ERROUT(ENOMEM);
632 			/* Race condition here is OK */
633 			*((int *) resp->data) = sc->hotchar;
634 			break;
635 		default:
636 			ERROUT(EINVAL);
637 		}
638 		break;
639 	default:
640 		ERROUT(EINVAL);
641 	}
642 done:
643 	NG_RESPOND_MSG(error, node, item, resp);
644 	NG_FREE_MSG(msg);
645 	return (error);
646 }
647 
648 /******************************************************************
649 		    	INITIALIZATION
650 ******************************************************************/
651 
652 /*
653  * Handle loading and unloading for this node type
654  */
655 static int
656 ngt_mod_event(module_t mod, int event, void *data)
657 {
658 	/* struct ng_type *const type = data;*/
659 	int s, error = 0;
660 
661 	switch (event) {
662 	case MOD_LOAD:
663 
664 		/* Register line discipline */
665 		s = spltty();
666 		if ((ngt_ldisc = ldisc_register(NETGRAPHDISC, &ngt_disc)) < 0) {
667 			splx(s);
668 			log(LOG_ERR, "%s: can't register line discipline",
669 			    __FUNCTION__);
670 			return (EIO);
671 		}
672 		splx(s);
673 		break;
674 
675 	case MOD_UNLOAD:
676 
677 		/* Unregister line discipline */
678 		s = spltty();
679 		ldisc_deregister(ngt_ldisc);
680 		splx(s);
681 		break;
682 
683 	default:
684 		error = EOPNOTSUPP;
685 		break;
686 	}
687 	return (error);
688 }
689 
690