The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netgraph/ng_eiface.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  *
    3  * Copyright (c) 1999-2001, Vitaly V Belekhov
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice unmodified, this list of conditions, and the following
   11  *    disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  *
   28  * $FreeBSD: releng/6.0/sys/netgraph/ng_eiface.c 149443 2005-08-25 05:01:24Z rwatson $
   29  */
   30 
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/errno.h>
   34 #include <sys/kernel.h>
   35 #include <sys/malloc.h>
   36 #include <sys/mbuf.h>
   37 #include <sys/errno.h>
   38 #include <sys/sockio.h>
   39 #include <sys/socket.h>
   40 #include <sys/syslog.h>
   41 
   42 #include <net/if.h>
   43 #include <net/if_dl.h>
   44 #include <net/if_types.h>
   45 #include <net/netisr.h>
   46 
   47 #include <netgraph/ng_message.h>
   48 #include <netgraph/netgraph.h>
   49 #include <netgraph/ng_parse.h>
   50 #include <netgraph/ng_eiface.h>
   51 
   52 #include <net/bpf.h>
   53 #include <net/ethernet.h>
   54 #include <net/if_arp.h>
   55 
   56 static const struct ng_cmdlist ng_eiface_cmdlist[] = {
   57         {
   58           NGM_EIFACE_COOKIE,
   59           NGM_EIFACE_GET_IFNAME,
   60           "getifname",
   61           NULL,
   62           &ng_parse_string_type
   63         },
   64         {
   65           NGM_EIFACE_COOKIE,
   66           NGM_EIFACE_SET,
   67           "set",
   68           &ng_parse_enaddr_type,
   69           NULL
   70         },
   71         { 0 }
   72 };
   73 
   74 /* Node private data */
   75 struct ng_eiface_private {
   76         struct ifnet    *ifp;           /* per-interface network data */
   77         int             unit;           /* Interface unit number */
   78         node_p          node;           /* Our netgraph node */
   79         hook_p          ether;          /* Hook for ethernet stream */
   80 };
   81 typedef struct ng_eiface_private *priv_p;
   82 
   83 /* Interface methods */
   84 static void     ng_eiface_init(void *xsc);
   85 static void     ng_eiface_start(struct ifnet *ifp);
   86 static int      ng_eiface_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
   87 #ifdef DEBUG
   88 static void     ng_eiface_print_ioctl(struct ifnet *ifp, int cmd, caddr_t data);
   89 #endif
   90 
   91 /* Netgraph methods */
   92 static int              ng_eiface_mod_event(module_t, int, void *);
   93 static ng_constructor_t ng_eiface_constructor;
   94 static ng_rcvmsg_t      ng_eiface_rcvmsg;
   95 static ng_shutdown_t    ng_eiface_rmnode;
   96 static ng_newhook_t     ng_eiface_newhook;
   97 static ng_rcvdata_t     ng_eiface_rcvdata;
   98 static ng_disconnect_t  ng_eiface_disconnect;
   99 
  100 /* Node type descriptor */
  101 static struct ng_type typestruct = {
  102         .version =      NG_ABI_VERSION,
  103         .name =         NG_EIFACE_NODE_TYPE,
  104         .mod_event =    ng_eiface_mod_event,
  105         .constructor =  ng_eiface_constructor,
  106         .rcvmsg =       ng_eiface_rcvmsg,
  107         .shutdown =     ng_eiface_rmnode,
  108         .newhook =      ng_eiface_newhook,
  109         .rcvdata =      ng_eiface_rcvdata,
  110         .disconnect =   ng_eiface_disconnect,
  111         .cmdlist =      ng_eiface_cmdlist
  112 };
  113 NETGRAPH_INIT(eiface, &typestruct);
  114 
  115 static struct unrhdr    *ng_eiface_unit;
  116 
  117 /************************************************************************
  118                         INTERFACE STUFF
  119  ************************************************************************/
  120 
  121 /*
  122  * Process an ioctl for the virtual interface
  123  */
  124 static int
  125 ng_eiface_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
  126 {
  127         struct ifreq *const ifr = (struct ifreq *)data;
  128         int s, error = 0;
  129 
  130 #ifdef DEBUG
  131         ng_eiface_print_ioctl(ifp, command, data);
  132 #endif
  133         s = splimp();
  134         switch (command) {
  135 
  136         /* These two are mostly handled at a higher layer */
  137         case SIOCSIFADDR:
  138                 error = ether_ioctl(ifp, command, data);
  139                 break;
  140         case SIOCGIFADDR:
  141                 break;
  142 
  143         /* Set flags */
  144         case SIOCSIFFLAGS:
  145                 /*
  146                  * If the interface is marked up and stopped, then start it.
  147                  * If it is marked down and running, then stop it.
  148                  */
  149                 if (ifr->ifr_flags & IFF_UP) {
  150                         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
  151                                 ifp->if_drv_flags &= ~(IFF_DRV_OACTIVE);
  152                                 ifp->if_drv_flags |= IFF_DRV_RUNNING;
  153                         }
  154                 } else {
  155                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
  156                                 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING |
  157                                     IFF_DRV_OACTIVE);
  158                 }
  159                 break;
  160 
  161         /* Set the interface MTU */
  162         case SIOCSIFMTU:
  163                 if (ifr->ifr_mtu > NG_EIFACE_MTU_MAX ||
  164                     ifr->ifr_mtu < NG_EIFACE_MTU_MIN)
  165                         error = EINVAL;
  166                 else
  167                         ifp->if_mtu = ifr->ifr_mtu;
  168                 break;
  169 
  170         /* Stuff that's not supported */
  171         case SIOCADDMULTI:
  172         case SIOCDELMULTI:
  173                 error = 0;
  174                 break;
  175         case SIOCSIFPHYS:
  176                 error = EOPNOTSUPP;
  177                 break;
  178 
  179         default:
  180                 error = EINVAL;
  181                 break;
  182         }
  183         splx(s);
  184         return (error);
  185 }
  186 
  187 static void
  188 ng_eiface_init(void *xsc)
  189 {
  190         priv_p sc = xsc;
  191         struct ifnet *ifp = sc->ifp;
  192         int s;
  193 
  194         s = splimp();
  195 
  196         ifp->if_drv_flags |= IFF_DRV_RUNNING;
  197         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  198 
  199         splx(s);
  200 }
  201 
  202 /*
  203  * We simply relay the packet to the "ether" hook, if it is connected.
  204  * We have been through the netgraph locking and are guaranteed to
  205  * be the only code running in this node at this time.
  206  */
  207 static void
  208 ng_eiface_start2(node_p node, hook_p hook, void *arg1, int arg2)
  209 {
  210         struct ifnet *ifp = arg1;
  211         const priv_p priv = (priv_p)ifp->if_softc;
  212         int len, error = 0;
  213         struct mbuf *m;
  214 
  215         /* Check interface flags */
  216 
  217         if (!((ifp->if_flags & IFF_UP) &&
  218             (ifp->if_drv_flags & IFF_DRV_RUNNING)))
  219                 return;
  220 
  221         /* Don't do anything if output is active */
  222         if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
  223                 return;
  224 
  225         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  226 
  227         /*
  228          * Grab a packet to transmit.
  229          */
  230         IF_DEQUEUE(&ifp->if_snd, m);
  231 
  232         /* If there's nothing to send, return. */
  233         if (m == NULL) {
  234                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  235                 return;
  236         }
  237 
  238         /*
  239          * Berkeley packet filter.
  240          * Pass packet to bpf if there is a listener.
  241          * XXX is this safe? locking?
  242          */
  243         BPF_MTAP(ifp, m);
  244 
  245         /* Copy length before the mbuf gets invalidated */
  246         len = m->m_pkthdr.len;
  247 
  248         /*
  249          * Send packet; if hook is not connected, mbuf will get
  250          * freed.
  251          */
  252         NG_SEND_DATA_ONLY(error, priv->ether, m);
  253 
  254         /* Update stats */
  255         if (error == 0) {
  256                 ifp->if_obytes += len;
  257                 ifp->if_opackets++;
  258         }
  259 
  260         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  261 
  262         return;
  263 }
  264 
  265 /*
  266  * This routine is called to deliver a packet out the interface.
  267  * We simply queue the netgraph version to be called when netgraph locking
  268  * allows it to happen.
  269  * Until we know what the rest of the networking code is doing for
  270  * locking, we don't know how we will interact with it.
  271  * Take comfort from the fact that the ifnet struct is part of our
  272  * private info and can't go away while we are queued.
  273  * [Though we don't know it is still there now....]
  274  * it is possible we don't gain anything from this because
  275  * we would like to get the mbuf and queue it as data
  276  * somehow, but we can't and if we did would we solve anything?
  277  */
  278 static void
  279 ng_eiface_start(struct ifnet *ifp)
  280 {
  281 
  282         const priv_p priv = (priv_p)ifp->if_softc;
  283 
  284         ng_send_fn(priv->node, NULL, &ng_eiface_start2, ifp, 0);
  285 }
  286 
  287 #ifdef DEBUG
  288 /*
  289  * Display an ioctl to the virtual interface
  290  */
  291 
  292 static void
  293 ng_eiface_print_ioctl(struct ifnet *ifp, int command, caddr_t data)
  294 {
  295         char *str;
  296 
  297         switch (command & IOC_DIRMASK) {
  298         case IOC_VOID:
  299                 str = "IO";
  300                 break;
  301         case IOC_OUT:
  302                 str = "IOR";
  303                 break;
  304         case IOC_IN:
  305                 str = "IOW";
  306                 break;
  307         case IOC_INOUT:
  308                 str = "IORW";
  309                 break;
  310         default:
  311                 str = "IO??";
  312         }
  313         log(LOG_DEBUG, "%s: %s('%c', %d, char[%d])\n",
  314             ifp->if_xname,
  315             str,
  316             IOCGROUP(command),
  317             command & 0xff,
  318             IOCPARM_LEN(command));
  319 }
  320 #endif /* DEBUG */
  321 
  322 /************************************************************************
  323                         NETGRAPH NODE STUFF
  324  ************************************************************************/
  325 
  326 /*
  327  * Constructor for a node
  328  */
  329 static int
  330 ng_eiface_constructor(node_p node)
  331 {
  332         struct ifnet *ifp;
  333         priv_p priv;
  334         u_char eaddr[6] = {0,0,0,0,0,0};
  335 
  336         /* Allocate node and interface private structures */
  337         MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT | M_ZERO);
  338         if (priv == NULL)
  339                 return (ENOMEM);
  340 
  341         ifp = priv->ifp = if_alloc(IFT_ETHER);
  342         if (ifp == NULL) {
  343                 free(priv, M_NETGRAPH);
  344                 return (ENOSPC);
  345         }
  346 
  347         /* Link them together */
  348         ifp->if_softc = priv;
  349 
  350         /* Get an interface unit number */
  351         priv->unit = alloc_unr(ng_eiface_unit);
  352 
  353         /* Link together node and private info */
  354         NG_NODE_SET_PRIVATE(node, priv);
  355         priv->node = node;
  356 
  357         /* Initialize interface structure */
  358         if_initname(ifp, NG_EIFACE_EIFACE_NAME, priv->unit);
  359         ifp->if_init = ng_eiface_init;
  360         ifp->if_output = ether_output;
  361         ifp->if_start = ng_eiface_start;
  362         ifp->if_ioctl = ng_eiface_ioctl;
  363         ifp->if_watchdog = NULL;
  364         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
  365         ifp->if_flags = (IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST);
  366 
  367 #if 0
  368         /* Give this node name */
  369         bzero(ifname, sizeof(ifname));
  370         sprintf(ifname, "if%s", ifp->if_xname);
  371         (void)ng_name_node(node, ifname);
  372 #endif
  373 
  374         /* Attach the interface */
  375         ether_ifattach(ifp, eaddr);
  376 
  377         /* Done */
  378         return (0);
  379 }
  380 
  381 /*
  382  * Give our ok for a hook to be added
  383  */
  384 static int
  385 ng_eiface_newhook(node_p node, hook_p hook, const char *name)
  386 {
  387         priv_p priv = NG_NODE_PRIVATE(node);
  388         struct ifnet *ifp = priv->ifp;
  389 
  390         if (strcmp(name, NG_EIFACE_HOOK_ETHER))
  391                 return (EPFNOSUPPORT);
  392         if (priv->ether != NULL)
  393                 return (EISCONN);
  394         priv->ether = hook;
  395         NG_HOOK_SET_PRIVATE(hook, &priv->ether);
  396 
  397         if_link_state_change(ifp, LINK_STATE_UP);
  398 
  399         return (0);
  400 }
  401 
  402 /*
  403  * Receive a control message
  404  */
  405 static int
  406 ng_eiface_rcvmsg(node_p node, item_p item, hook_p lasthook)
  407 {
  408         const priv_p priv = NG_NODE_PRIVATE(node);
  409         struct ifnet *const ifp = priv->ifp;
  410         struct ng_mesg *resp = NULL;
  411         int error = 0;
  412         struct ng_mesg *msg;
  413 
  414         NGI_GET_MSG(item, msg);
  415         switch (msg->header.typecookie) {
  416         case NGM_EIFACE_COOKIE:
  417                 switch (msg->header.cmd) {
  418 
  419                 case NGM_EIFACE_SET:
  420                     {
  421                         struct ether_addr *eaddr;
  422                         struct ifaddr *ifa;
  423                         struct sockaddr_dl *sdl;
  424 
  425                         if (msg->header.arglen != sizeof(struct ether_addr)) {
  426                                 error = EINVAL;
  427                                 break;
  428                         }
  429                         eaddr = (struct ether_addr *)(msg->data);
  430                         bcopy(eaddr, IFP2ENADDR(priv->ifp),
  431                             ETHER_ADDR_LEN);
  432 
  433                         /* And put it in the ifaddr list */
  434                         TAILQ_FOREACH(ifa, &(ifp->if_addrhead), ifa_link) {
  435                                 sdl = (struct sockaddr_dl *)ifa->ifa_addr;
  436                                 if (sdl->sdl_type == IFT_ETHER) {
  437                                         bcopy(IFP2ENADDR(ifp),
  438                                                 LLADDR(sdl), ifp->if_addrlen);
  439                                         break;
  440                                 }
  441                         }
  442                         break;
  443                     }
  444 
  445                 case NGM_EIFACE_GET_IFNAME:
  446                         NG_MKRESPONSE(resp, msg, IFNAMSIZ, M_NOWAIT);
  447                         if (resp == NULL) {
  448                                 error = ENOMEM;
  449                                 break;
  450                         }
  451                         strlcpy(resp->data, ifp->if_xname, IFNAMSIZ);
  452                         break;
  453 
  454                 case NGM_EIFACE_GET_IFADDRS:
  455                     {
  456                         struct ifaddr *ifa;
  457                         caddr_t ptr;
  458                         int buflen;
  459 
  460 #define SA_SIZE(s)      ((s)->sa_len<sizeof(*(s))? sizeof(*(s)):(s)->sa_len)
  461 
  462                         /* Determine size of response and allocate it */
  463                         buflen = 0;
  464                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
  465                                 buflen += SA_SIZE(ifa->ifa_addr);
  466                         NG_MKRESPONSE(resp, msg, buflen, M_NOWAIT);
  467                         if (resp == NULL) {
  468                                 error = ENOMEM;
  469                                 break;
  470                         }
  471 
  472                         /* Add addresses */
  473                         ptr = resp->data;
  474                         TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
  475                                 const int len = SA_SIZE(ifa->ifa_addr);
  476 
  477                                 if (buflen < len) {
  478                                         log(LOG_ERR, "%s: len changed?\n",
  479                                             ifp->if_xname);
  480                                         break;
  481                                 }
  482                                 bcopy(ifa->ifa_addr, ptr, len);
  483                                 ptr += len;
  484                                 buflen -= len;
  485                         }
  486                         break;
  487 #undef SA_SIZE
  488                     }
  489 
  490                 default:
  491                         error = EINVAL;
  492                         break;
  493                 } /* end of inner switch() */
  494                 break;
  495         case NGM_FLOW_COOKIE:
  496                 switch (msg->header.cmd) {
  497                 case NGM_LINK_IS_UP:
  498                         if_link_state_change(ifp, LINK_STATE_UP);
  499                         break;
  500                 case NGM_LINK_IS_DOWN:
  501                         if_link_state_change(ifp, LINK_STATE_DOWN);
  502                         break;
  503                 default:
  504                         break;
  505                 }
  506                 break;
  507         default:
  508                 error = EINVAL;
  509                 break;
  510         }
  511         NG_RESPOND_MSG(error, node, item, resp);
  512         NG_FREE_MSG(msg);
  513         return (error);
  514 }
  515 
  516 /*
  517  * Receive data from a hook. Pass the packet to the ether_input routine.
  518  */
  519 static int
  520 ng_eiface_rcvdata(hook_p hook, item_p item)
  521 {
  522         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  523         struct ifnet *const ifp = priv->ifp;
  524         struct mbuf *m;
  525 
  526         NGI_GET_M(item, m);
  527         NG_FREE_ITEM(item);
  528 
  529         if (!((ifp->if_flags & IFF_UP) &&
  530             (ifp->if_drv_flags & IFF_DRV_RUNNING))) {
  531                 NG_FREE_M(m);
  532                 return (ENETDOWN);
  533         }
  534 
  535         if (m->m_len < ETHER_HDR_LEN) {
  536                 m = m_pullup(m, ETHER_HDR_LEN);
  537                 if (m == NULL)
  538                         return (EINVAL);
  539         }
  540 
  541         /* Note receiving interface */
  542         m->m_pkthdr.rcvif = ifp;
  543 
  544         /* Update interface stats */
  545         ifp->if_ipackets++;
  546 
  547         (*ifp->if_input)(ifp, m);
  548 
  549         /* Done */
  550         return (0);
  551 }
  552 
  553 /*
  554  * Shutdown processing.
  555  */
  556 static int
  557 ng_eiface_rmnode(node_p node)
  558 {
  559         const priv_p priv = NG_NODE_PRIVATE(node);
  560         struct ifnet *const ifp = priv->ifp;
  561 
  562         ether_ifdetach(ifp);
  563         if_free(ifp);
  564         free_unr(ng_eiface_unit, priv->unit);
  565         FREE(priv, M_NETGRAPH);
  566         NG_NODE_SET_PRIVATE(node, NULL);
  567         NG_NODE_UNREF(node);
  568         return (0);
  569 }
  570 
  571 /*
  572  * Hook disconnection
  573  */
  574 static int
  575 ng_eiface_disconnect(hook_p hook)
  576 {
  577         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  578 
  579         priv->ether = NULL;
  580         return (0);
  581 }
  582 
  583 /*
  584  * Handle loading and unloading for this node type.
  585  */
  586 static int
  587 ng_eiface_mod_event(module_t mod, int event, void *data)
  588 {
  589         int error = 0;
  590 
  591         switch (event) {
  592         case MOD_LOAD:
  593                 ng_eiface_unit = new_unrhdr(0, 0xffff, NULL);
  594                 break;
  595         case MOD_UNLOAD:
  596                 delete_unrhdr(ng_eiface_unit);
  597                 break;
  598         default:
  599                 error = EOPNOTSUPP;
  600                 break;
  601         }
  602         return (error);
  603 }

Cache object: 78469a80bd3f8407665a83564ffc2e39


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.