root/net/if_trunk.c

DEFINITIONS

1. trunkattach
2. trunk_clone_create
3. trunk_clone_destroy
4. trunk_lladdr
5. trunk_capabilities
6. trunk_port_lladdr
7. trunk_port_create
8. trunk_port_checkstacking
9. trunk_port_destroy
10. trunk_port_watchdog
11. trunk_port_ioctl
12. trunk_port_ifdetach
13. trunk_port_get
14. trunk_port2req
15. trunk_ioctl
16. trunk_ether_addmulti
17. trunk_ether_delmulti
18. trunk_ether_purgemulti
19. trunk_ether_cmdmulti
20. trunk_ioctl_allports
21. trunk_start
22. trunk_enqueue
23. trunk_hashmbuf
24. trunk_init
25. trunk_stop
26. trunk_watchdog
27. trunk_input
28. trunk_media_change
29. trunk_media_status
30. trunk_port_state
31. trunk_link_active
32. trunk_rr_attach
33. trunk_rr_detach
34. trunk_rr_port_destroy
35. trunk_rr_start
36. trunk_rr_input
37. trunk_fail_attach
38. trunk_fail_detach
39. trunk_fail_start
40. trunk_fail_input
41. trunk_lb_attach
42. trunk_lb_detach
43. trunk_lb_porttable
44. trunk_lb_port_create
45. trunk_lb_port_destroy
46. trunk_lb_gethdr
47. trunk_lb_start
48. trunk_lb_input

    1 /*      $OpenBSD: if_trunk.c,v 1.32 2007/05/26 17:13:31 jason Exp $     */
    3 /*
    4  * Copyright (c) 2005, 2006 Reyk Floeter <reyk@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 #include "bpfilter.h"
   20 #include "trunk.h"
   22 #include <sys/param.h>
   23 #include <sys/kernel.h>
   24 #include <sys/malloc.h>
   25 #include <sys/mbuf.h>
   26 #include <sys/queue.h>
   27 #include <sys/socket.h>
   28 #include <sys/sockio.h>
   29 #include <sys/sysctl.h>
   30 #include <sys/systm.h>
   31 #include <sys/proc.h>
   32 #include <sys/hash.h>
   34 #include <dev/rndvar.h>
   36 #include <net/if.h>
   37 #include <net/if_arp.h>
   38 #include <net/if_dl.h>
   39 #include <net/if_llc.h>
   40 #include <net/if_media.h>
   41 #include <net/if_types.h>
   42 #if NBPFILTER > 0
   43 #include <net/bpf.h>
   44 #endif
   46 #ifdef INET
   47 #include <netinet/in.h>
   48 #include <netinet/in_systm.h>
   49 #include <netinet/if_ether.h>
   50 #include <netinet/ip.h>
   51 #endif
   53 #ifdef INET6
   54 #include <netinet/ip6.h>
   55 #endif
   57 #include <net/if_vlan_var.h>
   58 #include <net/if_trunk.h>
SLIST_HEAD(__trhead, trunk_softc) trunk_list;   /* list of trunks */
   62 extern struct ifaddr **ifnet_addrs;
   64 void     trunkattach(int);
   65 int      trunk_clone_create(struct if_clone *, int);
   66 int      trunk_clone_destroy(struct ifnet *);
   67 void     trunk_lladdr(struct arpcom *, u_int8_t *);
   68 int      trunk_capabilities(struct trunk_softc *);
   69 void     trunk_port_lladdr(struct trunk_port *, u_int8_t *);
   70 int      trunk_port_create(struct trunk_softc *, struct ifnet *);
   71 int      trunk_port_destroy(struct trunk_port *);
   72 void     trunk_port_watchdog(struct ifnet *);
   73 void     trunk_port_state(void *);
   74 int      trunk_port_ioctl(struct ifnet *, u_long, caddr_t);
   75 struct trunk_port *trunk_port_get(struct trunk_softc *, struct ifnet *);
   76 int      trunk_port_checkstacking(struct trunk_softc *);
   77 void     trunk_port2req(struct trunk_port *, struct trunk_reqport *);
   78 int      trunk_ioctl(struct ifnet *, u_long, caddr_t);
   79 int      trunk_ether_addmulti(struct trunk_softc *, struct ifreq *);
   80 int      trunk_ether_delmulti(struct trunk_softc *, struct ifreq *);
   81 void     trunk_ether_purgemulti(struct trunk_softc *);
   82 int      trunk_ether_cmdmulti(struct trunk_port *, u_long);
   83 int      trunk_ioctl_allports(struct trunk_softc *, u_long, caddr_t);
   84 void     trunk_start(struct ifnet *);
   85 void     trunk_init(struct ifnet *);
   86 void     trunk_stop(struct ifnet *);
   87 void     trunk_watchdog(struct ifnet *);
   88 int      trunk_media_change(struct ifnet *);
   89 void     trunk_media_status(struct ifnet *, struct ifmediareq *);
   90 struct trunk_port *trunk_link_active(struct trunk_softc *,
   91             struct trunk_port *);
   93 struct if_clone trunk_cloner =
