ng_device.c revision 141341
1/*- 2 * Copyright (c) 2002 Mark Santcroos <marks@ripe.net> 3 * Copyright (c) 2004 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: head/sys/netgraph/ng_device.c 141341 2005-02-05 08:28:36Z ru $ 31 * 32 */ 33 34#if 0 35#define DBG do { printf("ng_device: %s\n", __func__ ); } while (0) 36#else 37#define DBG do {} while (0) 38#endif 39 40#include <sys/param.h> 41#include <sys/conf.h> 42#include <sys/ioccom.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 <netgraph/ng_message.h> 60#include <netgraph/netgraph.h> 61#include <netgraph/ng_device.h> 62 63#define ERROUT(x) do { error = (x); goto done; } while (0) 64 65/* Netgraph methods */ 66static int ng_device_mod_event(module_t, int, void *); 67static ng_constructor_t ng_device_constructor; 68static ng_rcvmsg_t ng_device_rcvmsg; 69static ng_shutdown_t ng_device_shutdown; 70static ng_newhook_t ng_device_newhook; 71static ng_rcvdata_t ng_device_rcvdata; 72static ng_disconnect_t ng_device_disconnect; 73 74/* Netgraph type */ 75static 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}; 86NETGRAPH_INIT(device, &ngd_typestruct); 87 88/* per node data */ 89struct ngd_private { 90 struct ifqueue readq; 91 SLIST_ENTRY(ngd_private) links; 92 struct ng_node *node; 93 struct ng_hook *hook; 94 struct cdev *ngddev; 95 struct mtx ngd_mtx; 96 int unit; 97 uint16_t flags; 98#define NGDF_OPEN 0x0001 99#define NGDF_RWAIT 0x0002 100}; 101typedef struct ngd_private *priv_p; 102 103/* List of all active nodes and mutex to protect it */ 104static SLIST_HEAD(, ngd_private) ngd_nodes = SLIST_HEAD_INITIALIZER(ngd_nodes); 105static struct mtx ng_device_mtx; 106 107/* Maximum number of NGD devices */ 108#define MAX_NGD 25 /* should be more than enough for now */ 109 110static d_close_t ngdclose; 111static d_open_t ngdopen; 112static d_read_t ngdread; 113static d_write_t ngdwrite; 114#if 0 115static d_ioctl_t ngdioctl; 116#endif 117static d_poll_t ngdpoll; 118 119static struct cdevsw ngd_cdevsw = { 120 .d_version = D_VERSION, 121 .d_open = ngdopen, 122 .d_close = ngdclose, 123 .d_read = ngdread, 124 .d_write = ngdwrite, 125#if 0 126 .d_ioctl = ngdioctl, 127#endif 128 .d_poll = ngdpoll, 129 .d_name = NG_DEVICE_DEVNAME, 130}; 131 132/* Helper functions */ 133static int get_free_unit(void); 134 135/****************************************************************************** 136 * Netgraph methods 137 ******************************************************************************/ 138 139/* 140 * create new node 141 */ 142static int 143ng_device_constructor(node_p node) 144{ 145 priv_p priv; 146 147 DBG; 148 149 MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT | M_ZERO); 150 if (priv == NULL) 151 return (ENOMEM); 152 153 mtx_init(&priv->ngd_mtx, "ng_device", NULL, MTX_DEF); 154 mtx_lock(&priv->ngd_mtx); 155 156 mtx_lock(&ng_device_mtx); 157 158 priv->unit = get_free_unit(); 159 if(priv->unit < 0) { 160 printf("%s: No free unit found by get_free_unit(), " 161 "increase MAX_NGD\n",__func__); 162 mtx_unlock(&ng_device_mtx); 163 mtx_destroy(&priv->ngd_mtx); 164 FREE(priv, M_NETGRAPH); 165 return(EINVAL); 166 } 167 168 priv->ngddev = make_dev(&ngd_cdevsw, unit2minor(priv->unit), UID_ROOT, 169 GID_WHEEL, 0600, NG_DEVICE_DEVNAME "%d", priv->unit); 170 if(priv->ngddev == NULL) { 171 printf("%s(): make_dev() failed\n",__func__); 172 mtx_unlock(&ng_device_mtx); 173 mtx_destroy(&priv->ngd_mtx); 174 FREE(priv, M_NETGRAPH); 175 return(EINVAL); 176 } 177 178 SLIST_INSERT_HEAD(&ngd_nodes, priv, links); 179 180 mtx_unlock(&ng_device_mtx); 181 182 mtx_init(&priv->readq.ifq_mtx, "ng_device queue", NULL, MTX_DEF); 183 IFQ_SET_MAXLEN(&priv->readq, ifqmaxlen); 184 185 /* Link everything together */ 186 NG_NODE_SET_PRIVATE(node, priv); 187 priv->node = node; 188 priv->ngddev->si_drv1 = priv; 189 190 mtx_unlock(&priv->ngd_mtx); 191 192 return(0); 193} 194 195/* 196 * Process control message. 197 */ 198 199static int 200ng_device_rcvmsg(node_p node, item_p item, hook_p lasthook) 201{ 202 const priv_p priv = NG_NODE_PRIVATE(node); 203 struct ng_mesg *msg; 204 struct ng_mesg *resp = NULL; 205 int error = 0; 206 207 NGI_GET_MSG(item, msg); 208 209 if (msg->header.typecookie == NGM_DEVICE_COOKIE) { 210 switch (msg->header.cmd) { 211 case NGM_DEVICE_GET_DEVNAME: 212 /* XXX: Fix when NGD_MAX us bigger */ 213 NG_MKRESPONSE(resp, msg, 214 strlen(NG_DEVICE_DEVNAME) + 3, M_NOWAIT); 215 216 if (resp == NULL) 217 ERROUT(ENOMEM); 218 219 strlcpy((char *)resp->data, priv->ngddev->si_name, 220 strlen(priv->ngddev->si_name) + 1); 221 break; 222 223 default: 224 error = EINVAL; 225 break; 226 } 227 } else 228 error = EINVAL; 229 230done: 231 NG_RESPOND_MSG(error, node, item, resp); 232 NG_FREE_MSG(msg); 233 return (error); 234} 235 236/* 237 * Accept incoming hook. We support only one hook per node. 238 */ 239static int 240ng_device_newhook(node_p node, hook_p hook, const char *name) 241{ 242 priv_p priv = NG_NODE_PRIVATE(node); 243 244 DBG; 245 246 /* We have only one hook per node */ 247 if (priv->hook != NULL) 248 return (EISCONN); 249 250 priv->hook = hook; 251 252 return(0); 253} 254 255/* 256 * Receive data from hook, write it to device. 257 */ 258static int 259ng_device_rcvdata(hook_p hook, item_p item) 260{ 261 priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 262 struct mbuf *m; 263 264 DBG; 265 266 NGI_GET_M(item, m); 267 NG_FREE_ITEM(item); 268 269 IF_LOCK(&priv->readq); 270 if (_IF_QFULL(&priv->readq)) { 271 _IF_DROP(&priv->readq); 272 IF_UNLOCK(&priv->readq); 273 NG_FREE_M(m); 274 return (ENOBUFS); 275 } 276 277 _IF_ENQUEUE(&priv->readq, m); 278 IF_UNLOCK(&priv->readq); 279 mtx_lock(&priv->ngd_mtx); 280 if (priv->flags & NGDF_RWAIT) { 281 priv->flags &= ~NGDF_RWAIT; 282 wakeup(priv); 283 } 284 mtx_unlock(&priv->ngd_mtx); 285 286 return(0); 287} 288 289/* 290 * Removal of the hook destroys the node. 291 */ 292static int 293ng_device_disconnect(hook_p hook) 294{ 295 priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 296 297 DBG; 298 299 destroy_dev(priv->ngddev); 300 mtx_destroy(&priv->ngd_mtx); 301 302 mtx_lock(&ng_device_mtx); 303 SLIST_REMOVE(&ngd_nodes, priv, ngd_private, links); 304 mtx_unlock(&ng_device_mtx); 305 306 IF_DRAIN(&priv->readq); 307 mtx_destroy(&(priv)->readq.ifq_mtx); 308 309 FREE(priv, M_NETGRAPH); 310 311 ng_rmnode_self(NG_HOOK_NODE(hook)); 312 313 return(0); 314} 315 316/* 317 * Node shutdown. Everything is already done in disconnect method. 318 */ 319static int 320ng_device_shutdown(node_p node) 321{ 322 NG_NODE_UNREF(node); 323 return (0); 324} 325 326/****************************************************************************** 327 * Device methods 328 ******************************************************************************/ 329 330/* 331 * the device is opened 332 */ 333static int 334ngdopen(struct cdev *dev, int flag, int mode, struct thread *td) 335{ 336 priv_p priv = (priv_p )dev->si_drv1; 337 338 DBG; 339 340 mtx_lock(&priv->ngd_mtx); 341 priv->flags |= NGDF_OPEN; 342 mtx_unlock(&priv->ngd_mtx); 343 344 return(0); 345} 346 347/* 348 * the device is closed 349 */ 350static int 351ngdclose(struct cdev *dev, int flag, int mode, struct thread *td) 352{ 353 priv_p priv = (priv_p )dev->si_drv1; 354 355 DBG; 356 mtx_lock(&priv->ngd_mtx); 357 priv->flags &= ~NGDF_OPEN; 358 mtx_unlock(&priv->ngd_mtx); 359 360 return(0); 361} 362 363#if 0 /* 364 * The ioctl is transformed into netgraph control message. 365 * We do not process them, yet. 366 */ 367/* 368 * process ioctl 369 * 370 * they are translated into netgraph messages and passed on 371 * 372 */ 373static int 374ngdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td) 375{ 376 struct ngd_softc *sc = &ngd_softc; 377 struct ngd_connection * connection = NULL; 378 struct ngd_connection * tmp; 379 int error = 0; 380 struct ng_mesg *msg; 381 struct ngd_param_s * datap; 382 383 DBG; 384 385 SLIST_FOREACH(tmp,&sc->head,links) { 386 if(tmp->ngddev == dev) { 387 connection = tmp; 388 } 389 } 390 if(connection == NULL) { 391 printf("%s(): connection is still NULL, no dev found\n",__func__); 392 return(-1); 393 } 394 395 NG_MKMESSAGE(msg, NGM_DEVICE_COOKIE, cmd, sizeof(struct ngd_param_s), 396 M_NOWAIT); 397 if (msg == NULL) { 398 printf("%s(): msg == NULL\n",__func__); 399 goto nomsg; 400 } 401 402 /* pass the ioctl data into the ->data area */ 403 datap = (struct ngd_param_s *)msg->data; 404 datap->p = addr; 405 406 NG_SEND_MSG_HOOK(error, sc->node, msg, connection->active_hook, 0); 407 if(error) 408 printf("%s(): NG_SEND_MSG_HOOK error: %d\n",__func__,error); 409 410nomsg: 411 412 return(0); 413} 414#endif /* if 0 */ 415 416/* 417 * This function is called when a read(2) is done to our device. 418 * We process one mbuf from queue. 419 */ 420static int 421ngdread(struct cdev *dev, struct uio *uio, int flag) 422{ 423 priv_p priv = (priv_p )dev->si_drv1; 424 struct mbuf *m; 425 int len, error = 0; 426 427 DBG; 428 429 /* get an mbuf */ 430 do { 431 IF_DEQUEUE(&priv->readq, m); 432 if (m == NULL) { 433 if (flag & IO_NDELAY) 434 return (EWOULDBLOCK); 435 mtx_lock(&priv->ngd_mtx); 436 priv->flags |= NGDF_RWAIT; 437 if ((error = msleep(priv, &priv->ngd_mtx, 438 PDROP | PCATCH | (PZERO + 1), 439 "ngdread", 0)) != 0) 440 return (error); 441 } 442 } while (m == NULL); 443 444 while (m && uio->uio_resid > 0 && error == 0) { 445 len = MIN(uio->uio_resid, m->m_len); 446 if (len != 0) 447 error = uiomove(mtod(m, void *), len, uio); 448 m = m_free(m); 449 } 450 451 if (m) 452 m_freem(m); 453 454 return (error); 455} 456 457 458/* 459 * This function is called when our device is written to. 460 * We read the data from userland into mbuf chain and pass it to the remote hook. 461 * 462 */ 463static int 464ngdwrite(struct cdev *dev, struct uio *uio, int flag) 465{ 466 priv_p priv = (priv_p )dev->si_drv1; 467 struct mbuf *m; 468 int error = 0; 469 470 DBG; 471 472 if (uio->uio_resid == 0) 473 return (0); 474 475 if (uio->uio_resid < 0 || uio->uio_resid > IP_MAXPACKET) 476 return (EIO); 477 478 if ((m = m_uiotombuf(uio, M_DONTWAIT, 0)) == NULL) 479 return (ENOBUFS); 480 481 NG_SEND_DATA_ONLY(error, priv->hook, m); 482 483 return (error); 484} 485 486/* 487 * we are being polled/selected 488 * check if there is data available for read 489 */ 490static int 491ngdpoll(struct cdev *dev, int events, struct thread *td) 492{ 493 priv_p priv = (priv_p )dev->si_drv1; 494 int revents = 0; 495 496 if (events & (POLLIN | POLLRDNORM) && 497 !IFQ_IS_EMPTY(&priv->readq)) 498 revents |= events & (POLLIN | POLLRDNORM); 499 500 return (revents); 501} 502 503/****************************************************************************** 504 * Helper subroutines 505 ******************************************************************************/ 506 507static int 508get_free_unit() 509{ 510 struct ngd_private *priv = NULL; 511 int n = 0; 512 int unit = -1; 513 514 DBG; 515 516 mtx_assert(&ng_device_mtx, MA_OWNED); 517 518 /* When there is no list yet, the first device unit is always 0. */ 519 if SLIST_EMPTY(&ngd_nodes) 520 return(0); 521 522 /* Just do a brute force loop to find the first free unit that is 523 * smaller than MAX_NGD. 524 * Set MAX_NGD to a large value, doesn't impact performance. 525 */ 526 for(n = 0; n<MAX_NGD && unit == -1; n++) { 527 SLIST_FOREACH(priv, &ngd_nodes, links) { 528 529 if(priv->unit == n) { 530 unit = -1; 531 break; 532 } 533 unit = n; 534 } 535 } 536 537 return (unit); 538} 539 540/* 541 * Handle loading and unloading for this node type. 542 */ 543static int 544ng_device_mod_event(module_t mod, int event, void *data) 545{ 546 int error = 0; 547 548 switch (event) { 549 case MOD_LOAD: 550 mtx_init(&ng_device_mtx, "ng_device", NULL, MTX_DEF); 551 break; 552 case MOD_UNLOAD: 553 mtx_destroy(&ng_device_mtx); 554 break; 555 default: 556 error = EOPNOTSUPP; 557 break; 558 } 559 return (error); 560} 561