if_lagg.c revision 287723
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 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20#include <sys/cdefs.h> 21__FBSDID("$FreeBSD: stable/10/sys/net/if_lagg.c 287723 2015-09-12 20:36:39Z hrs $"); 22 23#include "opt_inet.h" 24#include "opt_inet6.h" 25 26#include <sys/param.h> 27#include <sys/kernel.h> 28#include <sys/malloc.h> 29#include <sys/mbuf.h> 30#include <sys/queue.h> 31#include <sys/socket.h> 32#include <sys/sockio.h> 33#include <sys/sysctl.h> 34#include <sys/module.h> 35#include <sys/priv.h> 36#include <sys/systm.h> 37#include <sys/proc.h> 38#include <sys/hash.h> 39#include <sys/lock.h> 40#include <sys/rmlock.h> 41#include <sys/taskqueue.h> 42#include <sys/eventhandler.h> 43 44#include <net/ethernet.h> 45#include <net/if.h> 46#include <net/if_clone.h> 47#include <net/if_arp.h> 48#include <net/if_dl.h> 49#include <net/if_llc.h> 50#include <net/if_media.h> 51#include <net/if_types.h> 52#include <net/if_var.h> 53#include <net/bpf.h> 54#include <net/vnet.h> 55 56#if defined(INET) || defined(INET6) 57#include <netinet/in.h> 58#include <netinet/ip.h> 59#endif 60#ifdef INET 61#include <netinet/in_systm.h> 62#include <netinet/if_ether.h> 63#endif 64 65#ifdef INET6 66#include <netinet/ip6.h> 67#include <netinet6/in6_var.h> 68#include <netinet6/in6_ifattach.h> 69#endif 70 71#include <net/if_vlan_var.h> 72#include <net/if_lagg.h> 73#include <net/ieee8023ad_lacp.h> 74 75/* Special flags we should propagate to the lagg ports. */ 76static struct { 77 int flag; 78 int (*func)(struct ifnet *, int); 79} lagg_pflags[] = { 80 {IFF_PROMISC, ifpromisc}, 81 {IFF_ALLMULTI, if_allmulti}, 82 {0, NULL} 83}; 84 85VNET_DEFINE(SLIST_HEAD(__trhead, lagg_softc), lagg_list); /* list of laggs */ 86#define V_lagg_list VNET(lagg_list) 87static VNET_DEFINE(struct mtx, lagg_list_mtx); 88#define V_lagg_list_mtx VNET(lagg_list_mtx) 89#define LAGG_LIST_LOCK_INIT(x) mtx_init(&V_lagg_list_mtx, \ 90 "if_lagg list", NULL, MTX_DEF) 91#define LAGG_LIST_LOCK_DESTROY(x) mtx_destroy(&V_lagg_list_mtx) 92#define LAGG_LIST_LOCK(x) mtx_lock(&V_lagg_list_mtx) 93#define LAGG_LIST_UNLOCK(x) mtx_unlock(&V_lagg_list_mtx) 94eventhandler_tag lagg_detach_cookie = NULL; 95 96static int lagg_clone_create(struct if_clone *, int, caddr_t); 97static void lagg_clone_destroy(struct ifnet *); 98static VNET_DEFINE(struct if_clone *, lagg_cloner); 99#define V_lagg_cloner VNET(lagg_cloner) 100static const char laggname[] = "lagg"; 101 102static void lagg_lladdr(struct lagg_softc *, uint8_t *); 103static void lagg_capabilities(struct lagg_softc *); 104static void lagg_port_lladdr(struct lagg_port *, uint8_t *); 105static void lagg_port_setlladdr(void *, int); 106static int lagg_port_create(struct lagg_softc *, struct ifnet *); 107static int lagg_port_destroy(struct lagg_port *, int); 108static struct mbuf *lagg_input(struct ifnet *, struct mbuf *); 109static void lagg_linkstate(struct lagg_softc *); 110static void lagg_port_state(struct ifnet *, int); 111static int lagg_port_ioctl(struct ifnet *, u_long, caddr_t); 112static int lagg_port_output(struct ifnet *, struct mbuf *, 113 const struct sockaddr *, struct route *); 114static void lagg_port_ifdetach(void *arg __unused, struct ifnet *); 115#ifdef LAGG_PORT_STACKING 116static int lagg_port_checkstacking(struct lagg_softc *); 117#endif 118static void lagg_port2req(struct lagg_port *, struct lagg_reqport *); 119static void lagg_init(void *); 120static void lagg_stop(struct lagg_softc *); 121static int lagg_ioctl(struct ifnet *, u_long, caddr_t); 122static int lagg_ether_setmulti(struct lagg_softc *); 123static int lagg_ether_cmdmulti(struct lagg_port *, int); 124static int lagg_setflag(struct lagg_port *, int, int, 125 int (*func)(struct ifnet *, int)); 126static int lagg_setflags(struct lagg_port *, int status); 127static int lagg_transmit(struct ifnet *, struct mbuf *); 128static void lagg_qflush(struct ifnet *); 129static int lagg_media_change(struct ifnet *); 130static void lagg_media_status(struct ifnet *, struct ifmediareq *); 131static struct lagg_port *lagg_link_active(struct lagg_softc *, 132 struct lagg_port *); 133static const void *lagg_gethdr(struct mbuf *, u_int, u_int, void *); 134 135/* Simple round robin */ 136static void lagg_rr_attach(struct lagg_softc *); 137static int lagg_rr_detach(struct lagg_softc *); 138static int lagg_rr_start(struct lagg_softc *, struct mbuf *); 139static struct mbuf *lagg_rr_input(struct lagg_softc *, struct lagg_port *, 140 struct mbuf *); 141 142/* Active failover */ 143static void lagg_fail_attach(struct lagg_softc *); 144static int lagg_fail_detach(struct lagg_softc *); 145static int lagg_fail_start(struct lagg_softc *, struct mbuf *); 146static struct mbuf *lagg_fail_input(struct lagg_softc *, struct lagg_port *, 147 struct mbuf *); 148 149/* Loadbalancing */ 150static void lagg_lb_attach(struct lagg_softc *); 151static int lagg_lb_detach(struct lagg_softc *); 152static int lagg_lb_port_create(struct lagg_port *); 153static void lagg_lb_port_destroy(struct lagg_port *); 154static int lagg_lb_start(struct lagg_softc *, struct mbuf *); 155static struct mbuf *lagg_lb_input(struct lagg_softc *, struct lagg_port *, 156 struct mbuf *); 157static int lagg_lb_porttable(struct lagg_softc *, struct lagg_port *); 158 159/* 802.3ad LACP */ 160static void lagg_lacp_attach(struct lagg_softc *); 161static int lagg_lacp_detach(struct lagg_softc *); 162static int lagg_lacp_start(struct lagg_softc *, struct mbuf *); 163static struct mbuf *lagg_lacp_input(struct lagg_softc *, struct lagg_port *, 164 struct mbuf *); 165static void lagg_lacp_lladdr(struct lagg_softc *); 166 167static void lagg_callout(void *); 168 169/* lagg protocol table */ 170static const struct lagg_proto { 171 lagg_proto ti_proto; 172 void (*ti_attach)(struct lagg_softc *); 173} lagg_protos[] = { 174 { LAGG_PROTO_ROUNDROBIN, lagg_rr_attach }, 175 { LAGG_PROTO_FAILOVER, lagg_fail_attach }, 176 { LAGG_PROTO_LOADBALANCE, lagg_lb_attach }, 177 { LAGG_PROTO_ETHERCHANNEL, lagg_lb_attach }, 178 { LAGG_PROTO_LACP, lagg_lacp_attach }, 179 { LAGG_PROTO_NONE, NULL } 180}; 181 182SYSCTL_DECL(_net_link); 183SYSCTL_NODE(_net_link, OID_AUTO, lagg, CTLFLAG_RW, 0, 184 "Link Aggregation"); 185 186/* Allow input on any failover links */ 187static VNET_DEFINE(int, lagg_failover_rx_all); 188#define V_lagg_failover_rx_all VNET(lagg_failover_rx_all) 189SYSCTL_INT(_net_link_lagg, OID_AUTO, failover_rx_all, CTLFLAG_RW | CTLFLAG_VNET, 190 &VNET_NAME(lagg_failover_rx_all), 0, 191 "Accept input from any interface in a failover lagg"); 192 193/* Default value for using M_FLOWID */ 194static VNET_DEFINE(int, def_use_flowid) = 1; 195#define V_def_use_flowid VNET(def_use_flowid) 196SYSCTL_INT(_net_link_lagg, OID_AUTO, default_use_flowid, CTLFLAG_RWTUN, 197 &VNET_NAME(def_use_flowid), 0, 198 "Default setting for using flow id for load sharing"); 199 200/* Default value for using M_FLOWID */ 201static VNET_DEFINE(int, def_flowid_shift) = 16; 202#define V_def_flowid_shift VNET(def_flowid_shift) 203SYSCTL_INT(_net_link_lagg, OID_AUTO, default_flowid_shift, CTLFLAG_RWTUN, 204 &VNET_NAME(def_flowid_shift), 0, 205 "Default setting for flowid shift for load sharing"); 206 207static void 208vnet_lagg_init(const void *unused __unused) 209{ 210 211 LAGG_LIST_LOCK_INIT(); 212 SLIST_INIT(&V_lagg_list); 213 V_lagg_cloner = if_clone_simple(laggname, lagg_clone_create, 214 lagg_clone_destroy, 0); 215} 216VNET_SYSINIT(vnet_lagg_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 217 vnet_lagg_init, NULL); 218 219static void 220vnet_lagg_uninit(const void *unused __unused) 221{ 222 223 if_clone_detach(V_lagg_cloner); 224 LAGG_LIST_LOCK_DESTROY(); 225} 226VNET_SYSUNINIT(vnet_lagg_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 227 vnet_lagg_uninit, NULL); 228 229static int 230lagg_modevent(module_t mod, int type, void *data) 231{ 232 233 switch (type) { 234 case MOD_LOAD: 235 lagg_input_p = lagg_input; 236 lagg_linkstate_p = lagg_port_state; 237 lagg_detach_cookie = EVENTHANDLER_REGISTER( 238 ifnet_departure_event, lagg_port_ifdetach, NULL, 239 EVENTHANDLER_PRI_ANY); 240 break; 241 case MOD_UNLOAD: 242 EVENTHANDLER_DEREGISTER(ifnet_departure_event, 243 lagg_detach_cookie); 244 lagg_input_p = NULL; 245 lagg_linkstate_p = NULL; 246 break; 247 default: 248 return (EOPNOTSUPP); 249 } 250 return (0); 251} 252 253static moduledata_t lagg_mod = { 254 "if_lagg", 255 lagg_modevent, 256 0 257}; 258 259DECLARE_MODULE(if_lagg, lagg_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 260MODULE_VERSION(if_lagg, 1); 261 262/* 263 * This routine is run via an vlan 264 * config EVENT 265 */ 266static void 267lagg_register_vlan(void *arg, struct ifnet *ifp, u_int16_t vtag) 268{ 269 struct lagg_softc *sc = ifp->if_softc; 270 struct lagg_port *lp; 271 struct rm_priotracker tracker; 272 273 if (ifp->if_softc != arg) /* Not our event */ 274 return; 275 276 LAGG_RLOCK(sc, &tracker); 277 if (!SLIST_EMPTY(&sc->sc_ports)) { 278 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 279 EVENTHANDLER_INVOKE(vlan_config, lp->lp_ifp, vtag); 280 } 281 LAGG_RUNLOCK(sc, &tracker); 282} 283 284/* 285 * This routine is run via an vlan 286 * unconfig EVENT 287 */ 288static void 289lagg_unregister_vlan(void *arg, struct ifnet *ifp, u_int16_t vtag) 290{ 291 struct lagg_softc *sc = ifp->if_softc; 292 struct lagg_port *lp; 293 struct rm_priotracker tracker; 294 295 if (ifp->if_softc != arg) /* Not our event */ 296 return; 297 298 LAGG_RLOCK(sc, &tracker); 299 if (!SLIST_EMPTY(&sc->sc_ports)) { 300 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 301 EVENTHANDLER_INVOKE(vlan_unconfig, lp->lp_ifp, vtag); 302 } 303 LAGG_RUNLOCK(sc, &tracker); 304} 305 306static int 307lagg_clone_create(struct if_clone *ifc, int unit, caddr_t params) 308{ 309 struct lagg_softc *sc; 310 struct ifnet *ifp; 311 static const u_char eaddr[6]; /* 00:00:00:00:00:00 */ 312 int i; 313 314 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK|M_ZERO); 315 ifp = sc->sc_ifp = if_alloc(IFT_ETHER); 316 if (ifp == NULL) { 317 free(sc, M_DEVBUF); 318 return (ENOSPC); 319 } 320 321 sc->sc_ipackets = counter_u64_alloc(M_WAITOK); 322 sc->sc_opackets = counter_u64_alloc(M_WAITOK); 323 sc->sc_ibytes = counter_u64_alloc(M_WAITOK); 324 sc->sc_obytes = counter_u64_alloc(M_WAITOK); 325 326 if (V_def_use_flowid) 327 sc->sc_opts |= LAGG_OPT_USE_FLOWID; 328 sc->flowid_shift = V_def_flowid_shift; 329 330 /* Hash all layers by default */ 331 sc->sc_flags = LAGG_F_HASHL2|LAGG_F_HASHL3|LAGG_F_HASHL4; 332 333 sc->sc_proto = LAGG_PROTO_NONE; 334 for (i = 0; lagg_protos[i].ti_proto != LAGG_PROTO_NONE; i++) { 335 if (lagg_protos[i].ti_proto == LAGG_PROTO_DEFAULT) { 336 sc->sc_proto = lagg_protos[i].ti_proto; 337 lagg_protos[i].ti_attach(sc); 338 break; 339 } 340 } 341 LAGG_LOCK_INIT(sc); 342 LAGG_CALLOUT_LOCK_INIT(sc); 343 SLIST_INIT(&sc->sc_ports); 344 TASK_INIT(&sc->sc_lladdr_task, 0, lagg_port_setlladdr, sc); 345 346 /* 347 * This uses the callout lock rather than the rmlock; one can't 348 * hold said rmlock during SWI. 349 */ 350 callout_init_mtx(&sc->sc_callout, &sc->sc_call_mtx, 0); 351 352 /* Initialise pseudo media types */ 353 ifmedia_init(&sc->sc_media, 0, lagg_media_change, 354 lagg_media_status); 355 ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL); 356 ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO); 357 358 if_initname(ifp, laggname, unit); 359 ifp->if_softc = sc; 360 ifp->if_transmit = lagg_transmit; 361 ifp->if_qflush = lagg_qflush; 362 ifp->if_init = lagg_init; 363 ifp->if_ioctl = lagg_ioctl; 364 ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST; 365 ifp->if_capenable = ifp->if_capabilities = IFCAP_HWSTATS; 366 367 /* 368 * Attach as an ordinary ethernet device, children will be attached 369 * as special device IFT_IEEE8023ADLAG. 370 */ 371 ether_ifattach(ifp, eaddr); 372 373 sc->vlan_attach = EVENTHANDLER_REGISTER(vlan_config, 374 lagg_register_vlan, sc, EVENTHANDLER_PRI_FIRST); 375 sc->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig, 376 lagg_unregister_vlan, sc, EVENTHANDLER_PRI_FIRST); 377 378 /* Insert into the global list of laggs */ 379 LAGG_LIST_LOCK(); 380 SLIST_INSERT_HEAD(&V_lagg_list, sc, sc_entries); 381 LAGG_LIST_UNLOCK(); 382 383 callout_reset(&sc->sc_callout, hz, lagg_callout, sc); 384 385 return (0); 386} 387 388static void 389lagg_clone_destroy(struct ifnet *ifp) 390{ 391 struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; 392 struct lagg_port *lp; 393 394 LAGG_WLOCK(sc); 395 396 lagg_stop(sc); 397 ifp->if_flags &= ~IFF_UP; 398 399 EVENTHANDLER_DEREGISTER(vlan_config, sc->vlan_attach); 400 EVENTHANDLER_DEREGISTER(vlan_unconfig, sc->vlan_detach); 401 402 /* Shutdown and remove lagg ports */ 403 while ((lp = SLIST_FIRST(&sc->sc_ports)) != NULL) 404 lagg_port_destroy(lp, 1); 405 /* Unhook the aggregation protocol */ 406 if (sc->sc_detach != NULL) 407 (*sc->sc_detach)(sc); 408 else 409 LAGG_WUNLOCK(sc); 410 411 ifmedia_removeall(&sc->sc_media); 412 ether_ifdetach(ifp); 413 if_free(ifp); 414 415 /* This grabs sc_callout_mtx, serialising it correctly */ 416 callout_drain(&sc->sc_callout); 417 418 /* At this point it's drained; we can free this */ 419 counter_u64_free(sc->sc_ipackets); 420 counter_u64_free(sc->sc_opackets); 421 counter_u64_free(sc->sc_ibytes); 422 counter_u64_free(sc->sc_obytes); 423 424 LAGG_LIST_LOCK(); 425 SLIST_REMOVE(&V_lagg_list, sc, lagg_softc, sc_entries); 426 LAGG_LIST_UNLOCK(); 427 428 taskqueue_drain(taskqueue_swi, &sc->sc_lladdr_task); 429 LAGG_LOCK_DESTROY(sc); 430 LAGG_CALLOUT_LOCK_DESTROY(sc); 431 free(sc, M_DEVBUF); 432} 433 434static void 435lagg_lladdr(struct lagg_softc *sc, uint8_t *lladdr) 436{ 437 struct ifnet *ifp = sc->sc_ifp; 438 struct lagg_port lp; 439 440 if (memcmp(lladdr, IF_LLADDR(ifp), ETHER_ADDR_LEN) == 0) 441 return; 442 443 LAGG_WLOCK_ASSERT(sc); 444 /* 445 * Set the link layer address on the lagg interface. 446 * sc_lladdr() notifies the MAC change to 447 * the aggregation protocol. iflladdr_event handler which 448 * may trigger gratuitous ARPs for INET will be handled in 449 * a taskqueue. 450 */ 451 bcopy(lladdr, IF_LLADDR(ifp), ETHER_ADDR_LEN); 452 if (sc->sc_lladdr != NULL) 453 (*sc->sc_lladdr)(sc); 454 455 bzero(&lp, sizeof(lp)); 456 lp.lp_ifp = sc->sc_ifp; 457 lp.lp_softc = sc; 458 459 lagg_port_lladdr(&lp, lladdr); 460} 461 462static void 463lagg_capabilities(struct lagg_softc *sc) 464{ 465 struct lagg_port *lp; 466 int cap = ~0, ena = ~0; 467 u_long hwa = ~0UL; 468 struct ifnet_hw_tsomax hw_tsomax; 469 470 LAGG_WLOCK_ASSERT(sc); 471 472 memset(&hw_tsomax, 0, sizeof(hw_tsomax)); 473 474 /* Get capabilities from the lagg ports */ 475 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 476 cap &= lp->lp_ifp->if_capabilities; 477 ena &= lp->lp_ifp->if_capenable; 478 hwa &= lp->lp_ifp->if_hwassist; 479 if_hw_tsomax_common(lp->lp_ifp, &hw_tsomax); 480 } 481 cap = (cap == ~0 ? 0 : cap); 482 ena = (ena == ~0 ? 0 : ena); 483 hwa = (hwa == ~0 ? 0 : hwa); 484 485 if (sc->sc_ifp->if_capabilities != cap || 486 sc->sc_ifp->if_capenable != ena || 487 sc->sc_ifp->if_hwassist != hwa || 488 if_hw_tsomax_update(sc->sc_ifp, &hw_tsomax) != 0) { 489 sc->sc_ifp->if_capabilities = cap; 490 sc->sc_ifp->if_capenable = ena; 491 sc->sc_ifp->if_hwassist = hwa; 492 getmicrotime(&sc->sc_ifp->if_lastchange); 493 494 if (sc->sc_ifflags & IFF_DEBUG) 495 if_printf(sc->sc_ifp, 496 "capabilities 0x%08x enabled 0x%08x\n", cap, ena); 497 } 498} 499 500static void 501lagg_port_lladdr(struct lagg_port *lp, uint8_t *lladdr) 502{ 503 struct lagg_softc *sc = lp->lp_softc; 504 struct ifnet *ifp = lp->lp_ifp; 505 struct lagg_llq *llq; 506 int pending = 0; 507 int primary; 508 509 LAGG_WLOCK_ASSERT(sc); 510 511 primary = (sc->sc_primary->lp_ifp == ifp) ? 1 : 0; 512 if (primary == 0 && (lp->lp_detaching || 513 memcmp(lladdr, IF_LLADDR(ifp), ETHER_ADDR_LEN) == 0)) 514 return; 515 516 /* Check to make sure its not already queued to be changed */ 517 SLIST_FOREACH(llq, &sc->sc_llq_head, llq_entries) { 518 if (llq->llq_ifp == ifp) { 519 pending = 1; 520 break; 521 } 522 } 523 524 if (!pending) { 525 llq = malloc(sizeof(struct lagg_llq), M_DEVBUF, M_NOWAIT); 526 if (llq == NULL) /* XXX what to do */ 527 return; 528 } 529 530 /* Update the lladdr even if pending, it may have changed */ 531 llq->llq_ifp = ifp; 532 llq->llq_primary = primary; 533 bcopy(lladdr, llq->llq_lladdr, ETHER_ADDR_LEN); 534 535 if (!pending) 536 SLIST_INSERT_HEAD(&sc->sc_llq_head, llq, llq_entries); 537 538 taskqueue_enqueue(taskqueue_swi, &sc->sc_lladdr_task); 539} 540 541/* 542 * Set the interface MAC address from a taskqueue to avoid a LOR. 543 */ 544static void 545lagg_port_setlladdr(void *arg, int pending) 546{ 547 struct lagg_softc *sc = (struct lagg_softc *)arg; 548 struct lagg_llq *llq, *head; 549 struct ifnet *ifp; 550 int error; 551 552 /* Grab a local reference of the queue and remove it from the softc */ 553 LAGG_WLOCK(sc); 554 head = SLIST_FIRST(&sc->sc_llq_head); 555 SLIST_FIRST(&sc->sc_llq_head) = NULL; 556 LAGG_WUNLOCK(sc); 557 558 /* 559 * Traverse the queue and set the lladdr on each ifp. It is safe to do 560 * unlocked as we have the only reference to it. 561 */ 562 for (llq = head; llq != NULL; llq = head) { 563 ifp = llq->llq_ifp; 564 565 CURVNET_SET(ifp->if_vnet); 566 if (llq->llq_primary == 0) { 567 /* 568 * Set the link layer address on the laggport interface. 569 * if_setlladdr() triggers gratuitous ARPs for INET. 570 */ 571 error = if_setlladdr(ifp, llq->llq_lladdr, 572 ETHER_ADDR_LEN); 573 if (error) 574 printf("%s: setlladdr failed on %s\n", __func__, 575 ifp->if_xname); 576 } else 577 EVENTHANDLER_INVOKE(iflladdr_event, ifp); 578 CURVNET_RESTORE(); 579 head = SLIST_NEXT(llq, llq_entries); 580 free(llq, M_DEVBUF); 581 } 582} 583 584static int 585lagg_port_create(struct lagg_softc *sc, struct ifnet *ifp) 586{ 587 struct lagg_softc *sc_ptr; 588 struct lagg_port *lp, *tlp; 589 int error = 0; 590 591 LAGG_WLOCK_ASSERT(sc); 592 593 /* Limit the maximal number of lagg ports */ 594 if (sc->sc_count >= LAGG_MAX_PORTS) 595 return (ENOSPC); 596 597 /* Check if port has already been associated to a lagg */ 598 if (ifp->if_lagg != NULL) { 599 /* Port is already in the current lagg? */ 600 lp = (struct lagg_port *)ifp->if_lagg; 601 if (lp->lp_softc == sc) 602 return (EEXIST); 603 return (EBUSY); 604 } 605 606 /* XXX Disallow non-ethernet interfaces (this should be any of 802) */ 607 if (ifp->if_type != IFT_ETHER) 608 return (EPROTONOSUPPORT); 609 610 /* Allow the first Ethernet member to define the MTU */ 611 if (SLIST_EMPTY(&sc->sc_ports)) 612 sc->sc_ifp->if_mtu = ifp->if_mtu; 613 else if (sc->sc_ifp->if_mtu != ifp->if_mtu) { 614 if_printf(sc->sc_ifp, "invalid MTU for %s\n", 615 ifp->if_xname); 616 return (EINVAL); 617 } 618 619 if ((lp = malloc(sizeof(struct lagg_port), 620 M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL) 621 return (ENOMEM); 622 623 /* Check if port is a stacked lagg */ 624 LAGG_LIST_LOCK(); 625 SLIST_FOREACH(sc_ptr, &V_lagg_list, sc_entries) { 626 if (ifp == sc_ptr->sc_ifp) { 627 LAGG_LIST_UNLOCK(); 628 free(lp, M_DEVBUF); 629 return (EINVAL); 630 /* XXX disable stacking for the moment, its untested */ 631#ifdef LAGG_PORT_STACKING 632 lp->lp_flags |= LAGG_PORT_STACK; 633 if (lagg_port_checkstacking(sc_ptr) >= 634 LAGG_MAX_STACKING) { 635 LAGG_LIST_UNLOCK(); 636 free(lp, M_DEVBUF); 637 return (E2BIG); 638 } 639#endif 640 } 641 } 642 LAGG_LIST_UNLOCK(); 643 644 /* Change the interface type */ 645 lp->lp_iftype = ifp->if_type; 646 ifp->if_type = IFT_IEEE8023ADLAG; 647 ifp->if_lagg = lp; 648 lp->lp_ioctl = ifp->if_ioctl; 649 ifp->if_ioctl = lagg_port_ioctl; 650 lp->lp_output = ifp->if_output; 651 ifp->if_output = lagg_port_output; 652 653 lp->lp_ifp = ifp; 654 lp->lp_softc = sc; 655 656 /* Save port link layer address */ 657 bcopy(IF_LLADDR(ifp), lp->lp_lladdr, ETHER_ADDR_LEN); 658 659 if (SLIST_EMPTY(&sc->sc_ports)) { 660 sc->sc_primary = lp; 661 lagg_lladdr(sc, IF_LLADDR(ifp)); 662 } else { 663 /* Update link layer address for this port */ 664 lagg_port_lladdr(lp, IF_LLADDR(sc->sc_ifp)); 665 } 666 667 /* 668 * Insert into the list of ports. 669 * Keep ports sorted by if_index. It is handy, when configuration 670 * is predictable and `ifconfig laggN create ...` command 671 * will lead to the same result each time. 672 */ 673 SLIST_FOREACH(tlp, &sc->sc_ports, lp_entries) { 674 if (tlp->lp_ifp->if_index < ifp->if_index && ( 675 SLIST_NEXT(tlp, lp_entries) == NULL || 676 SLIST_NEXT(tlp, lp_entries)->lp_ifp->if_index > 677 ifp->if_index)) 678 break; 679 } 680 if (tlp != NULL) 681 SLIST_INSERT_AFTER(tlp, lp, lp_entries); 682 else 683 SLIST_INSERT_HEAD(&sc->sc_ports, lp, lp_entries); 684 sc->sc_count++; 685 686 /* Update lagg capabilities */ 687 lagg_capabilities(sc); 688 lagg_linkstate(sc); 689 690 /* Add multicast addresses and interface flags to this port */ 691 lagg_ether_cmdmulti(lp, 1); 692 lagg_setflags(lp, 1); 693 694 if (sc->sc_port_create != NULL) 695 error = (*sc->sc_port_create)(lp); 696 if (error) { 697 /* remove the port again, without calling sc_port_destroy */ 698 lagg_port_destroy(lp, 0); 699 return (error); 700 } 701 702 return (error); 703} 704 705#ifdef LAGG_PORT_STACKING 706static int 707lagg_port_checkstacking(struct lagg_softc *sc) 708{ 709 struct lagg_softc *sc_ptr; 710 struct lagg_port *lp; 711 int m = 0; 712 713 LAGG_WLOCK_ASSERT(sc); 714 715 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 716 if (lp->lp_flags & LAGG_PORT_STACK) { 717 sc_ptr = (struct lagg_softc *)lp->lp_ifp->if_softc; 718 m = MAX(m, lagg_port_checkstacking(sc_ptr)); 719 } 720 } 721 722 return (m + 1); 723} 724#endif 725 726static int 727lagg_port_destroy(struct lagg_port *lp, int runpd) 728{ 729 struct lagg_softc *sc = lp->lp_softc; 730 struct lagg_port *lp_ptr; 731 struct lagg_llq *llq; 732 struct ifnet *ifp = lp->lp_ifp; 733 734 LAGG_WLOCK_ASSERT(sc); 735 736 if (runpd && sc->sc_port_destroy != NULL) 737 (*sc->sc_port_destroy)(lp); 738 739 /* 740 * Remove multicast addresses and interface flags from this port and 741 * reset the MAC address, skip if the interface is being detached. 742 */ 743 if (!lp->lp_detaching) { 744 lagg_ether_cmdmulti(lp, 0); 745 lagg_setflags(lp, 0); 746 lagg_port_lladdr(lp, lp->lp_lladdr); 747 } 748 749 /* Restore interface */ 750 ifp->if_type = lp->lp_iftype; 751 ifp->if_ioctl = lp->lp_ioctl; 752 ifp->if_output = lp->lp_output; 753 ifp->if_lagg = NULL; 754 755 /* Finally, remove the port from the lagg */ 756 SLIST_REMOVE(&sc->sc_ports, lp, lagg_port, lp_entries); 757 sc->sc_count--; 758 759 /* Update the primary interface */ 760 if (lp == sc->sc_primary) { 761 uint8_t lladdr[ETHER_ADDR_LEN]; 762 763 if ((lp_ptr = SLIST_FIRST(&sc->sc_ports)) == NULL) { 764 bzero(&lladdr, ETHER_ADDR_LEN); 765 } else { 766 bcopy(lp_ptr->lp_lladdr, 767 lladdr, ETHER_ADDR_LEN); 768 } 769 lagg_lladdr(sc, lladdr); 770 sc->sc_primary = lp_ptr; 771 772 /* Update link layer address for each port */ 773 SLIST_FOREACH(lp_ptr, &sc->sc_ports, lp_entries) 774 lagg_port_lladdr(lp_ptr, lladdr); 775 } 776 777 /* Remove any pending lladdr changes from the queue */ 778 if (lp->lp_detaching) { 779 SLIST_FOREACH(llq, &sc->sc_llq_head, llq_entries) { 780 if (llq->llq_ifp == ifp) { 781 SLIST_REMOVE(&sc->sc_llq_head, llq, lagg_llq, 782 llq_entries); 783 free(llq, M_DEVBUF); 784 break; /* Only appears once */ 785 } 786 } 787 } 788 789 if (lp->lp_ifflags) 790 if_printf(ifp, "%s: lp_ifflags unclean\n", __func__); 791 792 free(lp, M_DEVBUF); 793 794 /* Update lagg capabilities */ 795 lagg_capabilities(sc); 796 lagg_linkstate(sc); 797 798 return (0); 799} 800 801static int 802lagg_port_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 803{ 804 struct lagg_reqport *rp = (struct lagg_reqport *)data; 805 struct lagg_softc *sc; 806 struct lagg_port *lp = NULL; 807 int error = 0; 808 struct rm_priotracker tracker; 809 810 /* Should be checked by the caller */ 811 if (ifp->if_type != IFT_IEEE8023ADLAG || 812 (lp = ifp->if_lagg) == NULL || (sc = lp->lp_softc) == NULL) 813 goto fallback; 814 815 switch (cmd) { 816 case SIOCGLAGGPORT: 817 if (rp->rp_portname[0] == '\0' || 818 ifunit(rp->rp_portname) != ifp) { 819 error = EINVAL; 820 break; 821 } 822 823 LAGG_RLOCK(sc, &tracker); 824 if ((lp = ifp->if_lagg) == NULL || lp->lp_softc != sc) { 825 error = ENOENT; 826 LAGG_RUNLOCK(sc, &tracker); 827 break; 828 } 829 830 lagg_port2req(lp, rp); 831 LAGG_RUNLOCK(sc, &tracker); 832 break; 833 834 case SIOCSIFCAP: 835 if (lp->lp_ioctl == NULL) { 836 error = EINVAL; 837 break; 838 } 839 error = (*lp->lp_ioctl)(ifp, cmd, data); 840 if (error) 841 break; 842 843 /* Update lagg interface capabilities */ 844 LAGG_WLOCK(sc); 845 lagg_capabilities(sc); 846 LAGG_WUNLOCK(sc); 847 break; 848 849 case SIOCSIFMTU: 850 /* Do not allow the MTU to be changed once joined */ 851 error = EINVAL; 852 break; 853 854 default: 855 goto fallback; 856 } 857 858 return (error); 859 860fallback: 861 if (lp->lp_ioctl != NULL) 862 return ((*lp->lp_ioctl)(ifp, cmd, data)); 863 864 return (EINVAL); 865} 866 867/* 868 * For direct output to child ports. 869 */ 870static int 871lagg_port_output(struct ifnet *ifp, struct mbuf *m, 872 const struct sockaddr *dst, struct route *ro) 873{ 874 struct lagg_port *lp = ifp->if_lagg; 875 876 switch (dst->sa_family) { 877 case pseudo_AF_HDRCMPLT: 878 case AF_UNSPEC: 879 return ((*lp->lp_output)(ifp, m, dst, ro)); 880 } 881 882 /* drop any other frames */ 883 m_freem(m); 884 return (ENETDOWN); 885} 886 887static void 888lagg_port_ifdetach(void *arg __unused, struct ifnet *ifp) 889{ 890 struct lagg_port *lp; 891 struct lagg_softc *sc; 892 893 if ((lp = ifp->if_lagg) == NULL) 894 return; 895 /* If the ifnet is just being renamed, don't do anything. */ 896 if (ifp->if_flags & IFF_RENAMING) 897 return; 898 899 sc = lp->lp_softc; 900 901 LAGG_WLOCK(sc); 902 lp->lp_detaching = 1; 903 lagg_port_destroy(lp, 1); 904 LAGG_WUNLOCK(sc); 905} 906 907static void 908lagg_port2req(struct lagg_port *lp, struct lagg_reqport *rp) 909{ 910 struct lagg_softc *sc = lp->lp_softc; 911 912 strlcpy(rp->rp_ifname, sc->sc_ifname, sizeof(rp->rp_ifname)); 913 strlcpy(rp->rp_portname, lp->lp_ifp->if_xname, sizeof(rp->rp_portname)); 914 rp->rp_prio = lp->lp_prio; 915 rp->rp_flags = lp->lp_flags; 916 if (sc->sc_portreq != NULL) 917 (*sc->sc_portreq)(lp, (caddr_t)&rp->rp_psc); 918 919 /* Add protocol specific flags */ 920 switch (sc->sc_proto) { 921 case LAGG_PROTO_FAILOVER: 922 if (lp == sc->sc_primary) 923 rp->rp_flags |= LAGG_PORT_MASTER; 924 if (lp == lagg_link_active(sc, sc->sc_primary)) 925 rp->rp_flags |= LAGG_PORT_ACTIVE; 926 break; 927 928 case LAGG_PROTO_ROUNDROBIN: 929 case LAGG_PROTO_LOADBALANCE: 930 case LAGG_PROTO_ETHERCHANNEL: 931 if (LAGG_PORTACTIVE(lp)) 932 rp->rp_flags |= LAGG_PORT_ACTIVE; 933 break; 934 935 case LAGG_PROTO_LACP: 936 /* LACP has a different definition of active */ 937 if (lacp_isactive(lp)) 938 rp->rp_flags |= LAGG_PORT_ACTIVE; 939 if (lacp_iscollecting(lp)) 940 rp->rp_flags |= LAGG_PORT_COLLECTING; 941 if (lacp_isdistributing(lp)) 942 rp->rp_flags |= LAGG_PORT_DISTRIBUTING; 943 break; 944 } 945 946} 947 948static void 949lagg_init(void *xsc) 950{ 951 struct lagg_softc *sc = (struct lagg_softc *)xsc; 952 struct lagg_port *lp; 953 struct ifnet *ifp = sc->sc_ifp; 954 955 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 956 return; 957 958 LAGG_WLOCK(sc); 959 960 ifp->if_drv_flags |= IFF_DRV_RUNNING; 961 /* Update the port lladdrs */ 962 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 963 lagg_port_lladdr(lp, IF_LLADDR(ifp)); 964 965 if (sc->sc_init != NULL) 966 (*sc->sc_init)(sc); 967 968 LAGG_WUNLOCK(sc); 969} 970 971static void 972lagg_stop(struct lagg_softc *sc) 973{ 974 struct ifnet *ifp = sc->sc_ifp; 975 976 LAGG_WLOCK_ASSERT(sc); 977 978 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 979 return; 980 981 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 982 983 if (sc->sc_stop != NULL) 984 (*sc->sc_stop)(sc); 985} 986 987static int 988lagg_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 989{ 990 struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; 991 struct lagg_reqall *ra = (struct lagg_reqall *)data; 992 struct lagg_reqopts *ro = (struct lagg_reqopts *)data; 993 struct lagg_reqport *rp = (struct lagg_reqport *)data, rpbuf; 994 struct lagg_reqflags *rf = (struct lagg_reqflags *)data; 995 struct ifreq *ifr = (struct ifreq *)data; 996 struct lagg_port *lp; 997 const struct lagg_proto *proto = NULL; 998 struct ifnet *tpif; 999 struct thread *td = curthread; 1000 char *buf, *outbuf; 1001 int count, buflen, len, error = 0; 1002 struct rm_priotracker tracker; 1003 1004 bzero(&rpbuf, sizeof(rpbuf)); 1005 1006 switch (cmd) { 1007 case SIOCGLAGG: 1008 LAGG_RLOCK(sc, &tracker); 1009 count = 0; 1010 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 1011 count++; 1012 buflen = count * sizeof(struct lagg_reqport); 1013 LAGG_RUNLOCK(sc, &tracker); 1014 1015 outbuf = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO); 1016 1017 LAGG_RLOCK(sc, &tracker); 1018 ra->ra_proto = sc->sc_proto; 1019 if (sc->sc_req != NULL) 1020 (*sc->sc_req)(sc, (caddr_t)&ra->ra_psc); 1021 1022 count = 0; 1023 buf = outbuf; 1024 len = min(ra->ra_size, buflen); 1025 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 1026 if (len < sizeof(rpbuf)) 1027 break; 1028 1029 lagg_port2req(lp, &rpbuf); 1030 memcpy(buf, &rpbuf, sizeof(rpbuf)); 1031 count++; 1032 buf += sizeof(rpbuf); 1033 len -= sizeof(rpbuf); 1034 } 1035 LAGG_RUNLOCK(sc, &tracker); 1036 ra->ra_ports = count; 1037 ra->ra_size = count * sizeof(rpbuf); 1038 error = copyout(outbuf, ra->ra_port, ra->ra_size); 1039 free(outbuf, M_TEMP); 1040 break; 1041 case SIOCSLAGG: 1042 error = priv_check(td, PRIV_NET_LAGG); 1043 if (error) 1044 break; 1045 for (proto = lagg_protos; proto->ti_proto != LAGG_PROTO_NONE; 1046 proto++) { 1047 if (proto->ti_proto == ra->ra_proto) { 1048 if (sc->sc_ifflags & IFF_DEBUG) 1049 printf("%s: using proto %u\n", 1050 sc->sc_ifname, proto->ti_proto); 1051 break; 1052 } 1053 } 1054 if (proto->ti_proto == LAGG_PROTO_NONE) { 1055 error = EPROTONOSUPPORT; 1056 break; 1057 } 1058 /* Set to LAGG_PROTO_NONE during the attach. */ 1059 LAGG_WLOCK(sc); 1060 if (sc->sc_proto != LAGG_PROTO_NONE) { 1061 sc->sc_proto = LAGG_PROTO_NONE; 1062 if (sc->sc_detach != NULL) 1063 sc->sc_detach(sc); 1064 else 1065 LAGG_WUNLOCK(sc); 1066 } 1067 proto->ti_attach(sc); 1068 LAGG_WLOCK(sc); 1069 sc->sc_proto = proto->ti_proto; 1070 LAGG_WUNLOCK(sc); 1071 break; 1072 case SIOCGLAGGOPTS: 1073 ro->ro_opts = sc->sc_opts; 1074 if (sc->sc_proto == LAGG_PROTO_LACP) { 1075 struct lacp_softc *lsc; 1076 1077 lsc = (struct lacp_softc *)sc->sc_psc; 1078 if (lsc->lsc_debug.lsc_tx_test != 0) 1079 ro->ro_opts |= LAGG_OPT_LACP_TXTEST; 1080 if (lsc->lsc_debug.lsc_rx_test != 0) 1081 ro->ro_opts |= LAGG_OPT_LACP_RXTEST; 1082 if (lsc->lsc_strict_mode != 0) 1083 ro->ro_opts |= LAGG_OPT_LACP_STRICT; 1084 1085 ro->ro_active = sc->sc_active; 1086 } else { 1087 ro->ro_active = 0; 1088 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 1089 ro->ro_active += LAGG_PORTACTIVE(lp); 1090 } 1091 ro->ro_flapping = sc->sc_flapping; 1092 ro->ro_flowid_shift = sc->flowid_shift; 1093 break; 1094 case SIOCSLAGGOPTS: 1095 error = priv_check(td, PRIV_NET_LAGG); 1096 if (error) 1097 break; 1098 if (ro->ro_opts == 0) 1099 break; 1100 /* 1101 * Set options. LACP options are stored in sc->sc_psc, 1102 * not in sc_opts. 1103 */ 1104 int valid, lacp; 1105 1106 switch (ro->ro_opts) { 1107 case LAGG_OPT_USE_FLOWID: 1108 case -LAGG_OPT_USE_FLOWID: 1109 case LAGG_OPT_FLOWIDSHIFT: 1110 valid = 1; 1111 lacp = 0; 1112 break; 1113 case LAGG_OPT_LACP_TXTEST: 1114 case -LAGG_OPT_LACP_TXTEST: 1115 case LAGG_OPT_LACP_RXTEST: 1116 case -LAGG_OPT_LACP_RXTEST: 1117 case LAGG_OPT_LACP_STRICT: 1118 case -LAGG_OPT_LACP_STRICT: 1119 valid = lacp = 1; 1120 break; 1121 default: 1122 valid = lacp = 0; 1123 break; 1124 } 1125 1126 LAGG_WLOCK(sc); 1127 if (valid == 0 || 1128 (lacp == 1 && sc->sc_proto != LAGG_PROTO_LACP)) { 1129 /* Invalid combination of options specified. */ 1130 error = EINVAL; 1131 LAGG_WUNLOCK(sc); 1132 break; /* Return from SIOCSLAGGOPTS. */ 1133 } 1134 /* 1135 * Store new options into sc->sc_opts except for 1136 * FLOWIDSHIFT and LACP options. 1137 */ 1138 if (lacp == 0) { 1139 if (ro->ro_opts == LAGG_OPT_FLOWIDSHIFT) 1140 sc->flowid_shift = ro->ro_flowid_shift; 1141 else if (ro->ro_opts > 0) 1142 sc->sc_opts |= ro->ro_opts; 1143 else 1144 sc->sc_opts &= ~ro->ro_opts; 1145 } else { 1146 struct lacp_softc *lsc; 1147 1148 lsc = (struct lacp_softc *)sc->sc_psc; 1149 1150 switch (ro->ro_opts) { 1151 case LAGG_OPT_LACP_TXTEST: 1152 lsc->lsc_debug.lsc_tx_test = 1; 1153 break; 1154 case -LAGG_OPT_LACP_TXTEST: 1155 lsc->lsc_debug.lsc_tx_test = 0; 1156 break; 1157 case LAGG_OPT_LACP_RXTEST: 1158 lsc->lsc_debug.lsc_rx_test = 1; 1159 break; 1160 case -LAGG_OPT_LACP_RXTEST: 1161 lsc->lsc_debug.lsc_rx_test = 0; 1162 break; 1163 case LAGG_OPT_LACP_STRICT: 1164 lsc->lsc_strict_mode = 1; 1165 break; 1166 case -LAGG_OPT_LACP_STRICT: 1167 lsc->lsc_strict_mode = 0; 1168 break; 1169 } 1170 } 1171 proto->ti_attach(sc); 1172 LAGG_WLOCK(sc); 1173 sc->sc_proto = proto->ti_proto; 1174 LAGG_WUNLOCK(sc); 1175 break; 1176 case SIOCGLAGGFLAGS: 1177 rf->rf_flags = sc->sc_flags; 1178 break; 1179 case SIOCSLAGGHASH: 1180 error = priv_check(td, PRIV_NET_LAGG); 1181 if (error) 1182 break; 1183 if ((rf->rf_flags & LAGG_F_HASHMASK) == 0) { 1184 error = EINVAL; 1185 break; 1186 } 1187 LAGG_WLOCK(sc); 1188 sc->sc_flags &= ~LAGG_F_HASHMASK; 1189 sc->sc_flags |= rf->rf_flags & LAGG_F_HASHMASK; 1190 LAGG_WUNLOCK(sc); 1191 break; 1192 case SIOCGLAGGPORT: 1193 if (rp->rp_portname[0] == '\0' || 1194 (tpif = ifunit(rp->rp_portname)) == NULL) { 1195 error = EINVAL; 1196 break; 1197 } 1198 1199 LAGG_RLOCK(sc, &tracker); 1200 if ((lp = (struct lagg_port *)tpif->if_lagg) == NULL || 1201 lp->lp_softc != sc) { 1202 error = ENOENT; 1203 LAGG_RUNLOCK(sc, &tracker); 1204 break; 1205 } 1206 1207 lagg_port2req(lp, rp); 1208 LAGG_RUNLOCK(sc, &tracker); 1209 break; 1210 case SIOCSLAGGPORT: 1211 error = priv_check(td, PRIV_NET_LAGG); 1212 if (error) 1213 break; 1214 if (rp->rp_portname[0] == '\0' || 1215 (tpif = ifunit(rp->rp_portname)) == NULL) { 1216 error = EINVAL; 1217 break; 1218 } 1219#ifdef INET6 1220 /* 1221 * A laggport interface should not have inet6 address 1222 * because two interfaces with a valid link-local 1223 * scope zone must not be merged in any form. This 1224 * restriction is needed to prevent violation of 1225 * link-local scope zone. Attempts to add a laggport 1226 * interface which has inet6 addresses triggers 1227 * removal of all inet6 addresses on the member 1228 * interface. 1229 */ 1230 if (in6ifa_llaonifp(tpif)) { 1231 in6_ifdetach(tpif); 1232 if_printf(sc->sc_ifp, 1233 "IPv6 addresses on %s have been removed " 1234 "before adding it as a member to prevent " 1235 "IPv6 address scope violation.\n", 1236 tpif->if_xname); 1237 } 1238#endif 1239 LAGG_WLOCK(sc); 1240 error = lagg_port_create(sc, tpif); 1241 LAGG_WUNLOCK(sc); 1242 break; 1243 case SIOCSLAGGDELPORT: 1244 error = priv_check(td, PRIV_NET_LAGG); 1245 if (error) 1246 break; 1247 if (rp->rp_portname[0] == '\0' || 1248 (tpif = ifunit(rp->rp_portname)) == NULL) { 1249 error = EINVAL; 1250 break; 1251 } 1252 1253 LAGG_WLOCK(sc); 1254 if ((lp = (struct lagg_port *)tpif->if_lagg) == NULL || 1255 lp->lp_softc != sc) { 1256 error = ENOENT; 1257 LAGG_WUNLOCK(sc); 1258 break; 1259 } 1260 1261 error = lagg_port_destroy(lp, 1); 1262 LAGG_WUNLOCK(sc); 1263 break; 1264 case SIOCSIFFLAGS: 1265 /* Set flags on ports too */ 1266 LAGG_WLOCK(sc); 1267 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 1268 lagg_setflags(lp, 1); 1269 } 1270 LAGG_WUNLOCK(sc); 1271 1272 if (!(ifp->if_flags & IFF_UP) && 1273 (ifp->if_drv_flags & IFF_DRV_RUNNING)) { 1274 /* 1275 * If interface is marked down and it is running, 1276 * then stop and disable it. 1277 */ 1278 LAGG_WLOCK(sc); 1279 lagg_stop(sc); 1280 LAGG_WUNLOCK(sc); 1281 } else if ((ifp->if_flags & IFF_UP) && 1282 !(ifp->if_drv_flags & IFF_DRV_RUNNING)) { 1283 /* 1284 * If interface is marked up and it is stopped, then 1285 * start it. 1286 */ 1287 (*ifp->if_init)(sc); 1288 } 1289 break; 1290 case SIOCADDMULTI: 1291 case SIOCDELMULTI: 1292 LAGG_WLOCK(sc); 1293 error = lagg_ether_setmulti(sc); 1294 LAGG_WUNLOCK(sc); 1295 break; 1296 case SIOCSIFMEDIA: 1297 case SIOCGIFMEDIA: 1298 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd); 1299 break; 1300 1301 case SIOCSIFCAP: 1302 case SIOCSIFMTU: 1303 /* Do not allow the MTU or caps to be directly changed */ 1304 error = EINVAL; 1305 break; 1306 1307 default: 1308 error = ether_ioctl(ifp, cmd, data); 1309 break; 1310 } 1311 return (error); 1312} 1313 1314static int 1315lagg_ether_setmulti(struct lagg_softc *sc) 1316{ 1317 struct lagg_port *lp; 1318 1319 LAGG_WLOCK_ASSERT(sc); 1320 1321 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 1322 /* First, remove any existing filter entries. */ 1323 lagg_ether_cmdmulti(lp, 0); 1324 /* copy all addresses from the lagg interface to the port */ 1325 lagg_ether_cmdmulti(lp, 1); 1326 } 1327 return (0); 1328} 1329 1330static int 1331lagg_ether_cmdmulti(struct lagg_port *lp, int set) 1332{ 1333 struct lagg_softc *sc = lp->lp_softc; 1334 struct ifnet *ifp = lp->lp_ifp; 1335 struct ifnet *scifp = sc->sc_ifp; 1336 struct lagg_mc *mc; 1337 struct ifmultiaddr *ifma; 1338 int error; 1339 1340 LAGG_WLOCK_ASSERT(sc); 1341 1342 if (set) { 1343 IF_ADDR_WLOCK(scifp); 1344 TAILQ_FOREACH(ifma, &scifp->if_multiaddrs, ifma_link) { 1345 if (ifma->ifma_addr->sa_family != AF_LINK) 1346 continue; 1347 mc = malloc(sizeof(struct lagg_mc), M_DEVBUF, M_NOWAIT); 1348 if (mc == NULL) { 1349 IF_ADDR_WUNLOCK(scifp); 1350 return (ENOMEM); 1351 } 1352 bcopy(ifma->ifma_addr, &mc->mc_addr, 1353 ifma->ifma_addr->sa_len); 1354 mc->mc_addr.sdl_index = ifp->if_index; 1355 mc->mc_ifma = NULL; 1356 SLIST_INSERT_HEAD(&lp->lp_mc_head, mc, mc_entries); 1357 } 1358 IF_ADDR_WUNLOCK(scifp); 1359 SLIST_FOREACH (mc, &lp->lp_mc_head, mc_entries) { 1360 error = if_addmulti(ifp, 1361 (struct sockaddr *)&mc->mc_addr, &mc->mc_ifma); 1362 if (error) 1363 return (error); 1364 } 1365 } else { 1366 while ((mc = SLIST_FIRST(&lp->lp_mc_head)) != NULL) { 1367 SLIST_REMOVE(&lp->lp_mc_head, mc, lagg_mc, mc_entries); 1368 if (mc->mc_ifma && !lp->lp_detaching) 1369 if_delmulti_ifma(mc->mc_ifma); 1370 free(mc, M_DEVBUF); 1371 } 1372 } 1373 return (0); 1374} 1375 1376/* Handle a ref counted flag that should be set on the lagg port as well */ 1377static int 1378lagg_setflag(struct lagg_port *lp, int flag, int status, 1379 int (*func)(struct ifnet *, int)) 1380{ 1381 struct lagg_softc *sc = lp->lp_softc; 1382 struct ifnet *scifp = sc->sc_ifp; 1383 struct ifnet *ifp = lp->lp_ifp; 1384 int error; 1385 1386 LAGG_WLOCK_ASSERT(sc); 1387 1388 status = status ? (scifp->if_flags & flag) : 0; 1389 /* Now "status" contains the flag value or 0 */ 1390 1391 /* 1392 * See if recorded ports status is different from what 1393 * we want it to be. If it is, flip it. We record ports 1394 * status in lp_ifflags so that we won't clear ports flag 1395 * we haven't set. In fact, we don't clear or set ports 1396 * flags directly, but get or release references to them. 1397 * That's why we can be sure that recorded flags still are 1398 * in accord with actual ports flags. 1399 */ 1400 if (status != (lp->lp_ifflags & flag)) { 1401 error = (*func)(ifp, status); 1402 if (error) 1403 return (error); 1404 lp->lp_ifflags &= ~flag; 1405 lp->lp_ifflags |= status; 1406 } 1407 return (0); 1408} 1409 1410/* 1411 * Handle IFF_* flags that require certain changes on the lagg port 1412 * if "status" is true, update ports flags respective to the lagg 1413 * if "status" is false, forcedly clear the flags set on port. 1414 */ 1415static int 1416lagg_setflags(struct lagg_port *lp, int status) 1417{ 1418 int error, i; 1419 1420 for (i = 0; lagg_pflags[i].flag; i++) { 1421 error = lagg_setflag(lp, lagg_pflags[i].flag, 1422 status, lagg_pflags[i].func); 1423 if (error) 1424 return (error); 1425 } 1426 return (0); 1427} 1428 1429static int 1430lagg_transmit(struct ifnet *ifp, struct mbuf *m) 1431{ 1432 struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; 1433 int error, len, mcast; 1434 struct rm_priotracker tracker; 1435 1436 len = m->m_pkthdr.len; 1437 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0; 1438 1439 LAGG_RLOCK(sc, &tracker); 1440 /* We need a Tx algorithm and at least one port */ 1441 if (sc->sc_proto == LAGG_PROTO_NONE || sc->sc_count == 0) { 1442 LAGG_RUNLOCK(sc, &tracker); 1443 m_freem(m); 1444 ifp->if_oerrors++; 1445 return (ENXIO); 1446 } 1447 1448 ETHER_BPF_MTAP(ifp, m); 1449 1450 error = (*sc->sc_start)(sc, m); 1451 LAGG_RUNLOCK(sc, &tracker); 1452 1453 if (error == 0) { 1454 counter_u64_add(sc->sc_opackets, 1); 1455 counter_u64_add(sc->sc_obytes, len); 1456 ifp->if_omcasts += mcast; 1457 } else 1458 ifp->if_oerrors++; 1459 1460 return (error); 1461} 1462 1463/* 1464 * The ifp->if_qflush entry point for lagg(4) is no-op. 1465 */ 1466static void 1467lagg_qflush(struct ifnet *ifp __unused) 1468{ 1469} 1470 1471static struct mbuf * 1472lagg_input(struct ifnet *ifp, struct mbuf *m) 1473{ 1474 struct lagg_port *lp = ifp->if_lagg; 1475 struct lagg_softc *sc = lp->lp_softc; 1476 struct ifnet *scifp = sc->sc_ifp; 1477 struct rm_priotracker tracker; 1478 1479 LAGG_RLOCK(sc, &tracker); 1480 if ((scifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || 1481 (lp->lp_flags & LAGG_PORT_DISABLED) || 1482 sc->sc_proto == LAGG_PROTO_NONE) { 1483 LAGG_RUNLOCK(sc, &tracker); 1484 m_freem(m); 1485 return (NULL); 1486 } 1487 1488 ETHER_BPF_MTAP(scifp, m); 1489 1490 m = (lp->lp_detaching == 0) ? (*sc->sc_input)(sc, lp, m) : NULL; 1491 1492 if (m != NULL) { 1493 counter_u64_add(sc->sc_ipackets, 1); 1494 counter_u64_add(sc->sc_ibytes, m->m_pkthdr.len); 1495 1496 if (scifp->if_flags & IFF_MONITOR) { 1497 m_freem(m); 1498 m = NULL; 1499 } 1500 } 1501 1502 LAGG_RUNLOCK(sc, &tracker); 1503 return (m); 1504} 1505 1506static int 1507lagg_media_change(struct ifnet *ifp) 1508{ 1509 struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; 1510 1511 if (sc->sc_ifflags & IFF_DEBUG) 1512 printf("%s\n", __func__); 1513 1514 /* Ignore */ 1515 return (0); 1516} 1517 1518static void 1519lagg_media_status(struct ifnet *ifp, struct ifmediareq *imr) 1520{ 1521 struct lagg_softc *sc = (struct lagg_softc *)ifp->if_softc; 1522 struct lagg_port *lp; 1523 struct rm_priotracker tracker; 1524 1525 imr->ifm_status = IFM_AVALID; 1526 imr->ifm_active = IFM_ETHER | IFM_AUTO; 1527 1528 LAGG_RLOCK(sc, &tracker); 1529 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 1530 if (LAGG_PORTACTIVE(lp)) 1531 imr->ifm_status |= IFM_ACTIVE; 1532 } 1533 LAGG_RUNLOCK(sc, &tracker); 1534} 1535 1536static void 1537lagg_linkstate(struct lagg_softc *sc) 1538{ 1539 struct lagg_port *lp; 1540 int new_link = LINK_STATE_DOWN; 1541 uint64_t speed; 1542 1543 /* Our link is considered up if at least one of our ports is active */ 1544 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) { 1545 if (lp->lp_link_state == LINK_STATE_UP) { 1546 new_link = LINK_STATE_UP; 1547 break; 1548 } 1549 } 1550 if_link_state_change(sc->sc_ifp, new_link); 1551 1552 /* Update if_baudrate to reflect the max possible speed */ 1553 switch (sc->sc_proto) { 1554 case LAGG_PROTO_FAILOVER: 1555 sc->sc_ifp->if_baudrate = sc->sc_primary != NULL ? 1556 sc->sc_primary->lp_ifp->if_baudrate : 0; 1557 break; 1558 case LAGG_PROTO_ROUNDROBIN: 1559 case LAGG_PROTO_LOADBALANCE: 1560 case LAGG_PROTO_ETHERCHANNEL: 1561 speed = 0; 1562 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 1563 speed += lp->lp_ifp->if_baudrate; 1564 sc->sc_ifp->if_baudrate = speed; 1565 break; 1566 case LAGG_PROTO_LACP: 1567 /* LACP updates if_baudrate itself */ 1568 break; 1569 } 1570} 1571 1572static void 1573lagg_port_state(struct ifnet *ifp, int state) 1574{ 1575 struct lagg_port *lp = (struct lagg_port *)ifp->if_lagg; 1576 struct lagg_softc *sc = NULL; 1577 1578 if (lp != NULL) 1579 sc = lp->lp_softc; 1580 if (sc == NULL) 1581 return; 1582 1583 LAGG_WLOCK(sc); 1584 lagg_linkstate(sc); 1585 if (sc->sc_linkstate != NULL) 1586 (*sc->sc_linkstate)(lp); 1587 LAGG_WUNLOCK(sc); 1588} 1589 1590struct lagg_port * 1591lagg_link_active(struct lagg_softc *sc, struct lagg_port *lp) 1592{ 1593 struct lagg_port *lp_next, *rval = NULL; 1594 // int new_link = LINK_STATE_DOWN; 1595 1596 LAGG_RLOCK_ASSERT(sc); 1597 /* 1598 * Search a port which reports an active link state. 1599 */ 1600 1601 if (lp == NULL) 1602 goto search; 1603 if (LAGG_PORTACTIVE(lp)) { 1604 rval = lp; 1605 goto found; 1606 } 1607 if ((lp_next = SLIST_NEXT(lp, lp_entries)) != NULL && 1608 LAGG_PORTACTIVE(lp_next)) { 1609 rval = lp_next; 1610 goto found; 1611 } 1612 1613search: 1614 SLIST_FOREACH(lp_next, &sc->sc_ports, lp_entries) { 1615 if (LAGG_PORTACTIVE(lp_next)) { 1616 rval = lp_next; 1617 goto found; 1618 } 1619 } 1620 1621found: 1622 if (rval != NULL) { 1623 /* 1624 * The IEEE 802.1D standard assumes that a lagg with 1625 * multiple ports is always full duplex. This is valid 1626 * for load sharing laggs and if at least two links 1627 * are active. Unfortunately, checking the latter would 1628 * be too expensive at this point. 1629 XXX 1630 if ((sc->sc_capabilities & IFCAP_LAGG_FULLDUPLEX) && 1631 (sc->sc_count > 1)) 1632 new_link = LINK_STATE_FULL_DUPLEX; 1633 else 1634 new_link = rval->lp_link_state; 1635 */ 1636 } 1637 1638 return (rval); 1639} 1640 1641static const void * 1642lagg_gethdr(struct mbuf *m, u_int off, u_int len, void *buf) 1643{ 1644 if (m->m_pkthdr.len < (off + len)) { 1645 return (NULL); 1646 } else if (m->m_len < (off + len)) { 1647 m_copydata(m, off, len, buf); 1648 return (buf); 1649 } 1650 return (mtod(m, char *) + off); 1651} 1652 1653uint32_t 1654lagg_hashmbuf(struct lagg_softc *sc, struct mbuf *m, uint32_t key) 1655{ 1656 uint16_t etype; 1657 uint32_t p = key; 1658 int off; 1659 struct ether_header *eh; 1660 const struct ether_vlan_header *vlan; 1661#ifdef INET 1662 const struct ip *ip; 1663 const uint32_t *ports; 1664 int iphlen; 1665#endif 1666#ifdef INET6 1667 const struct ip6_hdr *ip6; 1668 uint32_t flow; 1669#endif 1670 union { 1671#ifdef INET 1672 struct ip ip; 1673#endif 1674#ifdef INET6 1675 struct ip6_hdr ip6; 1676#endif 1677 struct ether_vlan_header vlan; 1678 uint32_t port; 1679 } buf; 1680 1681 1682 off = sizeof(*eh); 1683 if (m->m_len < off) 1684 goto out; 1685 eh = mtod(m, struct ether_header *); 1686 etype = ntohs(eh->ether_type); 1687 if (sc->sc_flags & LAGG_F_HASHL2) { 1688 p = hash32_buf(&eh->ether_shost, ETHER_ADDR_LEN, p); 1689 p = hash32_buf(&eh->ether_dhost, ETHER_ADDR_LEN, p); 1690 } 1691 1692 /* Special handling for encapsulating VLAN frames */ 1693 if ((m->m_flags & M_VLANTAG) && (sc->sc_flags & LAGG_F_HASHL2)) { 1694 p = hash32_buf(&m->m_pkthdr.ether_vtag, 1695 sizeof(m->m_pkthdr.ether_vtag), p); 1696 } else if (etype == ETHERTYPE_VLAN) { 1697 vlan = lagg_gethdr(m, off, sizeof(*vlan), &buf); 1698 if (vlan == NULL) 1699 goto out; 1700 1701 if (sc->sc_flags & LAGG_F_HASHL2) 1702 p = hash32_buf(&vlan->evl_tag, sizeof(vlan->evl_tag), p); 1703 etype = ntohs(vlan->evl_proto); 1704 off += sizeof(*vlan) - sizeof(*eh); 1705 } 1706 1707 switch (etype) { 1708#ifdef INET 1709 case ETHERTYPE_IP: 1710 ip = lagg_gethdr(m, off, sizeof(*ip), &buf); 1711 if (ip == NULL) 1712 goto out; 1713 1714 if (sc->sc_flags & LAGG_F_HASHL3) { 1715 p = hash32_buf(&ip->ip_src, sizeof(struct in_addr), p); 1716 p = hash32_buf(&ip->ip_dst, sizeof(struct in_addr), p); 1717 } 1718 if (!(sc->sc_flags & LAGG_F_HASHL4)) 1719 break; 1720 switch (ip->ip_p) { 1721 case IPPROTO_TCP: 1722 case IPPROTO_UDP: 1723 case IPPROTO_SCTP: 1724 iphlen = ip->ip_hl << 2; 1725 if (iphlen < sizeof(*ip)) 1726 break; 1727 off += iphlen; 1728 ports = lagg_gethdr(m, off, sizeof(*ports), &buf); 1729 if (ports == NULL) 1730 break; 1731 p = hash32_buf(ports, sizeof(*ports), p); 1732 break; 1733 } 1734 break; 1735#endif 1736#ifdef INET6 1737 case ETHERTYPE_IPV6: 1738 if (!(sc->sc_flags & LAGG_F_HASHL3)) 1739 break; 1740 ip6 = lagg_gethdr(m, off, sizeof(*ip6), &buf); 1741 if (ip6 == NULL) 1742 goto out; 1743 1744 p = hash32_buf(&ip6->ip6_src, sizeof(struct in6_addr), p); 1745 p = hash32_buf(&ip6->ip6_dst, sizeof(struct in6_addr), p); 1746 flow = ip6->ip6_flow & IPV6_FLOWLABEL_MASK; 1747 p = hash32_buf(&flow, sizeof(flow), p); /* IPv6 flow label */ 1748 break; 1749#endif 1750 } 1751out: 1752 return (p); 1753} 1754 1755int 1756lagg_enqueue(struct ifnet *ifp, struct mbuf *m) 1757{ 1758 1759 return (ifp->if_transmit)(ifp, m); 1760} 1761 1762/* 1763 * Simple round robin aggregation 1764 */ 1765static void 1766lagg_rr_attach(struct lagg_softc *sc) 1767{ 1768 sc->sc_detach = lagg_rr_detach; 1769 sc->sc_start = lagg_rr_start; 1770 sc->sc_input = lagg_rr_input; 1771 sc->sc_detach = NULL; 1772 sc->sc_port_create = NULL; 1773 sc->sc_capabilities = IFCAP_LAGG_FULLDUPLEX; 1774 sc->sc_seq = 0; 1775} 1776 1777static int 1778lagg_rr_detach(struct lagg_softc *sc) 1779{ 1780 return (0); 1781} 1782 1783static int 1784lagg_rr_start(struct lagg_softc *sc, struct mbuf *m) 1785{ 1786 struct lagg_port *lp; 1787 uint32_t p; 1788 1789 p = atomic_fetchadd_32(&sc->sc_seq, 1); 1790 p %= sc->sc_count; 1791 lp = SLIST_FIRST(&sc->sc_ports); 1792 while (p--) 1793 lp = SLIST_NEXT(lp, lp_entries); 1794 1795 /* 1796 * Check the port's link state. This will return the next active 1797 * port if the link is down or the port is NULL. 1798 */ 1799 if ((lp = lagg_link_active(sc, lp)) == NULL) { 1800 m_freem(m); 1801 return (ENETDOWN); 1802 } 1803 1804 /* Send mbuf */ 1805 return (lagg_enqueue(lp->lp_ifp, m)); 1806} 1807 1808static struct mbuf * 1809lagg_rr_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m) 1810{ 1811 struct ifnet *ifp = sc->sc_ifp; 1812 1813 /* Just pass in the packet to our lagg device */ 1814 m->m_pkthdr.rcvif = ifp; 1815 1816 return (m); 1817} 1818 1819/* 1820 * Active failover 1821 */ 1822static void 1823lagg_fail_attach(struct lagg_softc *sc) 1824{ 1825 sc->sc_detach = lagg_fail_detach; 1826 sc->sc_start = lagg_fail_start; 1827 sc->sc_input = lagg_fail_input; 1828 sc->sc_port_create = NULL; 1829 sc->sc_port_destroy = NULL; 1830 sc->sc_detach = NULL; 1831} 1832 1833static int 1834lagg_fail_detach(struct lagg_softc *sc) 1835{ 1836 return (0); 1837} 1838 1839static int 1840lagg_fail_start(struct lagg_softc *sc, struct mbuf *m) 1841{ 1842 struct lagg_port *lp; 1843 1844 /* Use the master port if active or the next available port */ 1845 if ((lp = lagg_link_active(sc, sc->sc_primary)) == NULL) { 1846 m_freem(m); 1847 return (ENETDOWN); 1848 } 1849 1850 /* Send mbuf */ 1851 return (lagg_enqueue(lp->lp_ifp, m)); 1852} 1853 1854static struct mbuf * 1855lagg_fail_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m) 1856{ 1857 struct ifnet *ifp = sc->sc_ifp; 1858 struct lagg_port *tmp_tp; 1859 1860 if (lp == sc->sc_primary || V_lagg_failover_rx_all) { 1861 m->m_pkthdr.rcvif = ifp; 1862 return (m); 1863 } 1864 1865 if (!LAGG_PORTACTIVE(sc->sc_primary)) { 1866 tmp_tp = lagg_link_active(sc, sc->sc_primary); 1867 /* 1868 * If tmp_tp is null, we've recieved a packet when all 1869 * our links are down. Weird, but process it anyways. 1870 */ 1871 if ((tmp_tp == NULL || tmp_tp == lp)) { 1872 m->m_pkthdr.rcvif = ifp; 1873 return (m); 1874 } 1875 } 1876 1877 m_freem(m); 1878 return (NULL); 1879} 1880 1881/* 1882 * Loadbalancing 1883 */ 1884static void 1885lagg_lb_attach(struct lagg_softc *sc) 1886{ 1887 struct lagg_port *lp; 1888 struct lagg_lb *lb; 1889 1890 lb = malloc(sizeof(struct lagg_lb), M_DEVBUF, M_WAITOK | M_ZERO); 1891 1892 sc->sc_detach = lagg_lb_detach; 1893 sc->sc_start = lagg_lb_start; 1894 sc->sc_input = lagg_lb_input; 1895 sc->sc_port_create = lagg_lb_port_create; 1896 sc->sc_port_destroy = lagg_lb_port_destroy; 1897 sc->sc_capabilities = IFCAP_LAGG_FULLDUPLEX; 1898 1899 lb->lb_key = arc4random(); 1900 sc->sc_psc = (caddr_t)lb; 1901 1902 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 1903 lagg_lb_port_create(lp); 1904} 1905 1906static int 1907lagg_lb_detach(struct lagg_softc *sc) 1908{ 1909 struct lagg_lb *lb = (struct lagg_lb *)sc->sc_psc; 1910 LAGG_WUNLOCK(sc); 1911 if (lb != NULL) 1912 free(lb, M_DEVBUF); 1913 return (0); 1914} 1915 1916static int 1917lagg_lb_porttable(struct lagg_softc *sc, struct lagg_port *lp) 1918{ 1919 struct lagg_lb *lb = (struct lagg_lb *)sc->sc_psc; 1920 struct lagg_port *lp_next; 1921 int i = 0; 1922 1923 bzero(&lb->lb_ports, sizeof(lb->lb_ports)); 1924 SLIST_FOREACH(lp_next, &sc->sc_ports, lp_entries) { 1925 if (lp_next == lp) 1926 continue; 1927 if (i >= LAGG_MAX_PORTS) 1928 return (EINVAL); 1929 if (sc->sc_ifflags & IFF_DEBUG) 1930 printf("%s: port %s at index %d\n", 1931 sc->sc_ifname, lp_next->lp_ifname, i); 1932 lb->lb_ports[i++] = lp_next; 1933 } 1934 1935 return (0); 1936} 1937 1938static int 1939lagg_lb_port_create(struct lagg_port *lp) 1940{ 1941 struct lagg_softc *sc = lp->lp_softc; 1942 return (lagg_lb_porttable(sc, NULL)); 1943} 1944 1945static void 1946lagg_lb_port_destroy(struct lagg_port *lp) 1947{ 1948 struct lagg_softc *sc = lp->lp_softc; 1949 lagg_lb_porttable(sc, lp); 1950} 1951 1952static int 1953lagg_lb_start(struct lagg_softc *sc, struct mbuf *m) 1954{ 1955 struct lagg_lb *lb = (struct lagg_lb *)sc->sc_psc; 1956 struct lagg_port *lp = NULL; 1957 uint32_t p = 0; 1958 1959 if ((sc->sc_opts & LAGG_OPT_USE_FLOWID) && 1960 M_HASHTYPE_GET(m) != M_HASHTYPE_NONE) 1961 p = m->m_pkthdr.flowid >> sc->flowid_shift; 1962 else 1963 p = lagg_hashmbuf(sc, m, lb->lb_key); 1964 p %= sc->sc_count; 1965 lp = lb->lb_ports[p]; 1966 1967 /* 1968 * Check the port's link state. This will return the next active 1969 * port if the link is down or the port is NULL. 1970 */ 1971 if ((lp = lagg_link_active(sc, lp)) == NULL) { 1972 m_freem(m); 1973 return (ENETDOWN); 1974 } 1975 1976 /* Send mbuf */ 1977 return (lagg_enqueue(lp->lp_ifp, m)); 1978} 1979 1980static struct mbuf * 1981lagg_lb_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m) 1982{ 1983 struct ifnet *ifp = sc->sc_ifp; 1984 1985 /* Just pass in the packet to our lagg device */ 1986 m->m_pkthdr.rcvif = ifp; 1987 1988 return (m); 1989} 1990 1991/* 1992 * 802.3ad LACP 1993 */ 1994static void 1995lagg_lacp_attach(struct lagg_softc *sc) 1996{ 1997 struct lagg_port *lp; 1998 1999 sc->sc_detach = lagg_lacp_detach; 2000 sc->sc_port_create = lacp_port_create; 2001 sc->sc_port_destroy = lacp_port_destroy; 2002 sc->sc_linkstate = lacp_linkstate; 2003 sc->sc_start = lagg_lacp_start; 2004 sc->sc_input = lagg_lacp_input; 2005 sc->sc_init = lacp_init; 2006 sc->sc_stop = lacp_stop; 2007 sc->sc_lladdr = lagg_lacp_lladdr; 2008 sc->sc_req = lacp_req; 2009 sc->sc_portreq = lacp_portreq; 2010 2011 lacp_attach(sc); 2012 2013 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 2014 lacp_port_create(lp); 2015} 2016 2017static int 2018lagg_lacp_detach(struct lagg_softc *sc) 2019{ 2020 struct lagg_port *lp; 2021 void *psc; 2022 2023 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 2024 lacp_port_destroy(lp); 2025 2026 psc = sc->sc_psc; 2027 sc->sc_psc = NULL; 2028 LAGG_WUNLOCK(sc); 2029 2030 lacp_detach(psc); 2031 2032 return (0); 2033} 2034 2035static void 2036lagg_lacp_lladdr(struct lagg_softc *sc) 2037{ 2038 struct lagg_port *lp; 2039 2040 /* purge all the lacp ports */ 2041 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 2042 lacp_port_destroy(lp); 2043 2044 /* add them back in */ 2045 SLIST_FOREACH(lp, &sc->sc_ports, lp_entries) 2046 lacp_port_create(lp); 2047} 2048 2049static int 2050lagg_lacp_start(struct lagg_softc *sc, struct mbuf *m) 2051{ 2052 struct lagg_port *lp; 2053 2054 lp = lacp_select_tx_port(sc, m); 2055 if (lp == NULL) { 2056 m_freem(m); 2057 return (ENETDOWN); 2058 } 2059 2060 /* Send mbuf */ 2061 return (lagg_enqueue(lp->lp_ifp, m)); 2062} 2063 2064static struct mbuf * 2065lagg_lacp_input(struct lagg_softc *sc, struct lagg_port *lp, struct mbuf *m) 2066{ 2067 struct ifnet *ifp = sc->sc_ifp; 2068 struct ether_header *eh; 2069 u_short etype; 2070 2071 eh = mtod(m, struct ether_header *); 2072 etype = ntohs(eh->ether_type); 2073 2074 /* Tap off LACP control messages */ 2075 if ((m->m_flags & M_VLANTAG) == 0 && etype == ETHERTYPE_SLOW) { 2076 m = lacp_input(lp, m); 2077 if (m == NULL) 2078 return (NULL); 2079 } 2080 2081 /* 2082 * If the port is not collecting or not in the active aggregator then 2083 * free and return. 2084 */ 2085 if (lacp_iscollecting(lp) == 0 || lacp_isactive(lp) == 0) { 2086 m_freem(m); 2087 return (NULL); 2088 } 2089 2090 m->m_pkthdr.rcvif = ifp; 2091 return (m); 2092} 2093 2094static void 2095lagg_callout(void *arg) 2096{ 2097 struct lagg_softc *sc = (struct lagg_softc *)arg; 2098 struct ifnet *ifp = sc->sc_ifp; 2099 2100 ifp->if_ipackets = counter_u64_fetch(sc->sc_ipackets); 2101 ifp->if_opackets = counter_u64_fetch(sc->sc_opackets); 2102 ifp->if_ibytes = counter_u64_fetch(sc->sc_ibytes); 2103 ifp->if_obytes = counter_u64_fetch(sc->sc_obytes); 2104 2105 callout_reset(&sc->sc_callout, hz, lagg_callout, sc); 2106} 2107