IF_CLONE_INITIALIZER("trunk", trunk_clone_create, trunk_clone_destroy);
   96 /* Simple round robin */
   97 int      trunk_rr_attach(struct trunk_softc *);
   98 int      trunk_rr_detach(struct trunk_softc *);
   99 void     trunk_rr_port_destroy(struct trunk_port *);
  100 int      trunk_rr_start(struct trunk_softc *, struct mbuf *);
  101 int      trunk_rr_input(struct trunk_softc *, struct trunk_port *,
  102             struct ether_header *, struct mbuf *);
  104 /* Active failover */
  105 int      trunk_fail_attach(struct trunk_softc *);
  106 int      trunk_fail_detach(struct trunk_softc *);
  107 int      trunk_fail_start(struct trunk_softc *, struct mbuf *);
  108 int      trunk_fail_input(struct trunk_softc *, struct trunk_port *,
  109             struct ether_header *, struct mbuf *);
  111 /* Loadbalancing */
  112 int      trunk_lb_attach(struct trunk_softc *);
  113 int      trunk_lb_detach(struct trunk_softc *);
  114 int      trunk_lb_port_create(struct trunk_port *);
  115 void     trunk_lb_port_destroy(struct trunk_port *);
  116 int      trunk_lb_start(struct trunk_softc *, struct mbuf *);
  117 int      trunk_lb_input(struct trunk_softc *, struct trunk_port *,
  118             struct ether_header *, struct mbuf *);
  119 int      trunk_lb_porttable(struct trunk_softc *, struct trunk_port *);
  120 const void *trunk_lb_gethdr(struct mbuf *, u_int, u_int, void *);
  122 /* Trunk protocol table */
  123 static const struct {
  124         enum trunk_proto        ti_proto;
  125         int                     (*ti_attach)(struct trunk_softc *);
  126 } trunk_protos[] = {
  127         { TRUNK_PROTO_ROUNDROBIN,       trunk_rr_attach },
  128         { TRUNK_PROTO_FAILOVER,         trunk_fail_attach },
  129         { TRUNK_PROTO_LOADBALANCE,      trunk_lb_attach },
  130         { TRUNK_PROTO_NONE,             NULL }
  131 };
  133 void
  134 trunkattach(int count)
  135 {
SLIST_INIT(&trunk_list);
if_clone_attach(&trunk_cloner);
  138 }
  140 int
  141 trunk_clone_create(struct if_clone *ifc, int unit)
  142 {
  143         struct trunk_softc *tr;
  144         struct ifnet *ifp;
  145         int i, error = 0;
  147         if ((tr = malloc(sizeof(struct trunk_softc),
M_DEVBUF, M_NOWAIT)) == NULL)
  149                 return (ENOMEM);
bzero(tr, sizeof(struct trunk_softc));
tr->tr_unit = unit;
tr->tr_proto = TRUNK_PROTO_NONE;
  155         for (i = 0; trunk_protos[i].ti_proto != TRUNK_PROTO_NONE; i++) {
  156                 if (trunk_protos[i].ti_proto == TRUNK_PROTO_DEFAULT) {
tr->tr_proto = trunk_protos[i].ti_proto;
  158                         if ((error = trunk_protos[i].ti_attach(tr)) != 0) {
free(tr, M_DEVBUF);
  160                                 return (error);
  161                         }
  162                         break;
  163                 }
  164         }
SLIST_INIT(&tr->tr_ports);
  167         /* Initialise pseudo media types */
ifmedia_init(&tr->tr_media, 0, trunk_media_change,
trunk_media_status);
ifmedia_add(&tr->tr_media, IFM_ETHER | IFM_AUTO, 0, NULL);
ifmedia_set(&tr->tr_media, IFM_ETHER | IFM_AUTO);
ifp = &tr->tr_ac.ac_if;
ifp->if_carp = NULL;
ifp->if_type = IFT_ETHER;
ifp->if_softc = tr;
ifp->if_start = trunk_start;
ifp->if_watchdog = trunk_watchdog;
ifp->if_ioctl = trunk_ioctl;
ifp->if_output = ether_output;
ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
ifp->if_capabilities = trunk_capabilities(tr);
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
IFQ_SET_READY(&ifp->if_snd);
snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d",
ifc->ifc_name, unit);
  190         /*
  191          * Attach as an ordinary ethernet device, childs will be attached
  192          * as special device IFT_IEEE8023ADLAG.
  193          */
if_attach(ifp);
ether_ifattach(ifp);
  197         /* Insert into the global list of trunks */
SLIST_INSERT_HEAD(&trunk_list, tr, tr_entries);
  200         return (0);
  201 }
  203 int
  204 trunk_clone_destroy(struct ifnet *ifp)
  205 {
  206         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
  207         struct trunk_port *tp;
  208         int error, s;
  210         /* Remove any multicast groups that we may have joined. */
trunk_ether_purgemulti(tr);
s = splnet();
  215         /* Shutdown and remove trunk ports, return on error */
  216         while ((tp = SLIST_FIRST(&tr->tr_ports)) != NULL) {
  217                 if ((error = trunk_port_destroy(tp)) != 0) {
splx(s);
  219                         return (error);
  220                 }
  221         }
ifmedia_delete_instance(&tr->tr_media, IFM_INST_ANY);
ether_ifdetach(ifp);
if_detach(ifp);
SLIST_REMOVE(&trunk_list, tr, trunk_softc, tr_entries);
free(tr, M_DEVBUF);
splx(s);
  232         return (0);
  233 }
  235 void
trunk_lladdr(struct arpcom *ac, u_int8_t *lladdr)
  237 {
  238         struct ifnet *ifp = &ac->ac_if;
  239         struct ifaddr *ifa;
  240         struct sockaddr_dl *sdl;
ifa = ifnet_addrs[ifp->if_index];
sdl = (struct sockaddr_dl *)ifa->ifa_addr;
sdl->sdl_type = IFT_ETHER;
sdl->sdl_alen = ETHER_ADDR_LEN;
bcopy(lladdr, LLADDR(sdl), ETHER_ADDR_LEN);
bcopy(lladdr, ac->ac_enaddr, ETHER_ADDR_LEN);
  248 }
  250 int
trunk_capabilities(struct trunk_softc *tr)
  252 {
  253         struct trunk_port *tp;
  254         int cap = ~0, priv;
  256         /* Preserve private capabilities */
priv = tr->tr_capabilities & IFCAP_TRUNK_MASK;
  259         /* Get capabilities from the trunk ports */
SLIST_FOREACH(tp, &tr->tr_ports, tp_entries)
cap &= tp->tp_capabilities;
  263         if (tr->tr_ifflags & IFF_DEBUG) {
printf("%s: capabilities 0x%08x\n",
tr->tr_ifname, cap == ~0 ? priv : (cap | priv));
  266         }
  268         return (cap == ~0 ? priv : (cap | priv));
  269 }
  271 void
trunk_port_lladdr(struct trunk_port *tp, u_int8_t *lladdr)
  273 {
  274         struct ifnet *ifp = tp->tp_if;
  275         struct ifaddr *ifa;
  276         struct ifreq ifr;
  278         /* Set the link layer address */
trunk_lladdr((struct arpcom *)ifp, lladdr);
  281         /* Reset the port to update the lladdr */
  282         if (ifp->if_flags & IFF_UP) {
  283                 int s = splnet();
ifp->if_flags &= ~IFF_UP;
  285                 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
ifp->if_flags |= IFF_UP;
  287                 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr);
splx(s);
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
  290                         if (ifa->ifa_addr != NULL &&
ifa->ifa_addr->sa_family == AF_INET)
arp_ifinit((struct arpcom *)ifp, ifa);
  293                 }
  294         }
  295 }
  297 int
