[dragonfly.git] / sys / netgraph7 / ng_device.c

/*-
 * Copyright (c) 2002 Mark Santcroos <marks@ripe.net>
 * Copyright (c) 2004-2005 Gleb Smirnoff <glebius@FreeBSD.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 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 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Netgraph "device" node
 *
 * This node presents a /dev/ngd%d device that interfaces to an other
 * netgraph node.
 *
 * $FreeBSD: src/sys/netgraph/ng_device.c,v 1.22 2006/11/02 17:37:21 andre Exp $
 * $DragonFly: src/sys/netgraph7/ng_device.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
 *
 */

#if 0
#define	DBG do { printf("ng_device: %s\n", __func__ ); } while (0)
#else
#define	DBG do {} while (0)
#endif

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/poll.h>
#include <sys/queue.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/uio.h>
#include <sys/vnode.h>

#include <net/if.h>
#include <net/if_var.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>

#include "ng_message.h"
#include "netgraph.h"
#include "ng_device.h"

#define	ERROUT(x) do { error = (x); goto done; } while (0)

/* Netgraph methods */
static int		ng_device_mod_event(module_t, int, void *);
static ng_constructor_t	ng_device_constructor;
static ng_rcvmsg_t	ng_device_rcvmsg;
static ng_shutdown_t	ng_device_shutdown;
static ng_newhook_t	ng_device_newhook;
static ng_rcvdata_t	ng_device_rcvdata;
static ng_disconnect_t	ng_device_disconnect;

/* Netgraph type */
static struct ng_type ngd_typestruct = {
	.version =	NG_ABI_VERSION,
	.name =		NG_DEVICE_NODE_TYPE,
	.mod_event =	ng_device_mod_event,
	.constructor =	ng_device_constructor,
	.rcvmsg	=	ng_device_rcvmsg,
	.shutdown = 	ng_device_shutdown,
	.newhook =	ng_device_newhook,
	.rcvdata =	ng_device_rcvdata,
	.disconnect =	ng_device_disconnect,
};
NETGRAPH_INIT(device, &ngd_typestruct);

/* per node data */
struct ngd_private {
	struct	ifqueue	readq;
	struct	ng_node	*node;
	struct	ng_hook	*hook;
	struct	cdev	*ngddev;
	struct	mtx	ngd_mtx;
	int 		unit;
	uint16_t	flags;
#define	NGDF_OPEN	0x0001
#define	NGDF_RWAIT	0x0002
};
typedef struct ngd_private *priv_p;

/* unit number allocator entity */
static struct unrhdr *ngd_unit;

/* Maximum number of NGD devices */
#define MAX_NGD	999

static d_close_t ngdclose;
static d_open_t ngdopen;
static d_read_t ngdread;
static d_write_t ngdwrite;
#if 0
static d_ioctl_t ngdioctl;
#endif
static d_poll_t ngdpoll;

static struct cdevsw ngd_cdevsw = {
	.d_version =	D_VERSION,
	.d_open =	ngdopen,
	.d_close =	ngdclose,
	.d_read =	ngdread,
	.d_write =	ngdwrite,
#if 0
	.d_ioctl =	ngdioctl,
#endif
	.d_poll =	ngdpoll,
	.d_name =	NG_DEVICE_DEVNAME,
};

/******************************************************************************
 *  Netgraph methods
 ******************************************************************************/

/*
 * Handle loading and unloading for this node type.
 */
static int
ng_device_mod_event(module_t mod, int event, void *data)
{
	int error = 0;

	switch (event) {
	case MOD_LOAD:
		ngd_unit = new_unrhdr(0, MAX_NGD, NULL);
		break;
	case MOD_UNLOAD:
		delete_unrhdr(ngd_unit);
		break;
	default:
		error = EOPNOTSUPP;
		break;
	}
	return (error);
}

/*
 * create new node
 */
static int
ng_device_constructor(node_p node)
{
	priv_p	priv;

	DBG;

	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
	if (priv == NULL)
		return (ENOMEM);

	/* Allocate unit number */
	priv->unit = alloc_unr(ngd_unit);

	/* Initialize mutexes and queue */
	mtx_init(&priv->ngd_mtx, "ng_device", NULL, MTX_DEF);
	mtx_init(&priv->readq.ifq_mtx, "ng_device queue", NULL, MTX_DEF);
	IFQ_SET_MAXLEN(&priv->readq, ifqmaxlen);

	/* Link everything together */
	NG_NODE_SET_PRIVATE(node, priv);
	priv->node = node;

	priv->ngddev = make_dev(&ngd_cdevsw, unit2minor(priv->unit), UID_ROOT,
	    GID_WHEEL, 0600, NG_DEVICE_DEVNAME "%d", priv->unit);
	if(priv->ngddev == NULL) {
		printf("%s(): make_dev() failed\n",__func__);
		mtx_destroy(&priv->ngd_mtx);
		mtx_destroy(&priv->readq.ifq_mtx);
		free_unr(ngd_unit, priv->unit);
		FREE(priv, M_NETGRAPH);
		return(EINVAL);
	}
	/* XXX: race here? */
	priv->ngddev->si_drv1 = priv;

	return(0);
}

