xref: /dragonfly/sys/netgraph7/ng_device.c (revision 36a3d1d6) 
1 /*-
2  * Copyright (c) 2002 Mark Santcroos <marks@ripe.net>
3  * Copyright (c) 2004-2005 Gleb Smirnoff <glebius@FreeBSD.org>
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  *
25  * Netgraph "device" node
26  *
27  * This node presents a /dev/ngd%d device that interfaces to an other
28  * netgraph node.
29  *
30  * $FreeBSD: src/sys/netgraph/ng_device.c,v 1.22 2006/11/02 17:37:21 andre Exp $
31  * $DragonFly: src/sys/netgraph7/ng_device.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
32  *
33  */
34 
35 #if 0
36 #define	DBG do { printf("ng_device: %s\n", __func__ ); } while (0)
37 #else
38 #define	DBG do {} while (0)
39 #endif
40 
41 #include <sys/param.h>
42 #include <sys/conf.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h>
45 #include <sys/mbuf.h>
46 #include <sys/poll.h>
47 #include <sys/queue.h>
48 #include <sys/socket.h>
49 #include <sys/systm.h>
50 #include <sys/uio.h>
51 #include <sys/vnode.h>
52 
53 #include <net/if.h>
54 #include <net/if_var.h>
55 #include <netinet/in.h>
56 #include <netinet/in_systm.h>
57 #include <netinet/ip.h>
58 
59 #include "ng_message.h"
60 #include "netgraph.h"
61 #include "ng_device.h"
62 
63 #define	ERROUT(x) do { error = (x); goto done; } while (0)
64 
65 /* Netgraph methods */
66 static int		ng_device_mod_event(module_t, int, void *);
67 static ng_constructor_t	ng_device_constructor;
68 static ng_rcvmsg_t	ng_device_rcvmsg;
69 static ng_shutdown_t	ng_device_shutdown;
70 static ng_newhook_t	ng_device_newhook;
71 static ng_rcvdata_t	ng_device_rcvdata;
72 static ng_disconnect_t	ng_device_disconnect;
73 
74 /* Netgraph type */
75 static struct ng_type ngd_typestruct = {
76 	.version =	NG_ABI_VERSION,
77 	.name =		NG_DEVICE_NODE_TYPE,
78 	.mod_event =	ng_device_mod_event,
79 	.constructor =	ng_device_constructor,
80 	.rcvmsg	=	ng_device_rcvmsg,
81 	.shutdown = 	ng_device_shutdown,
82 	.newhook =	ng_device_newhook,
83 	.rcvdata =	ng_device_rcvdata,
84 	.disconnect =	ng_device_disconnect,
85 };
86 NETGRAPH_INIT(device, &ngd_typestruct);
87 
88 /* per node data */
89 struct ngd_private {
90 	struct	ifqueue	readq;
91 	struct	ng_node	*node;
92 	struct	ng_hook	*hook;
93 	struct	cdev	*ngddev;
94 	struct	mtx	ngd_mtx;
95 	int 		unit;
96 	uint16_t	flags;
97 #define	NGDF_OPEN	0x0001
98 #define	NGDF_RWAIT	0x0002
99 };
100 typedef struct ngd_private *priv_p;
101 
102 /* unit number allocator entity */
103 static struct unrhdr *ngd_unit;
104 
105 /* Maximum number of NGD devices */
106 #define MAX_NGD	999
107 
108 static d_close_t ngdclose;
109 static d_open_t ngdopen;
110 static d_read_t ngdread;
111 static d_write_t ngdwrite;
112 #if 0
113 static d_ioctl_t ngdioctl;
114 #endif
115 static d_poll_t ngdpoll;
116 
117 static struct cdevsw ngd_cdevsw = {
118 	.d_version =	D_VERSION,
119 	.d_open =	ngdopen,
120 	.d_close =	ngdclose,
121 	.d_read =	ngdread,
122 	.d_write =	ngdwrite,
123 #if 0
124 	.d_ioctl =	ngdioctl,
125 #endif
126 	.d_poll =	ngdpoll,
127 	.d_name =	NG_DEVICE_DEVNAME,
128 };
129 
130 /******************************************************************************
131  *  Netgraph methods
132  ******************************************************************************/
133 
134 /*
135  * Handle loading and unloading for this node type.
136  */
137 static int
138 ng_device_mod_event(module_t mod, int event, void *data)
139 {
140 	int error = 0;
141 
142 	switch (event) {
143 	case MOD_LOAD:
144 		ngd_unit = new_unrhdr(0, MAX_NGD, NULL);
145 		break;
146 	case MOD_UNLOAD:
147 		delete_unrhdr(ngd_unit);
148 		break;
149 	default:
150 		error = EOPNOTSUPP;
151 		break;
152 	}
153 	return (error);
154 }
155 
156 /*
157  * create new node
158  */
159 static int
160 ng_device_constructor(node_p node)
161 {
162 	priv_p	priv;
163 
164 	DBG;
165 
166 	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
167 	if (priv == NULL)
168 		return (ENOMEM);
169 
170 	/* Allocate unit number */
171 	priv->unit = alloc_unr(ngd_unit);
172 
173 	/* Initialize mutexes and queue */
174 	mtx_init(&priv->ngd_mtx, "ng_device", NULL, MTX_DEF);
175 	mtx_init(&priv->readq.ifq_mtx, "ng_device queue", NULL, MTX_DEF);
176 	IFQ_SET_MAXLEN(&priv->readq, ifqmaxlen);
177 
178 	/* Link everything together */
179 	NG_NODE_SET_PRIVATE(node, priv);
180 	priv->node = node;
181 
182 	priv->ngddev = make_dev(&ngd_cdevsw, unit2minor(priv->unit), UID_ROOT,
183 	    GID_WHEEL, 0600, NG_DEVICE_DEVNAME "%d", priv->unit);
184 	if(priv->ngddev == NULL) {
185 		printf("%s(): make_dev() failed\n",__func__);
186 		mtx_destroy(&priv->ngd_mtx);
187 		mtx_destroy(&priv->readq.ifq_mtx);
188 		free_unr(ngd_unit, priv->unit);
189 		FREE(priv, M_NETGRAPH);
190 		return(EINVAL);
191 	}
192 	/* XXX: race here? */
193 	priv->ngddev->si_drv1 = priv;
194 
195 	return(0);
196 }
197 
198 /*
199  * Process control message.
200  */
201 
202 static int
203 ng_device_rcvmsg(node_p node, item_p item, hook_p lasthook)
204 {
205 	const priv_p priv = NG_NODE_PRIVATE(node);
206 	struct ng_mesg *msg;
207 	struct ng_mesg *resp = NULL;
208 	int error = 0;
209 
210 	NGI_GET_MSG(item, msg);
211 
212 	if (msg->header.typecookie == NGM_DEVICE_COOKIE) {
213 		switch (msg->header.cmd) {
214 		case NGM_DEVICE_GET_DEVNAME:
215 			/* XXX: Fix when MAX_NGD us bigger */
216 			NG_MKRESPONSE(resp, msg,
217 			    strlen(NG_DEVICE_DEVNAME) + 4, M_WAITOK);
218 
219 			if (resp == NULL)
220 				ERROUT(ENOMEM);
221 
222 			strlcpy((char *)resp->data, priv->ngddev->si_name,
223 			    strlen(priv->ngddev->si_name) + 1);
224 			break;
225 
226 		default:
227 			error = EINVAL;
228 			break;
229 		}
230 	} else
231 		error = EINVAL;
232 
233 done:
234 	NG_RESPOND_MSG(error, node, item, resp);
235 	NG_FREE_MSG(msg);
236 	return (error);
237 }
238 
239 /*
240  * Accept incoming hook. We support only one hook per node.
241  */
242 static int
243 ng_device_newhook(node_p node, hook_p hook, const char *name)
244 {
245 	priv_p priv = NG_NODE_PRIVATE(node);
246 
247 	DBG;
248 
249 	/* We have only one hook per node */
250 	if (priv->hook != NULL)
251 		return (EISCONN);
252 
253 	priv->hook = hook;
254 
255 	return(0);
256 }
257 
258 /*
259  * Receive data from hook, write it to device.
260  */
261 static int
262 ng_device_rcvdata(hook_p hook, item_p item)
263 {
264 	priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
265 	struct mbuf *m;
266 
267 	DBG;
268 
269 	NGI_GET_M(item, m);
270 	NG_FREE_ITEM(item);
271 
272 	IF_LOCK(&priv->readq);
273 	if (_IF_QFULL(&priv->readq)) {
274 		_IF_DROP(&priv->readq);
275 		IF_UNLOCK(&priv->readq);
276 		NG_FREE_M(m);
277 		return (ENOBUFS);
278 	}
279 
280 	_IF_ENQUEUE(&priv->readq, m);
281 	IF_UNLOCK(&priv->readq);
282 	mtx_lock(&priv->ngd_mtx);
283 	if (priv->flags & NGDF_RWAIT) {
284 		priv->flags &= ~NGDF_RWAIT;
285 		wakeup(priv);
286 	}
287 	mtx_unlock(&priv->ngd_mtx);
288 
289 	return(0);
290 }
291 
292 /*
293  * Removal of the hook destroys the node.
294  */
295 static int
296 ng_device_disconnect(hook_p hook)
297 {
298 	priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
299 
300 	DBG;
301 
302 	destroy_dev(priv->ngddev);
303 	mtx_destroy(&priv->ngd_mtx);
304 
305 	IF_DRAIN(&priv->readq);
306 	mtx_destroy(&(priv)->readq.ifq_mtx);
307 
308 	free_unr(ngd_unit, priv->unit);
309 
310 	FREE(priv, M_NETGRAPH);
311 
312 	ng_rmnode_self(NG_HOOK_NODE(hook));
313 
314 	return(0);
315 }
316 
317 /*
318  * Node shutdown. Everything is already done in disconnect method.
319  */
320 static int
321 ng_device_shutdown(node_p node)
322 {
323 	NG_NODE_UNREF(node);
324 	return (0);
325 }
326 
327 /******************************************************************************
328  *  Device methods
329  ******************************************************************************/
330 
331 /*
332  * the device is opened
333  */
334 static int
335 ngdopen(struct cdev *dev, int flag, int mode, struct thread *td)
336 {
337 	priv_p	priv = (priv_p )dev->si_drv1;
338 
339 	DBG;
340 
341 	mtx_lock(&priv->ngd_mtx);
342 	priv->flags |= NGDF_OPEN;
343 	mtx_unlock(&priv->ngd_mtx);
344 
345 	return(0);
346 }
347 
348 /*
349  * the device is closed
350  */
351 static int
352 ngdclose(struct cdev *dev, int flag, int mode, struct thread *td)
353 {
354 	priv_p	priv = (priv_p )dev->si_drv1;
355 
356 	DBG;
357 	mtx_lock(&priv->ngd_mtx);
358 	priv->flags &= ~NGDF_OPEN;
359 	mtx_unlock(&priv->ngd_mtx);
360 
361 	return(0);
362 }
363 
364 #if 0	/*
365 	 * The ioctl is transformed into netgraph control message.
366 	 * We do not process them, yet.
367 	 */
368 /*
369  * process ioctl
370  *
371  * they are translated into netgraph messages and passed on
372  *
373  */
374 static int
375 ngdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
376 {
377 	struct ngd_softc *sc = &ngd_softc;
378 	struct ngd_connection * connection = NULL;
379 	struct ngd_connection * tmp;
380 	int error = 0;
381 	struct ng_mesg *msg;
382 	struct ngd_param_s * datap;
383 
384 	DBG;
385 
386 	NG_MKMESSAGE(msg, NGM_DEVICE_COOKIE, cmd, sizeof(struct ngd_param_s),
387 			M_WAITOK);
388 	if (msg == NULL) {
389 		printf("%s(): msg == NULL\n",__func__);
390 		goto nomsg;
391 	}
392 
393 	/* pass the ioctl data into the ->data area */
394 	datap = (struct ngd_param_s *)msg->data;
395 	datap->p = addr;
396 
397 	NG_SEND_MSG_HOOK(error, sc->node, msg, connection->active_hook, 0);
398 	if(error)
399 		printf("%s(): NG_SEND_MSG_HOOK error: %d\n",__func__,error);
400 
401 nomsg:
402 
403 	return(0);
404 }
405 #endif /* if 0 */
406 
407 /*
408  * This function is called when a read(2) is done to our device.
409  * We process one mbuf from queue.
410  */
411 static int
412 ngdread(struct cdev *dev, struct uio *uio, int flag)
413 {
414 	priv_p	priv = (priv_p )dev->si_drv1;
415 	struct mbuf *m;
416 	int len, error = 0;
417 
418 	DBG;
419 
420 	/* get an mbuf */
421 	do {
422 		IF_DEQUEUE(&priv->readq, m);
423 		if (m == NULL) {
424 			if (flag & IO_NDELAY)
425 				return (EWOULDBLOCK);
426 			mtx_lock(&priv->ngd_mtx);
427 			priv->flags |= NGDF_RWAIT;
428 			if ((error = msleep(priv, &priv->ngd_mtx,
429 			    PDROP | PCATCH | (PZERO + 1),
430 			    "ngdread", 0)) != 0)
431 				return (error);
432 		}
433 	} while (m == NULL);
434 
435 	while (m && uio->uio_resid > 0 && error == 0) {
436 		len = MIN(uio->uio_resid, m->m_len);
437 		if (len != 0)
438 			error = uiomove(mtod(m, void *), len, uio);
439 		m = m_free(m);
440 	}
441 
442 	if (m)
443 		m_freem(m);
444 
445 	return (error);
446 }
447 
448 
449 /*
450  * This function is called when our device is written to.
451  * We read the data from userland into mbuf chain and pass it to the remote hook.
452  *
453  */
454 static int
455 ngdwrite(struct cdev *dev, struct uio *uio, int flag)
456 {
457 	priv_p	priv = (priv_p )dev->si_drv1;
458 	struct mbuf *m;
459 	int error = 0;
460 
461 	DBG;
462 
463 	if (uio->uio_resid == 0)
464 		return (0);
465 
466 	if (uio->uio_resid > IP_MAXPACKET)
467 		return (EIO);
468 
469 	if ((m = m_uiotombuf(uio, MB_DONTWAIT, 0, 0, M_PKTHDR)) == NULL)
470 		return (ENOBUFS);
471 
472 	NG_SEND_DATA_ONLY(error, priv->hook, m);
473 
474 	return (error);
475 }
476 
477 /*
478  * we are being polled/selected
479  * check if there is data available for read
480  */
481 static int
482 ngdpoll(struct cdev *dev, int events, struct thread *td)
483 {
484 	priv_p	priv = (priv_p )dev->si_drv1;
485 	int revents = 0;
486 
487 	if (events & (POLLIN | POLLRDNORM) &&
488 	    !IFQ_IS_EMPTY(&priv->readq))
489 		revents |= events & (POLLIN | POLLRDNORM);
490 
491 	return (revents);
492 }
493