trunk_port_create(struct trunk_softc *tr, struct ifnet *ifp)
  299 {
  300         struct trunk_softc *tr_ptr;
  301         struct trunk_port *tp;
  302         int error = 0;
  304         /* Limit the maximal number of trunk ports */
  305         if (tr->tr_count >= TRUNK_MAX_PORTS)
  306                 return (ENOSPC);
  308         /* New trunk port has to be in an idle state */
  309         if (ifp->if_flags & IFF_OACTIVE)
  310                 return (EBUSY);
  312         /* Check if port has already been associated to a trunk */
  313         if (trunk_port_get(NULL, ifp) != NULL)
  314                 return (EBUSY);
  316         /* XXX Disallow non-ethernet interfaces (this should be any of 802) */
  317         if (ifp->if_type != IFT_ETHER)
  318                 return (EPROTONOSUPPORT);
  320         if ((error = ifpromisc(ifp, 1)) != 0)
  321                 return (error);
  323         if ((tp = malloc(sizeof(struct trunk_port),
M_DEVBUF, M_NOWAIT)) == NULL)
  325                 return (ENOMEM);
bzero(tp, sizeof(struct trunk_port));
  329         /* Check if port is a stacked trunk */
SLIST_FOREACH(tr_ptr, &trunk_list, tr_entries) {
  331                 if (ifp == &tr_ptr->tr_ac.ac_if) {
tp->tp_flags |= TRUNK_PORT_STACK;
  333                         if (trunk_port_checkstacking(tr_ptr) >=
TRUNK_MAX_STACKING) {
free(tp, M_DEVBUF);
  336                                 return (E2BIG);
  337                         }
  338                 }
  339         }
  341         /* Change the interface type */
tp->tp_iftype = ifp->if_type;
ifp->if_type = IFT_IEEE8023ADLAG;
ifp->if_tp = (caddr_t)tp;
tp->tp_watchdog = ifp->if_watchdog;
ifp->if_watchdog = trunk_port_watchdog;
tp->tp_ioctl = ifp->if_ioctl;
ifp->if_ioctl = trunk_port_ioctl;
tp->tp_if = ifp;
tp->tp_trunk = tr;
  353         /* Save port link layer address */
bcopy(((struct arpcom *)ifp)->ac_enaddr, tp->tp_lladdr, ETHER_ADDR_LEN);
  356         if (SLIST_EMPTY(&tr->tr_ports)) {
tr->tr_primary = tp;
tp->tp_flags |= TRUNK_PORT_MASTER;
trunk_lladdr(&tr->tr_ac, tp->tp_lladdr);
  360         }
  362         /* Update link layer address for this port */
trunk_port_lladdr(tp, tr->tr_primary->tp_lladdr);
  365         /* Insert into the list of ports */
SLIST_INSERT_HEAD(&tr->tr_ports, tp, tp_entries);
tr->tr_count++;
  369         /* Update trunk capabilities */
tr->tr_capabilities = trunk_capabilities(tr);
  372         /* Add multicast addresses to this port */
trunk_ether_cmdmulti(tp, SIOCADDMULTI);
  375         /* Register callback for physical link state changes */
  376         if (ifp->if_linkstatehooks != NULL)
tp->lh_cookie = hook_establish(ifp->if_linkstatehooks, 1,
trunk_port_state, tp);
  380         if (tr->tr_port_create != NULL)
error = (*tr->tr_port_create)(tp);
  383         return (error);
  384 }
  386 int
trunk_port_checkstacking(struct trunk_softc *tr)
  388 {
  389         struct trunk_softc *tr_ptr;
  390         struct trunk_port *tp;
  391         int m = 0;
SLIST_FOREACH(tp, &tr->tr_ports, tp_entries) {
  394                 if (tp->tp_flags & TRUNK_PORT_STACK) {
tr_ptr = (struct trunk_softc *)tp->tp_if->if_softc;
m = MAX(m, trunk_port_checkstacking(tr_ptr));
  397                 }
  398         }
  400         return (m + 1);
  401 }
  403 int
trunk_port_destroy(struct trunk_port *tp)
  405 {
  406         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
  407         struct trunk_port *tp_ptr;
  408         struct ifnet *ifp = tp->tp_if;
  410         if (tr->tr_port_destroy != NULL)
  411                 (*tr->tr_port_destroy)(tp);
  413         /* Remove multicast addresses from this port */
trunk_ether_cmdmulti(tp, SIOCDELMULTI);
  416         /* Port has to be down */
  417         if (ifp->if_flags & IFF_UP)
if_down(ifp);
ifpromisc(ifp, 0);
  422         /* Restore interface */
ifp->if_type = tp->tp_iftype;
ifp->if_watchdog = tp->tp_watchdog;
ifp->if_ioctl = tp->tp_ioctl;
ifp->if_tp = NULL;
  428         if (ifp->if_linkstatehooks != NULL)
hook_disestablish(ifp->if_linkstatehooks, tp->lh_cookie);
  431         /* Finally, remove the port from the trunk */
SLIST_REMOVE(&tr->tr_ports, tp, trunk_port, tp_entries);
tr->tr_count--;
  435         /* Update the primary interface */
  436         if (tp == tr->tr_primary) {
u_int8_t lladdr[ETHER_ADDR_LEN];
  439                 if ((tp_ptr = SLIST_FIRST(&tr->tr_ports)) == NULL) {
bzero(&lladdr, ETHER_ADDR_LEN);
  441                 } else {
bcopy(((struct arpcom *)tp_ptr->tp_if)->ac_enaddr,
lladdr, ETHER_ADDR_LEN);
tp_ptr->tp_flags = TRUNK_PORT_MASTER;
  445                 }
trunk_lladdr(&tr->tr_ac, lladdr);
tr->tr_primary = tp_ptr;
  449                 /* Update link layer address for each port */
SLIST_FOREACH(tp_ptr, &tr->tr_ports, tp_entries)
trunk_port_lladdr(tp_ptr, lladdr);
  452         }
  454         /* Reset the port lladdr */
trunk_port_lladdr(tp, tp->tp_lladdr);
free(tp, M_DEVBUF);
  459         /* Update trunk capabilities */
tr->tr_capabilities = trunk_capabilities(tr);
  462         return (0);
  463 }
  465 void
trunk_port_watchdog(struct ifnet *ifp)
  467 {
  468         struct trunk_softc *tr;
  469         struct trunk_port *tp;
  471         /* Should be checked by the caller */
  472         if (ifp->if_type != IFT_IEEE8023ADLAG)
  473                 return;
  474         if ((tp = (struct trunk_port *)ifp->if_tp) == NULL ||
  475             (tr = (struct trunk_softc *)tp->tp_trunk) == NULL)
  476                 return;
  478         if (tp->tp_watchdog != NULL)
  479                 (*tp->tp_watchdog)(ifp);
  480 }
  483 int