/*
 * Process control message.
 */

static int
ng_device_rcvmsg(node_p node, item_p item, hook_p lasthook)
{
	const priv_p priv = NG_NODE_PRIVATE(node);
	struct ng_mesg *msg;
	struct ng_mesg *resp = NULL;
	int error = 0;

	NGI_GET_MSG(item, msg);

	if (msg->header.typecookie == NGM_DEVICE_COOKIE) {
		switch (msg->header.cmd) {
		case NGM_DEVICE_GET_DEVNAME:
			/* XXX: Fix when MAX_NGD us bigger */
			NG_MKRESPONSE(resp, msg,
			    strlen(NG_DEVICE_DEVNAME) + 4, M_WAITOK);

			if (resp == NULL)
				ERROUT(ENOMEM);

			strlcpy((char *)resp->data, priv->ngddev->si_name,
			    strlen(priv->ngddev->si_name) + 1);
			break;

		default:
			error = EINVAL;
			break;
		}
	} else
		error = EINVAL;

done:
	NG_RESPOND_MSG(error, node, item, resp);
	NG_FREE_MSG(msg);
	return (error);
}

/*
 * Accept incoming hook. We support only one hook per node.
 */
static int
ng_device_newhook(node_p node, hook_p hook, const char *name)
{
	priv_p priv = NG_NODE_PRIVATE(node);

	DBG;

	/* We have only one hook per node */
	if (priv->hook != NULL)
		return (EISCONN);

	priv->hook = hook;

	return(0);
}

/*
 * Receive data from hook, write it to device.
 */
static int
ng_device_rcvdata(hook_p hook, item_p item)
{
	priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
	struct mbuf *m;

	DBG;

	NGI_GET_M(item, m);
	NG_FREE_ITEM(item);

	IF_LOCK(&priv->readq);
	if (_IF_QFULL(&priv->readq)) {
		_IF_DROP(&priv->readq);
		IF_UNLOCK(&priv->readq);
		NG_FREE_M(m);
		return (ENOBUFS);
	}

	_IF_ENQUEUE(&priv->readq, m);
	IF_UNLOCK(&priv->readq);
	mtx_lock(&priv->ngd_mtx);
	if (priv->flags & NGDF_RWAIT) {
		priv->flags &= ~NGDF_RWAIT;
		wakeup(priv);
	}
	mtx_unlock(&priv->ngd_mtx);

	return(0);
}

/*
 * Removal of the hook destroys the node.
 */
static int
ng_device_disconnect(hook_p hook)
{
	priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));

	DBG;

	destroy_dev(priv->ngddev);
	mtx_destroy(&priv->ngd_mtx);

	IF_DRAIN(&priv->readq);
	mtx_destroy(&(priv)->readq.ifq_mtx);

	free_unr(ngd_unit, priv->unit);

	FREE(priv, M_NETGRAPH);

	ng_rmnode_self(NG_HOOK_NODE(hook));

	return(0);
}

/*
 * Node shutdown. Everything is already done in disconnect method.
 */
static int
ng_device_shutdown(node_p node)
{
	NG_NODE_UNREF(node);
	return (0);
}

/******************************************************************************
 *  Device methods
 ******************************************************************************/

/*
 * the device is opened
 */
static int
ngdopen(struct cdev *dev, int flag, int mode, struct thread *td)
{
	priv_p	priv = (priv_p )dev->si_drv1;

	DBG;

	mtx_lock(&priv->ngd_mtx);
	priv->flags |= NGDF_OPEN;
	mtx_unlock(&priv->ngd_mtx);

	return(0);
}

/*
 * the device is closed
 */
static int
ngdclose(struct cdev *dev, int flag, int mode, struct thread *td)
{
	priv_p	priv = (priv_p )dev->si_drv1;

	DBG;
	mtx_lock(&priv->ngd_mtx);
	priv->flags &= ~NGDF_OPEN;
	mtx_unlock(&priv->ngd_mtx);

	return(0);
}

