sys/net/if_lagg.c

   1 /*      $OpenBSD: if_trunk.c,v 1.30 2007/01/31 06:20:19 reyk Exp $      */
   2
   3 /*
   4  * Copyright (c) 2005, 2006 Reyk Floeter <reyk@openbsd.org>
   5  * Copyright (c) 2007 Andrew Thompson <thompsa@FreeBSD.org>
   6  * Copyright (c) 2014, 2016 Marcelo Araujo <araujo@FreeBSD.org>
   7  *
   8  * Permission to use, copy, modify, and distribute this software for any
   9  * purpose with or without fee is hereby granted, provided that the above
  10  * copyright notice and this permission notice appear in all copies.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19  */
  20
  21 #include <sys/cdefs.h>
  22 __FBSDID("$FreeBSD$");
  23
  24 #include "opt_inet.h"
  25 #include "opt_inet6.h"
  26 #include "opt_kern_tls.h"
  27 #include "opt_ratelimit.h"
  28
  29 #include <sys/param.h>
  30 #include <sys/kernel.h>
  31 #include <sys/malloc.h>
  32 #include <sys/mbuf.h>
  33 #include <sys/queue.h>
  34 #include <sys/socket.h>
  35 #include <sys/sockio.h>
  36 #include <sys/sysctl.h>
  37 #include <sys/module.h>
  38 #include <sys/priv.h>
  39 #include <sys/systm.h>
  40 #include <sys/proc.h>
  41 #include <sys/lock.h>
  42 #include <sys/rmlock.h>
  43 #include <sys/sx.h>
  44 #include <sys/taskqueue.h>
  45 #include <sys/eventhandler.h>
  46
  47 #include <net/ethernet.h>
  48 #include <net/if.h>
  49 #include <net/if_clone.h>
  50 #include <net/if_arp.h>
  51 #include <net/if_dl.h>
  52 #include <net/if_media.h>
  53 #include <net/if_types.h>
  54 #include <net/if_var.h>
  55 #include <net/bpf.h>
  56 #include <net/route.h>
  57 #include <net/vnet.h>
  58 #include <net/infiniband.h>
  59
  60 #if defined(INET) || defined(INET6)
  61 #include <netinet/in.h>
  62 #include <netinet/ip.h>
  63 #endif
  64 #ifdef INET
  65 #include <netinet/in_systm.h>
  66 #include <netinet/if_ether.h>
  67 #endif
  68
  69 #ifdef INET6
  70 #include <netinet/ip6.h>
  71 #include <netinet6/in6_var.h>
  72 #include <netinet6/in6_ifattach.h>
  73 #endif
  74
  75 #include <net/if_vlan_var.h>
  76 #include <net/if_lagg.h>
  77 #include <net/ieee8023ad_lacp.h>
  78
  79 #ifdef INET6
  80 /*
  81  * XXX: declare here to avoid to include many inet6 related files..
  82  * should be more generalized?
  83  */
  84 extern void     nd6_setmtu(struct ifnet *);
  85 #endif
  86
  87 #define LAGG_RLOCK()    struct epoch_tracker lagg_et; epoch_enter_preempt(net_epoch_preempt, &lagg_et)
  88 #define LAGG_RUNLOCK()  epoch_exit_preempt(net_epoch_preempt, &lagg_et)
  89 #define LAGG_RLOCK_ASSERT()     NET_EPOCH_ASSERT()
  90 #define LAGG_UNLOCK_ASSERT()    MPASS(!in_epoch(net_epoch_preempt))
  91
  92 #define LAGG_SX_INIT(_sc)       sx_init(&(_sc)->sc_sx, "if_lagg sx")
  93 #define LAGG_SX_DESTROY(_sc)    sx_destroy(&(_sc)->sc_sx)
  94 #define LAGG_XLOCK(_sc)         sx_xlock(&(_sc)->sc_sx)
  95 #define LAGG_XUNLOCK(_sc)       sx_xunlock(&(_sc)->sc_sx)
  96 #define LAGG_SXLOCK_ASSERT(_sc) sx_assert(&(_sc)->sc_sx, SA_LOCKED)
  97 #define LAGG_XLOCK_ASSERT(_sc)  sx_assert(&(_sc)->sc_sx, SA_XLOCKED)
  98
  99 /* Special flags we should propagate to the lagg ports. */
 100 static struct {
 101         int flag;
 102         int (*func)(struct ifnet *, int);
 103 } lagg_pflags[] = {
 104         {IFF_PROMISC, ifpromisc},
 105         {IFF_ALLMULTI, if_allmulti},
 106         {0, NULL}
 107 };
 108
 109 struct lagg_snd_tag {
 110         struct m_snd_tag com;
 111         struct m_snd_tag *tag;
 112 };
 113
 114 VNET_DEFINE(SLIST_HEAD(__trhead, lagg_softc), lagg_list); /* list of laggs */
 115 #define V_lagg_list     VNET(lagg_list)
 116 VNET_DEFINE_STATIC(struct mtx, lagg_list_mtx);
 117 #define V_lagg_list_mtx VNET(lagg_list_mtx)
 118 #define LAGG_LIST_LOCK_INIT(x)          mtx_init(&V_lagg_list_mtx, \
 119                                         "if_lagg list", NULL, MTX_DEF)
 120 #define LAGG_LIST_LOCK_DESTROY(x)       mtx_destroy(&V_lagg_list_mtx)
 121 #define LAGG_LIST_LOCK(x)               mtx_lock(&V_lagg_list_mtx)
 122 #define LAGG_LIST_UNLOCK(x)             mtx_unlock(&V_lagg_list_mtx)
 123 eventhandler_tag        lagg_detach_cookie = NULL;
 124
 125 static int      lagg_clone_create(struct if_clone *, int, caddr_t);
 126 static void     lagg_clone_destroy(struct ifnet *);
 127 VNET_DEFINE_STATIC(struct if_clone *, lagg_cloner);
 128 #define V_lagg_cloner   VNET(lagg_cloner)
 129 static const char laggname[] = "lagg";
 130 static MALLOC_DEFINE(M_LAGG, laggname, "802.3AD Link Aggregation Interface");
 131
 132 static void     lagg_capabilities(struct lagg_softc *);
 133 static int      lagg_port_create(struct lagg_softc *, struct ifnet *);
 134 static int      lagg_port_destroy(struct lagg_port *, int);
 135 static struct mbuf *lagg_input_ethernet(struct ifnet *, struct mbuf *);
 136 static struct mbuf *lagg_input_infiniband(struct ifnet *, struct mbuf *);
 137 static void     lagg_linkstate(struct lagg_softc *);
 138 static void     lagg_port_state(struct ifnet *, int);
 139 static int      lagg_port_ioctl(struct ifnet *, u_long, caddr_t);
 140 static int      lagg_port_output(struct ifnet *, struct mbuf *,
 141                     const struct sockaddr *, struct route *);
 142 static void     lagg_port_ifdetach(void *arg __unused, struct ifnet *);
 143 #ifdef LAGG_PORT_STACKING
 144 static int      lagg_port_checkstacking(struct lagg_softc *);
 145 #endif
 146 static void     lagg_port2req(struct lagg_port *, struct lagg_reqport *);
 147 static void     lagg_init(void *);
 148 static void     lagg_stop(struct lagg_softc *);
 149 static int      lagg_ioctl(struct ifnet *, u_long, caddr_t);
 150 #if defined(KERN_TLS) || defined(RATELIMIT)
 151 static int      lagg_snd_tag_alloc(struct ifnet *,
 152                     union if_snd_tag_alloc_params *,
 153                     struct m_snd_tag **);
 154 static int      lagg_snd_tag_modify(struct m_snd_tag *,
 155                     union if_snd_tag_modify_params *);
 156 static int      lagg_snd_tag_query(struct m_snd_tag *,
 157                     union if_snd_tag_query_params *);
 158 static void     lagg_snd_tag_free(struct m_snd_tag *);
 159 static void     lagg_ratelimit_query(struct ifnet *,
 160                     struct if_ratelimit_query_results *);
 161 #endif
 162 static int      lagg_setmulti(struct lagg_port *);
 163 static int      lagg_clrmulti(struct lagg_port *);
 164 static  int     lagg_setcaps(struct lagg_port *, int cap);
 165 static  int     lagg_setflag(struct lagg_port *, int, int,
 166                     int (*func)(struct ifnet *, int));
 167 static  int     lagg_setflags(struct lagg_port *, int status);
 168 static uint64_t lagg_get_counter(struct ifnet *ifp, ift_counter cnt);
 169 static int      lagg_transmit_ethernet(struct ifnet *, struct mbuf *);
 170 static int      lagg_transmit_infiniband(struct ifnet *, struct mbuf *);
 171 static void     lagg_qflush(struct ifnet *);
 172 static int      lagg_media_change(struct ifnet *);
 173 static void     lagg_media_status(struct ifnet *, struct ifmediareq *);
 174 static struct lagg_port *lagg_link_active(struct lagg_softc *,
 175             struct lagg_port *);
 176
 177 /* Simple round robin */
 178 static void     lagg_rr_attach(struct lagg_softc *);
 179 static int      lagg_rr_start(struct lagg_softc *, struct mbuf *);
 180 static struct mbuf *lagg_rr_input(struct lagg_softc *, struct lagg_port *,
 181                     struct mbuf *);
 182
 183 /* Active failover */
 184 static int      lagg_fail_start(struct lagg_softc *, struct mbuf *);
 185 static struct mbuf *lagg_fail_input(struct lagg_softc *, struct lagg_port *,
 186                     struct mbuf *);
 187
 188 /* Loadbalancing */
 189 static void     lagg_lb_attach(struct lagg_softc *);
 190 static void     lagg_lb_detach(struct lagg_softc *);
 191 static int      lagg_lb_port_create(struct lagg_port *);
 192 static void     lagg_lb_port_destroy(struct lagg_port *);
 193 static int      lagg_lb_start(struct lagg_softc *, struct mbuf *);
 194 static struct mbuf *lagg_lb_input(struct lagg_softc *, struct lagg_port *,
 195                     struct mbuf *);
 196 static int      lagg_lb_porttable(struct lagg_softc *, struct lagg_port *);
 197
 198 /* Broadcast */
 199 static int    lagg_bcast_start(struct lagg_softc *, struct mbuf *);
 200 static struct mbuf *lagg_bcast_input(struct lagg_softc *, struct lagg_port *,
 201                     struct mbuf *);
 202
 203 /* 802.3ad LACP */
 204 static void     lagg_lacp_attach(struct lagg_softc *);
 205 static void     lagg_lacp_detach(struct lagg_softc *);
 206 static int      lagg_lacp_start(struct lagg_softc *, struct mbuf *);
 207 static struct mbuf *lagg_lacp_input(struct lagg_softc *, struct lagg_port *,
 208                     struct mbuf *);
 209 static void     lagg_lacp_lladdr(struct lagg_softc *);
 210
 211 /* lagg protocol table */
 212 static const struct lagg_proto {
 213         lagg_proto      pr_num;
 214         void            (*pr_attach)(struct lagg_softc *);
 215         void            (*pr_detach)(struct lagg_softc *);
 216         int             (*pr_start)(struct lagg_softc *, struct mbuf *);
 217         struct mbuf *   (*pr_input)(struct lagg_softc *, struct lagg_port *,
 218                             struct mbuf *);
 219         int             (*pr_addport)(struct lagg_port *);
 220         void            (*pr_delport)(struct lagg_port *);
 221         void            (*pr_linkstate)(struct lagg_port *);
 222         void            (*pr_init)(struct lagg_softc *);
 223         void            (*pr_stop)(struct lagg_softc *);
 224         void            (*pr_lladdr)(struct lagg_softc *);
 225         void            (*pr_request)(struct lagg_softc *, void *);
 226         void            (*pr_portreq)(struct lagg_port *, void *);
 227 } lagg_protos[] = {
 228     {
 229         .pr_num = LAGG_PROTO_NONE
 230     },
 231     {
 232         .pr_num = LAGG_PROTO_ROUNDROBIN,
 233         .pr_attach = lagg_rr_attach,
 234         .pr_start = lagg_rr_start,
 235         .pr_input = lagg_rr_input,
 236     },
 237     {
 238         .pr_num = LAGG_PROTO_FAILOVER,
 239         .pr_start = lagg_fail_start,
 240         .pr_input = lagg_fail_input,
 241     },
 242     {
 243         .pr_num = LAGG_PROTO_LOADBALANCE,
 244         .pr_attach = lagg_lb_attach,
 245         .pr_detach = lagg_lb_detach,
 246         .pr_start = lagg_lb_start,
 247         .pr_input = lagg_lb_input,
 248         .pr_addport = lagg_lb_port_create,
 249         .pr_delport = lagg_lb_port_destroy,
 250     },
 251     {
 252         .pr_num = LAGG_PROTO_LACP,
 253         .pr_attach = lagg_lacp_attach,
 254         .pr_detach = lagg_lacp_detach,
 255         .pr_start = lagg_lacp_start,
 256         .pr_input = lagg_lacp_input,
 257         .pr_addport = lacp_port_create,
 258         .pr_delport = lacp_port_destroy,
 259         .pr_linkstate = lacp_linkstate,
 260         .pr_init = lacp_init,
 261         .pr_stop = lacp_stop,
 262         .pr_lladdr = lagg_lacp_lladdr,
 263         .pr_request = lacp_req,
 264         .pr_portreq = lacp_portreq,
 265     },
 266     {
 267         .pr_num = LAGG_PROTO_BROADCAST,
 268         .pr_start = lagg_bcast_start,
 269         .pr_input = lagg_bcast_input,
 270     },
 271 };
 272
 273 SYSCTL_DECL(_net_link);
 274 SYSCTL_NODE(_net_link, OID_AUTO, lagg, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 275     "Link Aggregation");
 276
 277 /* Allow input on any failover links */
 278 VNET_DEFINE_STATIC(int, lagg_failover_rx_all);
 279 #define V_lagg_failover_rx_all  VNET(lagg_failover_rx_all)
 280 SYSCTL_INT(_net_link_lagg, OID_AUTO, failover_rx_all, CTLFLAG_RW | CTLFLAG_VNET,
 281     &VNET_NAME(lagg_failover_rx_all), 0,
 282     "Accept input from any interface in a failover lagg");
 283
 284 /* Default value for using flowid */
 285 VNET_DEFINE_STATIC(int, def_use_flowid) = 0;
 286 #define V_def_use_flowid        VNET(def_use_flowid)
 287 SYSCTL_INT(_net_link_lagg, OID_AUTO, default_use_flowid, CTLFLAG_RWTUN,
 288     &VNET_NAME(def_use_flowid), 0,
 289     "Default setting for using flow id for load sharing");
 290
 291 /* Default value for using numa */
 292 VNET_DEFINE_STATIC(int, def_use_numa) = 1;
 293 #define V_def_use_numa  VNET(def_use_numa)
 294 SYSCTL_INT(_net_link_lagg, OID_AUTO, default_use_numa, CTLFLAG_RWTUN,
 295     &VNET_NAME(def_use_numa), 0,
 296     "Use numa to steer flows");
 297
 298 /* Default value for flowid shift */
 299 VNET_DEFINE_STATIC(int, def_flowid_shift) = 16;
 300 #define V_def_flowid_shift      VNET(def_flowid_shift)
 301 SYSCTL_INT(_net_link_lagg, OID_AUTO, default_flowid_shift, CTLFLAG_RWTUN,
 302     &VNET_NAME(def_flowid_shift), 0,
 303     "Default setting for flowid shift for load sharing");
 304
 305 static void
 306 vnet_lagg_init(const void *unused __unused)
 307 {
 308
 309         LAGG_LIST_LOCK_INIT();
 310         SLIST_INIT(&V_lagg_list);
 311         V_lagg_cloner = if_clone_simple(laggname, lagg_clone_create,
 312             lagg_clone_destroy, 0);
 313 }
 314 VNET_SYSINIT(vnet_lagg_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
 315     vnet_lagg_init, NULL);
 316
 317 static void
 318 vnet_lagg_uninit(const void *unused __unused)
 319 {
 320
 321         if_clone_detach(V_lagg_cloner);
 322         LAGG_LIST_LOCK_DESTROY();
 323 }
 324 VNET_SYSUNINIT(vnet_lagg_uninit, SI_SUB_INIT_IF, SI_ORDER_ANY,
 325     vnet_lagg_uninit, NULL);
 326
 327 static int
 328 lagg_modevent(module_t mod, int type, void *data)
 329 {
 330
 331         switch (type) {
 332         case MOD_LOAD:
 333                 lagg_input_ethernet_p = lagg_input_ethernet;
 334                 lagg_input_infiniband_p = lagg_input_infiniband;
 335                 lagg_linkstate_p = lagg_port_state;
 336                 lagg_detach_cookie = EVENTHANDLER_REGISTER(
 337                     ifnet_departure_event, lagg_port_ifdetach, NULL,
 338                     EVENTHANDLER_PRI_ANY);
 339                 break;
 340         case MOD_UNLOAD:
 341                 EVENTHANDLER_DEREGISTER(ifnet_departure_event,
 342                     lagg_detach_cookie);
 343                 lagg_input_ethernet_p = NULL;
 344                 lagg_input_infiniband_p = NULL;
 345                 lagg_linkstate_p = NULL;
 346                 break;
 347         default:
 348                 return (EOPNOTSUPP);
 349         }
 350         return (0);
 351 }
 352
 353 static moduledata_t lagg_mod = {
 354         "if_lagg",
 355         lagg_modevent,
 356         0
 357 };
 358
 359 DECLARE_MODULE(if_lagg, lagg_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 360 MODULE_VERSION(if_lagg, 1);
 361 MODULE_DEPEND(if_lagg, if_infiniband, 1, 1, 1);
 362
 363 static void
 364 lagg_proto_attach(struct lagg_softc *sc, lagg_proto pr)
 365 {
 366
 367         LAGG_XLOCK_ASSERT(sc);
 368         KASSERT(sc->sc_proto == LAGG_PROTO_NONE, ("%s: sc %p has proto",
 369             __func__, sc));
 370
 371         if (sc->sc_ifflags & IFF_DEBUG)
 372                 if_printf(sc->sc_ifp, "using proto %u\n", pr);
 373
 374         if (lagg_protos[pr].pr_attach != NULL)
 375                 lagg_protos[pr].pr_attach(sc);
 376         sc->sc_proto = pr;
 377 }
 378
 379 static void
 380 lagg_proto_detach(struct lagg_softc *sc)
 381 {
 382         lagg_proto pr;
 383
 384         LAGG_XLOCK_ASSERT(sc);
 385         pr = sc->sc_proto;
 386         sc->sc_proto = LAGG_PROTO_NONE;
 387
 388         if (lagg_protos[pr].pr_detach != NULL)
 389                 lagg_protos[pr].pr_detach(sc);
 390 }
 391
 392 static int
 393 lagg_proto_start(struct lagg_softc *sc, struct mbuf *m)
 394 {
 395
 396         return (lagg_protos[sc->sc_proto].pr_start(sc, m));
 397 }
 398
 399 static struct mbuf *
 400 lagg_proto_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
 401 {
 402
 403         return (lagg_protos[sc->sc_proto].pr_input(sc, lp, m));
 404 }
 405
 406 static int
 407 lagg_proto_addport(struct lagg_softc *sc, struct lagg_port *lp)
 408 {
 409
 410         if (lagg_protos[sc->sc_proto].pr_addport == NULL)
 411                 return (0);
 412         else
 413                 return (lagg_protos[sc->sc_proto].pr_addport(lp));
 414 }
 415
 416 static void
 417 lagg_proto_delport(struct lagg_softc *sc, struct lagg_port *lp)
 418 {
 419
 420         if (lagg_protos[sc->sc_proto].pr_delport != NULL)
 421                 lagg_protos[sc->sc_proto].pr_delport(lp);
 422 }
 423
 424 static void
 425 lagg_proto_linkstate(struct lagg_softc *sc, struct lagg_port *lp)
 426 {
 427
 428         if (lagg_protos[sc->sc_proto].pr_linkstate != NULL)
 429                 lagg_protos[sc->sc_proto].pr_linkstate(lp);
 430 }
 431
 432 static void
 433 lagg_proto_init(struct lagg_softc *sc)
 434 {
 435
 436         if (lagg_protos[sc->sc_proto].pr_init != NULL)
 437                 lagg_protos[sc->sc_proto].pr_init(sc);
 438 }
 439
 440 static void
 441 lagg_proto_stop(struct lagg_softc *sc)
 442 {
 443
 444         if (lagg_protos[sc->sc_proto].pr_stop != NULL)
 445                 lagg_protos[sc->sc_proto].pr_stop(sc);
 446 }
 447
 448 static void
 449 lagg_proto_lladdr(struct lagg_softc *sc)
 450 {
 451
 452         if (lagg_protos[sc->sc_proto].pr_lladdr != NULL)
 453                 lagg_protos[sc->sc_proto].pr_lladdr(sc);
 454 }
 455
 456 static void
 457 lagg_proto_request(struct lagg_softc *sc, void *v)
 458 {
 459
 460         if (lagg_protos[sc->sc_proto].pr_request != NULL)
 461                 lagg_protos[sc->sc_proto].pr_request(sc, v);
 462 }
 463
 464 static void
 465 lagg_proto_portreq(struct lagg_softc *sc, struct lagg_port *lp, void *v)
 466 {
 467
 468         if (lagg_protos[sc->sc_proto].pr_portreq != NULL)
 469                 lagg_protos[sc->sc_proto].pr_portreq(lp, v);
 470 }
 471
 472 /*
 473  * This routine is run via an vlan
 474  * config EVENT
 475  */
 476 static void
 477 lagg_register_vlan(void *arg, struct ifnet *ifp, u_int16_t vtag)
 478 {
 479         struct lagg_softc *sc = ifp->if_softc;
 480         struct lagg_port *lp;
 481
 482         if (ifp->if_softc !=  arg)   /* Not our event */
 483                 return;
 484
 485         LAGG_RLOCK();
 486         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
 487                 EVENTHANDLER_INVOKE(vlan_config, lp->lp_ifp, vtag);
 488         LAGG_RUNLOCK();
 489 }
 490
 491 /*
 492  * This routine is run via an vlan
 493  * unconfig EVENT
 494  */
 495 static void
 496 lagg_unregister_vlan(void *arg, struct ifnet *ifp, u_int16_t vtag)
 497 {
 498         struct lagg_softc *sc = ifp->if_softc;
 499         struct lagg_port *lp;
 500
 501         if (ifp->if_softc !=  arg)   /* Not our event */
 502                 return;
 503
 504         LAGG_RLOCK();
 505         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
 506                 EVENTHANDLER_INVOKE(vlan_unconfig, lp->lp_ifp, vtag);
 507         LAGG_RUNLOCK();
 508 }
 509
 510 static int
 511 lagg_clone_create(struct if_clone *ifc, int unit, caddr_t params)
 512 {
 513         struct iflaggparam iflp;
 514         struct lagg_softc *sc;
 515         struct ifnet *ifp;
 516         int if_type;
 517         int error;
 518         static const uint8_t eaddr[LAGG_ADDR_LEN];
 519         static const uint8_t ib_bcast_addr[INFINIBAND_ADDR_LEN] = {
 520                 0x00, 0xff, 0xff, 0xff,
 521                 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
 522                 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff
 523         };
 524
 525         if (params != NULL) {
 526                 error = copyin(params, &iflp, sizeof(iflp));
 527                 if (error)
 528                         return (error);
 529
 530                 switch (iflp.lagg_type) {
 531                 case LAGG_TYPE_ETHERNET:
 532                         if_type = IFT_ETHER;
 533                         break;
 534                 case LAGG_TYPE_INFINIBAND:
 535                         if_type = IFT_INFINIBAND;
 536                         break;
 537                 default:
 538                         return (EINVAL);
 539                 }
 540         } else {
 541                 if_type = IFT_ETHER;
 542         }
 543
 544         sc = malloc(sizeof(*sc), M_LAGG, M_WAITOK|M_ZERO);
 545         ifp = sc->sc_ifp = if_alloc(if_type);
 546         if (ifp == NULL) {
 547                 free(sc, M_LAGG);
 548                 return (ENOSPC);
 549         }
 550         LAGG_SX_INIT(sc);
 551
 552         mtx_init(&sc->sc_mtx, "lagg-mtx", NULL, MTX_DEF);
 553         callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0);
 554
 555         LAGG_XLOCK(sc);
 556         if (V_def_use_flowid)
 557                 sc->sc_opts |= LAGG_OPT_USE_FLOWID;
 558         if (V_def_use_numa)
 559                 sc->sc_opts |= LAGG_OPT_USE_NUMA;
 560         sc->flowid_shift = V_def_flowid_shift;
 561
 562         /* Hash all layers by default */
 563         sc->sc_flags = MBUF_HASHFLAG_L2|MBUF_HASHFLAG_L3|MBUF_HASHFLAG_L4;
 564
 565         lagg_proto_attach(sc, LAGG_PROTO_DEFAULT);
 566
 567         CK_SLIST_INIT(&sc->sc_ports);
 568
 569         switch (if_type) {
 570         case IFT_ETHER:
 571                 /* Initialise pseudo media types */
 572                 ifmedia_init(&sc->sc_media, 0, lagg_media_change,
 573                     lagg_media_status);
 574                 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
 575                 ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);
 576
 577                 if_initname(ifp, laggname, unit);
 578                 ifp->if_transmit = lagg_transmit_ethernet;
 579                 break;
 580         case IFT_INFINIBAND:
 581                 if_initname(ifp, laggname, unit);
 582                 ifp->if_transmit = lagg_transmit_infiniband;
 583                 break;
 584         default:
 585                 break;
 586         }
 587         ifp->if_softc = sc;
 588         ifp->if_qflush = lagg_qflush;
 589         ifp->if_init = lagg_init;
 590         ifp->if_ioctl = lagg_ioctl;
 591         ifp->if_get_counter = lagg_get_counter;
 592         ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
 593 #if defined(KERN_TLS) || defined(RATELIMIT)
 594         ifp->if_snd_tag_alloc = lagg_snd_tag_alloc;
 595         ifp->if_snd_tag_modify = lagg_snd_tag_modify;
 596         ifp->if_snd_tag_query = lagg_snd_tag_query;
 597         ifp->if_snd_tag_free = lagg_snd_tag_free;
 598         ifp->if_ratelimit_query = lagg_ratelimit_query;
 599 #endif
 600         ifp->if_capenable = ifp->if_capabilities = IFCAP_HWSTATS;
 601
 602         /*
 603          * Attach as an ordinary ethernet device, children will be attached
 604          * as special device IFT_IEEE8023ADLAG or IFT_INFINIBANDLAG.
 605          */
 606         switch (if_type) {
 607         case IFT_ETHER:
 608                 ether_ifattach(ifp, eaddr);
 609                 break;
 610         case IFT_INFINIBAND:
 611                 infiniband_ifattach(ifp, eaddr, ib_bcast_addr);
 612                 break;
 613         default:
 614                 break;
 615         }
 616
 617         sc->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
 618                 lagg_register_vlan, sc, EVENTHANDLER_PRI_FIRST);
 619         sc->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
 620                 lagg_unregister_vlan, sc, EVENTHANDLER_PRI_FIRST);
 621
 622         /* Insert into the global list of laggs */
 623         LAGG_LIST_LOCK();
 624         SLIST_INSERT_HEAD(&V_lagg_list, sc, sc_entries);
 625         LAGG_LIST_UNLOCK();
 626         LAGG_XUNLOCK(sc);
 627
 628         return (0);
 629 }
 630
 631 static void
 632 lagg_clone_destroy(struct ifnet *ifp)
 633 {
 634         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
 635         struct lagg_port *lp;
 636
 637         LAGG_XLOCK(sc);
 638         sc->sc_destroying = 1;
 639         lagg_stop(sc);
 640         ifp->if_flags &= ~IFF_UP;
 641
 642         EVENTHANDLER_DEREGISTER(vlan_config, sc->vlan_attach);
 643         EVENTHANDLER_DEREGISTER(vlan_unconfig, sc->vlan_detach);
 644
 645         /* Shutdown and remove lagg ports */
 646         while ((lp = CK_SLIST_FIRST(&sc->sc_ports)) != NULL)
 647                 lagg_port_destroy(lp, 1);
 648
 649         /* Unhook the aggregation protocol */
 650         lagg_proto_detach(sc);
 651         LAGG_XUNLOCK(sc);
 652
 653         switch (ifp->if_type) {
 654         case IFT_ETHER:
 655                 ifmedia_removeall(&sc->sc_media);
 656                 ether_ifdetach(ifp);
 657                 break;
 658         case IFT_INFINIBAND:
 659                 infiniband_ifdetach(ifp);
 660                 break;
 661         default:
 662                 break;
 663         }
 664         if_free(ifp);
 665
 666         LAGG_LIST_LOCK();
 667         SLIST_REMOVE(&V_lagg_list, sc, lagg_softc, sc_entries);
 668         LAGG_LIST_UNLOCK();
 669
 670         mtx_destroy(&sc->sc_mtx);
 671         LAGG_SX_DESTROY(sc);
 672         free(sc, M_LAGG);
 673 }
 674
 675 static void
 676 lagg_capabilities(struct lagg_softc *sc)
 677 {
 678         struct lagg_port *lp;
 679         int cap, ena, pena;
 680         uint64_t hwa;
 681         struct ifnet_hw_tsomax hw_tsomax;
 682
 683         LAGG_XLOCK_ASSERT(sc);
 684
 685         /* Get common enabled capabilities for the lagg ports */
 686         ena = ~0;
 687         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
 688                 ena &= lp->lp_ifp->if_capenable;
 689         ena = (ena == ~0 ? 0 : ena);
 690
 691         /*
 692          * Apply common enabled capabilities back to the lagg ports.
 693          * May require several iterations if they are dependent.
 694          */
 695         do {
 696                 pena = ena;
 697                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
 698                         lagg_setcaps(lp, ena);
 699                         ena &= lp->lp_ifp->if_capenable;
 700                 }
 701         } while (pena != ena);
 702
 703         /* Get other capabilities from the lagg ports */
 704         cap = ~0;
 705         hwa = ~(uint64_t)0;
 706         memset(&hw_tsomax, 0, sizeof(hw_tsomax));
 707         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
 708                 cap &= lp->lp_ifp->if_capabilities;
 709                 hwa &= lp->lp_ifp->if_hwassist;
 710                 if_hw_tsomax_common(lp->lp_ifp, &hw_tsomax);
 711         }
 712         cap = (cap == ~0 ? 0 : cap);
 713         hwa = (hwa == ~(uint64_t)0 ? 0 : hwa);
 714
 715         if (sc->sc_ifp->if_capabilities != cap ||
 716             sc->sc_ifp->if_capenable != ena ||
 717             sc->sc_ifp->if_hwassist != hwa ||
 718             if_hw_tsomax_update(sc->sc_ifp, &hw_tsomax) != 0) {
 719                 sc->sc_ifp->if_capabilities = cap;
 720                 sc->sc_ifp->if_capenable = ena;
 721                 sc->sc_ifp->if_hwassist = hwa;
 722                 getmicrotime(&sc->sc_ifp->if_lastchange);
 723
 724                 if (sc->sc_ifflags & IFF_DEBUG)
 725                         if_printf(sc->sc_ifp,
 726                             "capabilities 0x%08x enabled 0x%08x\n", cap, ena);
 727         }
 728 }
 729
 730 static int
 731 lagg_port_create(struct lagg_softc *sc, struct ifnet *ifp)
 732 {
 733         struct lagg_softc *sc_ptr;
 734         struct lagg_port *lp, *tlp;
 735         struct ifreq ifr;
 736         int error, i, oldmtu;
 737         int if_type;
 738         uint64_t *pval;
 739
 740         LAGG_XLOCK_ASSERT(sc);
 741
 742         if (sc->sc_ifp == ifp) {
 743                 if_printf(sc->sc_ifp,
 744                     "cannot add a lagg to itself as a port\n");
 745                 return (EINVAL);
 746         }
 747
 748         if (sc->sc_destroying == 1)
 749                 return (ENXIO);
 750
 751         /* Limit the maximal number of lagg ports */
 752         if (sc->sc_count >= LAGG_MAX_PORTS)
 753                 return (ENOSPC);
 754
 755         /* Check if port has already been associated to a lagg */
 756         if (ifp->if_lagg != NULL) {
 757                 /* Port is already in the current lagg? */
 758                 lp = (struct lagg_port *)ifp->if_lagg;
 759                 if (lp->lp_softc == sc)
 760                         return (EEXIST);
 761                 return (EBUSY);
 762         }
 763
 764         switch (sc->sc_ifp->if_type) {
 765         case IFT_ETHER:
 766                 /* XXX Disallow non-ethernet interfaces (this should be any of 802) */
 767                 if (ifp->if_type != IFT_ETHER && ifp->if_type != IFT_L2VLAN)
 768                         return (EPROTONOSUPPORT);
 769                 if_type = IFT_IEEE8023ADLAG;
 770                 break;
 771         case IFT_INFINIBAND:
 772                 /* XXX Disallow non-infiniband interfaces */
 773                 if (ifp->if_type != IFT_INFINIBAND)
 774                         return (EPROTONOSUPPORT);
 775                 if_type = IFT_INFINIBANDLAG;
 776                 break;
 777         default:
 778                 break;
 779         }
 780
 781         /* Allow the first Ethernet member to define the MTU */
 782         oldmtu = -1;
 783         if (CK_SLIST_EMPTY(&sc->sc_ports)) {
 784                 sc->sc_ifp->if_mtu = ifp->if_mtu;
 785         } else if (sc->sc_ifp->if_mtu != ifp->if_mtu) {
 786                 if (ifp->if_ioctl == NULL) {
 787                         if_printf(sc->sc_ifp, "cannot change MTU for %s\n",
 788                             ifp->if_xname);
 789                         return (EINVAL);
 790                 }
 791                 oldmtu = ifp->if_mtu;
 792                 strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name));
 793                 ifr.ifr_mtu = sc->sc_ifp->if_mtu;
 794                 error = (*ifp->if_ioctl)(ifp, SIOCSIFMTU, (caddr_t)&ifr);
 795                 if (error != 0) {
 796                         if_printf(sc->sc_ifp, "invalid MTU for %s\n",
 797                             ifp->if_xname);
 798                         return (error);
 799                 }
 800                 ifr.ifr_mtu = oldmtu;
 801         }
 802
 803         lp = malloc(sizeof(struct lagg_port), M_LAGG, M_WAITOK|M_ZERO);
 804         lp->lp_softc = sc;
 805
 806         /* Check if port is a stacked lagg */
 807         LAGG_LIST_LOCK();
 808         SLIST_FOREACH(sc_ptr, &V_lagg_list, sc_entries) {
 809                 if (ifp == sc_ptr->sc_ifp) {
 810                         LAGG_LIST_UNLOCK();
 811                         free(lp, M_LAGG);
 812                         if (oldmtu != -1)
 813                                 (*ifp->if_ioctl)(ifp, SIOCSIFMTU,
 814                                     (caddr_t)&ifr);
 815                         return (EINVAL);
 816                         /* XXX disable stacking for the moment, its untested */
 817 #ifdef LAGG_PORT_STACKING
 818                         lp->lp_flags |= LAGG_PORT_STACK;
 819                         if (lagg_port_checkstacking(sc_ptr) >=
 820                             LAGG_MAX_STACKING) {
 821                                 LAGG_LIST_UNLOCK();
 822                                 free(lp, M_LAGG);
 823                                 if (oldmtu != -1)
 824                                         (*ifp->if_ioctl)(ifp, SIOCSIFMTU,
 825                                             (caddr_t)&ifr);
 826                                 return (E2BIG);
 827                         }
 828 #endif
 829                 }
 830         }
 831         LAGG_LIST_UNLOCK();
 832
 833         if_ref(ifp);
 834         lp->lp_ifp = ifp;
 835
 836         bcopy(IF_LLADDR(ifp), lp->lp_lladdr, ifp->if_addrlen);
 837         lp->lp_ifcapenable = ifp->if_capenable;
 838         if (CK_SLIST_EMPTY(&sc->sc_ports)) {
 839                 bcopy(IF_LLADDR(ifp), IF_LLADDR(sc->sc_ifp), ifp->if_addrlen);
 840                 lagg_proto_lladdr(sc);
 841                 EVENTHANDLER_INVOKE(iflladdr_event, sc->sc_ifp);
 842         } else {
 843                 if_setlladdr(ifp, IF_LLADDR(sc->sc_ifp), ifp->if_addrlen);
 844         }
 845         lagg_setflags(lp, 1);
 846
 847         if (CK_SLIST_EMPTY(&sc->sc_ports))
 848                 sc->sc_primary = lp;
 849
 850         /* Change the interface type */
 851         lp->lp_iftype = ifp->if_type;
 852         ifp->if_type = if_type;
 853         ifp->if_lagg = lp;
 854         lp->lp_ioctl = ifp->if_ioctl;
 855         ifp->if_ioctl = lagg_port_ioctl;
 856         lp->lp_output = ifp->if_output;
 857         ifp->if_output = lagg_port_output;
 858
 859         /* Read port counters */
 860         pval = lp->port_counters.val;
 861         for (i = 0; i < IFCOUNTERS; i++, pval++)
 862                 *pval = ifp->if_get_counter(ifp, i);
 863
 864         /*
 865          * Insert into the list of ports.
 866          * Keep ports sorted by if_index. It is handy, when configuration
 867          * is predictable and `ifconfig laggN create ...` command
 868          * will lead to the same result each time.
 869          */
 870         CK_SLIST_FOREACH(tlp, &sc->sc_ports, lp_entries) {
 871                 if (tlp->lp_ifp->if_index < ifp->if_index && (
 872                     CK_SLIST_NEXT(tlp, lp_entries) == NULL ||
 873                     ((struct  lagg_port*)CK_SLIST_NEXT(tlp, lp_entries))->lp_ifp->if_index >
 874                     ifp->if_index))
 875                         break;
 876         }
 877         if (tlp != NULL)
 878                 CK_SLIST_INSERT_AFTER(tlp, lp, lp_entries);
 879         else
 880                 CK_SLIST_INSERT_HEAD(&sc->sc_ports, lp, lp_entries);
 881         sc->sc_count++;
 882
 883         lagg_setmulti(lp);
 884
 885         if ((error = lagg_proto_addport(sc, lp)) != 0) {
 886                 /* Remove the port, without calling pr_delport. */
 887                 lagg_port_destroy(lp, 0);
 888                 if (oldmtu != -1)
 889                         (*ifp->if_ioctl)(ifp, SIOCSIFMTU, (caddr_t)&ifr);
 890                 return (error);
 891         }
 892
 893         /* Update lagg capabilities */
 894         lagg_capabilities(sc);
 895         lagg_linkstate(sc);
 896
 897         return (0);
 898 }
 899
 900 #ifdef LAGG_PORT_STACKING
 901 static int
 902 lagg_port_checkstacking(struct lagg_softc *sc)
 903 {
 904         struct lagg_softc *sc_ptr;
 905         struct lagg_port *lp;
 906         int m = 0;
 907
 908         LAGG_SXLOCK_ASSERT(sc);
 909         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
 910                 if (lp->lp_flags & LAGG_PORT_STACK) {
 911                         sc_ptr = (struct lagg_softc *)lp->lp_ifp->if_softc;
 912                         m = MAX(m, lagg_port_checkstacking(sc_ptr));
 913                 }
 914         }
 915
 916         return (m + 1);
 917 }
 918 #endif
 919
 920 static void
 921 lagg_port_destroy_cb(epoch_context_t ec)
 922 {
 923         struct lagg_port *lp;
 924         struct ifnet *ifp;
 925
 926         lp = __containerof(ec, struct lagg_port, lp_epoch_ctx);
 927         ifp = lp->lp_ifp;
 928
 929         if_rele(ifp);
 930         free(lp, M_LAGG);
 931 }
 932
 933 static int
 934 lagg_port_destroy(struct lagg_port *lp, int rundelport)
 935 {
 936         struct lagg_softc *sc = lp->lp_softc;
 937         struct lagg_port *lp_ptr, *lp0;
 938         struct ifnet *ifp = lp->lp_ifp;
 939         uint64_t *pval, vdiff;
 940         int i;
 941
 942         LAGG_XLOCK_ASSERT(sc);
 943
 944         if (rundelport)
 945                 lagg_proto_delport(sc, lp);
 946
 947         if (lp->lp_detaching == 0)
 948                 lagg_clrmulti(lp);
 949
 950         /* Restore interface */
 951         ifp->if_type = lp->lp_iftype;
 952         ifp->if_ioctl = lp->lp_ioctl;
 953         ifp->if_output = lp->lp_output;
 954         ifp->if_lagg = NULL;
 955
 956         /* Update detached port counters */
 957         pval = lp->port_counters.val;
 958         for (i = 0; i < IFCOUNTERS; i++, pval++) {
 959                 vdiff = ifp->if_get_counter(ifp, i) - *pval;
 960                 sc->detached_counters.val[i] += vdiff;
 961         }
 962
 963         /* Finally, remove the port from the lagg */
 964         CK_SLIST_REMOVE(&sc->sc_ports, lp, lagg_port, lp_entries);
 965         sc->sc_count--;
 966
 967         /* Update the primary interface */
 968         if (lp == sc->sc_primary) {
 969                 uint8_t lladdr[LAGG_ADDR_LEN];
 970
 971                 if ((lp0 = CK_SLIST_FIRST(&sc->sc_ports)) == NULL)
 972                         bzero(&lladdr, LAGG_ADDR_LEN);
 973                 else
 974                         bcopy(lp0->lp_lladdr, lladdr, LAGG_ADDR_LEN);
 975                 sc->sc_primary = lp0;
 976                 if (sc->sc_destroying == 0) {
 977                         bcopy(lladdr, IF_LLADDR(sc->sc_ifp), sc->sc_ifp->if_addrlen);
 978                         lagg_proto_lladdr(sc);
 979                         EVENTHANDLER_INVOKE(iflladdr_event, sc->sc_ifp);
 980                 }
 981
 982                 /*
 983                  * Update lladdr for each port (new primary needs update
 984                  * as well, to switch from old lladdr to its 'real' one)
 985                  */
 986                 CK_SLIST_FOREACH(lp_ptr, &sc->sc_ports, lp_entries)
 987                         if_setlladdr(lp_ptr->lp_ifp, lladdr, lp_ptr->lp_ifp->if_addrlen);
 988         }
 989
 990         if (lp->lp_ifflags)
 991                 if_printf(ifp, "%s: lp_ifflags unclean\n", __func__);
 992
 993         if (lp->lp_detaching == 0) {
 994                 lagg_setflags(lp, 0);
 995                 lagg_setcaps(lp, lp->lp_ifcapenable);
 996                 if_setlladdr(ifp, lp->lp_lladdr, ifp->if_addrlen);
 997         }
 998
 999         /*
1000          * free port and release it's ifnet reference after a grace period has
1001          * elapsed.
1002          */
1003         NET_EPOCH_CALL(lagg_port_destroy_cb, &lp->lp_epoch_ctx);
1004         /* Update lagg capabilities */
1005         lagg_capabilities(sc);
1006         lagg_linkstate(sc);
1007
1008         return (0);
1009 }
1010
1011 static int
1012 lagg_port_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1013 {
1014         struct lagg_reqport *rp = (struct lagg_reqport *)data;
1015         struct lagg_softc *sc;
1016         struct lagg_port *lp = NULL;
1017         int error = 0;
1018
1019         /* Should be checked by the caller */
1020         switch (ifp->if_type) {
1021         case IFT_IEEE8023ADLAG:
1022         case IFT_INFINIBANDLAG:
1023                 if ((lp = ifp->if_lagg) == NULL || (sc = lp->lp_softc) == NULL)
1024                         goto fallback;
1025                 break;
1026         default:
1027                 goto fallback;
1028         }
1029
1030         switch (cmd) {
1031         case SIOCGLAGGPORT:
1032                 if (rp->rp_portname[0] == '\0' ||
1033                     ifunit(rp->rp_portname) != ifp) {
1034                         error = EINVAL;
1035                         break;
1036                 }
1037
1038                 LAGG_RLOCK();
1039                 if ((lp = ifp->if_lagg) == NULL || lp->lp_softc != sc) {
1040                         error = ENOENT;
1041                         LAGG_RUNLOCK();
1042                         break;
1043                 }
1044
1045                 lagg_port2req(lp, rp);
1046                 LAGG_RUNLOCK();
1047                 break;
1048
1049         case SIOCSIFCAP:
1050                 if (lp->lp_ioctl == NULL) {
1051                         error = EINVAL;
1052                         break;
1053                 }
1054                 error = (*lp->lp_ioctl)(ifp, cmd, data);
1055                 if (error)
1056                         break;
1057
1058                 /* Update lagg interface capabilities */
1059                 LAGG_XLOCK(sc);
1060                 lagg_capabilities(sc);
1061                 LAGG_XUNLOCK(sc);
1062                 VLAN_CAPABILITIES(sc->sc_ifp);
1063                 break;
1064
1065         case SIOCSIFMTU:
1066                 /* Do not allow the MTU to be changed once joined */
1067                 error = EINVAL;
1068                 break;
1069
1070         default:
1071                 goto fallback;
1072         }
1073
1074         return (error);
1075
1076 fallback:
1077         if (lp != NULL && lp->lp_ioctl != NULL)
1078                 return ((*lp->lp_ioctl)(ifp, cmd, data));
1079
1080         return (EINVAL);
1081 }
1082
1083 /*
1084  * Requests counter @cnt data.
1085  *
1086  * Counter value is calculated the following way:
1087  * 1) for each port, sum  difference between current and "initial" measurements.
1088  * 2) add lagg logical interface counters.
1089  * 3) add data from detached_counters array.
1090  *
1091  * We also do the following things on ports attach/detach:
1092  * 1) On port attach we store all counters it has into port_counter array.
1093  * 2) On port detach we add the different between "initial" and
1094  *   current counters data to detached_counters array.
1095  */
1096 static uint64_t
1097 lagg_get_counter(struct ifnet *ifp, ift_counter cnt)
1098 {
1099         struct lagg_softc *sc;
1100         struct lagg_port *lp;
1101         struct ifnet *lpifp;
1102         uint64_t newval, oldval, vsum;
1103
1104         /* Revise this when we've got non-generic counters. */
1105         KASSERT(cnt < IFCOUNTERS, ("%s: invalid cnt %d", __func__, cnt));
1106
1107         sc = (struct lagg_softc *)ifp->if_softc;
1108
1109         vsum = 0;
1110         LAGG_RLOCK();
1111         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1112                 /* Saved attached value */
1113                 oldval = lp->port_counters.val[cnt];
1114                 /* current value */
1115                 lpifp = lp->lp_ifp;
1116                 newval = lpifp->if_get_counter(lpifp, cnt);
1117                 /* Calculate diff and save new */
1118                 vsum += newval - oldval;
1119         }
1120         LAGG_RUNLOCK();
1121
1122         /*
1123          * Add counter data which might be added by upper
1124          * layer protocols operating on logical interface.
1125          */
1126         vsum += if_get_counter_default(ifp, cnt);
1127
1128         /*
1129          * Add counter data from detached ports counters
1130          */
1131         vsum += sc->detached_counters.val[cnt];
1132
1133         return (vsum);
1134 }
1135
1136 /*
1137  * For direct output to child ports.
1138  */
1139 static int
1140 lagg_port_output(struct ifnet *ifp, struct mbuf *m,
1141         const struct sockaddr *dst, struct route *ro)
1142 {
1143         struct lagg_port *lp = ifp->if_lagg;
1144
1145         switch (dst->sa_family) {
1146                 case pseudo_AF_HDRCMPLT:
1147                 case AF_UNSPEC:
1148                         return ((*lp->lp_output)(ifp, m, dst, ro));
1149         }
1150
1151         /* drop any other frames */
1152         m_freem(m);
1153         return (ENETDOWN);
1154 }
1155
1156 static void
1157 lagg_port_ifdetach(void *arg __unused, struct ifnet *ifp)
1158 {
1159         struct lagg_port *lp;
1160         struct lagg_softc *sc;
1161
1162         if ((lp = ifp->if_lagg) == NULL)
1163                 return;
1164         /* If the ifnet is just being renamed, don't do anything. */
1165         if (ifp->if_flags & IFF_RENAMING)
1166                 return;
1167
1168         sc = lp->lp_softc;
1169
1170         LAGG_XLOCK(sc);
1171         lp->lp_detaching = 1;
1172         lagg_port_destroy(lp, 1);
1173         LAGG_XUNLOCK(sc);
1174         VLAN_CAPABILITIES(sc->sc_ifp);
1175 }
1176
1177 static void
1178 lagg_port2req(struct lagg_port *lp, struct lagg_reqport *rp)
1179 {
1180         struct lagg_softc *sc = lp->lp_softc;
1181
1182         strlcpy(rp->rp_ifname, sc->sc_ifname, sizeof(rp->rp_ifname));
1183         strlcpy(rp->rp_portname, lp->lp_ifp->if_xname, sizeof(rp->rp_portname));
1184         rp->rp_prio = lp->lp_prio;
1185         rp->rp_flags = lp->lp_flags;
1186         lagg_proto_portreq(sc, lp, &rp->rp_psc);
1187
1188         /* Add protocol specific flags */
1189         switch (sc->sc_proto) {
1190                 case LAGG_PROTO_FAILOVER:
1191                         if (lp == sc->sc_primary)
1192                                 rp->rp_flags |= LAGG_PORT_MASTER;
1193                         if (lp == lagg_link_active(sc, sc->sc_primary))
1194                                 rp->rp_flags |= LAGG_PORT_ACTIVE;
1195                         break;
1196
1197                 case LAGG_PROTO_ROUNDROBIN:
1198                 case LAGG_PROTO_LOADBALANCE:
1199                 case LAGG_PROTO_BROADCAST:
1200                         if (LAGG_PORTACTIVE(lp))
1201                                 rp->rp_flags |= LAGG_PORT_ACTIVE;
1202                         break;
1203
1204                 case LAGG_PROTO_LACP:
1205                         /* LACP has a different definition of active */
1206                         if (lacp_isactive(lp))
1207                                 rp->rp_flags |= LAGG_PORT_ACTIVE;
1208                         if (lacp_iscollecting(lp))
1209                                 rp->rp_flags |= LAGG_PORT_COLLECTING;
1210                         if (lacp_isdistributing(lp))
1211                                 rp->rp_flags |= LAGG_PORT_DISTRIBUTING;
1212                         break;
1213         }
1214
1215 }
1216
1217 static void
1218 lagg_watchdog_infiniband(void *arg)
1219 {
1220         struct lagg_softc *sc;
1221         struct lagg_port *lp;
1222         struct ifnet *ifp;
1223         struct ifnet *lp_ifp;
1224
1225         sc = arg;
1226
1227         /*
1228          * Because infiniband nodes have a fixed MAC address, which is
1229          * generated by the so-called GID, we need to regularly update
1230          * the link level address of the parent lagg<N> device when
1231          * the active port changes. Possibly we could piggy-back on
1232          * link up/down events aswell, but using a timer also provides
1233          * a guarantee against too frequent events. This operation
1234          * does not have to be atomic.
1235          */
1236         LAGG_RLOCK();
1237         lp = lagg_link_active(sc, sc->sc_primary);
1238         if (lp != NULL) {
1239                 ifp = sc->sc_ifp;
1240                 lp_ifp = lp->lp_ifp;
1241
1242                 if (ifp != NULL && lp_ifp != NULL &&
1243                     memcmp(IF_LLADDR(ifp), IF_LLADDR(lp_ifp), ifp->if_addrlen) != 0) {
1244                         memcpy(IF_LLADDR(ifp), IF_LLADDR(lp_ifp), ifp->if_addrlen);
1245                         CURVNET_SET(ifp->if_vnet);
1246                         EVENTHANDLER_INVOKE(iflladdr_event, ifp);
1247                         CURVNET_RESTORE();
1248                 }
1249         }
1250         LAGG_RUNLOCK();
1251
1252         callout_reset(&sc->sc_watchdog, hz, &lagg_watchdog_infiniband, arg);
1253 }
1254
1255 static void
1256 lagg_init(void *xsc)
1257 {
1258         struct lagg_softc *sc = (struct lagg_softc *)xsc;
1259         struct ifnet *ifp = sc->sc_ifp;
1260         struct lagg_port *lp;
1261
1262         LAGG_XLOCK(sc);
1263         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1264                 LAGG_XUNLOCK(sc);
1265                 return;
1266         }
1267
1268         ifp->if_drv_flags |= IFF_DRV_RUNNING;
1269
1270         /*
1271          * Update the port lladdrs if needed.
1272          * This might be if_setlladdr() notification
1273          * that lladdr has been changed.
1274          */
1275         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1276                 if (memcmp(IF_LLADDR(ifp), IF_LLADDR(lp->lp_ifp),
1277                     ifp->if_addrlen) != 0)
1278                         if_setlladdr(lp->lp_ifp, IF_LLADDR(ifp), ifp->if_addrlen);
1279         }
1280
1281         lagg_proto_init(sc);
1282
1283         if (ifp->if_type == IFT_INFINIBAND) {
1284                 mtx_lock(&sc->sc_mtx);
1285                 lagg_watchdog_infiniband(sc);
1286                 mtx_unlock(&sc->sc_mtx);
1287         }
1288
1289         LAGG_XUNLOCK(sc);
1290 }
1291
1292 static void
1293 lagg_stop(struct lagg_softc *sc)
1294 {
1295         struct ifnet *ifp = sc->sc_ifp;
1296
1297         LAGG_XLOCK_ASSERT(sc);
1298
1299         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1300                 return;
1301
1302         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1303
1304         lagg_proto_stop(sc);
1305
1306         mtx_lock(&sc->sc_mtx);
1307         callout_stop(&sc->sc_watchdog);
1308         mtx_unlock(&sc->sc_mtx);
1309
1310         callout_drain(&sc->sc_watchdog);
1311 }
1312
1313 static int
1314 lagg_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1315 {
1316         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
1317         struct lagg_reqall *ra = (struct lagg_reqall *)data;
1318         struct lagg_reqopts *ro = (struct lagg_reqopts *)data;
1319         struct lagg_reqport *rp = (struct lagg_reqport *)data, rpbuf;
1320         struct lagg_reqflags *rf = (struct lagg_reqflags *)data;
1321         struct ifreq *ifr = (struct ifreq *)data;
1322         struct lagg_port *lp;
1323         struct ifnet *tpif;
1324         struct thread *td = curthread;
1325         char *buf, *outbuf;
1326         int count, buflen, len, error = 0, oldmtu;
1327
1328         bzero(&rpbuf, sizeof(rpbuf));
1329
1330         /* XXX: This can race with lagg_clone_destroy. */
1331
1332         switch (cmd) {
1333         case SIOCGLAGG:
1334                 LAGG_XLOCK(sc);
1335                 buflen = sc->sc_count * sizeof(struct lagg_reqport);
1336                 outbuf = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO);
1337                 ra->ra_proto = sc->sc_proto;
1338                 lagg_proto_request(sc, &ra->ra_psc);
1339                 count = 0;
1340                 buf = outbuf;
1341                 len = min(ra->ra_size, buflen);
1342                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1343                         if (len < sizeof(rpbuf))
1344                                 break;
1345
1346                         lagg_port2req(lp, &rpbuf);
1347                         memcpy(buf, &rpbuf, sizeof(rpbuf));
1348                         count++;
1349                         buf += sizeof(rpbuf);
1350                         len -= sizeof(rpbuf);
1351                 }
1352                 LAGG_XUNLOCK(sc);
1353                 ra->ra_ports = count;
1354                 ra->ra_size = count * sizeof(rpbuf);
1355                 error = copyout(outbuf, ra->ra_port, ra->ra_size);
1356                 free(outbuf, M_TEMP);
1357                 break;
1358         case SIOCSLAGG:
1359                 error = priv_check(td, PRIV_NET_LAGG);
1360                 if (error)
1361                         break;
1362                 if (ra->ra_proto >= LAGG_PROTO_MAX) {
1363                         error = EPROTONOSUPPORT;
1364                         break;
1365                 }
1366                 /* Infiniband only supports the failover protocol. */
1367                 if (ra->ra_proto != LAGG_PROTO_FAILOVER &&
1368                     ifp->if_type == IFT_INFINIBAND) {
1369                         error = EPROTONOSUPPORT;
1370                         break;
1371                 }
1372                 LAGG_XLOCK(sc);
1373                 lagg_proto_detach(sc);
1374                 LAGG_UNLOCK_ASSERT();
1375                 lagg_proto_attach(sc, ra->ra_proto);
1376                 LAGG_XUNLOCK(sc);
1377                 break;
1378         case SIOCGLAGGOPTS:
1379                 LAGG_XLOCK(sc);
1380                 ro->ro_opts = sc->sc_opts;
1381                 if (sc->sc_proto == LAGG_PROTO_LACP) {
1382                         struct lacp_softc *lsc;
1383
1384                         lsc = (struct lacp_softc *)sc->sc_psc;
1385                         if (lsc->lsc_debug.lsc_tx_test != 0)
1386                                 ro->ro_opts |= LAGG_OPT_LACP_TXTEST;
1387                         if (lsc->lsc_debug.lsc_rx_test != 0)
1388                                 ro->ro_opts |= LAGG_OPT_LACP_RXTEST;
1389                         if (lsc->lsc_strict_mode != 0)
1390                                 ro->ro_opts |= LAGG_OPT_LACP_STRICT;
1391                         if (lsc->lsc_fast_timeout != 0)
1392                                 ro->ro_opts |= LAGG_OPT_LACP_FAST_TIMO;
1393
1394                         ro->ro_active = sc->sc_active;
1395                 } else {
1396                         ro->ro_active = 0;
1397                         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
1398                                 ro->ro_active += LAGG_PORTACTIVE(lp);
1399                 }
1400                 ro->ro_bkt = sc->sc_stride;
1401                 ro->ro_flapping = sc->sc_flapping;
1402                 ro->ro_flowid_shift = sc->flowid_shift;
1403                 LAGG_XUNLOCK(sc);
1404                 break;
1405         case SIOCSLAGGOPTS:
1406                 error = priv_check(td, PRIV_NET_LAGG);
1407                 if (error)
1408                         break;
1409
1410                 /*
1411                  * The stride option was added without defining a corresponding
1412                  * LAGG_OPT flag, so handle a non-zero value before checking
1413                  * anything else to preserve compatibility.
1414                  */
1415                 LAGG_XLOCK(sc);
1416                 if (ro->ro_opts == 0 && ro->ro_bkt != 0) {
1417                         if (sc->sc_proto != LAGG_PROTO_ROUNDROBIN) {
1418                                 LAGG_XUNLOCK(sc);
1419                                 error = EINVAL;
1420                                 break;
1421                         }
1422                         sc->sc_stride = ro->ro_bkt;
1423                 }
1424                 if (ro->ro_opts == 0) {
1425                         LAGG_XUNLOCK(sc);
1426                         break;
1427                 }
1428
1429                 /*
1430                  * Set options.  LACP options are stored in sc->sc_psc,
1431                  * not in sc_opts.
1432                  */
1433                 int valid, lacp;
1434
1435                 switch (ro->ro_opts) {
1436                 case LAGG_OPT_USE_FLOWID:
1437                 case -LAGG_OPT_USE_FLOWID:
1438                 case LAGG_OPT_USE_NUMA:
1439                 case -LAGG_OPT_USE_NUMA:
1440                 case LAGG_OPT_FLOWIDSHIFT:
1441                 case LAGG_OPT_RR_LIMIT:
1442                         valid = 1;
1443                         lacp = 0;
1444                         break;
1445                 case LAGG_OPT_LACP_TXTEST:
1446                 case -LAGG_OPT_LACP_TXTEST:
1447                 case LAGG_OPT_LACP_RXTEST:
1448                 case -LAGG_OPT_LACP_RXTEST:
1449                 case LAGG_OPT_LACP_STRICT:
1450                 case -LAGG_OPT_LACP_STRICT:
1451                 case LAGG_OPT_LACP_FAST_TIMO:
1452                 case -LAGG_OPT_LACP_FAST_TIMO:
1453                         valid = lacp = 1;
1454                         break;
1455                 default:
1456                         valid = lacp = 0;
1457                         break;
1458                 }
1459
1460                 if (valid == 0 ||
1461                     (lacp == 1 && sc->sc_proto != LAGG_PROTO_LACP)) {
1462                         /* Invalid combination of options specified. */
1463                         error = EINVAL;
1464                         LAGG_XUNLOCK(sc);
1465                         break;  /* Return from SIOCSLAGGOPTS. */
1466                 }
1467
1468                 /*
1469                  * Store new options into sc->sc_opts except for
1470                  * FLOWIDSHIFT, RR and LACP options.
1471                  */
1472                 if (lacp == 0) {
1473                         if (ro->ro_opts == LAGG_OPT_FLOWIDSHIFT)
1474                                 sc->flowid_shift = ro->ro_flowid_shift;
1475                         else if (ro->ro_opts == LAGG_OPT_RR_LIMIT) {
1476                                 if (sc->sc_proto != LAGG_PROTO_ROUNDROBIN ||
1477                                     ro->ro_bkt == 0) {
1478                                         error = EINVAL;
1479                                         LAGG_XUNLOCK(sc);
1480                                         break;
1481                                 }
1482                                 sc->sc_stride = ro->ro_bkt;
1483                         } else if (ro->ro_opts > 0)
1484                                 sc->sc_opts |= ro->ro_opts;
1485                         else
1486                                 sc->sc_opts &= ~ro->ro_opts;
1487                 } else {
1488                         struct lacp_softc *lsc;
1489                         struct lacp_port *lp;
1490
1491                         lsc = (struct lacp_softc *)sc->sc_psc;
1492
1493                         switch (ro->ro_opts) {
1494                         case LAGG_OPT_LACP_TXTEST:
1495                                 lsc->lsc_debug.lsc_tx_test = 1;
1496                                 break;
1497                         case -LAGG_OPT_LACP_TXTEST:
1498                                 lsc->lsc_debug.lsc_tx_test = 0;
1499                                 break;
1500                         case LAGG_OPT_LACP_RXTEST:
1501                                 lsc->lsc_debug.lsc_rx_test = 1;
1502                                 break;
1503                         case -LAGG_OPT_LACP_RXTEST:
1504                                 lsc->lsc_debug.lsc_rx_test = 0;
1505                                 break;
1506                         case LAGG_OPT_LACP_STRICT:
1507                                 lsc->lsc_strict_mode = 1;
1508                                 break;
1509                         case -LAGG_OPT_LACP_STRICT:
1510                                 lsc->lsc_strict_mode = 0;
1511                                 break;
1512                         case LAGG_OPT_LACP_FAST_TIMO:
1513                                 LACP_LOCK(lsc);
1514                                 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next)
1515                                         lp->lp_state |= LACP_STATE_TIMEOUT;
1516                                 LACP_UNLOCK(lsc);
1517                                 lsc->lsc_fast_timeout = 1;
1518                                 break;
1519                         case -LAGG_OPT_LACP_FAST_TIMO:
1520                                 LACP_LOCK(lsc);
1521                                 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next)
1522                                         lp->lp_state &= ~LACP_STATE_TIMEOUT;
1523                                 LACP_UNLOCK(lsc);
1524                                 lsc->lsc_fast_timeout = 0;
1525                                 break;
1526                         }
1527                 }
1528                 LAGG_XUNLOCK(sc);
1529                 break;
1530         case SIOCGLAGGFLAGS:
1531                 rf->rf_flags = 0;
1532                 LAGG_XLOCK(sc);
1533                 if (sc->sc_flags & MBUF_HASHFLAG_L2)
1534                         rf->rf_flags |= LAGG_F_HASHL2;
1535                 if (sc->sc_flags & MBUF_HASHFLAG_L3)
1536                         rf->rf_flags |= LAGG_F_HASHL3;
1537                 if (sc->sc_flags & MBUF_HASHFLAG_L4)
1538                         rf->rf_flags |= LAGG_F_HASHL4;
1539                 LAGG_XUNLOCK(sc);
1540                 break;
1541         case SIOCSLAGGHASH:
1542                 error = priv_check(td, PRIV_NET_LAGG);
1543                 if (error)
1544                         break;
1545                 if ((rf->rf_flags & LAGG_F_HASHMASK) == 0) {
1546                         error = EINVAL;
1547                         break;
1548                 }
1549                 LAGG_XLOCK(sc);
1550                 sc->sc_flags = 0;
1551                 if (rf->rf_flags & LAGG_F_HASHL2)
1552                         sc->sc_flags |= MBUF_HASHFLAG_L2;
1553                 if (rf->rf_flags & LAGG_F_HASHL3)
1554                         sc->sc_flags |= MBUF_HASHFLAG_L3;
1555                 if (rf->rf_flags & LAGG_F_HASHL4)
1556                         sc->sc_flags |= MBUF_HASHFLAG_L4;
1557                 LAGG_XUNLOCK(sc);
1558                 break;
1559         case SIOCGLAGGPORT:
1560                 if (rp->rp_portname[0] == '\0' ||
1561                     (tpif = ifunit_ref(rp->rp_portname)) == NULL) {
1562                         error = EINVAL;
1563                         break;
1564                 }
1565
1566                 LAGG_RLOCK();
1567                 if ((lp = (struct lagg_port *)tpif->if_lagg) == NULL ||
1568                     lp->lp_softc != sc) {
1569                         error = ENOENT;
1570                         LAGG_RUNLOCK();
1571                         if_rele(tpif);
1572                         break;
1573                 }
1574
1575                 lagg_port2req(lp, rp);
1576                 LAGG_RUNLOCK();
1577                 if_rele(tpif);
1578                 break;
1579         case SIOCSLAGGPORT:
1580                 error = priv_check(td, PRIV_NET_LAGG);
1581                 if (error)
1582                         break;
1583                 if (rp->rp_portname[0] == '\0' ||
1584                     (tpif = ifunit_ref(rp->rp_portname)) == NULL) {
1585                         error = EINVAL;
1586                         break;
1587                 }
1588 #ifdef INET6
1589                 /*
1590                  * A laggport interface should not have inet6 address
1591                  * because two interfaces with a valid link-local
1592                  * scope zone must not be merged in any form.  This
1593                  * restriction is needed to prevent violation of
1594                  * link-local scope zone.  Attempts to add a laggport
1595                  * interface which has inet6 addresses triggers
1596                  * removal of all inet6 addresses on the member
1597                  * interface.
1598                  */
1599                 if (in6ifa_llaonifp(tpif)) {
1600                         in6_ifdetach(tpif);
1601                                 if_printf(sc->sc_ifp,
1602                                     "IPv6 addresses on %s have been removed "
1603                                     "before adding it as a member to prevent "
1604                                     "IPv6 address scope violation.\n",
1605                                     tpif->if_xname);
1606                 }
1607 #endif
1608                 oldmtu = ifp->if_mtu;
1609                 LAGG_XLOCK(sc);
1610                 error = lagg_port_create(sc, tpif);
1611                 LAGG_XUNLOCK(sc);
1612                 if_rele(tpif);
1613
1614                 /*
1615                  * LAGG MTU may change during addition of the first port.
1616                  * If it did, do network layer specific procedure.
1617                  */
1618                 if (ifp->if_mtu != oldmtu) {
1619 #ifdef INET6
1620                         nd6_setmtu(ifp);
1621 #endif
1622                         rt_updatemtu(ifp);
1623                 }
1624
1625                 VLAN_CAPABILITIES(ifp);
1626                 break;
1627         case SIOCSLAGGDELPORT:
1628                 error = priv_check(td, PRIV_NET_LAGG);
1629                 if (error)
1630                         break;
1631                 if (rp->rp_portname[0] == '\0' ||
1632                     (tpif = ifunit_ref(rp->rp_portname)) == NULL) {
1633                         error = EINVAL;
1634                         break;
1635                 }
1636
1637                 LAGG_XLOCK(sc);
1638                 if ((lp = (struct lagg_port *)tpif->if_lagg) == NULL ||
1639                     lp->lp_softc != sc) {
1640                         error = ENOENT;
1641                         LAGG_XUNLOCK(sc);
1642                         if_rele(tpif);
1643                         break;
1644                 }
1645
1646                 error = lagg_port_destroy(lp, 1);
1647                 LAGG_XUNLOCK(sc);
1648                 if_rele(tpif);
1649                 VLAN_CAPABILITIES(ifp);
1650                 break;
1651         case SIOCSIFFLAGS:
1652                 /* Set flags on ports too */
1653                 LAGG_XLOCK(sc);
1654                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1655                         lagg_setflags(lp, 1);
1656                 }
1657
1658                 if (!(ifp->if_flags & IFF_UP) &&
1659                     (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1660                         /*
1661                          * If interface is marked down and it is running,
1662                          * then stop and disable it.
1663                          */
1664                         lagg_stop(sc);
1665                         LAGG_XUNLOCK(sc);
1666                 } else if ((ifp->if_flags & IFF_UP) &&
1667                     !(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1668                         /*
1669                          * If interface is marked up and it is stopped, then
1670                          * start it.
1671                          */
1672                         LAGG_XUNLOCK(sc);
1673                         (*ifp->if_init)(sc);
1674                 } else
1675                         LAGG_XUNLOCK(sc);
1676                 break;
1677         case SIOCADDMULTI:
1678         case SIOCDELMULTI:
1679                 LAGG_XLOCK(sc);
1680                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1681                         lagg_clrmulti(lp);
1682                         lagg_setmulti(lp);
1683                 }
1684                 LAGG_XUNLOCK(sc);
1685                 error = 0;
1686                 break;
1687         case SIOCSIFMEDIA:
1688         case SIOCGIFMEDIA:
1689                 if (ifp->if_type == IFT_INFINIBAND)
1690                         error = EINVAL;
1691                 else
1692                         error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
1693                 break;
1694
1695         case SIOCSIFCAP:
1696                 LAGG_XLOCK(sc);
1697                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1698                         if (lp->lp_ioctl != NULL)
1699                                 (*lp->lp_ioctl)(lp->lp_ifp, cmd, data);
1700                 }
1701                 lagg_capabilities(sc);
1702                 LAGG_XUNLOCK(sc);
1703                 VLAN_CAPABILITIES(ifp);
1704                 error = 0;
1705                 break;
1706
1707         case SIOCSIFMTU:
1708                 LAGG_XLOCK(sc);
1709                 CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1710                         if (lp->lp_ioctl != NULL)
1711                                 error = (*lp->lp_ioctl)(lp->lp_ifp, cmd, data);
1712                         else
1713                                 error = EINVAL;
1714                         if (error != 0) {
1715                                 if_printf(ifp,
1716                                     "failed to change MTU to %d on port %s, "
1717                                     "reverting all ports to original MTU (%d)\n",
1718                                     ifr->ifr_mtu, lp->lp_ifp->if_xname, ifp->if_mtu);
1719                                 break;
1720                         }
1721                 }
1722                 if (error == 0) {
1723                         ifp->if_mtu = ifr->ifr_mtu;
1724                 } else {
1725                         /* set every port back to the original MTU */
1726                         ifr->ifr_mtu = ifp->if_mtu;
1727                         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
1728                                 if (lp->lp_ioctl != NULL)
1729                                         (*lp->lp_ioctl)(lp->lp_ifp, cmd, data);
1730                         }
1731                 }
1732                 LAGG_XUNLOCK(sc);
1733                 break;
1734
1735         default:
1736                 error = ether_ioctl(ifp, cmd, data);
1737                 break;
1738         }
1739         return (error);
1740 }
1741
1742 #if defined(KERN_TLS) || defined(RATELIMIT)
1743 static inline struct lagg_snd_tag *
1744 mst_to_lst(struct m_snd_tag *mst)
1745 {
1746
1747         return (__containerof(mst, struct lagg_snd_tag, com));
1748 }
1749
1750 /*
1751  * Look up the port used by a specific flow.  This only works for lagg
1752  * protocols with deterministic port mappings (e.g. not roundrobin).
1753  * In addition protocols which use a hash to map flows to ports must
1754  * be configured to use the mbuf flowid rather than hashing packet
1755  * contents.
1756  */
1757 static struct lagg_port *
1758 lookup_snd_tag_port(struct ifnet *ifp, uint32_t flowid, uint32_t flowtype,
1759     uint8_t numa_domain)
1760 {
1761         struct lagg_softc *sc;
1762         struct lagg_port *lp;
1763         struct lagg_lb *lb;
1764         uint32_t hash, p;
1765
1766         sc = ifp->if_softc;
1767
1768         switch (sc->sc_proto) {
1769         case LAGG_PROTO_FAILOVER:
1770                 return (lagg_link_active(sc, sc->sc_primary));
1771         case LAGG_PROTO_LOADBALANCE:
1772                 if ((sc->sc_opts & LAGG_OPT_USE_FLOWID) == 0 ||
1773                     flowtype == M_HASHTYPE_NONE)
1774                         return (NULL);
1775                 p = flowid >> sc->flowid_shift;
1776                 p %= sc->sc_count;
1777                 lb = (struct lagg_lb *)sc->sc_psc;
1778                 lp = lb->lb_ports[p];
1779                 return (lagg_link_active(sc, lp));
1780         case LAGG_PROTO_LACP:
1781                 if ((sc->sc_opts & LAGG_OPT_USE_FLOWID) == 0 ||
1782                     flowtype == M_HASHTYPE_NONE)
1783                         return (NULL);
1784                 hash = flowid >> sc->flowid_shift;
1785                 return (lacp_select_tx_port_by_hash(sc, hash, numa_domain));
1786         default:
1787                 return (NULL);
1788         }
1789 }
1790
1791 static int
1792 lagg_snd_tag_alloc(struct ifnet *ifp,
1793     union if_snd_tag_alloc_params *params,
1794     struct m_snd_tag **ppmt)
1795 {
1796         struct lagg_snd_tag *lst;
1797         struct lagg_softc *sc;
1798         struct lagg_port *lp;
1799         struct ifnet *lp_ifp;
1800         int error;
1801
1802         sc = ifp->if_softc;
1803
1804         LAGG_RLOCK();
1805         lp = lookup_snd_tag_port(ifp, params->hdr.flowid,
1806             params->hdr.flowtype, params->hdr.numa_domain);
1807         if (lp == NULL) {
1808                 LAGG_RUNLOCK();
1809                 return (EOPNOTSUPP);
1810         }
1811         if (lp->lp_ifp == NULL || lp->lp_ifp->if_snd_tag_alloc == NULL) {
1812                 LAGG_RUNLOCK();
1813                 return (EOPNOTSUPP);
1814         }
1815         lp_ifp = lp->lp_ifp;
1816         if_ref(lp_ifp);
1817         LAGG_RUNLOCK();
1818
1819         lst = malloc(sizeof(*lst), M_LAGG, M_NOWAIT);
1820         if (lst == NULL) {
1821                 if_rele(lp_ifp);
1822                 return (ENOMEM);
1823         }
1824
1825         error = lp_ifp->if_snd_tag_alloc(lp_ifp, params, &lst->tag);
1826         if_rele(lp_ifp);
1827         if (error) {
1828                 free(lst, M_LAGG);
1829                 return (error);
1830         }
1831
1832         m_snd_tag_init(&lst->com, ifp, lst->tag->type);
1833
1834         *ppmt = &lst->com;
1835         return (0);
1836 }
1837
1838 static int
1839 lagg_snd_tag_modify(struct m_snd_tag *mst,
1840     union if_snd_tag_modify_params *params)
1841 {
1842         struct lagg_snd_tag *lst;
1843
1844         lst = mst_to_lst(mst);
1845         return (lst->tag->ifp->if_snd_tag_modify(lst->tag, params));
1846 }
1847
1848 static int
1849 lagg_snd_tag_query(struct m_snd_tag *mst,
1850     union if_snd_tag_query_params *params)
1851 {
1852         struct lagg_snd_tag *lst;
1853
1854         lst = mst_to_lst(mst);
1855         return (lst->tag->ifp->if_snd_tag_query(lst->tag, params));
1856 }
1857
1858 static void
1859 lagg_snd_tag_free(struct m_snd_tag *mst)
1860 {
1861         struct lagg_snd_tag *lst;
1862
1863         lst = mst_to_lst(mst);
1864         m_snd_tag_rele(lst->tag);
1865         free(lst, M_LAGG);
1866 }
1867
1868 static void
1869 lagg_ratelimit_query(struct ifnet *ifp __unused, struct if_ratelimit_query_results *q)
1870 {
1871         /*
1872          * For lagg, we have an indirect
1873          * interface. The caller needs to
1874          * get a ratelimit tag on the actual
1875          * interface the flow will go on.
1876          */
1877         q->rate_table = NULL;
1878         q->flags = RT_IS_INDIRECT;
1879         q->max_flows = 0;
1880         q->number_of_rates = 0;
1881 }
1882 #endif
1883
1884 static int
1885 lagg_setmulti(struct lagg_port *lp)
1886 {
1887         struct lagg_softc *sc = lp->lp_softc;
1888         struct ifnet *ifp = lp->lp_ifp;
1889         struct ifnet *scifp = sc->sc_ifp;
1890         struct lagg_mc *mc;
1891         struct ifmultiaddr *ifma;
1892         int error;
1893
1894         IF_ADDR_WLOCK(scifp);
1895         CK_STAILQ_FOREACH(ifma, &scifp->if_multiaddrs, ifma_link) {
1896                 if (ifma->ifma_addr->sa_family != AF_LINK)
1897                         continue;
1898                 mc = malloc(sizeof(struct lagg_mc), M_LAGG, M_NOWAIT);
1899                 if (mc == NULL) {
1900                         IF_ADDR_WUNLOCK(scifp);
1901                         return (ENOMEM);
1902                 }
1903                 bcopy(ifma->ifma_addr, &mc->mc_addr,
1904                     ifma->ifma_addr->sa_len);
1905                 mc->mc_addr.sdl_index = ifp->if_index;
1906                 mc->mc_ifma = NULL;
1907                 SLIST_INSERT_HEAD(&lp->lp_mc_head, mc, mc_entries);
1908         }
1909         IF_ADDR_WUNLOCK(scifp);
1910         SLIST_FOREACH (mc, &lp->lp_mc_head, mc_entries) {
1911                 error = if_addmulti(ifp,
1912                     (struct sockaddr *)&mc->mc_addr, &mc->mc_ifma);
1913                 if (error)
1914                         return (error);
1915         }
1916         return (0);
1917 }
1918
1919 static int
1920 lagg_clrmulti(struct lagg_port *lp)
1921 {
1922         struct lagg_mc *mc;
1923
1924         LAGG_XLOCK_ASSERT(lp->lp_softc);
1925         while ((mc = SLIST_FIRST(&lp->lp_mc_head)) != NULL) {
1926                 SLIST_REMOVE(&lp->lp_mc_head, mc, lagg_mc, mc_entries);
1927                 if (mc->mc_ifma && lp->lp_detaching == 0)
1928                         if_delmulti_ifma(mc->mc_ifma);
1929                 free(mc, M_LAGG);
1930         }
1931         return (0);
1932 }
1933
1934 static int
1935 lagg_setcaps(struct lagg_port *lp, int cap)
1936 {
1937         struct ifreq ifr;
1938
1939         if (lp->lp_ifp->if_capenable == cap)
1940                 return (0);
1941         if (lp->lp_ioctl == NULL)
1942                 return (ENXIO);
1943         ifr.ifr_reqcap = cap;
1944         return ((*lp->lp_ioctl)(lp->lp_ifp, SIOCSIFCAP, (caddr_t)&ifr));
1945 }
1946
1947 /* Handle a ref counted flag that should be set on the lagg port as well */
1948 static int
1949 lagg_setflag(struct lagg_port *lp, int flag, int status,
1950     int (*func)(struct ifnet *, int))
1951 {
1952         struct lagg_softc *sc = lp->lp_softc;
1953         struct ifnet *scifp = sc->sc_ifp;
1954         struct ifnet *ifp = lp->lp_ifp;
1955         int error;
1956
1957         LAGG_XLOCK_ASSERT(sc);
1958
1959         status = status ? (scifp->if_flags & flag) : 0;
1960         /* Now "status" contains the flag value or 0 */
1961
1962         /*
1963          * See if recorded ports status is different from what
1964          * we want it to be.  If it is, flip it.  We record ports
1965          * status in lp_ifflags so that we won't clear ports flag
1966          * we haven't set.  In fact, we don't clear or set ports
1967          * flags directly, but get or release references to them.
1968          * That's why we can be sure that recorded flags still are
1969          * in accord with actual ports flags.
1970          */
1971         if (status != (lp->lp_ifflags & flag)) {
1972                 error = (*func)(ifp, status);
1973                 if (error)
1974                         return (error);
1975                 lp->lp_ifflags &= ~flag;
1976                 lp->lp_ifflags |= status;
1977         }
1978         return (0);
1979 }
1980
1981 /*
1982  * Handle IFF_* flags that require certain changes on the lagg port
1983  * if "status" is true, update ports flags respective to the lagg
1984  * if "status" is false, forcedly clear the flags set on port.
1985  */
1986 static int
1987 lagg_setflags(struct lagg_port *lp, int status)
1988 {
1989         int error, i;
1990
1991         for (i = 0; lagg_pflags[i].flag; i++) {
1992                 error = lagg_setflag(lp, lagg_pflags[i].flag,
1993                     status, lagg_pflags[i].func);
1994                 if (error)
1995                         return (error);
1996         }
1997         return (0);
1998 }
1999
2000 static int
2001 lagg_transmit_ethernet(struct ifnet *ifp, struct mbuf *m)
2002 {
2003         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
2004         int error;
2005
2006 #if defined(KERN_TLS) || defined(RATELIMIT)
2007         if (m->m_pkthdr.csum_flags & CSUM_SND_TAG)
2008                 MPASS(m->m_pkthdr.snd_tag->ifp == ifp);
2009 #endif
2010         LAGG_RLOCK();
2011         /* We need a Tx algorithm and at least one port */
2012         if (sc->sc_proto == LAGG_PROTO_NONE || sc->sc_count == 0) {
2013                 LAGG_RUNLOCK();
2014                 m_freem(m);
2015                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2016                 return (ENXIO);
2017         }
2018
2019         ETHER_BPF_MTAP(ifp, m);
2020
2021         error = lagg_proto_start(sc, m);
2022         LAGG_RUNLOCK();
2023         return (error);
2024 }
2025
2026 static int
2027 lagg_transmit_infiniband(struct ifnet *ifp, struct mbuf *m)
2028 {
2029         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
2030         int error;
2031
2032 #if defined(KERN_TLS) || defined(RATELIMIT)
2033         if (m->m_pkthdr.csum_flags & CSUM_SND_TAG)
2034                 MPASS(m->m_pkthdr.snd_tag->ifp == ifp);
2035 #endif
2036         LAGG_RLOCK();
2037         /* We need a Tx algorithm and at least one port */
2038         if (sc->sc_proto == LAGG_PROTO_NONE || sc->sc_count == 0) {
2039                 LAGG_RUNLOCK();
2040                 m_freem(m);
2041                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2042                 return (ENXIO);
2043         }
2044
2045         INFINIBAND_BPF_MTAP(ifp, m);
2046
2047         error = lagg_proto_start(sc, m);
2048         LAGG_RUNLOCK();
2049         return (error);
2050 }
2051
2052 /*
2053  * The ifp->if_qflush entry point for lagg(4) is no-op.
2054  */
2055 static void
2056 lagg_qflush(struct ifnet *ifp __unused)
2057 {
2058 }
2059
2060 static struct mbuf *
2061 lagg_input_ethernet(struct ifnet *ifp, struct mbuf *m)
2062 {
2063         struct lagg_port *lp = ifp->if_lagg;
2064         struct lagg_softc *sc = lp->lp_softc;
2065         struct ifnet *scifp = sc->sc_ifp;
2066
2067         LAGG_RLOCK();
2068         if ((scifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
2069             lp->lp_detaching != 0 ||
2070             sc->sc_proto == LAGG_PROTO_NONE) {
2071                 LAGG_RUNLOCK();
2072                 m_freem(m);
2073                 return (NULL);
2074         }
2075
2076         ETHER_BPF_MTAP(scifp, m);
2077
2078         m = lagg_proto_input(sc, lp, m);
2079         if (m != NULL && (scifp->if_flags & IFF_MONITOR) != 0) {
2080                 m_freem(m);
2081                 m = NULL;
2082         }
2083
2084         LAGG_RUNLOCK();
2085         return (m);
2086 }
2087
2088 static struct mbuf *
2089 lagg_input_infiniband(struct ifnet *ifp, struct mbuf *m)
2090 {
2091         struct lagg_port *lp = ifp->if_lagg;
2092         struct lagg_softc *sc = lp->lp_softc;
2093         struct ifnet *scifp = sc->sc_ifp;
2094
2095         LAGG_RLOCK();
2096         if ((scifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
2097             lp->lp_detaching != 0 ||
2098             sc->sc_proto == LAGG_PROTO_NONE) {
2099                 LAGG_RUNLOCK();
2100                 m_freem(m);
2101                 return (NULL);
2102         }
2103
2104         INFINIBAND_BPF_MTAP(scifp, m);
2105
2106         m = lagg_proto_input(sc, lp, m);
2107         if (m != NULL && (scifp->if_flags & IFF_MONITOR) != 0) {
2108                 m_freem(m);
2109                 m = NULL;
2110         }
2111
2112         LAGG_RUNLOCK();
2113         return (m);
2114 }
2115
2116 static int
2117 lagg_media_change(struct ifnet *ifp)
2118 {
2119         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
2120
2121         if (sc->sc_ifflags & IFF_DEBUG)
2122                 printf("%s\n", __func__);
2123
2124         /* Ignore */
2125         return (0);
2126 }
2127
2128 static void
2129 lagg_media_status(struct ifnet *ifp, struct ifmediareq *imr)
2130 {
2131         struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc;
2132         struct lagg_port *lp;
2133
2134         imr->ifm_status = IFM_AVALID;
2135         imr->ifm_active = IFM_ETHER | IFM_AUTO;
2136
2137         LAGG_RLOCK();
2138         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
2139                 if (LAGG_PORTACTIVE(lp))
2140                         imr->ifm_status |= IFM_ACTIVE;
2141         }
2142         LAGG_RUNLOCK();
2143 }
2144
2145 static void
2146 lagg_linkstate(struct lagg_softc *sc)
2147 {
2148         struct lagg_port *lp;
2149         int new_link = LINK_STATE_DOWN;
2150         uint64_t speed;
2151
2152         LAGG_XLOCK_ASSERT(sc);
2153
2154         /* LACP handles link state itself */
2155         if (sc->sc_proto == LAGG_PROTO_LACP)
2156                 return;
2157
2158         /* Our link is considered up if at least one of our ports is active */
2159         LAGG_RLOCK();
2160         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
2161                 if (lp->lp_ifp->if_link_state == LINK_STATE_UP) {
2162                         new_link = LINK_STATE_UP;
2163                         break;
2164                 }
2165         }
2166         LAGG_RUNLOCK();
2167         if_link_state_change(sc->sc_ifp, new_link);
2168
2169         /* Update if_baudrate to reflect the max possible speed */
2170         switch (sc->sc_proto) {
2171                 case LAGG_PROTO_FAILOVER:
2172                         sc->sc_ifp->if_baudrate = sc->sc_primary != NULL ?
2173                             sc->sc_primary->lp_ifp->if_baudrate : 0;
2174                         break;
2175                 case LAGG_PROTO_ROUNDROBIN:
2176                 case LAGG_PROTO_LOADBALANCE:
2177                 case LAGG_PROTO_BROADCAST:
2178                         speed = 0;
2179                         LAGG_RLOCK();
2180                         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2181                                 speed += lp->lp_ifp->if_baudrate;
2182                         LAGG_RUNLOCK();
2183                         sc->sc_ifp->if_baudrate = speed;
2184                         break;
2185                 case LAGG_PROTO_LACP:
2186                         /* LACP updates if_baudrate itself */
2187                         break;
2188         }
2189 }
2190
2191 static void
2192 lagg_port_state(struct ifnet *ifp, int state)
2193 {
2194         struct lagg_port *lp = (struct lagg_port *)ifp->if_lagg;
2195         struct lagg_softc *sc = NULL;
2196
2197         if (lp != NULL)
2198                 sc = lp->lp_softc;
2199         if (sc == NULL)
2200                 return;
2201
2202         LAGG_XLOCK(sc);
2203         lagg_linkstate(sc);
2204         lagg_proto_linkstate(sc, lp);
2205         LAGG_XUNLOCK(sc);
2206 }
2207
2208 struct lagg_port *
2209 lagg_link_active(struct lagg_softc *sc, struct lagg_port *lp)
2210 {
2211         struct lagg_port *lp_next, *rval = NULL;
2212
2213         /*
2214          * Search a port which reports an active link state.
2215          */
2216
2217 #ifdef INVARIANTS
2218         /*
2219          * This is called with either LAGG_RLOCK() held or
2220          * LAGG_XLOCK(sc) held.
2221          */
2222         if (!in_epoch(net_epoch_preempt))
2223                 LAGG_XLOCK_ASSERT(sc);
2224 #endif
2225
2226         if (lp == NULL)
2227                 goto search;
2228         if (LAGG_PORTACTIVE(lp)) {
2229                 rval = lp;
2230                 goto found;
2231         }
2232         if ((lp_next = CK_SLIST_NEXT(lp, lp_entries)) != NULL &&
2233             LAGG_PORTACTIVE(lp_next)) {
2234                 rval = lp_next;
2235                 goto found;
2236         }
2237
2238 search:
2239         CK_SLIST_FOREACH(lp_next, &sc->sc_ports, lp_entries) {
2240                 if (LAGG_PORTACTIVE(lp_next)) {
2241                         return (lp_next);
2242                 }
2243         }
2244 found:
2245         return (rval);
2246 }
2247
2248 int
2249 lagg_enqueue(struct ifnet *ifp, struct mbuf *m)
2250 {
2251
2252 #if defined(KERN_TLS) || defined(RATELIMIT)
2253         if (m->m_pkthdr.csum_flags & CSUM_SND_TAG) {
2254                 struct lagg_snd_tag *lst;
2255                 struct m_snd_tag *mst;
2256
2257                 mst = m->m_pkthdr.snd_tag;
2258                 lst = mst_to_lst(mst);
2259                 if (lst->tag->ifp != ifp) {
2260                         m_freem(m);
2261                         return (EAGAIN);
2262                 }
2263                 m->m_pkthdr.snd_tag = m_snd_tag_ref(lst->tag);
2264                 m_snd_tag_rele(mst);
2265         }
2266 #endif
2267         return (ifp->if_transmit)(ifp, m);
2268 }
2269
2270 /*
2271  * Simple round robin aggregation
2272  */
2273 static void
2274 lagg_rr_attach(struct lagg_softc *sc)
2275 {
2276         sc->sc_seq = 0;
2277         sc->sc_stride = 1;
2278 }
2279
2280 static int
2281 lagg_rr_start(struct lagg_softc *sc, struct mbuf *m)
2282 {
2283         struct lagg_port *lp;
2284         uint32_t p;
2285
2286         p = atomic_fetchadd_32(&sc->sc_seq, 1);
2287         p /= sc->sc_stride;
2288         p %= sc->sc_count;
2289         lp = CK_SLIST_FIRST(&sc->sc_ports);
2290
2291         while (p--)
2292                 lp = CK_SLIST_NEXT(lp, lp_entries);
2293
2294         /*
2295          * Check the port's link state. This will return the next active
2296          * port if the link is down or the port is NULL.
2297          */
2298         if ((lp = lagg_link_active(sc, lp)) == NULL) {
2299                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
2300                 m_freem(m);
2301                 return (ENETDOWN);
2302         }
2303
2304         /* Send mbuf */
2305         return (lagg_enqueue(lp->lp_ifp, m));
2306 }
2307
2308 static struct mbuf *
2309 lagg_rr_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
2310 {
2311         struct ifnet *ifp = sc->sc_ifp;
2312
2313         /* Just pass in the packet to our lagg device */
2314         m->m_pkthdr.rcvif = ifp;
2315
2316         return (m);
2317 }
2318
2319 /*
2320  * Broadcast mode
2321  */
2322 static int
2323 lagg_bcast_start(struct lagg_softc *sc, struct mbuf *m)
2324 {
2325         int active_ports = 0;
2326         int errors = 0;
2327         int ret;
2328         struct lagg_port *lp, *last = NULL;
2329         struct mbuf *m0;
2330
2331         LAGG_RLOCK_ASSERT();
2332         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) {
2333                 if (!LAGG_PORTACTIVE(lp))
2334                         continue;
2335
2336                 active_ports++;
2337
2338                 if (last != NULL) {
2339                         m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
2340                         if (m0 == NULL) {
2341                                 ret = ENOBUFS;
2342                                 errors++;
2343                                 break;
2344                         }
2345                         lagg_enqueue(last->lp_ifp, m0);
2346                 }
2347                 last = lp;
2348         }
2349
2350         if (last == NULL) {
2351                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
2352                 m_freem(m);
2353                 return (ENOENT);
2354         }
2355         if ((last = lagg_link_active(sc, last)) == NULL) {
2356                 errors++;
2357                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, errors);
2358                 m_freem(m);
2359                 return (ENETDOWN);
2360         }
2361
2362         ret = lagg_enqueue(last->lp_ifp, m);
2363         if (errors != 0)
2364                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, errors);
2365
2366         return (ret);
2367 }
2368
2369 static struct mbuf*
2370 lagg_bcast_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
2371 {
2372         struct ifnet *ifp = sc->sc_ifp;
2373
2374         /* Just pass in the packet to our lagg device */
2375         m->m_pkthdr.rcvif = ifp;
2376         return (m);
2377 }
2378
2379 /*
2380  * Active failover
2381  */
2382 static int
2383 lagg_fail_start(struct lagg_softc *sc, struct mbuf *m)
2384 {
2385         struct lagg_port *lp;
2386
2387         /* Use the master port if active or the next available port */
2388         if ((lp = lagg_link_active(sc, sc->sc_primary)) == NULL) {
2389                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
2390                 m_freem(m);
2391                 return (ENETDOWN);
2392         }
2393
2394         /* Send mbuf */
2395         return (lagg_enqueue(lp->lp_ifp, m));
2396 }
2397
2398 static struct mbuf *
2399 lagg_fail_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
2400 {
2401         struct ifnet *ifp = sc->sc_ifp;
2402         struct lagg_port *tmp_tp;
2403
2404         if (lp == sc->sc_primary || V_lagg_failover_rx_all) {
2405                 m->m_pkthdr.rcvif = ifp;
2406                 return (m);
2407         }
2408
2409         if (!LAGG_PORTACTIVE(sc->sc_primary)) {
2410                 tmp_tp = lagg_link_active(sc, sc->sc_primary);
2411                 /*
2412                  * If tmp_tp is null, we've received a packet when all
2413                  * our links are down. Weird, but process it anyways.
2414                  */
2415                 if ((tmp_tp == NULL || tmp_tp == lp)) {
2416                         m->m_pkthdr.rcvif = ifp;
2417                         return (m);
2418                 }
2419         }
2420
2421         m_freem(m);
2422         return (NULL);
2423 }
2424
2425 /*
2426  * Loadbalancing
2427  */
2428 static void
2429 lagg_lb_attach(struct lagg_softc *sc)
2430 {
2431         struct lagg_port *lp;
2432         struct lagg_lb *lb;
2433
2434         LAGG_XLOCK_ASSERT(sc);
2435         lb = malloc(sizeof(struct lagg_lb), M_LAGG, M_WAITOK | M_ZERO);
2436         lb->lb_key = m_ether_tcpip_hash_init();
2437         sc->sc_psc = lb;
2438
2439         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2440                 lagg_lb_port_create(lp);
2441 }
2442
2443 static void
2444 lagg_lb_detach(struct lagg_softc *sc)
2445 {
2446         struct lagg_lb *lb;
2447
2448         lb = (struct lagg_lb *)sc->sc_psc;
2449         if (lb != NULL)
2450                 free(lb, M_LAGG);
2451 }
2452
2453 static int
2454 lagg_lb_porttable(struct lagg_softc *sc, struct lagg_port *lp)
2455 {
2456         struct lagg_lb *lb = (struct lagg_lb *)sc->sc_psc;
2457         struct lagg_port *lp_next;
2458         int i = 0, rv;
2459
2460         rv = 0;
2461         bzero(&lb->lb_ports, sizeof(lb->lb_ports));
2462         LAGG_XLOCK_ASSERT(sc);
2463         CK_SLIST_FOREACH(lp_next, &sc->sc_ports, lp_entries) {
2464                 if (lp_next == lp)
2465                         continue;
2466                 if (i >= LAGG_MAX_PORTS) {
2467                         rv = EINVAL;
2468                         break;
2469                 }
2470                 if (sc->sc_ifflags & IFF_DEBUG)
2471                         printf("%s: port %s at index %d\n",
2472                             sc->sc_ifname, lp_next->lp_ifp->if_xname, i);
2473                 lb->lb_ports[i++] = lp_next;
2474         }
2475
2476         return (rv);
2477 }
2478
2479 static int
2480 lagg_lb_port_create(struct lagg_port *lp)
2481 {
2482         struct lagg_softc *sc = lp->lp_softc;
2483         return (lagg_lb_porttable(sc, NULL));
2484 }
2485
2486 static void
2487 lagg_lb_port_destroy(struct lagg_port *lp)
2488 {
2489         struct lagg_softc *sc = lp->lp_softc;
2490         lagg_lb_porttable(sc, lp);
2491 }
2492
2493 static int
2494 lagg_lb_start(struct lagg_softc *sc, struct mbuf *m)
2495 {
2496         struct lagg_lb *lb = (struct lagg_lb *)sc->sc_psc;
2497         struct lagg_port *lp = NULL;
2498         uint32_t p = 0;
2499
2500         if ((sc->sc_opts & LAGG_OPT_USE_FLOWID) &&
2501             M_HASHTYPE_GET(m) != M_HASHTYPE_NONE)
2502                 p = m->m_pkthdr.flowid >> sc->flowid_shift;
2503         else
2504                 p = m_ether_tcpip_hash(sc->sc_flags, m, lb->lb_key);
2505         p %= sc->sc_count;
2506         lp = lb->lb_ports[p];
2507
2508         /*
2509          * Check the port's link state. This will return the next active
2510          * port if the link is down or the port is NULL.
2511          */
2512         if ((lp = lagg_link_active(sc, lp)) == NULL) {
2513                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
2514                 m_freem(m);
2515                 return (ENETDOWN);
2516         }
2517
2518         /* Send mbuf */
2519         return (lagg_enqueue(lp->lp_ifp, m));
2520 }
2521
2522 static struct mbuf *
2523 lagg_lb_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
2524 {
2525         struct ifnet *ifp = sc->sc_ifp;
2526
2527         /* Just pass in the packet to our lagg device */
2528         m->m_pkthdr.rcvif = ifp;
2529
2530         return (m);
2531 }
2532
2533 /*
2534  * 802.3ad LACP
2535  */
2536 static void
2537 lagg_lacp_attach(struct lagg_softc *sc)
2538 {
2539         struct lagg_port *lp;
2540
2541         lacp_attach(sc);
2542         LAGG_XLOCK_ASSERT(sc);
2543         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2544                 lacp_port_create(lp);
2545 }
2546
2547 static void
2548 lagg_lacp_detach(struct lagg_softc *sc)
2549 {
2550         struct lagg_port *lp;
2551         void *psc;
2552
2553         LAGG_XLOCK_ASSERT(sc);
2554         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2555                 lacp_port_destroy(lp);
2556
2557         psc = sc->sc_psc;
2558         sc->sc_psc = NULL;
2559         lacp_detach(psc);
2560 }
2561
2562 static void
2563 lagg_lacp_lladdr(struct lagg_softc *sc)
2564 {
2565         struct lagg_port *lp;
2566
2567         LAGG_SXLOCK_ASSERT(sc);
2568
2569         /* purge all the lacp ports */
2570         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2571                 lacp_port_destroy(lp);
2572
2573         /* add them back in */
2574         CK_SLIST_FOREACH(lp, &sc->sc_ports, lp_entries)
2575                 lacp_port_create(lp);
2576 }
2577
2578 static int
2579 lagg_lacp_start(struct lagg_softc *sc, struct mbuf *m)
2580 {
2581         struct lagg_port *lp;
2582
2583         lp = lacp_select_tx_port(sc, m);
2584         if (lp == NULL) {
2585                 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1);
2586                 m_freem(m);
2587                 return (ENETDOWN);
2588         }
2589
2590         /* Send mbuf */
2591         return (lagg_enqueue(lp->lp_ifp, m));
2592 }
2593
2594 static struct mbuf *
2595 lagg_lacp_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m)
2596 {
2597         struct ifnet *ifp = sc->sc_ifp;
2598         struct ether_header *eh;
2599         u_short etype;
2600
2601         eh = mtod(m, struct ether_header *);
2602         etype = ntohs(eh->ether_type);
2603
2604         /* Tap off LACP control messages */
2605         if ((m->m_flags & M_VLANTAG) == 0 && etype == ETHERTYPE_SLOW) {
2606                 m = lacp_input(lp, m);
2607                 if (m == NULL)
2608                         return (NULL);
2609         }
2610
2611         /*
2612          * If the port is not collecting or not in the active aggregator then
2613          * free and return.
2614          */
2615         if (lacp_iscollecting(lp) == 0 || lacp_isactive(lp) == 0) {
2616                 m_freem(m);
2617                 return (NULL);
2618         }
2619
2620         m->m_pkthdr.rcvif = ifp;
2621         return (m);
2622 }