trunk_port_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
  485 {
  486         struct trunk_reqport *rp = (struct trunk_reqport *)data;
  487         struct trunk_softc *tr;
  488         struct trunk_port *tp;
  489         int s, error = 0;
s = splnet();
  493         /* Should be checked by the caller */
  494         if (ifp->if_type != IFT_IEEE8023ADLAG ||
  495             (tp = (struct trunk_port *)ifp->if_tp) == NULL ||
  496             (tr = (struct trunk_softc *)tp->tp_trunk) == NULL)
  497                 goto fallback;
  499         switch (cmd) {
  500         case SIOCGTRUNKPORT:
  501                 if (rp->rp_portname[0] == '\0' ||
ifunit(rp->rp_portname) != ifp) {
error = EINVAL;
  504                         break;
  505                 }
  507                 /* Search in all trunks if the global flag is set */
  508                 if ((tp = trunk_port_get(rp->rp_flags & TRUNK_PORT_GLOBAL ?
NULL : tr, ifp)) == NULL) {
error = ENOENT;
  511                         break;
  512                 }
trunk_port2req(tp, rp);
  515                 break;
  516         default:
  517                 goto fallback;
  518         }
splx(s);
  521         return (error);
fallback:
splx(s);
  526         if (tp != NULL)
  527                 return ((*tp->tp_ioctl)(ifp, cmd, data));
  529         return (EINVAL);
  530 }
  532 void
trunk_port_ifdetach(struct ifnet *ifp)
  534 {
  535         struct trunk_port *tp;
  537         if ((tp = (struct trunk_port *)ifp->if_tp) == NULL)
  538                 return;
trunk_port_destroy(tp);
  541 }
  543 struct trunk_port *
trunk_port_get(struct trunk_softc *tr, struct ifnet *ifp)
  545 {
  546         struct trunk_port *tp;
  547         struct trunk_softc *tr_ptr;
  549         if (tr != NULL) {
  550                 /* Search port in specified trunk */
SLIST_FOREACH(tp, &tr->tr_ports, tp_entries) {
  552                         if (tp->tp_if == ifp)
  553                                 return (tp);
  554                 }
  555         } else {
  556                 /* Search all trunks for the selected port */
SLIST_FOREACH(tr_ptr, &trunk_list, tr_entries) {
SLIST_FOREACH(tp, &tr_ptr->tr_ports, tp_entries) {
  559                                 if (tp->tp_if == ifp)
  560                                         return (tp);
  561                         }
  562                 }
  563         }
  565         return (NULL);
  566 }
  568 void
trunk_port2req(struct trunk_port *tp, struct trunk_reqport *rp)
  570 {
  571         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
strlcpy(rp->rp_ifname, tr->tr_ifname, sizeof(rp->rp_ifname));
strlcpy(rp->rp_portname, tp->tp_if->if_xname, sizeof(rp->rp_portname));
rp->rp_prio = tp->tp_prio;
rp->rp_flags = tp->tp_flags;
  576         if (TRUNK_PORTACTIVE(tp))
rp->rp_flags |= TRUNK_PORT_ACTIVE;
  578 }
  580 int
trunk_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
  582 {
  583         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
  584         struct trunk_reqall *ra = (struct trunk_reqall *)data;
  585         struct trunk_reqport *rp = (struct trunk_reqport *)data, rpbuf;
  586         struct ifreq *ifr = (struct ifreq *)data;
  587         struct ifaddr *ifa = (struct ifaddr *)data;
  588         struct trunk_port *tp;
  589         struct ifnet *tpif;
  590         int s, i, error = 0;
s = splnet();
  594         if ((error = ether_ioctl(ifp, &tr->tr_ac, cmd, data)) > 0)
  595                 goto out;
bzero(&rpbuf, sizeof(rpbuf));
  599         switch (cmd) {
  600         case SIOCGTRUNK:
ra->ra_proto = tr->tr_proto;
ra->ra_ports = i = 0;
tp = SLIST_FIRST(&tr->tr_ports);
  604                 while (tp && ra->ra_size >=
i + sizeof(struct trunk_reqport)) {
trunk_port2req(tp, &rpbuf);
error = copyout(&rpbuf, (caddr_t)ra->ra_port + i,
  608                             sizeof(struct trunk_reqport));
  609                         if (error)
  610                                 break;
i += sizeof(struct trunk_reqport);
ra->ra_ports++;
tp = SLIST_NEXT(tp, tp_entries);
  614                 }
  615                 break;
  616         case SIOCSTRUNK:
  617                 if ((error = suser(curproc, 0)) != 0) {
error = EPERM;
  619                         break;
  620                 }
  621                 if (ra->ra_proto >= TRUNK_PROTO_MAX) {
error = EPROTONOSUPPORT;
  623                         break;
  624                 }
  625                 if (tr->tr_proto != TRUNK_PROTO_NONE)
error = tr->tr_detach(tr);
  627                 if (error != 0)
  628                         break;
  629                 for (i = 0; i < (sizeof(trunk_protos) /
  630                     sizeof(trunk_protos[0])); i++) {
  631                         if (trunk_protos[i].ti_proto == ra->ra_proto) {
  632                                 if (tr->tr_ifflags & IFF_DEBUG)
printf("%s: using proto %u\n",
tr->tr_ifname,
trunk_protos[i].ti_proto);
tr->tr_proto = trunk_protos[i].ti_proto;
  637                                 if (tr->tr_proto != TRUNK_PROTO_NONE)
error = trunk_protos[i].ti_attach(tr);
  639                                 goto out;
  640                         }
  641                 }
error = EPROTONOSUPPORT;
  643                 break;
  644         case SIOCGTRUNKPORT:
  645                 if (rp->rp_portname[0] == '\0' ||
  646                     (tpif = ifunit(rp->rp_portname)) == NULL) {
error = EINVAL;
  648                         break;
  649                 }
  651                 /* Search in all trunks if the global flag is set */
  652                 if ((tp = trunk_port_get(rp->rp_flags & TRUNK_PORT_GLOBAL ?
NULL : tr, tpif)) == NULL) {
error = ENOENT;
  655                         break;
  656                 }
trunk_port2req(tp, rp);
  659                 break;
  660         case SIOCSTRUNKPORT:
  661                 if ((error = suser(curproc, 0)) != 0) {
error = EPERM;
  663                         break;
  664                 }
  665                 if (rp->rp_portname[0] == '\0' ||
  666                     (tpif = ifunit(rp->rp_portname)) == NULL) {
error = EINVAL;
  668                         break;
  669                 }
error = trunk_port_create(tr, tpif);
  671                 break;
  672         case SIOCSTRUNKDELPORT:
  673                 if ((error = suser(curproc, 0)) != 0) {
error = EPERM;
  675                         break;
  676                 }
  677                 if (rp->rp_portname[0] == '\0' ||
  678                     (tpif = ifunit(rp->rp_portname)) == NULL) {
error = EINVAL;
  680                         break;
  681                 }
  683                 /* Search in all trunks if the global flag is set */
  684                 if ((tp = trunk_port_get(rp->rp_flags & TRUNK_PORT_GLOBAL ?
NULL : tr, tpif)) == NULL) {
error = ENOENT;
  687                         break;
  688                 }
error = trunk_port_destroy(tp);
  691                 break;
  692         case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
  695 #ifdef INET
  696                 if (ifa->ifa_addr->sa_family == AF_INET)
arp_ifinit(&tr->tr_ac, ifa);
  698 #endif /* INET */
error = ENETRESET;
  700                 break;
  701         case SIOCSIFMTU:
  702                 if (ifr->ifr_mtu > ETHERMTU) {
error = EINVAL;
  704                         break;
  705                 }
ifp->if_mtu = ifr->ifr_mtu;
  707                 break;
  708         case SIOCSIFFLAGS:
error = ENETRESET;
  710                 break;
  711         case SIOCADDMULTI:
error = trunk_ether_addmulti(tr, ifr);
  713                 break;
  714         case SIOCDELMULTI:
error = trunk_ether_delmulti(tr, ifr);
  716                 break;
  717         case SIOCSIFMEDIA:
  718         case SIOCGIFMEDIA:
error = ifmedia_ioctl(ifp, ifr, &tr->tr_media, cmd);
  720                 break;
  721         case SIOCSIFLLADDR:
  722                 /* Update the port lladdrs as well */
SLIST_FOREACH(tp, &tr->tr_ports, tp_entries)
trunk_port_lladdr(tp, ifr->ifr_addr.sa_data);
error = ENETRESET;
  726                 break;
  727         default:
error = EINVAL;
  729                 break;
  730         }
  732         if (error == ENETRESET) {
  733                 if (ifp->if_flags & IFF_UP) {
  734                         if ((ifp->if_flags & IFF_RUNNING) == 0)
trunk_init(ifp);
  736                 } else {
  737                         if (ifp->if_flags & IFF_RUNNING)
trunk_stop(ifp);
  739                 }
error = 0;
  741         }
out:
splx(s);
  745         return (error);
  746 }
  748 int