#if 0	/*
	 * The ioctl is transformed into netgraph control message.
	 * We do not process them, yet.
	 */
/*
 * process ioctl
 *
 * they are translated into netgraph messages and passed on
 *
 */
static int
ngdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
{
	struct ngd_softc *sc = &ngd_softc;
	struct ngd_connection * connection = NULL;
	struct ngd_connection * tmp;
	int error = 0;
	struct ng_mesg *msg;
	struct ngd_param_s * datap;

	DBG;

	NG_MKMESSAGE(msg, NGM_DEVICE_COOKIE, cmd, sizeof(struct ngd_param_s),
			M_WAITOK);
	if (msg == NULL) {
		printf("%s(): msg == NULL\n",__func__);
		goto nomsg;
	}

	/* pass the ioctl data into the ->data area */
	datap = (struct ngd_param_s *)msg->data;
	datap->p = addr;

	NG_SEND_MSG_HOOK(error, sc->node, msg, connection->active_hook, 0);
	if(error)
		printf("%s(): NG_SEND_MSG_HOOK error: %d\n",__func__,error);

nomsg:

	return(0);
}
#endif /* if 0 */

/*
 * This function is called when a read(2) is done to our device.
 * We process one mbuf from queue.
 */
static int
ngdread(struct cdev *dev, struct uio *uio, int flag)
{
	priv_p	priv = (priv_p )dev->si_drv1;
	struct mbuf *m;
	int len, error = 0;

	DBG;

	/* get an mbuf */
	do {
		IF_DEQUEUE(&priv->readq, m);
		if (m == NULL) {
			if (flag & IO_NDELAY)
				return (EWOULDBLOCK);
			mtx_lock(&priv->ngd_mtx);
			priv->flags |= NGDF_RWAIT;
			if ((error = msleep(priv, &priv->ngd_mtx,
			    PDROP | PCATCH | (PZERO + 1),
			    "ngdread", 0)) != 0)
				return (error);
		}
	} while (m == NULL);

	while (m && uio->uio_resid > 0 && error == 0) {
		len = MIN(uio->uio_resid, m->m_len);
		if (len != 0)
			error = uiomove(mtod(m, void *), len, uio);
		m = m_free(m);
	}

	if (m)
		m_freem(m);

	return (error);
}


/*
 * This function is called when our device is written to.
 * We read the data from userland into mbuf chain and pass it to the remote hook.
 *
 */
static int
ngdwrite(struct cdev *dev, struct uio *uio, int flag)
{
	priv_p	priv = (priv_p )dev->si_drv1;
	struct mbuf *m;
	int error = 0;

	DBG;

	if (uio->uio_resid == 0)
		return (0);

	if (uio->uio_resid > IP_MAXPACKET)
		return (EIO);

	if ((m = m_uiotombuf(uio, MB_DONTWAIT, 0, 0, M_PKTHDR)) == NULL)
		return (ENOBUFS);

	NG_SEND_DATA_ONLY(error, priv->hook, m);

	return (error);
}

/*
 * we are being polled/selected
 * check if there is data available for read
 */
static int
ngdpoll(struct cdev *dev, int events, struct thread *td)
{
	priv_p	priv = (priv_p )dev->si_drv1;
	int revents = 0;

	if (events & (POLLIN | POLLRDNORM) &&
	    !IFQ_IS_EMPTY(&priv->readq))
		revents |= events & (POLLIN | POLLRDNORM);

	return (revents);
}
Commit	Line	Data
b06ebda0 MD	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 $
5a975a3d	31	* $DragonFly: src/sys/netgraph7/ng_device.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
b06ebda0 MD	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>
b06ebda0 MD	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
5a975a3d MD	59	#include "ng_message.h"
	60	#include "netgraph.h"
	61	#include "ng_device.h"
b06ebda0 MD	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
5a975a3d	166	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK \| M_ZERO);
b06ebda0 MD	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,
5a975a3d	217	strlen(NG_DEVICE_DEVNAME) + 4, M_WAITOK);
b06ebda0 MD	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),
5a975a3d	387	M_WAITOK);
b06ebda0 MD	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
e54488bb	466	if (uio->uio_resid > IP_MAXPACKET)
b06ebda0 MD	467	return (EIO);
b06ebda0 MD	468
5a975a3d	469	if ((m = m_uiotombuf(uio, MB_DONTWAIT, 0, 0, M_PKTHDR)) == NULL)
b06ebda0 MD	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	}