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/net/if_epair.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  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  * Copyright (c) 2008 The FreeBSD Foundation
    3  * Copyright (c) 2009-2010 Bjoern A. Zeeb <bz@FreeBSD.org>
    4  * All rights reserved.
    5  *
    6  * This software was developed by CK Software GmbH under sponsorship
    7  * from the FreeBSD Foundation.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  * notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  * notice, this list of conditions and the following disclaimer in the
   16  * documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  */
   30 
   31 /*
   32  * A pair of virtual back-to-back connected ethernet like interfaces
   33  * (``two interfaces with a virtual cross-over cable'').
   34  *
   35  * This is mostly intended to be used to provide connectivity between
   36  * different virtual network stack instances.
   37  */
   38 /*
   39  * Things to re-think once we have more experience:
   40  * - ifp->if_reassign function once we can test with vimage. Depending on
   41  *   how if_vmove() is going to be improved.
   42  * - Real random etheraddrs that are checked to be uniquish; we would need
   43  *   to re-do them in case we move the interface between network stacks
   44  *   in a private if_reassign function.
   45  *   In case we bridge to a real interface/network or between indepedent
   46  *   epairs on multiple stacks/machines, we may need this.
   47  *   For now let the user handle that case.
   48  */
   49 
   50 #include <sys/cdefs.h>
   51 __FBSDID("$FreeBSD: releng/8.1/sys/net/if_epair.c 205760 2010-03-27 17:48:13Z bz $");
   52 
   53 #include <sys/param.h>
   54 #include <sys/kernel.h>
   55 #include <sys/mbuf.h>
   56 #include <sys/module.h>
   57 #include <sys/refcount.h>
   58 #include <sys/queue.h>
   59 #include <sys/smp.h>
   60 #include <sys/socket.h>
   61 #include <sys/sockio.h>
   62 #include <sys/sysctl.h>
   63 #include <sys/types.h>
   64 
   65 #include <net/bpf.h>
   66 #include <net/ethernet.h>
   67 #include <net/if.h>
   68 #include <net/if_clone.h>
   69 #include <net/if_var.h>
   70 #include <net/if_types.h>
   71 #include <net/netisr.h>
   72 #include <net/vnet.h>
   73 
   74 #define EPAIRNAME       "epair"
   75 
   76 SYSCTL_DECL(_net_link);
   77 SYSCTL_NODE(_net_link, OID_AUTO, epair, CTLFLAG_RW, 0, "epair sysctl");
   78 
   79 #ifdef EPAIR_DEBUG
   80 static int epair_debug = 0;
   81 SYSCTL_XINT(_net_link_epair, OID_AUTO, epair_debug, CTLFLAG_RW,
   82     &epair_debug, 0, "if_epair(4) debugging.");
   83 #define DPRINTF(fmt, arg...)                                            \
   84         if (epair_debug)                                                \
   85                 printf("[%s:%d] " fmt, __func__, __LINE__, ##arg)
   86 #else
   87 #define DPRINTF(fmt, arg...)
   88 #endif
   89 
   90 static void epair_nh_sintr(struct mbuf *);
   91 static struct mbuf *epair_nh_m2cpuid(struct mbuf *, uintptr_t, u_int *);
   92 static void epair_nh_drainedcpu(u_int);
   93 
   94 static void epair_start_locked(struct ifnet *);
   95 
   96 static int epair_clone_match(struct if_clone *, const char *);
   97 static int epair_clone_create(struct if_clone *, char *, size_t, caddr_t);
   98 static int epair_clone_destroy(struct if_clone *, struct ifnet *);
   99 
  100 /* Netisr realted definitions and sysctl. */
  101 static struct netisr_handler epair_nh = {
  102         .nh_name        = EPAIRNAME,
  103         .nh_proto       = NETISR_EPAIR,
  104         .nh_policy      = NETISR_POLICY_CPU,
  105         .nh_handler     = epair_nh_sintr,
  106         .nh_m2cpuid     = epair_nh_m2cpuid,
  107         .nh_drainedcpu  = epair_nh_drainedcpu,
  108 };
  109 
  110 static int
  111 sysctl_epair_netisr_maxqlen(SYSCTL_HANDLER_ARGS)
  112 {
  113         int error, qlimit;
  114 
  115         netisr_getqlimit(&epair_nh, &qlimit);
  116         error = sysctl_handle_int(oidp, &qlimit, 0, req);
  117         if (error || !req->newptr)
  118                 return (error);
  119         if (qlimit < 1)
  120                 return (EINVAL);
  121         return (netisr_setqlimit(&epair_nh, qlimit));
  122 }
  123 SYSCTL_PROC(_net_link_epair, OID_AUTO, netisr_maxqlen, CTLTYPE_INT|CTLFLAG_RW,
  124     0, 0, sysctl_epair_netisr_maxqlen, "I",
  125     "Maximum if_epair(4) netisr \"hw\" queue length");
  126 
  127 struct epair_softc {
  128         struct ifnet    *ifp;           /* This ifp. */
  129         struct ifnet    *oifp;          /* other ifp of pair. */
  130         u_int           refcount;       /* # of mbufs in flight. */
  131         u_int           cpuid;          /* CPU ID assigned upon creation. */
  132         void            (*if_qflush)(struct ifnet *);
  133                                         /* Original if_qflush routine. */
  134 };
  135 
  136 /*
  137  * Per-CPU list of ifps with data in the ifq that needs to be flushed
  138  * to the netisr ``hw'' queue before we allow any further direct queuing
  139  * to the ``hw'' queue.
  140  */
  141 struct epair_ifp_drain {
  142         STAILQ_ENTRY(epair_ifp_drain)   ifp_next;
  143         struct ifnet                    *ifp;
  144 };
  145 STAILQ_HEAD(eid_list, epair_ifp_drain);
  146 
  147 #define EPAIR_LOCK_INIT(dpcpu)          mtx_init(&(dpcpu)->if_epair_mtx, \
  148                                             "if_epair", NULL, MTX_DEF)
  149 #define EPAIR_LOCK_DESTROY(dpcpu)       mtx_destroy(&(dpcpu)->if_epair_mtx)
  150 #define EPAIR_LOCK_ASSERT(dpcpu)        mtx_assert(&(dpcpu)->if_epair_mtx, \
  151                                             MA_OWNED)
  152 #define EPAIR_LOCK(dpcpu)               mtx_lock(&(dpcpu)->if_epair_mtx)
  153 #define EPAIR_UNLOCK(dpcpu)             mtx_unlock(&(dpcpu)->if_epair_mtx)
  154 
  155 #ifdef INVARIANTS
  156 #define EPAIR_REFCOUNT_INIT(r, v)       refcount_init((r), (v))
  157 #define EPAIR_REFCOUNT_AQUIRE(r)        refcount_acquire((r))
  158 #define EPAIR_REFCOUNT_RELEASE(r)       refcount_release((r))
  159 #define EPAIR_REFCOUNT_ASSERT(a, p)     KASSERT(a, p)
  160 #else
  161 #define EPAIR_REFCOUNT_INIT(r, v)
  162 #define EPAIR_REFCOUNT_AQUIRE(r)
  163 #define EPAIR_REFCOUNT_RELEASE(r)
  164 #define EPAIR_REFCOUNT_ASSERT(a, p)
  165 #endif
  166 
  167 static MALLOC_DEFINE(M_EPAIR, EPAIRNAME,
  168     "Pair of virtual cross-over connected Ethernet-like interfaces");
  169 
  170 static struct if_clone epair_cloner = IFC_CLONE_INITIALIZER(
  171     EPAIRNAME, NULL, IF_MAXUNIT,
  172     NULL, epair_clone_match, epair_clone_create, epair_clone_destroy);
  173 
  174 /*
  175  * DPCPU area and functions.
  176  */
  177 struct epair_dpcpu {
  178         struct mtx      if_epair_mtx;           /* Per-CPU locking. */
  179         int             epair_drv_flags;        /* Per-CPU ``hw'' drv flags. */
  180         struct eid_list epair_ifp_drain_list;   /* Per-CPU list of ifps with
  181                                                  * data in the ifq. */
  182 };
  183 DPCPU_DEFINE(struct epair_dpcpu, epair_dpcpu);
  184 
  185 static void
  186 epair_dpcpu_init(void)
  187 {
  188         struct epair_dpcpu *epair_dpcpu;
  189         struct eid_list *s;
  190         u_int cpuid;
  191 
  192         for (cpuid = 0; cpuid <= mp_maxid; cpuid++) {
  193                 if (CPU_ABSENT(cpuid))
  194                         continue;
  195 
  196                 epair_dpcpu = DPCPU_ID_PTR(cpuid, epair_dpcpu);
  197 
  198                 /* Initialize per-cpu lock. */
  199                 EPAIR_LOCK_INIT(epair_dpcpu);
  200 
  201                 /* Driver flags are per-cpu as are our netisr "hw" queues. */
  202                 epair_dpcpu->epair_drv_flags = 0;
  203 
  204                 /*
  205                  * Initialize per-cpu drain list.
  206                  * Manually do what STAILQ_HEAD_INITIALIZER would do.
  207                  */
  208                 s = &epair_dpcpu->epair_ifp_drain_list;
  209                 s->stqh_first = NULL;
  210                 s->stqh_last = &s->stqh_first;
  211         } 
  212 }
  213 
  214 static void
  215 epair_dpcpu_detach(void)
  216 {
  217         struct epair_dpcpu *epair_dpcpu;
  218         u_int cpuid;
  219 
  220         for (cpuid = 0; cpuid <= mp_maxid; cpuid++) {
  221                 if (CPU_ABSENT(cpuid))
  222                         continue;
  223 
  224                 epair_dpcpu = DPCPU_ID_PTR(cpuid, epair_dpcpu);
  225 
  226                 /* Destroy per-cpu lock. */
  227                 EPAIR_LOCK_DESTROY(epair_dpcpu);
  228         }
  229 }
  230 
  231 /*
  232  * Helper functions.
  233  */
  234 static u_int
  235 cpuid_from_ifp(struct ifnet *ifp)
  236 {
  237         struct epair_softc *sc;
  238 
  239         if (ifp == NULL)
  240                 return (0);
  241         sc = ifp->if_softc;
  242 
  243         return (sc->cpuid);
  244 }
  245 
  246 /*
  247  * Netisr handler functions.
  248  */
  249 static void
  250 epair_nh_sintr(struct mbuf *m)
  251 {
  252         struct ifnet *ifp;
  253         struct epair_softc *sc;
  254 
  255         ifp = m->m_pkthdr.rcvif;
  256         (*ifp->if_input)(ifp, m);
  257         sc = ifp->if_softc;
  258         EPAIR_REFCOUNT_RELEASE(&sc->refcount);
  259         EPAIR_REFCOUNT_ASSERT((int)sc->refcount >= 1,
  260             ("%s: ifp=%p sc->refcount not >= 1: %d",
  261             __func__, ifp, sc->refcount));
  262         DPRINTF("ifp=%p refcount=%u\n", ifp, sc->refcount);
  263 }
  264 
  265 static struct mbuf *
  266 epair_nh_m2cpuid(struct mbuf *m, uintptr_t source, u_int *cpuid)
  267 {
  268 
  269         *cpuid = cpuid_from_ifp(m->m_pkthdr.rcvif);
  270 
  271         return (m);
  272 }
  273 
  274 static void
  275 epair_nh_drainedcpu(u_int cpuid)
  276 {
  277         struct epair_dpcpu *epair_dpcpu;
  278         struct epair_ifp_drain *elm, *tvar;
  279         struct ifnet *ifp;
  280 
  281         epair_dpcpu = DPCPU_ID_PTR(cpuid, epair_dpcpu);
  282         EPAIR_LOCK(epair_dpcpu);
  283         /*
  284          * Assume our "hw" queue and possibly ifq will be emptied
  285          * again. In case we will overflow the "hw" queue while
  286          * draining, epair_start_locked will set IFF_DRV_OACTIVE
  287          * again and we will stop and return.
  288          */
  289         STAILQ_FOREACH_SAFE(elm, &epair_dpcpu->epair_ifp_drain_list,
  290             ifp_next, tvar) {
  291                 ifp = elm->ifp;
  292                 epair_dpcpu->epair_drv_flags &= ~IFF_DRV_OACTIVE;
  293                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
  294                 epair_start_locked(ifp);
  295 
  296                 IFQ_LOCK(&ifp->if_snd);
  297                 if (IFQ_IS_EMPTY(&ifp->if_snd)) {
  298                         struct epair_softc *sc;
  299 
  300                         STAILQ_REMOVE(&epair_dpcpu->epair_ifp_drain_list,
  301                             elm, epair_ifp_drain, ifp_next);
  302                         /* The cached ifp goes off the list. */
  303                         sc = ifp->if_softc;
  304                         EPAIR_REFCOUNT_RELEASE(&sc->refcount);
  305                         EPAIR_REFCOUNT_ASSERT((int)sc->refcount >= 1,
  306                             ("%s: ifp=%p sc->refcount not >= 1: %d",
  307                             __func__, ifp, sc->refcount));
  308                         free(elm, M_EPAIR);
  309                 }
  310                 IFQ_UNLOCK(&ifp->if_snd);
  311 
  312                 if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) != 0) {
  313                         /* Our "hw"q overflew again. */
  314                         epair_dpcpu->epair_drv_flags |= IFF_DRV_OACTIVE
  315                         DPRINTF("hw queue length overflow at %u\n",
  316                             epair_nh.nh_qlimit);
  317                         break;
  318                 }
  319         }
  320         EPAIR_UNLOCK(epair_dpcpu);
  321 }
  322 
  323 /*
  324  * Network interface (`if') related functions.
  325  */
  326 static void
  327 epair_remove_ifp_from_draining(struct ifnet *ifp)
  328 {
  329         struct epair_dpcpu *epair_dpcpu;
  330         struct epair_ifp_drain *elm, *tvar;
  331         u_int cpuid;
  332 
  333         for (cpuid = 0; cpuid <= mp_maxid; cpuid++) {
  334                 if (CPU_ABSENT(cpuid))
  335                         continue;
  336 
  337                 epair_dpcpu = DPCPU_ID_PTR(cpuid, epair_dpcpu);
  338                 EPAIR_LOCK(epair_dpcpu);
  339                 STAILQ_FOREACH_SAFE(elm, &epair_dpcpu->epair_ifp_drain_list,
  340                     ifp_next, tvar) {
  341                         if (ifp == elm->ifp) {
  342                                 struct epair_softc *sc;
  343 
  344                                 STAILQ_REMOVE(
  345                                     &epair_dpcpu->epair_ifp_drain_list, elm,
  346                                     epair_ifp_drain, ifp_next);
  347                                 /* The cached ifp goes off the list. */
  348                                 sc = ifp->if_softc;
  349                                 EPAIR_REFCOUNT_RELEASE(&sc->refcount);
  350                                 EPAIR_REFCOUNT_ASSERT((int)sc->refcount >= 1,
  351                                     ("%s: ifp=%p sc->refcount not >= 1: %d",
  352                                     __func__, ifp, sc->refcount));
  353                                 free(elm, M_EPAIR);
  354                         }
  355                 }
  356                 EPAIR_UNLOCK(epair_dpcpu);
  357         }
  358 }
  359 
  360 static int
  361 epair_add_ifp_for_draining(struct ifnet *ifp)
  362 {
  363         struct epair_dpcpu *epair_dpcpu;
  364         struct epair_softc *sc;
  365         struct epair_ifp_drain *elm = NULL;
  366 
  367         sc = ifp->if_softc;
  368         epair_dpcpu = DPCPU_ID_PTR(sc->cpuid, epair_dpcpu);
  369         EPAIR_LOCK_ASSERT(epair_dpcpu);
  370         STAILQ_FOREACH(elm, &epair_dpcpu->epair_ifp_drain_list, ifp_next)
  371                 if (elm->ifp == ifp)
  372                         break;
  373         /* If the ifp is there already, return success. */
  374         if (elm != NULL)
  375                 return (0);
  376 
  377         elm = malloc(sizeof(struct epair_ifp_drain), M_EPAIR, M_NOWAIT|M_ZERO);
  378         if (elm == NULL)
  379                 return (ENOMEM);
  380 
  381         elm->ifp = ifp;
  382         /* Add a reference for the ifp pointer on the list. */
  383         EPAIR_REFCOUNT_AQUIRE(&sc->refcount);
  384         STAILQ_INSERT_TAIL(&epair_dpcpu->epair_ifp_drain_list, elm, ifp_next);
  385 
  386         return (0);
  387 }
  388 
  389 static void
  390 epair_start_locked(struct ifnet *ifp)
  391 {
  392         struct epair_dpcpu *epair_dpcpu;
  393         struct mbuf *m;
  394         struct epair_softc *sc;
  395         struct ifnet *oifp;
  396         int error;
  397 
  398         DPRINTF("ifp=%p\n", ifp);
  399         sc = ifp->if_softc;
  400         epair_dpcpu = DPCPU_ID_PTR(sc->cpuid, epair_dpcpu);
  401         EPAIR_LOCK_ASSERT(epair_dpcpu);
  402 
  403         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
  404                 return;
  405         if ((ifp->if_flags & IFF_UP) == 0)
  406                 return;
  407 
  408         /*
  409          * We get patckets here from ether_output via if_handoff()
  410          * and ned to put them into the input queue of the oifp
  411          * and call oifp->if_input() via netisr/epair_sintr().
  412          */
  413         oifp = sc->oifp;
  414         sc = oifp->if_softc;
  415         for (;;) {
  416                 IFQ_DEQUEUE(&ifp->if_snd, m);
  417                 if (m == NULL)
  418                         break;
  419                 BPF_MTAP(ifp, m);
  420 
  421                 /*
  422                  * In case the outgoing interface is not usable,
  423                  * drop the packet.
  424                  */
  425                 if ((oifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
  426                     (oifp->if_flags & IFF_UP) ==0) {
  427                         ifp->if_oerrors++;
  428                         m_freem(m);
  429                         continue;
  430                 }
  431                 DPRINTF("packet %s -> %s\n", ifp->if_xname, oifp->if_xname);
  432 
  433                 /*
  434                  * Add a reference so the interface cannot go while the
  435                  * packet is in transit as we rely on rcvif to stay valid.
  436                  */
  437                 EPAIR_REFCOUNT_AQUIRE(&sc->refcount);
  438                 m->m_pkthdr.rcvif = oifp;
  439                 CURVNET_SET_QUIET(oifp->if_vnet);
  440                 error = netisr_queue(NETISR_EPAIR, m);
  441                 CURVNET_RESTORE();
  442                 if (!error) {
  443                         ifp->if_opackets++;
  444                         /* Someone else received the packet. */
  445                         oifp->if_ipackets++;
  446                 } else {
  447                         /* The packet was freed already. */
  448                         epair_dpcpu->epair_drv_flags |= IFF_DRV_OACTIVE;
  449                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  450                         (void) epair_add_ifp_for_draining(ifp);
  451                         ifp->if_oerrors++;
  452                         EPAIR_REFCOUNT_RELEASE(&sc->refcount);
  453                         EPAIR_REFCOUNT_ASSERT((int)sc->refcount >= 1,
  454                             ("%s: ifp=%p sc->refcount not >= 1: %d",
  455                             __func__, oifp, sc->refcount));
  456                 }
  457         }
  458 }
  459 
  460 static void
  461 epair_start(struct ifnet *ifp)
  462 {
  463         struct epair_dpcpu *epair_dpcpu;
  464 
  465         epair_dpcpu = DPCPU_ID_PTR(cpuid_from_ifp(ifp), epair_dpcpu);
  466         EPAIR_LOCK(epair_dpcpu);
  467         epair_start_locked(ifp);
  468         EPAIR_UNLOCK(epair_dpcpu);
  469 }
  470 
  471 static int
  472 epair_transmit_locked(struct ifnet *ifp, struct mbuf *m)
  473 {
  474         struct epair_dpcpu *epair_dpcpu;
  475         struct epair_softc *sc;
  476         struct ifnet *oifp;
  477         int error, len;
  478         short mflags;
  479 
  480         DPRINTF("ifp=%p m=%p\n", ifp, m);
  481         sc = ifp->if_softc;
  482         epair_dpcpu = DPCPU_ID_PTR(sc->cpuid, epair_dpcpu);
  483         EPAIR_LOCK_ASSERT(epair_dpcpu);
  484 
  485         if (m == NULL)
  486                 return (0);
  487         
  488         /*
  489          * We are not going to use the interface en/dequeue mechanism
  490          * on the TX side. We are called from ether_output_frame()
  491          * and will put the packet into the incoming queue of the
  492          * other interface of our pair via the netsir.
  493          */
  494         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
  495                 m_freem(m);
  496                 return (ENXIO);
  497         }
  498         if ((ifp->if_flags & IFF_UP) == 0) {
  499                 m_freem(m);
  500                 return (ENETDOWN);
  501         }
  502 
  503         BPF_MTAP(ifp, m);
  504 
  505         /*
  506          * In case the outgoing interface is not usable,
  507          * drop the packet.
  508          */
  509         oifp = sc->oifp;
  510         if ((oifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
  511             (oifp->if_flags & IFF_UP) ==0) {
  512                 ifp->if_oerrors++;
  513                 m_freem(m);
  514                 return (0);
  515         }
  516         len = m->m_pkthdr.len;
  517         mflags = m->m_flags;
  518         DPRINTF("packet %s -> %s\n", ifp->if_xname, oifp->if_xname);
  519 
  520 #ifdef ALTQ
  521         /* Support ALTQ via the clasic if_start() path. */
  522         IF_LOCK(&ifp->if_snd);
  523         if (ALTQ_IS_ENABLED(&ifp->if_snd)) {
  524                 ALTQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
  525                 if (error)
  526                         ifp->if_snd.ifq_drops++;
  527                 IF_UNLOCK(&ifp->if_snd);
  528                 if (!error) {
  529                         ifp->if_obytes += len;
  530                         if (mflags & (M_BCAST|M_MCAST))
  531                                 ifp->if_omcasts++;
  532                         
  533                         if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0)
  534                                 epair_start_locked(ifp);
  535                         else
  536                                 (void)epair_add_ifp_for_draining(ifp);
  537                 }
  538                 return (error);
  539         }
  540         IF_UNLOCK(&ifp->if_snd);
  541 #endif
  542 
  543         if ((epair_dpcpu->epair_drv_flags & IFF_DRV_OACTIVE) != 0) {
  544                 /*
  545                  * Our hardware queue is full, try to fall back
  546                  * queuing to the ifq but do not call ifp->if_start.
  547                  * Either we are lucky or the packet is gone.
  548                  */
  549                 IFQ_ENQUEUE(&ifp->if_snd, m, error);
  550                 if (!error)
  551                         (void)epair_add_ifp_for_draining(ifp);
  552                 return (error);
  553         }
  554         sc = oifp->if_softc;
  555         /*
  556          * Add a reference so the interface cannot go while the
  557          * packet is in transit as we rely on rcvif to stay valid.
  558          */
  559         EPAIR_REFCOUNT_AQUIRE(&sc->refcount);
  560         m->m_pkthdr.rcvif = oifp;
  561         CURVNET_SET_QUIET(oifp->if_vnet);
  562         error = netisr_queue(NETISR_EPAIR, m);
  563         CURVNET_RESTORE();
  564         if (!error) {
  565                 ifp->if_opackets++;
  566                 /*
  567                  * IFQ_HANDOFF_ADJ/ip_handoff() update statistics,
  568                  * but as we bypass all this we have to duplicate
  569                  * the logic another time.
  570                  */
  571                 ifp->if_obytes += len;
  572                 if (mflags & (M_BCAST|M_MCAST))
  573                         ifp->if_omcasts++;
  574                 /* Someone else received the packet. */
  575                 oifp->if_ipackets++;
  576         } else {
  577                 /* The packet was freed already. */
  578                 epair_dpcpu->epair_drv_flags |= IFF_DRV_OACTIVE;
  579                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
  580                 ifp->if_oerrors++;
  581                 EPAIR_REFCOUNT_RELEASE(&sc->refcount);
  582                 EPAIR_REFCOUNT_ASSERT((int)sc->refcount >= 1,
  583                     ("%s: ifp=%p sc->refcount not >= 1: %d",
  584                     __func__, oifp, sc->refcount));
  585         }
  586 
  587         return (error);
  588 }
  589 
  590 static int
  591 epair_transmit(struct ifnet *ifp, struct mbuf *m)
  592 {
  593         struct epair_dpcpu *epair_dpcpu;
  594         int error;
  595 
  596         epair_dpcpu = DPCPU_ID_PTR(cpuid_from_ifp(ifp), epair_dpcpu);
  597         EPAIR_LOCK(epair_dpcpu);
  598         error = epair_transmit_locked(ifp, m);
  599         EPAIR_UNLOCK(epair_dpcpu);
  600         return (error);
  601 }
  602 
  603 static void
  604 epair_qflush(struct ifnet *ifp)
  605 {
  606         struct epair_softc *sc;
  607         
  608         sc = ifp->if_softc;
  609         KASSERT(sc != NULL, ("%s: ifp=%p, epair_softc gone? sc=%p\n",
  610             __func__, ifp, sc));
  611         /*
  612          * Remove this ifp from all backpointer lists. The interface will not
  613          * usable for flushing anyway nor should it have anything to flush
  614          * after if_qflush().
  615          */
  616         epair_remove_ifp_from_draining(ifp);
  617 
  618         if (sc->if_qflush)
  619                 sc->if_qflush(ifp);
  620 }
  621 
  622 static int
  623 epair_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
  624 {
  625         struct ifreq *ifr;
  626         int error;
  627 
  628         ifr = (struct ifreq *)data;
  629         switch (cmd) {
  630         case SIOCSIFFLAGS:
  631         case SIOCADDMULTI:
  632         case SIOCDELMULTI:
  633                 error = 0;
  634                 break;
  635 
  636         case SIOCSIFMTU:
  637                 /* We basically allow all kinds of MTUs. */
  638                 ifp->if_mtu = ifr->ifr_mtu;
  639                 error = 0;
  640                 break;
  641 
  642         default:
  643                 /* Let the common ethernet handler process this. */
  644                 error = ether_ioctl(ifp, cmd, data);
  645                 break;
  646         }
  647 
  648         return (error);
  649 }
  650 
  651 static void
  652 epair_init(void *dummy __unused)
  653 {
  654 }
  655 
  656 
  657 /*
  658  * Interface cloning functions.
  659  * We use our private ones so that we can create/destroy our secondary
  660  * device along with the primary one.
  661  */
  662 static int
  663 epair_clone_match(struct if_clone *ifc, const char *name)
  664 {
  665         const char *cp;
  666 
  667         DPRINTF("name='%s'\n", name);
  668 
  669         /*
  670          * Our base name is epair.
  671          * Our interfaces will be named epair<n>[ab].
  672          * So accept anything of the following list:
  673          * - epair
  674          * - epair<n>
  675          * but not the epair<n>[ab] versions.
  676          */
  677         if (strncmp(EPAIRNAME, name, sizeof(EPAIRNAME)-1) != 0)
  678                 return (0);
  679 
  680         for (cp = name + sizeof(EPAIRNAME) - 1; *cp != '\0'; cp++) {
  681                 if (*cp < '' || *cp > '9')
  682                         return (0);
  683         }
  684 
  685         return (1);
  686 }
  687 
  688 static int
  689 epair_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
  690 {
  691         struct epair_softc *sca, *scb;
  692         struct ifnet *ifp;
  693         char *dp;
  694         int error, unit, wildcard;
  695         uint8_t eaddr[ETHER_ADDR_LEN];  /* 00:00:00:00:00:00 */
  696 
  697         /*
  698          * We are abusing params to create our second interface.
  699          * Actually we already created it and called if_clone_createif()
  700          * for it to do the official insertion procedure the moment we knew
  701          * it cannot fail anymore. So just do attach it here.
  702          */
  703         if (params) {
  704                 scb = (struct epair_softc *)params;
  705                 ifp = scb->ifp;
  706                 /* Assign a hopefully unique, locally administered etheraddr. */
  707                 eaddr[0] = 0x02;
  708                 eaddr[3] = (ifp->if_index >> 8) & 0xff;
  709                 eaddr[4] = ifp->if_index & 0xff;
  710                 eaddr[5] = 0x0b;
  711                 ether_ifattach(ifp, eaddr);
  712                 /* Correctly set the name for the cloner list. */
  713                 strlcpy(name, scb->ifp->if_xname, len);
  714                 return (0);
  715         }
  716 
  717         /* Try to see if a special unit was requested. */
  718         error = ifc_name2unit(name, &unit);
  719         if (error != 0)
  720                 return (error);
  721         wildcard = (unit < 0);
  722 
  723         error = ifc_alloc_unit(ifc, &unit);
  724         if (error != 0)
  725                 return (error);
  726 
  727         /*
  728          * If no unit had been given, we need to adjust the ifName.
  729          * Also make sure there is space for our extra [ab] suffix.
  730          */
  731         for (dp = name; *dp != '\0'; dp++);
  732         if (wildcard) {
  733                 error = snprintf(dp, len - (dp - name), "%d", unit);
  734                 if (error > len - (dp - name) - 1) {
  735                         /* ifName too long. */
  736                         ifc_free_unit(ifc, unit);
  737                         return (ENOSPC);
  738                 }
  739                 dp += error;
  740         }
  741         if (len - (dp - name) - 1 < 1) {
  742                 /* No space left for our [ab] suffix. */
  743                 ifc_free_unit(ifc, unit);
  744                 return (ENOSPC);
  745         }
  746         *dp = 'a';
  747         /* Must not change dp so we can replace 'a' by 'b' later. */
  748         *(dp+1) = '\0';
  749 
  750         /* Allocate memory for both [ab] interfaces */
  751         sca = malloc(sizeof(struct epair_softc), M_EPAIR, M_WAITOK | M_ZERO);
  752         EPAIR_REFCOUNT_INIT(&sca->refcount, 1);
  753         sca->ifp = if_alloc(IFT_ETHER);
  754         if (sca->ifp == NULL) {
  755                 free(sca, M_EPAIR);
  756                 ifc_free_unit(ifc, unit);
  757                 return (ENOSPC);
  758         }
  759 
  760         scb = malloc(sizeof(struct epair_softc), M_EPAIR, M_WAITOK | M_ZERO);
  761         EPAIR_REFCOUNT_INIT(&scb->refcount, 1);
  762         scb->ifp = if_alloc(IFT_ETHER);
  763         if (scb->ifp == NULL) {
  764                 free(scb, M_EPAIR);
  765                 if_free(sca->ifp);
  766                 free(sca, M_EPAIR);
  767                 ifc_free_unit(ifc, unit);
  768                 return (ENOSPC);
  769         }
  770         
  771         /*
  772          * Cross-reference the interfaces so we will be able to free both.
  773          */
  774         sca->oifp = scb->ifp;
  775         scb->oifp = sca->ifp;
  776 
  777         /*
  778          * Calculate the cpuid for netisr queueing based on the
  779          * ifIndex of the interfaces. As long as we cannot configure
  780          * this or use cpuset information easily we cannot guarantee
  781          * cache locality but we can at least allow parallelism.
  782          */
  783         sca->cpuid =
  784             netisr_get_cpuid(sca->ifp->if_index % netisr_get_cpucount());
  785         scb->cpuid =
  786             netisr_get_cpuid(scb->ifp->if_index % netisr_get_cpucount());
  787         
  788         /* Finish initialization of interface <n>a. */
  789         ifp = sca->ifp;
  790         ifp->if_softc = sca;
  791         strlcpy(ifp->if_xname, name, IFNAMSIZ);
  792         ifp->if_dname = ifc->ifc_name;
  793         ifp->if_dunit = unit;
  794         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
  795         ifp->if_start = epair_start;
  796         ifp->if_ioctl = epair_ioctl;
  797         ifp->if_init  = epair_init;
  798         ifp->if_snd.ifq_maxlen = ifqmaxlen;
  799         /* Assign a hopefully unique, locally administered etheraddr. */
  800         eaddr[0] = 0x02;
  801         eaddr[3] = (ifp->if_index >> 8) & 0xff;
  802         eaddr[4] = ifp->if_index & 0xff;
  803         eaddr[5] = 0x0a;
  804         ether_ifattach(ifp, eaddr);
  805         sca->if_qflush = ifp->if_qflush;
  806         ifp->if_qflush = epair_qflush;
  807         ifp->if_transmit = epair_transmit;
  808         ifp->if_baudrate = IF_Gbps(10UL);       /* arbitrary maximum */
  809 
  810         /* Swap the name and finish initialization of interface <n>b. */
  811         *dp = 'b';
  812 
  813         ifp = scb->ifp;
  814         ifp->if_softc = scb;
  815         strlcpy(ifp->if_xname, name, IFNAMSIZ);
  816         ifp->if_dname = ifc->ifc_name;
  817         ifp->if_dunit = unit;
  818         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
  819         ifp->if_start = epair_start;
  820         ifp->if_ioctl = epair_ioctl;
  821         ifp->if_init  = epair_init;
  822         ifp->if_snd.ifq_maxlen = ifqmaxlen;
  823         /* We need to play some tricks here for the second interface. */
  824         strlcpy(name, EPAIRNAME, len);
  825         error = if_clone_create(name, len, (caddr_t)scb);
  826         if (error)
  827                 panic("%s: if_clone_createif() for our 2nd iface failed: %d",
  828                     __func__, error);
  829         scb->if_qflush = ifp->if_qflush;
  830         ifp->if_qflush = epair_qflush;
  831         ifp->if_transmit = epair_transmit;
  832         ifp->if_baudrate = IF_Gbps(10UL);       /* arbitrary maximum */
  833 
  834         /*
  835          * Restore name to <n>a as the ifp for this will go into the
  836          * cloner list for the initial call.
  837          */
  838         strlcpy(name, sca->ifp->if_xname, len);
  839         DPRINTF("name='%s/%db' created sca=%p scb=%p\n", name, unit, sca, scb);
  840 
  841         /* Tell the world, that we are ready to rock. */
  842         sca->ifp->if_drv_flags |= IFF_DRV_RUNNING;
  843         scb->ifp->if_drv_flags |= IFF_DRV_RUNNING;
  844 
  845         return (0);
  846 }
  847 
  848 static int
  849 epair_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
  850 {
  851         struct ifnet *oifp;
  852         struct epair_softc *sca, *scb;
  853         int unit, error;
  854 
  855         DPRINTF("ifp=%p\n", ifp);
  856 
  857         /*
  858          * In case we called into if_clone_destroyif() ourselves
  859          * again to remove the second interface, the softc will be
  860          * NULL. In that case so not do anything but return success.
  861          */
  862         if (ifp->if_softc == NULL)
  863                 return (0);
  864         
  865         unit = ifp->if_dunit;
  866         sca = ifp->if_softc;
  867         oifp = sca->oifp;
  868         scb = oifp->if_softc;
  869 
  870         DPRINTF("ifp=%p oifp=%p\n", ifp, oifp);
  871         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
  872         oifp->if_drv_flags &= ~IFF_DRV_RUNNING;
  873         ether_ifdetach(oifp);
  874         ether_ifdetach(ifp);
  875         /*
  876          * Wait for all packets to be dispatched to if_input.
  877          * The numbers can only go down as the interfaces are
  878          * detached so there is no need to use atomics.
  879          */
  880         DPRINTF("sca refcnt=%u scb refcnt=%u\n", sca->refcount, scb->refcount);
  881         EPAIR_REFCOUNT_ASSERT(sca->refcount == 1 && scb->refcount == 1,
  882             ("%s: ifp=%p sca->refcount!=1: %d || ifp=%p scb->refcount!=1: %d",
  883             __func__, ifp, sca->refcount, oifp, scb->refcount));
  884 
  885         /*
  886          * Get rid of our second half.
  887          */
  888         oifp->if_softc = NULL;
  889         error = if_clone_destroyif(ifc, oifp);
  890         if (error)
  891                 panic("%s: if_clone_destroyif() for our 2nd iface failed: %d",
  892                     __func__, error);
  893 
  894         /*
  895          * Finish cleaning up. Free them and release the unit.
  896          * As the other of the two interfaces my reside in a different vnet,
  897          * we need to switch before freeing them.
  898          */
  899         CURVNET_SET_QUIET(oifp->if_vnet);
  900         if_free_type(oifp, IFT_ETHER);
  901         CURVNET_RESTORE();
  902         if_free_type(ifp, IFT_ETHER);
  903         free(scb, M_EPAIR);
  904         free(sca, M_EPAIR);
  905         ifc_free_unit(ifc, unit);
  906 
  907         return (0);
  908 }
  909 
  910 static int
  911 epair_modevent(module_t mod, int type, void *data)
  912 {
  913         int qlimit;
  914 
  915         switch (type) {
  916         case MOD_LOAD:
  917                 /* For now limit us to one global mutex and one inq. */
  918                 epair_dpcpu_init();
  919                 epair_nh.nh_qlimit = 42 * ifqmaxlen; /* 42 shall be the number. */
  920                 if (TUNABLE_INT_FETCH("net.link.epair.netisr_maxqlen", &qlimit))
  921                     epair_nh.nh_qlimit = qlimit;
  922                 netisr_register(&epair_nh);
  923                 if_clone_attach(&epair_cloner);
  924                 if (bootverbose)
  925                         printf("%s initialized.\n", EPAIRNAME);
  926                 break;
  927         case MOD_UNLOAD:
  928                 if_clone_detach(&epair_cloner);
  929                 netisr_unregister(&epair_nh);
  930                 epair_dpcpu_detach();
  931                 if (bootverbose)
  932                         printf("%s unloaded.\n", EPAIRNAME);
  933                 break;
  934         default:
  935                 return (EOPNOTSUPP);
  936         }
  937         return (0);
  938 }
  939 
  940 static moduledata_t epair_mod = {
  941         "if_epair",
  942         epair_modevent,
  943         0
  944 };
  945 
  946 DECLARE_MODULE(if_epair, epair_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
  947 MODULE_VERSION(if_epair, 1);

Cache object: a7e263ec350137bd4af54196f2ee94d0


[ 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.