trunk_ether_addmulti(struct trunk_softc *tr, struct ifreq *ifr)
  750 {
  751         struct trunk_mc *mc;
u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
  753         int error;
  755         /* Ignore ENETRESET error code */
  756         if ((error = ether_addmulti(ifr, &tr->tr_ac)) != ENETRESET)
  757                 return (error);
  759         if ((mc = (struct trunk_mc *)malloc(sizeof(struct trunk_mc),
M_DEVBUF, M_NOWAIT)) == NULL) {
error = ENOMEM;
  762                 goto failed;
  763         }
ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi);
ETHER_LOOKUP_MULTI(addrlo, addrhi, &tr->tr_ac, mc->mc_enm);
bcopy(&ifr->ifr_addr, &mc->mc_addr, ifr->ifr_addr.sa_len);
SLIST_INSERT_HEAD(&tr->tr_mc_head, mc, mc_entries);
  770         if ((error = trunk_ioctl_allports(tr, SIOCADDMULTI,
  771             (caddr_t)ifr)) != 0) {
trunk_ether_delmulti(tr, ifr);
  773                 return (error);
  774         }
  776         return (error);
failed:
ether_delmulti(ifr, &tr->tr_ac);
  781         return (error);
  782 }
  784 int
trunk_ether_delmulti(struct trunk_softc *tr, struct ifreq *ifr)
  786 {
  787         struct ether_multi *enm;
  788         struct trunk_mc *mc;
u_int8_t addrlo[ETHER_ADDR_LEN], addrhi[ETHER_ADDR_LEN];
  790         int error;
  792         if ((error = ether_multiaddr(&ifr->ifr_addr, addrlo, addrhi)) != 0)
  793                 return (error);
ETHER_LOOKUP_MULTI(addrlo, addrhi, &tr->tr_ac, enm);
  795         if (enm == NULL)
  796                 return (EINVAL);
SLIST_FOREACH(mc, &tr->tr_mc_head, mc_entries)
  799                 if (mc->mc_enm == enm)
  800                         break;
  802         /* We won't delete entries we didn't add */
  803         if (mc == NULL)
  804                 return (EINVAL);
  806         if ((error = ether_delmulti(ifr, &tr->tr_ac)) != ENETRESET)
  807                 return (error);
  809         if ((error = trunk_ioctl_allports(tr, SIOCDELMULTI,
  810             (caddr_t)ifr)) != 0) {
  811                 /* XXX At least one port failed to remove the address */
  812                 if (tr->tr_ifflags & IFF_DEBUG) {
printf("%s: failed to remove multicast address "
  814                             "on all ports\n", tr->tr_ifname);
  815                 }
  816         }
SLIST_REMOVE(&tr->tr_mc_head, mc, trunk_mc, mc_entries);
free(mc, M_DEVBUF);
  821         return (0);
  822 }
  824 void
trunk_ether_purgemulti(struct trunk_softc *tr)
  826 {
  827         struct trunk_mc *mc;
  828         struct trunk_ifreq ifs;
  829         struct ifreq *ifr = &ifs.ifreq.ifreq;
  831         while ((mc = SLIST_FIRST(&tr->tr_mc_head)) != NULL) {
bcopy(&mc->mc_addr, &ifr->ifr_addr, mc->mc_addr.ss_len);
  834                 /* Try to remove multicast address on all ports */
trunk_ioctl_allports(tr, SIOCDELMULTI, (caddr_t)ifr);
SLIST_REMOVE(&tr->tr_mc_head, mc, trunk_mc, mc_entries);
free(mc, M_DEVBUF);
  839         }
  840 }
  842 int
trunk_ether_cmdmulti(struct trunk_port *tp, u_long cmd)
  844 {
  845         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
  846         struct trunk_mc *mc;
  847         struct trunk_ifreq ifs;
  848         struct ifreq *ifr = &ifs.ifreq.ifreq;
  849         int ret, error = 0;
bcopy(tp->tp_ifname, ifr->ifr_name, IFNAMSIZ);
SLIST_FOREACH(mc, &tr->tr_mc_head, mc_entries) {
bcopy(&mc->mc_addr, &ifr->ifr_addr, mc->mc_addr.ss_len);
  855                 if ((ret = tp->tp_ioctl(tp->tp_if, cmd, (caddr_t)ifr)) != 0) {
  856                         if (tr->tr_ifflags & IFF_DEBUG) {
printf("%s: ioctl %lu failed on %s: %d\n",
tr->tr_ifname, cmd, tp->tp_ifname, ret);
  859                         }
  860                         /* Store last known error and continue */
error = ret;
  862                 }
  863         }
  865         return (error);
  866 }
  868 int
trunk_ioctl_allports(struct trunk_softc *tr, u_long cmd, caddr_t data)
  870 {
  871         struct ifreq *ifr = (struct ifreq *)data;
  872         struct trunk_port *tp;
  873         int ret, error = 0;
SLIST_FOREACH(tp, &tr->tr_ports, tp_entries) {
bcopy(tp->tp_ifname, ifr->ifr_name, IFNAMSIZ);
  877                 if ((ret = tp->tp_ioctl(tp->tp_if, cmd, data)) != 0) {
  878                         if (tr->tr_ifflags & IFF_DEBUG) {
printf("%s: ioctl %lu failed on %s: %d\n",
tr->tr_ifname, cmd, tp->tp_ifname, ret);
  881                         }
  882                         /* Store last known error and continue */
error = ret;
  884                 }
  885         }
  887         return (error);
  888 }
  890 void
trunk_start(struct ifnet *ifp)
  892 {
  893         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
  894         struct mbuf *m;
  895         int error = 0;
  897         for (;; error = 0) {
IFQ_DEQUEUE(&ifp->if_snd, m);
  899                 if (m == NULL)
  900                         break;
  902 #if NBPFILTER > 0
  903                 if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
  905 #endif
  907                 if (tr->tr_proto != TRUNK_PROTO_NONE)
error = (*tr->tr_start)(tr, m);
  909                 else
m_free(m);
  912                 if (error == 0)
ifp->if_opackets++;
  914                 else
ifp->if_oerrors++;
  916         }
  918         return;
  919 }
  921 int
trunk_enqueue(struct ifnet *ifp, struct mbuf *m)
  923 {
  924         int error = 0;
  926         /* Send mbuf */
IFQ_ENQUEUE(&ifp->if_snd, m, NULL, error);
  928         if (error)
  929                 return (error);
  930         if ((ifp->if_flags & IFF_OACTIVE) == 0)
  931                 (*ifp->if_start)(ifp);
ifp->if_obytes += m->m_pkthdr.len;
  934         if (m->m_flags & M_MCAST)
ifp->if_omcasts++;
  937         return (error);
  938 }
u_int32_t
trunk_hashmbuf(struct mbuf *m, u_int32_t key)
  942 {
u_int16_t etype;
u_int32_t p = 0;
u_int16_t *vlan, vlanbuf[2];
  946         int off;
  947         struct ether_header *eh;
  948 #ifdef INET
  949         struct ip *ip, ipbuf;
  950 #endif
  951 #ifdef INET6
  952         struct ip6_hdr *ip6, ip6buf;
  953 #endif
off = sizeof(*eh);
  956         if (m->m_len < off)
  957                 return (p);
eh = mtod(m, struct ether_header *);
etype = ntohs(eh->ether_type);
p = hash32_buf(&eh->ether_shost, ETHER_ADDR_LEN, key);
p = hash32_buf(&eh->ether_dhost, ETHER_ADDR_LEN, p);
  963         /* Special handling for encapsulating VLAN frames */
  964         if (etype == ETHERTYPE_VLAN) {
  965                 if ((vlan = (u_int16_t *)
trunk_lb_gethdr(m, off, EVL_ENCAPLEN, &vlanbuf)) == NULL)
  967                         return (p);
p = hash32_buf(vlan, sizeof(*vlan), p);
etype = ntohs(vlan[1]);
off += EVL_ENCAPLEN;
  971         }
  973         switch (etype) {
  974 #ifdef INET
  975         case ETHERTYPE_IP:
  976                 if ((ip = (struct ip *)
trunk_lb_gethdr(m, off, sizeof(*ip), &ipbuf)) == NULL)
  978                         return (p);
p = hash32_buf(&ip->ip_src, sizeof(struct in_addr), p);
p = hash32_buf(&ip->ip_dst, sizeof(struct in_addr), p);
  981                 break;
  982 #endif
  983 #ifdef INET6
  984         case ETHERTYPE_IPV6:
  985                 if ((ip6 = (struct ip6_hdr *)
trunk_lb_gethdr(m, off, sizeof(*ip6), &ip6buf)) == NULL)
  987                         return (p);
p = hash32_buf(&ip6->ip6_src, sizeof(struct in6_addr), p);
p = hash32_buf(&ip6->ip6_dst, sizeof(struct in6_addr), p);
  990                 break;
  991 #endif
  992         }
  994         return (p);
  995 }
  997 void
trunk_init(struct ifnet *ifp)
  999 {
 1000         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
 1001         int s;
s = splnet();
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
 1008         if (tr->tr_init != NULL)
 1009                 (*tr->tr_init)(tr);
splx(s);
 1012 }
 1014 void
trunk_stop(struct ifnet *ifp)
 1016 {
 1017         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
 1018         int s;
s = splnet();
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 1024         if (tr->tr_stop != NULL)
 1025                 (*tr->tr_stop)(tr);
splx(s);
 1028 }
 1030 void
trunk_watchdog(struct ifnet *ifp)
 1032 {
 1033         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
 1035         if (tr->tr_proto != TRUNK_PROTO_NONE &&
 1036             (*tr->tr_watchdog)(tr) != 0) {
ifp->if_oerrors++;
 1038         }
 1040 }
 1042 int
trunk_input(struct ifnet *ifp, struct ether_header *eh, struct mbuf *m)
 1044 {
 1045         struct trunk_softc *tr;
 1046         struct trunk_port *tp;
 1047         struct ifnet *trifp = NULL;
 1048         int error = 0;
 1050         /* Should be checked by the caller */
 1051         if (ifp->if_type != IFT_IEEE8023ADLAG) {
error = EPROTONOSUPPORT;
 1053                 goto bad;
 1054         }
 1055         if ((tp = (struct trunk_port *)ifp->if_tp) == NULL ||
 1056             (tr = (struct trunk_softc *)tp->tp_trunk) == NULL) {
error = ENOENT;
 1058                 goto bad;
 1059         }
 1060         if (tr->tr_proto == TRUNK_PROTO_NONE)
 1061                 goto bad;
trifp = &tr->tr_ac.ac_if;
error = (*tr->tr_input)(tr, tp, eh, m);
 1065         if (error != 0)
 1066                 goto bad;
 1068 #if NBPFILTER > 0
 1069         if (trifp->if_bpf)
bpf_mtap_hdr(trifp->if_bpf, (char *)eh, ETHER_HDR_LEN, m,
BPF_DIRECTION_IN);
 1072 #endif
trifp->if_ipackets++;
 1076         return (0);
bad:
 1079         if (error && trifp != NULL)
trifp->if_ierrors++;
 1081         return (error);
 1082 }
 1084 int
trunk_media_change(struct ifnet *ifp)
 1086 {
 1087         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
 1089         if (tr->tr_ifflags & IFF_DEBUG)
printf("%s\n", __func__);
 1092         /* Ignore */
 1093         return (0);
 1094 }
 1096 void
trunk_media_status(struct ifnet *ifp, struct ifmediareq *imr)
 1098 {
 1099         struct trunk_softc *tr = (struct trunk_softc *)ifp->if_softc;
 1100         struct trunk_port *tp;
imr->ifm_status = IFM_AVALID;
imr->ifm_active = IFM_ETHER | IFM_AUTO;
tp = tr->tr_primary;
 1106         if (tp != NULL && tp->tp_if->if_flags & IFF_UP)
imr->ifm_status |= IFM_ACTIVE;
 1108 }
 1110 void
trunk_port_state(void *arg)
 1112 {
 1113         struct trunk_port *tp = (struct trunk_port *)arg;
 1114         struct trunk_softc *tr = NULL;
 1116         if (tp != NULL)
tr = (struct trunk_softc *)tp->tp_trunk;
 1118         if (tr == NULL)
 1119                 return;
 1120         if (tr->tr_linkstate != NULL)
 1121                 (*tr->tr_linkstate)(tp);
trunk_link_active(tr, tp);
 1123 }
 1125 struct trunk_port *
trunk_link_active(struct trunk_softc *tr, struct trunk_port *tp)
 1127 {
 1128         struct trunk_port *tp_next, *rval = NULL;
 1129         int new_link = LINK_STATE_DOWN;
 1131         /*
 1132          * Search a port which reports an active link state.
 1133          */
 1135         if (tp == NULL)
 1136                 goto search;
 1137         if (TRUNK_PORTACTIVE(tp)) {
rval = tp;
 1139                 goto found;
 1140         }
 1141         if ((tp_next = SLIST_NEXT(tp, tp_entries)) != NULL &&
TRUNK_PORTACTIVE(tp_next)) {
rval = tp_next;
 1144                 goto found;
 1145         }
search:
SLIST_FOREACH(tp_next, &tr->tr_ports, tp_entries) {
 1149                 if (TRUNK_PORTACTIVE(tp_next)) {
rval = tp_next;
 1151                         goto found;
 1152                 }
 1153         }
found:
 1156         if (rval != NULL) {
 1157                 /*
 1158                  * The IEEE 802.1D standard assumes that a trunk with
 1159                  * multiple ports is always full duplex. This is valid
 1160                  * for load sharing trunks and if at least two links
 1161                  * are active. Unfortunately, checking the latter would
 1162                  * be too expensive at this point.
 1163                  */
 1164                 if ((tr->tr_capabilities & IFCAP_TRUNK_FULLDUPLEX) &&
 1165                     (tr->tr_count > 1))
new_link = LINK_STATE_FULL_DUPLEX;
 1167                 else
new_link = rval->tp_link_state;
 1169         }
 1171         if (tr->tr_ac.ac_if.if_link_state != new_link) {
tr->tr_ac.ac_if.if_link_state = new_link;
if_link_state_change(&tr->tr_ac.ac_if);
 1174         }
 1176         return (rval);
 1177 }
 1179 /*
 1180  * Simple round robin trunking
 1181  */
 1183 int
trunk_rr_attach(struct trunk_softc *tr)
 1185 {
 1186         struct trunk_port *tp;
tr->tr_detach = trunk_rr_detach;
tr->tr_start = trunk_rr_start;
tr->tr_input = trunk_rr_input;
tr->tr_init = NULL;
tr->tr_stop = NULL;
tr->tr_port_create = NULL;
tr->tr_port_destroy = trunk_rr_port_destroy;
tr->tr_capabilities = IFCAP_TRUNK_FULLDUPLEX;
tp = SLIST_FIRST(&tr->tr_ports);
tr->tr_psc = (caddr_t)tp;
 1200         return (0);
 1201 }
 1203 int
trunk_rr_detach(struct trunk_softc *tr)
 1205 {
tr->tr_psc = NULL;
 1207         return (0);
 1208 }
 1210 void
trunk_rr_port_destroy(struct trunk_port *tp)
 1212 {
 1213         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
 1215         if (tp == (struct trunk_port *)tr->tr_psc)
tr->tr_psc = NULL;
 1217 }
 1219 int
trunk_rr_start(struct trunk_softc *tr, struct mbuf *m)
 1221 {
 1222         struct trunk_port *tp = (struct trunk_port *)tr->tr_psc, *tp_next;
 1223         int error = 0;
 1225         if (tp == NULL && (tp = trunk_link_active(tr, NULL)) == NULL)
 1226                 return (ENOENT);
 1228         /* Send mbuf */
 1229         if ((error = trunk_enqueue(tp->tp_if, m)) != 0)
 1230                 return (error);
 1232         /* Get next active port */
tp_next = trunk_link_active(tr, SLIST_NEXT(tp, tp_entries));
tr->tr_psc = (caddr_t)tp_next;
 1236         return (0);
 1237 }
 1239 int
trunk_rr_input(struct trunk_softc *tr, struct trunk_port *tp,
 1241     struct ether_header *eh, struct mbuf *m)
 1242 {
 1243         struct ifnet *ifp = &tr->tr_ac.ac_if;
 1245         /* Just pass in the packet to our trunk device */
m->m_pkthdr.rcvif = ifp;
 1248         return (0);
 1249 }
 1251 /*
 1252  * Active failover
 1253  */
 1255 int
trunk_fail_attach(struct trunk_softc *tr)
 1257 {
tr->tr_detach = trunk_fail_detach;
tr->tr_start = trunk_fail_start;
tr->tr_input = trunk_fail_input;
tr->tr_init = NULL;
tr->tr_stop = NULL;
tr->tr_port_create = NULL;
tr->tr_port_destroy = NULL;
tr->tr_linkstate = NULL;
 1267         return (0);
 1268 }
 1270 int
trunk_fail_detach(struct trunk_softc *tr)
 1272 {
 1273         return (0);
 1274 }
 1276 int
trunk_fail_start(struct trunk_softc *tr, struct mbuf *m)
 1278 {
 1279         struct trunk_port *tp;
 1281         /* Use the master port if active or the next available port */
 1282         if ((tp = trunk_link_active(tr, tr->tr_primary)) == NULL)
 1283                 return (ENOENT);
 1285         /* Send mbuf */
 1286         return (trunk_enqueue(tp->tp_if, m));
 1287 }
 1289 int
trunk_fail_input(struct trunk_softc *tr, struct trunk_port *tp,
 1291     struct ether_header *eh, struct mbuf *m)
 1292 {
 1293         struct ifnet *ifp = &tr->tr_ac.ac_if;
 1294         struct trunk_port *tmp_tp;
 1296         if (tp == tr->tr_primary) {
m->m_pkthdr.rcvif = ifp;
 1298                 return (0);
 1299         }
 1301         if (tr->tr_primary->tp_link_state == LINK_STATE_DOWN) {
tmp_tp = trunk_link_active(tr, NULL);
 1303                 /*
 1304                  * If tmp_tp is null, we've recieved a packet when all
 1305                  * our links are down. Weird, but process it anyways.
 1306                  */
 1307                 if ((tmp_tp == NULL || tmp_tp == tp)) {
m->m_pkthdr.rcvif = ifp;
 1309                         return (0);
 1310                 }
 1311         }
 1313         return (-1);
 1314 }
 1316 /*
 1317  * Loadbalancing
 1318  */
 1320 int
trunk_lb_attach(struct trunk_softc *tr)
 1322 {
 1323         struct trunk_lb *lb;
 1325         if ((lb = (struct trunk_lb *)malloc(sizeof(struct trunk_lb),
M_DEVBUF, M_NOWAIT)) == NULL)
 1327                 return (ENOMEM);
bzero(lb, sizeof(struct trunk_lb));
tr->tr_detach = trunk_lb_detach;
tr->tr_start = trunk_lb_start;
tr->tr_input = trunk_lb_input;
tr->tr_port_create = trunk_lb_port_create;
tr->tr_port_destroy = trunk_lb_port_destroy;
tr->tr_linkstate = NULL;
tr->tr_capabilities = IFCAP_TRUNK_FULLDUPLEX;
lb->lb_key = arc4random();
tr->tr_psc = (caddr_t)lb;
 1341         return (0);
 1342 }
 1344 int
trunk_lb_detach(struct trunk_softc *tr)
 1346 {
 1347         struct trunk_lb *lb = (struct trunk_lb *)tr->tr_psc;
 1348         if (lb != NULL)
free(lb, M_DEVBUF);
 1350         return (0);
 1351 }
 1353 int
trunk_lb_porttable(struct trunk_softc *tr, struct trunk_port *tp)
 1355 {
 1356         struct trunk_lb *lb = (struct trunk_lb *)tr->tr_psc;
 1357         struct trunk_port *tp_next;
 1358         int i = 0;
bzero(&lb->lb_ports, sizeof(lb->lb_ports));
SLIST_FOREACH(tp_next, &tr->tr_ports, tp_entries) {
 1362                 if (tp_next == tp)
 1363                         continue;
 1364                 if (i >= TRUNK_MAX_PORTS)
 1365                         return (EINVAL);
 1366                 if (tr->tr_ifflags & IFF_DEBUG)
printf("%s: port %s at index %d\n",
tr->tr_ifname, tp_next->tp_ifname, i);
lb->lb_ports[i++] = tp_next;
 1370         }
 1372         return (0);
 1373 }
 1375 int
trunk_lb_port_create(struct trunk_port *tp)
 1377 {
 1378         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
 1379         return (trunk_lb_porttable(tr, NULL));
 1380 }
 1382 void
trunk_lb_port_destroy(struct trunk_port *tp)
 1384 {
 1385         struct trunk_softc *tr = (struct trunk_softc *)tp->tp_trunk;
trunk_lb_porttable(tr, tp);
 1387 }
 1389 const void *
trunk_lb_gethdr(struct mbuf *m, u_int off, u_int len, void *buf)
 1391 {
 1392         if (m->m_pkthdr.len < (off + len)) {
 1393                 return (NULL);
 1394         } else if (m->m_len < (off + len)) {
m_copydata(m, off, len, buf);
 1396                 return (buf);
 1397         }
 1398         return (mtod(m, const void *) + off);
 1399 }
 1401 int
trunk_lb_start(struct trunk_softc *tr, struct mbuf *m)
 1403 {
 1404         struct trunk_lb *lb = (struct trunk_lb *)tr->tr_psc;
 1405         struct trunk_port *tp = NULL;
u_int32_t p = 0;
 1407         int idx;
p = trunk_hashmbuf(m, lb->lb_key);
 1410         if ((idx = p % tr->tr_count) >= TRUNK_MAX_PORTS)
 1411                 return (EINVAL);
tp = lb->lb_ports[idx];
 1414         /*
 1415          * Check the port's link state. This will return the next active
 1416          * port if the link is down or the port is NULL.
 1417          */
 1418         if ((tp = trunk_link_active(tr, tp)) == NULL)
 1419                 return (ENOENT);
 1421         /* Send mbuf */
 1422         return (trunk_enqueue(tp->tp_if, m));
 1423 }
 1425 int
trunk_lb_input(struct trunk_softc *tr, struct trunk_port *tp,
 1427     struct ether_header *eh, struct mbuf *m)
 1428 {
 1429         struct ifnet *ifp = &tr->tr_ac.ac_if;
 1431         /* Just pass in the packet to our trunk device */
m->m_pkthdr.rcvif = ifp;
 1434         return (0);
 1435 }