/* $NetBSD: if_lagg_lacp.c,v 1.43 2024/04/05 06:31:37 yamaguchi Exp $ */
/*-
* SPDX-License-Identifier: BSD-2-Clause-NetBSD
*
* Copyright (c)2005 YAMAMOTO Takashi,
* Copyright (c)2008 Andrew Thompson <
[email protected]>
* Copyright (c)2021 Internet Initiative Japan, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_lagg_lacp.c,v 1.43 2024/04/05 06:31:37 yamaguchi Exp $");
#ifdef _KERNEL_OPT
#include "opt_lagg.h"
#endif
#include <sys/param.h>
#include <sys/types.h>
#include <sys/evcnt.h>
#include <sys/kmem.h>
#include <sys/pcq.h>
#include <sys/pslist.h>
#include <sys/sysctl.h>
#include <sys/syslog.h>
#include <sys/workqueue.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_ether.h>
#include <net/if_media.h>
#include <net/ether_slowprotocols.h>
#include <net/lagg/if_lagg.h>
#include <net/lagg/if_laggproto.h>
#include <net/lagg/if_lagg_lacp.h>
#define LACP_SYSTEMIDSTR_LEN 32
enum {
LACP_TIMER_CURRENT_WHILE = 0,
LACP_TIMER_PERIODIC,
LACP_TIMER_WAIT_WHILE,
LACP_NTIMER
};
enum {
LACP_PTIMER_DISTRIBUTING = 0,
LACP_NPTIMER
};
enum lacp_selected {
LACP_UNSELECTED,
LACP_READY,
LACP_STANDBY,
LACP_SELECTED,
};
enum lacp_mux_state {
LACP_MUX_DETACHED,
LACP_MUX_WAITING,
LACP_MUX_STANDBY,
LACP_MUX_ATTACHED,
LACP_MUX_COLLECTING,
LACP_MUX_DISTRIBUTING,
LACP_MUX_INIT,
};
struct lacp_aggregator_systemid {
uint16_t sid_prio;
uint16_t sid_key;
uint8_t sid_mac[LACP_MAC_LEN];
};
struct lacp_aggregator {
TAILQ_ENTRY(lacp_aggregator)
la_q;
LIST_HEAD(, lacp_port)
la_ports;
ssize_t la_attached_port;
struct lacp_aggregator_systemid
la_sid;
};
struct lacp_portinfo {
uint8_t lpi_state;
uint16_t lpi_portno;
#define LACP_PORTNO_NONE 0
uint16_t lpi_portprio;
};
struct lacp_port {
struct lagg_port *lp_laggport;
bool lp_added_multi;
int lp_timer[LACP_NTIMER];
uint32_t lp_marker_xid;
enum lacp_selected lp_selected;
enum lacp_mux_state lp_mux_state;
struct lacp_portinfo lp_actor;
struct lacp_portinfo lp_partner;
struct lacp_aggregator *lp_aggregator;
struct lacp_aggregator_systemid
lp_aggregator_sidbuf;
uint64_t lp_linkspeed;
int lp_pending;
LIST_ENTRY(lacp_port) lp_entry_la;
struct timeval lp_last_lacpdu;
int lp_lacpdu_sent;
bool lp_collector;
unsigned int lp_flags;
#define LACP_PORT_NTT __BIT(0)
#define LACP_PORT_MARK __BIT(1)
struct lagg_work lp_work_smtx;
struct lagg_work lp_work_marker;
};
struct lacp_portmap {
size_t pm_count;
struct lagg_port *pm_ports[LACP_MAX_PORTS];
};
struct lacp_softc {
struct lagg_softc *lsc_softc;
kmutex_t lsc_lock;
pserialize_t lsc_psz;
bool lsc_running;
bool lsc_suppress_distributing;
int lsc_timer[LACP_NPTIMER];
uint8_t lsc_system_mac[LACP_MAC_LEN];
uint16_t lsc_system_prio;
uint16_t lsc_key;
size_t lsc_max_ports;
size_t lsc_activemap;
struct lacp_portmap lsc_portmaps[2]; /* active & idle */
struct lacp_aggregator *lsc_aggregator;
TAILQ_HEAD(, lacp_aggregator)
lsc_aggregators;
struct workqueue *lsc_workq;
struct lagg_work lsc_work_tick;
struct lagg_work lsc_work_rcvdu;
struct lagg_work lsc_work_linkspeed;
callout_t lsc_tick;
pcq_t *lsc_du_q;
char lsc_evgroup[32];
struct evcnt lsc_mgethdr_failed;
struct evcnt lsc_mpullup_failed;
struct evcnt lsc_badlacpdu;
struct evcnt lsc_badmarkerdu;
struct evcnt lsc_norcvif;
struct evcnt lsc_nolaggport;
struct evcnt lsc_duq_nospc;
bool lsc_optimistic;
bool lsc_stop_lacpdu;
bool lsc_dump_du;
bool lsc_multi_linkspeed;
};
/*
* Locking notes:
* - Items in struct lacp_softc are protected by
* lsc_lock (an adaptive mutex)
* - lsc_activemap is protected by pserialize (lsc_psz)
* - Items of struct lagg_port in lsc_portmaps are protected by
* protected by both pserialize (lsc_psz) and psref (lp_psref)
* - Updates for lsc_activemap and lsc_portmaps is serialized by
* sc_lock in struct lagg_softc
* - Other locking notes are described in if_laggproto.h
*/
static void lacp_dprintf(const struct lacp_softc *,
const struct lacp_port *, const char *, ...)
__attribute__((__format__(__printf__, 3, 4)));
#ifdef LACP_DEBUG
#define LACP_DPRINTF(a) do { lacp_dprintf a; } while (/*CONSTCOND*/ 0)
#define LACP_PEERINFO_IDSTR(_pi, _b, _bs) \
lacp_peerinfo_idstr(_pi, _b, _bs)
#define LACP_STATE_STR(_s, _b, _bs) lacp_state_str(_s, _b, _bs)
#define LACP_AGGREGATOR_STR(_a, _b, _bs) \
lacp_aggregator_str(_a, _b, _bs)
#define __LACPDEBUGUSED
#else
#define LACP_DPRINTF(a) __nothing
#define LACP_PEERINFO_IDSTR(_pi, _b, _bs) __nothing
#define LACP_STATE_STR(_s, _b, _bs) __nothing
#define LACP_AGGREGATOR_STR(_a, _b, _bs) __nothing
#define __LACPDEBUGUSED __unused
#endif
#define LACP_LOCK(_sc) mutex_enter(&(_sc)->lsc_lock)
#define LACP_UNLOCK(_sc) mutex_exit(&(_sc)->lsc_lock)
#define LACP_LOCKED(_sc) mutex_owned(&(_sc)->lsc_lock)
#define LACP_TIMER_ARM(_lacpp, _timer, _val) \
(_lacpp)->lp_timer[(_timer)] = (_val)
#define LACP_TIMER_DISARM(_lacpp, _timer) \
LACP_TIMER_ARM((_lacpp), (_timer), 0)
#define LACP_TIMER_ISARMED(_lacpp, _timer) \
((_lacpp)->lp_timer[(_timer)] > 0)
#define LACP_PTIMER_ARM(_sc, _timer, _val) \
(_sc)->lsc_timer[(_timer)] = (_val)
#define LACP_PTIMER_DISARM(_sc, _timer) \
LACP_PTIMER_ARM((_sc), (_timer), 0)
#define LACP_PTIMER_ISARMED(_sc, _timer) \
((_sc)->lsc_timer[(_timer)] > 0)
#define LACP_STATE_EQ(_s1, _s2, _mask) (!ISSET((_s1) ^ (_s2), (_mask)))
#define LACP_PORT_XNAME(_lacpp) (_lacpp != NULL) ? \
(_lacpp)->lp_laggport->lp_ifp->if_xname : "(unknown)"
#define LACP_ISDUMPING(_sc) (_sc)->lsc_dump_du
#define LACP_PORTMAP_ACTIVE(_sc) \
atomic_load_consume(&(_sc)->lsc_activemap)
#define LACP_PORTMAP_NEXT(_sc) \
(((LACP_PORTMAP_ACTIVE((_sc))) ^ 0x01) &0x01)
#define LACP_SYS_PRI(_la) ntohs((_la)->la_sid.sid_prio)
#define LACP_TLV_PARSE(_du, _st, _name, _tlvlist) \
tlv_parse(&(_du)->_name, \
sizeof(_st) - offsetof(_st, _name), \
(_tlvlist))
static void lacp_tick(void *);
static void lacp_tick_work(struct lagg_work *, void *);
static void lacp_linkstate(struct lagg_proto_softc *, struct lagg_port *);
static void lacp_port_disable(struct lacp_softc *, struct lacp_port *);
static void lacp_port_enable(struct lacp_softc *, struct lacp_port *);
static void lacp_peerinfo_actor(struct lacp_softc *, struct lacp_port *,
struct lacpdu_peerinfo *);
static void lacp_peerinfo_partner(struct lacp_port *,
struct lacpdu_peerinfo *);
static struct lagg_port *
lacp_select_tx_port(struct lacp_softc *, struct mbuf *,
struct psref *);
static void lacp_suppress_distributing(struct lacp_softc *);
static void lacp_distributing_timer(struct lacp_softc *);
static void lacp_select(struct lacp_softc *, struct lacp_port *);
static void lacp_unselect(struct lacp_softc *, struct lacp_port *);
static void lacp_selected_update(struct lacp_softc *,
struct lacp_aggregator *);
static void lacp_sm_port_init(struct lacp_softc *,
struct lacp_port *, struct lagg_port *);
static int lacp_set_mux(struct lacp_softc *,
struct lacp_port *, enum lacp_mux_state);
static void lacp_sm_mux(struct lacp_softc *, struct lacp_port *);
static void lacp_sm_mux_timer(struct lacp_softc *, struct lacp_port *);
static void lacp_sm_rx(struct lacp_softc *, struct lacp_port *,
struct lacpdu_peerinfo *, struct lacpdu_peerinfo *);
static void lacp_sm_rx_set_expired(struct lacp_port *);
static void lacp_sm_rx_timer(struct lacp_softc *, struct lacp_port *);
static void lacp_sm_rx_record_default(struct lacp_softc *,
struct lacp_port *);
static void lacp_sm_tx(struct lacp_softc *, struct lacp_port *);
static void lacp_sm_tx_work(struct lagg_work *, void *);
static void lacp_sm_ptx_timer(struct lacp_softc *, struct lacp_port *);
static void lacp_sm_ptx_schedule(struct lacp_port *);
static void lacp_sm_ptx_update_timeout(struct lacp_port *, uint8_t);
static void lacp_rcvdu_work(struct lagg_work *, void *);
static void lacp_marker_work(struct lagg_work *, void *);
static void lacp_linkspeed_work(struct lagg_work *, void *);
static void lacp_dump_lacpdutlv(const struct lacpdu_peerinfo *,
const struct lacpdu_peerinfo *,
const struct lacpdu_collectorinfo *);
static void lacp_dump_markertlv(const struct markerdu_info *,
const struct markerdu_info *);
typedef void (*lacp_timer_func_t)(struct lacp_softc *, struct lacp_port *);
static const lacp_timer_func_t lacp_timer_funcs[] = {
[LACP_TIMER_CURRENT_WHILE] = lacp_sm_rx_timer,
[LACP_TIMER_PERIODIC] = lacp_sm_ptx_timer,
[LACP_TIMER_WAIT_WHILE] = lacp_sm_mux_timer,
};
typedef void (*lacp_prototimer_func_t)(struct lacp_softc *);
static const lacp_prototimer_func_t lacp_ptimer_funcs[] = {
[LACP_PTIMER_DISTRIBUTING] = lacp_distributing_timer,
};
static void
lacp_dprintf(const struct lacp_softc *lsc, const struct lacp_port *lacpp,
const char *fmt, ...)
{
struct lagg_softc *sc;
va_list va;
if (lsc != NULL && lsc->lsc_softc != NULL) {
sc = lsc->lsc_softc;
printf("%s", sc->sc_if.if_xname);
} else {
printf("lacp");
}
if (lacpp != NULL)
printf("(%s)", LACP_PORT_XNAME(lacpp));
printf(": ");
va_start(va, fmt);
vprintf(fmt, va);
va_end(va);
}
static inline void
lacp_evcnt_attach(struct lacp_softc *lsc,
struct evcnt *ev, const char *name)
{
evcnt_attach_dynamic(ev, EVCNT_TYPE_MISC, NULL,
lsc->lsc_evgroup, name);
}
static inline bool
lacp_iscollecting(struct lacp_port *lacpp)
{
return atomic_load_relaxed(&lacpp->lp_collector);
}
static inline bool
lacp_isdistributing(struct lacp_port *lacpp)
{
return ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_DISTRIBUTING);
}
static inline bool
lacp_isactive(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
if (lacpp->lp_selected != LACP_SELECTED)
return false;
if (lacpp->lp_aggregator == NULL)
return false;
if (lacpp->lp_aggregator != lsc->lsc_aggregator)
return false;
return true;
}
static inline void
lacp_mcastaddr(struct ifreq *ifr, const char *if_xname)
{
static const uint8_t addr[ETHER_ADDR_LEN] =
{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x02 };
memset(ifr, 0, sizeof(*ifr));
strlcpy(ifr->ifr_name, if_xname,
sizeof(ifr->ifr_name));
ifr->ifr_addr.sa_len = sizeof(ifr->ifr_addr);
ifr->ifr_addr.sa_family = AF_UNSPEC;
CTASSERT(sizeof(ifr->ifr_addr) >= sizeof(addr));
memcpy(&ifr->ifr_addr.sa_data, addr, sizeof(addr));
}
static inline u_int
lacp_portmap_linkstate(struct lacp_portmap *pm)
{
if (pm->pm_count == 0)
return LINK_STATE_DOWN;
return LINK_STATE_UP;
}
static inline struct lacp_port *
lacp_port_priority_max(struct lacp_port *a, struct lacp_port *b)
{
uint16_t pri_a, pri_b;
pri_a = ntohs(a->lp_actor.lpi_portprio);
pri_b = ntohs(b->lp_actor.lpi_portprio);
if (pri_a < pri_b)
return a;
if (pri_b < pri_a)
return b;
pri_a = ntohs(a->lp_partner.lpi_portprio);
pri_b = ntohs(b->lp_partner.lpi_portprio);
if (pri_a < pri_b)
return a;
if (pri_b < pri_a)
return b;
if (a->lp_linkspeed > b->lp_linkspeed)
return a;
if (b->lp_linkspeed > a->lp_linkspeed)
return b;
return a;
}
static void
tlv_parse(void *vp, size_t len, struct tlv *list)
{
struct tlvhdr *th;
uint8_t *p;
size_t l, i;
th = (struct tlvhdr *)vp;
p = (uint8_t *)vp;
for (l = 0; l < len; l += th->tlv_length) {
th = (struct tlvhdr *)(p + l);
if (th->tlv_type == TLV_TYPE_TERMINATE)
break;
if (th->tlv_length <= 0)
break;
for (i = 0; list[i].tlv_t != TLV_TYPE_TERMINATE; i++) {
if (th->tlv_type != list[i].tlv_t)
continue;
if (th->tlv_length - sizeof(*th) != list[i].tlv_l)
break;
if (list[i].tlv_v == NULL) {
list[i].tlv_v =
(void *)((uint8_t *)th + sizeof(*th));
}
break;
}
}
}
int
lacp_attach(struct lagg_softc *sc, struct lagg_proto_softc **lscp)
{
struct lacp_softc *lsc;
char xnamebuf[MAXCOMLEN];
int error;
KASSERT(LAGG_LOCKED(sc));
lsc = kmem_zalloc(sizeof(*lsc), KM_NOSLEEP);
if (lsc == NULL)
return ENOMEM;
lsc->lsc_du_q = pcq_create(LACP_RCVDU_LIMIT, KM_NOSLEEP);
if (lsc->lsc_du_q == NULL) {
error = ENOMEM;
goto free_lsc;
}
mutex_init(&lsc->lsc_lock, MUTEX_DEFAULT, IPL_SOFTNET);
lsc->lsc_softc = sc;
lsc->lsc_key = htons(if_get_index(&sc->sc_if));
lsc->lsc_system_prio = htons(LACP_SYSTEM_PRIO);
lsc->lsc_running = false;
lsc->lsc_max_ports = LACP_MAX_PORTS;
lsc->lsc_multi_linkspeed = true;
TAILQ_INIT(&lsc->lsc_aggregators);
lagg_work_set(&lsc->lsc_work_tick, lacp_tick_work, lsc);
lagg_work_set(&lsc->lsc_work_rcvdu, lacp_rcvdu_work, lsc);
lagg_work_set(&lsc->lsc_work_linkspeed,
lacp_linkspeed_work, lsc);
snprintf(xnamebuf, sizeof(xnamebuf), "%s.lacp",
sc->sc_if.if_xname);
lsc->lsc_workq = lagg_workq_create(xnamebuf,
PRI_SOFTNET, IPL_SOFTNET, WQ_MPSAFE);
if (lsc->lsc_workq == NULL) {
LAGG_LOG(sc, LOG_ERR, "workqueue create failed\n");
error = ENOMEM;
goto destroy_lock;
}
lsc->lsc_psz = pserialize_create();
callout_init(&lsc->lsc_tick, CALLOUT_MPSAFE);
callout_setfunc(&lsc->lsc_tick, lacp_tick, lsc);
snprintf(lsc->lsc_evgroup, sizeof(lsc->lsc_evgroup),
"%s-lacp", sc->sc_if.if_xname);
lacp_evcnt_attach(lsc, &lsc->lsc_mgethdr_failed, "MGETHDR failed");
lacp_evcnt_attach(lsc, &lsc->lsc_mpullup_failed, "m_pullup failed");
lacp_evcnt_attach(lsc, &lsc->lsc_badlacpdu, "Bad LACPDU received");
lacp_evcnt_attach(lsc, &lsc->lsc_badmarkerdu, "Bad MarkerDU received");
lacp_evcnt_attach(lsc, &lsc->lsc_norcvif, "No received interface");
lacp_evcnt_attach(lsc, &lsc->lsc_nolaggport, "No lagg context");
lacp_evcnt_attach(lsc, &lsc->lsc_duq_nospc, "No space left on queues");
if_link_state_change(&sc->sc_if, LINK_STATE_DOWN);
*lscp = (struct lagg_proto_softc *)lsc;
return 0;
destroy_lock:
mutex_destroy(&lsc->lsc_lock);
pcq_destroy(lsc->lsc_du_q);
free_lsc:
kmem_free(lsc, sizeof(*lsc));
return error;
}
void
lacp_detach(struct lagg_proto_softc *xlsc)
{
struct lacp_softc *lsc = (struct lacp_softc *)xlsc;
struct lagg_softc *sc __diagused = lsc->lsc_softc;
KASSERT(TAILQ_EMPTY(&lsc->lsc_aggregators));
KASSERT(SIMPLEQ_EMPTY(&sc->sc_ports));
LAGG_LOCK(lsc->lsc_softc);
lacp_down(xlsc);
LAGG_UNLOCK(lsc->lsc_softc);
lagg_workq_wait(lsc->lsc_workq, &lsc->lsc_work_rcvdu);
lagg_workq_wait(lsc->lsc_workq, &lsc->lsc_work_tick);
evcnt_detach(&lsc->lsc_mgethdr_failed);
evcnt_detach(&lsc->lsc_mpullup_failed);
evcnt_detach(&lsc->lsc_badlacpdu);
evcnt_detach(&lsc->lsc_badmarkerdu);
evcnt_detach(&lsc->lsc_norcvif);
evcnt_detach(&lsc->lsc_nolaggport);
evcnt_detach(&lsc->lsc_duq_nospc);
lagg_workq_destroy(lsc->lsc_workq);
pserialize_destroy(lsc->lsc_psz);
mutex_destroy(&lsc->lsc_lock);
pcq_destroy(lsc->lsc_du_q);
kmem_free(lsc, sizeof(*lsc));
}
int
lacp_up(struct lagg_proto_softc *xlsc)
{
struct lagg_softc *sc;
struct lagg_port *lp;
struct lacp_softc *lsc;
lsc = (struct lacp_softc *)xlsc;
sc = lsc->lsc_softc;
KASSERT(LAGG_LOCKED(sc));
LACP_LOCK(lsc);
if (memcmp(lsc->lsc_system_mac, LAGG_CLLADDR(sc),
sizeof(lsc->lsc_system_mac)) != 0) {
memcpy(lsc->lsc_system_mac, LAGG_CLLADDR(sc),
sizeof(lsc->lsc_system_mac));
}
lsc->lsc_running = true;
callout_schedule(&lsc->lsc_tick, hz);
LACP_UNLOCK(lsc);
LAGG_PORTS_FOREACH(sc, lp) {
lacp_linkstate(xlsc, lp);
}
LACP_DPRINTF((lsc, NULL, "lacp start\n"));
return 0;
}
static void
lacp_down_locked(struct lacp_softc *lsc)
{
struct lagg_softc *sc;
struct lagg_port *lp;
sc = lsc->lsc_softc;
KASSERT(LAGG_LOCKED(sc));
KASSERT(LACP_LOCKED(lsc));
lsc->lsc_running = false;
callout_halt(&lsc->lsc_tick, &lsc->lsc_lock);
LAGG_PORTS_FOREACH(sc, lp) {
lacp_port_disable(lsc, lp->lp_proto_ctx);
}
memset(lsc->lsc_system_mac, 0,
sizeof(lsc->lsc_system_mac));
LACP_DPRINTF((lsc, NULL, "lacp stopped\n"));
}
void
lacp_down(struct lagg_proto_softc *xlsc)
{
struct lacp_softc *lsc;
lsc = (struct lacp_softc *)xlsc;
KASSERT(LAGG_LOCKED(lsc->lsc_softc));
LACP_LOCK(lsc);
lacp_down_locked(lsc);
LACP_UNLOCK(lsc);
}
int
lacp_transmit(struct lagg_proto_softc *xlsc, struct mbuf *m)
{
struct lacp_softc *lsc;
struct lagg_port *lp;
struct ifnet *ifp;
struct psref psref;
lsc = (struct lacp_softc *)xlsc;
if (__predict_false(lsc->lsc_suppress_distributing)) {
LACP_DPRINTF((lsc, NULL, "waiting transit\n"));
m_freem(m);
return EBUSY;
}
lp = lacp_select_tx_port(lsc, m, &psref);
if (__predict_false(lp == NULL)) {
LACP_DPRINTF((lsc, NULL, "no distributing port\n"));
ifp = &lsc->lsc_softc->sc_if;
if_statinc(ifp, if_oerrors);
m_freem(m);
return ENOENT;
}
lagg_output(lsc->lsc_softc, lp, m);
lagg_port_putref(lp, &psref);
return 0;
}
int
lacp_allocport(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
struct lagg_softc *sc;
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct ifreq ifr;
bool added_multi;
int error;
lsc = (struct lacp_softc *)xlsc;
sc = lsc->lsc_softc;
KASSERT(LAGG_LOCKED(sc));
KASSERT(IFNET_LOCKED(lp->lp_ifp));
lacpp = kmem_zalloc(sizeof(*lacpp), KM_NOSLEEP);
if (lacpp == NULL)
return ENOMEM;
lacp_mcastaddr(&ifr, lp->lp_ifp->if_xname);
error = lp->lp_ioctl(lp->lp_ifp, SIOCADDMULTI, (void *)&ifr);
switch (error) {
case 0:
added_multi = true;
break;
case EAFNOSUPPORT:
added_multi = false;
break;
default:
LAGG_LOG(sc, LOG_ERR, "SIOCADDMULTI failed on %s\n",
lp->lp_ifp->if_xname);
kmem_free(lacpp, sizeof(*lacpp));
return error;
}
lacpp->lp_added_multi = added_multi;
lagg_work_set(&lacpp->lp_work_smtx, lacp_sm_tx_work, lsc);
lagg_work_set(&lacpp->lp_work_marker, lacp_marker_work, lsc);
LACP_LOCK(lsc);
lacp_sm_port_init(lsc, lacpp, lp);
LACP_UNLOCK(lsc);
lp->lp_proto_ctx = (void *)lacpp;
lp->lp_prio = ntohs(lacpp->lp_actor.lpi_portprio);
return 0;
}
void
lacp_startport(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
struct lacp_port *lacpp;
uint16_t prio;
lacpp = lp->lp_proto_ctx;
prio = (uint16_t)MIN(lp->lp_prio, UINT16_MAX);
lacpp->lp_actor.lpi_portprio = htons(prio);
lacp_linkstate(xlsc, lp);
}
void
lacp_stopport(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
int i;
lsc = (struct lacp_softc *)xlsc;
lacpp = lp->lp_proto_ctx;
KASSERT(LAGG_LOCKED(lsc->lsc_softc));
LACP_LOCK(lsc);
for (i = 0; i < LACP_NTIMER; i++) {
LACP_TIMER_DISARM(lacpp, i);
}
lacp_port_disable(lsc, lacpp);
LACP_UNLOCK(lsc);
}
void
lacp_freeport(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct ifreq ifr;
lsc = (struct lacp_softc *)xlsc;
lacpp = lp->lp_proto_ctx;
KASSERT(LAGG_LOCKED(lsc->lsc_softc));
KASSERT(IFNET_LOCKED(lp->lp_ifp));
lagg_workq_wait(lsc->lsc_workq, &lacpp->lp_work_smtx);
lagg_workq_wait(lsc->lsc_workq, &lacpp->lp_work_marker);
if (lacpp->lp_added_multi) {
lacp_mcastaddr(&ifr, LACP_PORT_XNAME(lacpp));
(void)lp->lp_ioctl(lp->lp_ifp, SIOCDELMULTI, (void *)&ifr);
}
lp->lp_proto_ctx = NULL;
kmem_free(lacpp, sizeof(*lacpp));
}
void
lacp_protostat(struct lagg_proto_softc *xlsc, struct laggreqproto *resp)
{
struct laggreq_lacp *rplacp;
struct lacp_softc *lsc;
struct lacp_aggregator *la;
struct lacp_aggregator_systemid *sid;
lsc = (struct lacp_softc *)xlsc;
LACP_LOCK(lsc);
la = lsc->lsc_aggregator;
rplacp = &resp->rp_lacp;
if (lsc->lsc_optimistic)
SET(rplacp->flags, LAGGREQLACP_OPTIMISTIC);
if (lsc->lsc_dump_du)
SET(rplacp->flags, LAGGREQLACP_DUMPDU);
if (lsc->lsc_stop_lacpdu)
SET(rplacp->flags, LAGGREQLACP_STOPDU);
if (lsc->lsc_multi_linkspeed)
SET(rplacp->flags, LAGGREQLACP_MULTILS);
rplacp->maxports = lsc->lsc_max_ports;
rplacp->actor_prio = ntohs(lsc->lsc_system_prio);
memcpy(rplacp->actor_mac, lsc->lsc_system_mac,
sizeof(rplacp->actor_mac));
rplacp->actor_key = ntohs(lsc->lsc_key);
if (la != NULL) {
sid = &la->la_sid;
rplacp->partner_prio = ntohs(sid->sid_prio);
memcpy(rplacp->partner_mac, sid->sid_mac,
sizeof(rplacp->partner_mac));
rplacp->partner_key = ntohs(sid->sid_key);
}
LACP_UNLOCK(lsc);
}
void
lacp_portstat(struct lagg_proto_softc *xlsc, struct lagg_port *lp,
struct laggreqport *resp)
{
struct laggreq_lacpport *llp;
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct lacp_aggregator *la;
struct lacp_aggregator_systemid *sid;
lsc = (struct lacp_softc *)xlsc;
lacpp = lp->lp_proto_ctx;
la = lacpp->lp_aggregator;
llp = &resp->rp_lacpport;
if (lacp_isactive(lsc, lacpp))
SET(resp->rp_flags, LAGG_PORT_ACTIVE);
if (lacp_iscollecting(lacpp))
SET(resp->rp_flags, LAGG_PORT_COLLECTING);
if (lacp_isdistributing(lacpp))
SET(resp->rp_flags, LAGG_PORT_DISTRIBUTING);
if (lacpp->lp_selected == LACP_STANDBY)
SET(resp->rp_flags, LAGG_PORT_STANDBY);
if (la != NULL) {
sid = &la->la_sid;
llp->partner_prio = ntohs(sid->sid_prio);
memcpy(llp->partner_mac, sid->sid_mac,
sizeof(llp->partner_mac));
llp->partner_key = ntohs(sid->sid_key);
}
llp->actor_portprio = ntohs(lacpp->lp_actor.lpi_portprio);
llp->actor_portno = ntohs(lacpp->lp_actor.lpi_portno);
llp->actor_state = lacpp->lp_actor.lpi_state;
llp->partner_portprio = ntohs(lacpp->lp_partner.lpi_portprio);
llp->partner_portno = ntohs(lacpp->lp_partner.lpi_portno);
llp->partner_state = lacpp->lp_partner.lpi_state;
}
void
lacp_linkstate_ifnet_locked(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct ifmediareq ifmr;
struct ifnet *ifp_port;
uint8_t old_state;
uint64_t old_linkspeed, new_linkspeed;
int error;
KASSERT(IFNET_LOCKED(lp->lp_ifp));
lsc = (struct lacp_softc *)xlsc;
ifp_port = lp->lp_ifp;
lacpp = lp->lp_proto_ctx;
memset(&ifmr, 0, sizeof(ifmr));
ifmr.ifm_count = 0;
error = if_ioctl(ifp_port, SIOCGIFMEDIA, (void *)&ifmr);
if (error == 0) {
new_linkspeed = ifmedia_baudrate(ifmr.ifm_active);
#ifdef LACP_NOFDX
/*
* some driver that has no media, e.g. vioif(4),
* returns (IFM_ETHER | IFM_AUTO)
*/
if ((ifmr.ifm_active & ~(IFM_ETHER | IFM_AUTO)) == 0)
ifmr.ifm_active |= IFM_FDX;
#endif
} else if (error == ENOTTY) {
ifmr.ifm_active = IFM_FDX | IF_Gbps(0);
new_linkspeed = 0;
} else {
LACP_DPRINTF((lsc, lacpp,
"SIOCGIFMEDIA failed (%d)\n", error));
return;
}
LACP_LOCK(lsc);
if (lsc->lsc_running) {
old_linkspeed = lacpp->lp_linkspeed;
old_state = lacpp->lp_actor.lpi_state;
if (new_linkspeed != old_linkspeed) {
LACP_DPRINTF((lsc, lacpp,
"linkspeed changed %"PRIu64" -> %"PRIu64"\n",
old_linkspeed, new_linkspeed));
lacpp->lp_linkspeed = new_linkspeed;
}
if (ISSET(ifmr.ifm_active, IFM_FDX) &&
ISSET(ifp_port->if_flags, IFF_RUNNING) &&
ifp_port->if_link_state != LINK_STATE_DOWN) {
lacp_port_enable(lsc, lacpp);
} else {
LACP_DPRINTF((lsc, lacpp,
"FDX=%d, RUNNING=%d, link=%d\n",
ISSET(ifmr.ifm_active, IFM_FDX) != 0,
ISSET(ifp_port->if_flags, IFF_RUNNING) != 0,
ifp_port->if_link_state != LINK_STATE_DOWN));
lacp_port_disable(lsc, lacpp);
}
if (old_state != lacpp->lp_actor.lpi_state ||
old_linkspeed != new_linkspeed) {
LACP_DPRINTF((lsc, lacpp,
"state changed to UNSELECTED\n"));
lacpp->lp_selected = LACP_UNSELECTED;
}
} else {
LACP_DPRINTF((lsc, lacpp,
"LACP is inactive, skip linkstate\n"));
}
LACP_UNLOCK(lsc);
}
int
lacp_ioctl(struct lagg_proto_softc *xlsc, struct laggreqproto *lreq)
{
struct lacp_softc *lsc;
struct laggreq_lacp *rplacp;
struct lacp_aggregator *la;
int error;
size_t maxports;
bool set;
lsc = (struct lacp_softc *)xlsc;
rplacp = &lreq->rp_lacp;
error = 0;
switch (rplacp->command) {
case LAGGIOC_LACPSETFLAGS:
case LAGGIOC_LACPCLRFLAGS:
set = (rplacp->command == LAGGIOC_LACPSETFLAGS) ?
true : false;
LACP_LOCK(lsc);
if (ISSET(rplacp->flags, LAGGREQLACP_OPTIMISTIC))
lsc->lsc_optimistic = set;
if (ISSET(rplacp->flags, LAGGREQLACP_DUMPDU))
lsc->lsc_dump_du = set;
if (ISSET(rplacp->flags, LAGGREQLACP_STOPDU))
lsc->lsc_stop_lacpdu = set;
if (ISSET(rplacp->flags, LAGGREQLACP_MULTILS) &&
lsc->lsc_multi_linkspeed != set) {
lsc->lsc_multi_linkspeed = set;
TAILQ_FOREACH(la, &lsc->lsc_aggregators, la_q) {
lacp_selected_update(lsc, la);
}
}
LACP_UNLOCK(lsc);
break;
case LAGGIOC_LACPSETMAXPORTS:
case LAGGIOC_LACPCLRMAXPORTS:
maxports = (rplacp->command == LAGGIOC_LACPSETMAXPORTS) ?
rplacp->maxports : LACP_MAX_PORTS;
if (0 == maxports || LACP_MAX_PORTS < maxports) {
error = ERANGE;
break;
}
LACP_LOCK(lsc);
if (lsc->lsc_max_ports != maxports) {
lsc->lsc_max_ports = maxports;
TAILQ_FOREACH(la, &lsc->lsc_aggregators, la_q) {
lacp_selected_update(lsc, la);
}
}
LACP_UNLOCK(lsc);
break;
default:
error = ENOTTY;
}
return error;
}
static int
lacp_pdu_input(struct lacp_softc *lsc, struct lacp_port *lacpp, struct mbuf *m)
{
enum {
LACP_TLV_ACTOR = 0,
LACP_TLV_PARTNER,
LACP_TLV_COLLECTOR,
LACP_TLV_TERM,
LACP_TLV_NUM
};
struct lacpdu *du;
struct lacpdu_peerinfo *pi_actor, *pi_partner;
struct lacpdu_collectorinfo *lci;
struct tlv tlvlist_lacp[LACP_TLV_NUM] = {
[LACP_TLV_ACTOR] = {
.tlv_t = LACP_TYPE_ACTORINFO,
.tlv_l = sizeof(*pi_actor)},
[LACP_TLV_PARTNER] = {
.tlv_t = LACP_TYPE_PARTNERINFO,
.tlv_l = sizeof(*pi_partner)},
[LACP_TLV_COLLECTOR] = {
.tlv_t = LACP_TYPE_COLLECTORINFO,
.tlv_l = sizeof(*lci)},
[LACP_TLV_TERM] = {
.tlv_t = TLV_TYPE_TERMINATE,
.tlv_l = 0},
};
if (m->m_pkthdr.len != sizeof(*du))
goto bad;
if (m->m_len < (int)sizeof(*du)) {
m = m_pullup(m, sizeof(*du));
if (m == NULL) {
lsc->lsc_mpullup_failed.ev_count++;
return ENOMEM;
}
}
du = mtod(m, struct lacpdu *);
if (memcmp(&du->ldu_eh.ether_dhost,
ethermulticastaddr_slowprotocols, ETHER_ADDR_LEN) != 0)
goto bad;
LACP_TLV_PARSE(du, struct lacpdu, ldu_tlv_actor,
tlvlist_lacp);
pi_actor = tlvlist_lacp[LACP_TLV_ACTOR].tlv_v;
pi_partner = tlvlist_lacp[LACP_TLV_PARTNER].tlv_v;
lci = tlvlist_lacp[LACP_TLV_COLLECTOR].tlv_v;
if (pi_actor == NULL || pi_partner == NULL)
goto bad;
if (LACP_ISDUMPING(lsc)) {
lacp_dprintf(lsc, lacpp, "lacpdu received\n");
lacp_dump_lacpdutlv(pi_actor, pi_partner, lci);
}
LACP_LOCK(lsc);
lacp_sm_rx(lsc, lacpp, pi_partner, pi_actor);
LACP_UNLOCK(lsc);
m_freem(m);
return 0;
bad:
lsc->lsc_badlacpdu.ev_count++;
m_freem(m);
return EINVAL;
}
static int
marker_cmp(struct markerdu_info *mi,
struct lacp_softc *lsc, struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
if (mi->mi_rq_port != lacpp->lp_actor.lpi_portno)
return -1;
if (ntohl(mi->mi_rq_xid) != lacpp->lp_marker_xid)
return -1;
return memcmp(mi->mi_rq_system, lsc->lsc_system_mac,
LACP_MAC_LEN);
}
static void
lacp_marker_reply(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct mbuf *m_info)
{
struct lagg_port *lp;
struct markerdu *mdu;
struct ifnet *ifp_port;
struct psref psref;
LACP_LOCK(lsc);
lp = lacpp->lp_laggport;
lagg_port_getref(lp, &psref);
LACP_UNLOCK(lsc);
ifp_port = lp->lp_ifp;
mdu = mtod(m_info, struct markerdu *);
mdu->mdu_tlv_info.tlv_type = MARKER_TYPE_RESPONSE;
/* ether_dhost is already ethermulticastaddr_slowprotocols */
m_info->m_flags |= M_MCAST;
memcpy(mdu->mdu_eh.ether_shost,
CLLADDR(ifp_port->if_sadl), ETHER_ADDR_LEN);
if (LACP_ISDUMPING(lsc)) {
lacp_dprintf(lsc, lacpp, "markerdu reply\n");
lacp_dump_markertlv(NULL, &mdu->mdu_info);
}
lagg_port_xmit(lp, m_info);
lagg_port_putref(lp, &psref);
}
static int
lacp_marker_recv_response(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct markerdu_info *mi_res)
{
struct lagg_softc *sc;
struct lagg_port *lp0;
struct lacp_port *lacpp0;
bool pending;
sc = lsc->lsc_softc;
LACP_LOCK(lsc);
if (marker_cmp(mi_res, lsc, lacpp) != 0) {
LACP_UNLOCK(lsc);
return -1;
}
CLR(lacpp->lp_flags, LACP_PORT_MARK);
LACP_UNLOCK(lsc);
LAGG_LOCK(sc);
LACP_LOCK(lsc);
if (lsc->lsc_suppress_distributing) {
pending = false;
LAGG_PORTS_FOREACH(sc, lp0) {
lacpp0 = lp0->lp_proto_ctx;
if (ISSET(lacpp0->lp_flags, LACP_PORT_MARK)) {
pending = true;
break;
}
}
if (!pending) {
LACP_DPRINTF((lsc, NULL, "queue flush complete\n"));
LACP_PTIMER_DISARM(lsc, LACP_PTIMER_DISTRIBUTING);
lsc->lsc_suppress_distributing = false;
}
}
LACP_UNLOCK(lsc);
LAGG_UNLOCK(sc);
return 0;
}
static int
lacp_marker_input(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct mbuf *m)
{
enum {
MARKER_TLV_INFO = 0,
MARKER_TLV_RESPONSE,
MARKER_TLV_TERM,
MARKER_TLV_NUM
};
struct markerdu *mdu;
struct markerdu_info *mi_info, *mi_res;
int error;
struct tlv tlvlist_marker[MARKER_TLV_NUM] = {
[MARKER_TLV_INFO] = {
.tlv_t = MARKER_TYPE_INFO,
.tlv_l = sizeof(*mi_info)},
[MARKER_TLV_RESPONSE] = {
.tlv_t = MARKER_TYPE_RESPONSE,
.tlv_l = sizeof(*mi_res)},
[MARKER_TLV_TERM] = {
.tlv_t = TLV_TYPE_TERMINATE,
.tlv_l = 0},
};
if (m->m_pkthdr.len != sizeof(*mdu))
goto bad;
if (m->m_len < (int)sizeof(*mdu)) {
m = m_pullup(m, sizeof(*mdu));
if (m == NULL) {
lsc->lsc_mpullup_failed.ev_count++;
return ENOMEM;
}
}
mdu = mtod(m, struct markerdu *);
if (memcmp(mdu->mdu_eh.ether_dhost,
ethermulticastaddr_slowprotocols, ETHER_ADDR_LEN) != 0)
goto bad;
LACP_TLV_PARSE(mdu, struct markerdu, mdu_tlv_info,
tlvlist_marker);
mi_info = tlvlist_marker[MARKER_TLV_INFO].tlv_v;
mi_res = tlvlist_marker[MARKER_TLV_RESPONSE].tlv_v;
if (LACP_ISDUMPING(lsc)) {
lacp_dprintf(lsc, lacpp, "markerdu received\n");
lacp_dump_markertlv(mi_info, mi_res);
}
if (mi_info != NULL && mi_res == NULL) {
lacp_marker_reply(lsc, lacpp, m);
} else if (mi_info == NULL && mi_res != NULL) {
error = lacp_marker_recv_response(lsc, lacpp,
mi_res);
if (error != 0) {
goto bad;
} else {
m_freem(m);
}
} else {
goto bad;
}
return 0;
bad:
lsc->lsc_badmarkerdu.ev_count++;
m_freem(m);
return EINVAL;
}
struct mbuf *
lacp_input(struct lagg_proto_softc *xlsc, struct lagg_port *lp, struct mbuf *m)
{
struct ifnet *ifp;
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct ether_header *eh;
uint8_t subtype;
eh = mtod(m, struct ether_header *);
lsc = (struct lacp_softc *)xlsc;
ifp = &lsc->lsc_softc->sc_if;
lacpp = lp->lp_proto_ctx;
if (!vlan_has_tag(m) &&
eh->ether_type == htons(ETHERTYPE_SLOWPROTOCOLS)) {
if (m->m_pkthdr.len < (int)(sizeof(*eh) + sizeof(subtype))) {
m_freem(m);
return NULL;
}
m_copydata(m, sizeof(struct ether_header),
sizeof(subtype), &subtype);
switch (subtype) {
case SLOWPROTOCOLS_SUBTYPE_LACP:
case SLOWPROTOCOLS_SUBTYPE_MARKER:
if (pcq_put(lsc->lsc_du_q, (void *)m)) {
lagg_workq_add(lsc->lsc_workq,
&lsc->lsc_work_rcvdu);
} else {
m_freem(m);
lsc->lsc_duq_nospc.ev_count++;
}
return NULL;
}
}
if (!lacp_iscollecting(lacpp) || !lacp_isactive(lsc, lacpp)) {
if_statinc(ifp, if_ierrors);
m_freem(m);
return NULL;
}
return m;
}
static void
lacp_rcvdu_work(struct lagg_work *lw __unused, void *xlsc)
{
struct lacp_softc *lsc = (struct lacp_softc *)xlsc;
struct ifnet *ifp;
struct psref psref_lp;
struct lagg_port *lp;
struct mbuf *m;
uint8_t subtype;
int bound, s0, s1;
bound = curlwp_bind();
for (;;) {
m = pcq_get(lsc->lsc_du_q);
if (m == NULL)
break;
ifp = m_get_rcvif(m, &s0);
if (ifp == NULL) {
m_freem(m);
lsc->lsc_norcvif.ev_count++;
continue;
}
s1 = pserialize_read_enter();
lp = atomic_load_consume(&ifp->if_lagg);
if (lp == NULL) {
pserialize_read_exit(s1);
m_put_rcvif(ifp, &s0);
m_freem(m);
lsc->lsc_norcvif.ev_count++;
continue;
}
lagg_port_getref(lp, &psref_lp);
pserialize_read_exit(s1);
m_put_rcvif(ifp, &s0);
m_copydata(m, sizeof(struct ether_header),
sizeof(subtype), &subtype);
switch (subtype) {
case SLOWPROTOCOLS_SUBTYPE_LACP:
(void)lacp_pdu_input(lsc,
lp->lp_proto_ctx, m);
break;
case SLOWPROTOCOLS_SUBTYPE_MARKER:
(void)lacp_marker_input(lsc,
lp->lp_proto_ctx, m);
break;
}
lagg_port_putref(lp, &psref_lp);
}
curlwp_bindx(bound);
}
static bool
lacp_port_need_to_tell(struct lacp_port *lacpp)
{
if (!ISSET(lacpp->lp_actor.lpi_state,
LACP_STATE_AGGREGATION)) {
return false;
}
if (!ISSET(lacpp->lp_actor.lpi_state,
LACP_STATE_ACTIVITY)
&& !ISSET(lacpp->lp_partner.lpi_state,
LACP_STATE_ACTIVITY)) {
return false;
}
if (!ISSET(lacpp->lp_flags, LACP_PORT_NTT))
return false;
return true;
}
static void
lacp_sm_assert_ntt(struct lacp_port *lacpp)
{
SET(lacpp->lp_flags, LACP_PORT_NTT);
}
static void
lacp_sm_negate_ntt(struct lacp_port *lacpp)
{
CLR(lacpp->lp_flags, LACP_PORT_NTT);
}
static struct mbuf *
lacp_lacpdu_mbuf(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct ifnet *ifp_port;
struct mbuf *m;
struct lacpdu *du;
KASSERT(LACP_LOCKED(lsc));
ifp_port = lacpp->lp_laggport->lp_ifp;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL) {
lsc->lsc_mgethdr_failed.ev_count++;
return NULL;
}
m->m_pkthdr.len = m->m_len = sizeof(*du);
m_reset_rcvif(m);
du = mtod(m, struct lacpdu *);
memset(du, 0, sizeof(*du));
m->m_flags |= M_MCAST;
memcpy(du->ldu_eh.ether_dhost, ethermulticastaddr_slowprotocols,
ETHER_ADDR_LEN);
memcpy(du->ldu_eh.ether_shost, CLLADDR(ifp_port->if_sadl),
ETHER_ADDR_LEN);
du->ldu_eh.ether_type = htons(ETHERTYPE_SLOWPROTOCOLS);
du->ldu_sph.sph_subtype = SLOWPROTOCOLS_SUBTYPE_LACP;
du->ldu_sph.sph_version = 1;
tlv_set(&du->ldu_tlv_actor, LACP_TYPE_ACTORINFO,
sizeof(du->ldu_actor));
lacp_peerinfo_actor(lsc, lacpp, &du->ldu_actor);
tlv_set(&du->ldu_tlv_partner, LACP_TYPE_PARTNERINFO,
sizeof(du->ldu_partner));
lacp_peerinfo_partner(lacpp, &du->ldu_partner);
tlv_set(&du->ldu_tlv_collector, LACP_TYPE_COLLECTORINFO,
sizeof(du->ldu_collector));
du->ldu_collector.lci_maxdelay = 0;
du->ldu_tlv_term.tlv_type = LACP_TYPE_TERMINATE;
du->ldu_tlv_term.tlv_length = 0;
return m;
}
static void
lacp_sm_tx_work(struct lagg_work *lw, void *xlsc)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct lagg_port *lp;
struct lacpdu *du;
struct mbuf *m;
struct psref psref;
int bound;
lsc = xlsc;
lacpp = container_of(lw, struct lacp_port, lp_work_smtx);
LACP_LOCK(lsc);
if (lsc->lsc_stop_lacpdu) {
LACP_UNLOCK(lsc);
return;
}
m = lacp_lacpdu_mbuf(lsc, lacpp);
if (m == NULL) {
LACP_UNLOCK(lsc);
return;
}
lacp_sm_negate_ntt(lacpp);
lp = lacpp->lp_laggport;
bound = curlwp_bind();
lagg_port_getref(lp, &psref);
LACP_UNLOCK(lsc);
if (LACP_ISDUMPING(lsc)) {
lacp_dprintf(lsc, lacpp, "lacpdu transmit\n");
du = mtod(m, struct lacpdu *);
lacp_dump_lacpdutlv(&du->ldu_actor,
&du->ldu_partner, &du->ldu_collector);
}
lagg_port_xmit(lp, m);
lagg_port_putref(lp, &psref);
curlwp_bindx(bound);
}
static void
lacp_sm_tx(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
if (!lacp_port_need_to_tell(lacpp))
return;
lagg_workq_add(lsc->lsc_workq, &lacpp->lp_work_smtx);
}
static void
lacp_tick(void *xlsc)
{
struct lacp_softc *lsc;
lsc = xlsc;
LACP_LOCK(lsc);
if (!lsc->lsc_running) {
LACP_UNLOCK(lsc);
return;
}
lagg_workq_add(lsc->lsc_workq, &lsc->lsc_work_tick);
callout_schedule(&lsc->lsc_tick, hz);
LACP_UNLOCK(lsc);
}
static void
lacp_run_timers(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
size_t i;
KASSERT(LACP_LOCKED(lsc));
for (i = 0; i < LACP_NTIMER; i++) {
KASSERT(lacpp->lp_timer[i] >= 0);
if (lacpp->lp_timer[i] == 0)
continue;
if (--lacpp->lp_timer[i] > 0)
continue;
KASSERT(lacp_timer_funcs[i] != NULL);
lacp_timer_funcs[i](lsc, lacpp);
}
}
static void
lacp_run_prototimers(struct lacp_softc *lsc)
{
size_t i;
for (i = 0; i < LACP_NPTIMER; i++) {
KASSERT(lsc->lsc_timer[i] >= 0);
if (lsc->lsc_timer[i] == 0)
continue;
if (--lsc->lsc_timer[i] > 0)
continue;
KASSERT(lacp_ptimer_funcs[i] != NULL);
lacp_ptimer_funcs[i](lsc);
}
}
static void
lacp_tick_work(struct lagg_work *lw __unused, void *xlsc)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct lagg_softc *sc;
struct lagg_port *lp;
lsc = xlsc;
sc = lsc->lsc_softc;
LACP_LOCK(lsc);
if (!lsc->lsc_running) {
LACP_UNLOCK(lsc);
return;
}
lacp_run_prototimers(lsc);
LACP_UNLOCK(lsc);
LAGG_LOCK(sc);
LACP_LOCK(lsc);
LAGG_PORTS_FOREACH(sc, lp) {
lacpp = lp->lp_proto_ctx;
if (!ISSET(lacpp->lp_actor.lpi_state,
LACP_STATE_AGGREGATION)) {
continue;
}
lacp_run_timers(lsc, lacpp);
lacp_select(lsc, lacpp);
lacp_sm_mux(lsc, lacpp);
lacp_sm_tx(lsc, lacpp);
lacp_sm_ptx_schedule(lacpp);
}
LACP_UNLOCK(lsc);
LAGG_UNLOCK(sc);
}
static void
lacp_systemid_str(char *buf, size_t buflen,
uint16_t prio, const uint8_t *mac, uint16_t key)
{
snprintf(buf, buflen,
"%04X,"
"%02X-%02X-%02X-%02X-%02X-%02X,"
"%04X",
(unsigned int)ntohs(prio),
(int)mac[0], (int)mac[1], (int)mac[2],
(int)mac[3], (int)mac[4], (int)mac[5],
(unsigned int)htons(key));
}
__LACPDEBUGUSED static void
lacp_aggregator_str(struct lacp_aggregator *la, char *buf, size_t buflen)
{
lacp_systemid_str(buf, buflen, la->la_sid.sid_prio,
la->la_sid.sid_mac, la->la_sid.sid_key);
}
static void
lacp_peerinfo_idstr(const struct lacpdu_peerinfo *pi,
char *buf, size_t buflen)
{
lacp_systemid_str(buf, buflen, pi->lpi_system_prio,
pi->lpi_system_mac, pi->lpi_key);
}
static void
lacp_state_str(uint8_t state, char *buf, size_t buflen)
{
snprintb(buf, buflen, LACP_STATE_BITS, state);
}
static struct lagg_port *
lacp_select_tx_port(struct lacp_softc *lsc, struct mbuf *m,
struct psref *psref)
{
struct lacp_portmap *pm;
struct lagg_port *lp;
uint32_t hash;
size_t act;
int s;
hash = lagg_hashmbuf(lsc->lsc_softc, m);
s = pserialize_read_enter();
act = LACP_PORTMAP_ACTIVE(lsc);
pm = &lsc->lsc_portmaps[act];
if (pm->pm_count == 0) {
pserialize_read_exit(s);
return NULL;
}
hash %= pm->pm_count;
lp = pm->pm_ports[hash];
lagg_port_getref(lp, psref);
pserialize_read_exit(s);
return lp;
}
static void
lacp_peerinfo_actor(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *dst)
{
memcpy(dst->lpi_system_mac, lsc->lsc_system_mac, LACP_MAC_LEN);
dst->lpi_system_prio = lsc->lsc_system_prio;
dst->lpi_key = lsc->lsc_key;
dst->lpi_port_no = lacpp->lp_actor.lpi_portno;
dst->lpi_port_prio = lacpp->lp_actor.lpi_portprio;
dst->lpi_state = lacpp->lp_actor.lpi_state;
}
static void
lacp_peerinfo_partner(struct lacp_port *lacpp, struct lacpdu_peerinfo *dst)
{
struct lacp_aggregator *la;
la = lacpp->lp_aggregator;
if (la != NULL) {
memcpy(dst->lpi_system_mac, la->la_sid.sid_mac, LACP_MAC_LEN);
dst->lpi_system_prio = la->la_sid.sid_prio;
dst->lpi_key = la->la_sid.sid_key;
} else {
memset(dst->lpi_system_mac, 0, LACP_MAC_LEN);
dst->lpi_system_prio = 0;
dst->lpi_key = 0;
}
dst->lpi_port_no = lacpp->lp_partner.lpi_portno;
dst->lpi_port_prio = lacpp->lp_partner.lpi_portprio;
dst->lpi_state = lacpp->lp_partner.lpi_state;
}
static int
lacp_compare_peerinfo(struct lacpdu_peerinfo *a, struct lacpdu_peerinfo *b)
{
return memcmp(a, b, offsetof(struct lacpdu_peerinfo, lpi_state));
}
static void
lacp_sm_rx_record_default(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
uint8_t oldpstate;
struct lacp_portinfo *pi;
char buf[LACP_STATESTR_LEN] __LACPDEBUGUSED;
pi = &lacpp->lp_partner;
oldpstate = pi->lpi_state;
pi->lpi_portno = htons(LACP_PORTNO_NONE);
pi->lpi_portprio = htons(0xffff);
if (lsc->lsc_optimistic)
pi->lpi_state = LACP_PARTNER_ADMIN_OPTIMISTIC;
else
pi->lpi_state = LACP_PARTNER_ADMIN_STRICT;
SET(lacpp->lp_actor.lpi_state, LACP_STATE_DEFAULTED);
if (oldpstate != pi->lpi_state) {
LACP_STATE_STR(oldpstate, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "oldpstate %s\n", buf));
LACP_STATE_STR(pi->lpi_state, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "newpstate %s\n", buf));
}
lacp_sm_ptx_update_timeout(lacpp, oldpstate);
}
static inline bool
lacp_port_is_synced(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *my_pi, struct lacpdu_peerinfo *peer_pi)
{
struct lacpdu_peerinfo actor;
if (!ISSET(peer_pi->lpi_state, LACP_STATE_ACTIVITY) &&
(!ISSET(my_pi->lpi_state, LACP_STATE_ACTIVITY) ||
!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_ACTIVITY)))
return false;
if (!ISSET(peer_pi->lpi_state, LACP_STATE_AGGREGATION))
return false;
lacp_peerinfo_actor(lsc, lacpp, &actor);
if (lacp_compare_peerinfo(&actor, my_pi) != 0)
return false;
if (!LACP_STATE_EQ(actor.lpi_state, my_pi->lpi_state,
LACP_STATE_AGGREGATION)) {
return false;
}
return true;
}
static void
lacp_sm_rx_record_peerinfo(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *my_pi, struct lacpdu_peerinfo *peer_pi)
{
char buf[LACP_STATESTR_LEN] __LACPDEBUGUSED;
uint8_t oldpstate;
struct lacp_portinfo *pi;
struct lacp_aggregator_systemid *sid;
pi = &lacpp->lp_partner;
sid = &lacpp->lp_aggregator_sidbuf;
oldpstate = lacpp->lp_partner.lpi_state;
sid->sid_prio = peer_pi->lpi_system_prio;
sid->sid_key = peer_pi->lpi_key;
memcpy(sid->sid_mac, peer_pi->lpi_system_mac,
sizeof(sid->sid_mac));
pi->lpi_portno = peer_pi->lpi_port_no;
pi->lpi_portprio = peer_pi->lpi_port_prio;
pi->lpi_state = peer_pi->lpi_state;
if (lacp_port_is_synced(lsc, lacpp, my_pi, peer_pi)) {
if (lsc->lsc_optimistic)
SET(lacpp->lp_partner.lpi_state, LACP_STATE_SYNC);
} else {
CLR(lacpp->lp_partner.lpi_state, LACP_STATE_SYNC);
}
CLR(lacpp->lp_actor.lpi_state, LACP_STATE_DEFAULTED);
if (oldpstate != lacpp->lp_partner.lpi_state) {
LACP_STATE_STR(oldpstate, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "oldpstate %s\n", buf));
LACP_STATE_STR(lacpp->lp_partner.lpi_state,
buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "newpstate %s\n", buf));
}
lacp_sm_ptx_update_timeout(lacpp, oldpstate);
}
static void
lacp_sm_rx_set_expired(struct lacp_port *lacpp)
{
uint8_t oldpstate;
oldpstate = lacpp->lp_partner.lpi_state;
CLR(lacpp->lp_partner.lpi_state, LACP_STATE_SYNC);
SET(lacpp->lp_partner.lpi_state, LACP_STATE_TIMEOUT);
LACP_TIMER_ARM(lacpp, LACP_TIMER_CURRENT_WHILE,
LACP_SHORT_TIMEOUT_TIME);
SET(lacpp->lp_actor.lpi_state, LACP_STATE_EXPIRED);
lacp_sm_ptx_update_timeout(lacpp, oldpstate);
}
static void
lacp_sm_port_init(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lagg_port *lp)
{
KASSERT(LACP_LOCKED(lsc));
lacpp->lp_laggport = lp;
lacpp->lp_actor.lpi_state = LACP_STATE_ACTIVITY;
lacpp->lp_actor.lpi_portno = htons(if_get_index(lp->lp_ifp));
lacpp->lp_actor.lpi_portprio = htons(LACP_PORT_PRIO);
lacpp->lp_partner.lpi_state = LACP_STATE_TIMEOUT;
lacpp->lp_aggregator = NULL;
lacpp->lp_marker_xid = 0;
lacpp->lp_mux_state = LACP_MUX_INIT;
lacp_set_mux(lsc, lacpp, LACP_MUX_DETACHED);
lacp_sm_rx_record_default(lsc, lacpp);
}
static void
lacp_port_disable(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
if (ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_AGGREGATION))
LACP_DPRINTF((lsc, lacpp, "enable -> disable\n"));
lacp_set_mux(lsc, lacpp, LACP_MUX_DETACHED);
lacp_sm_rx_record_default(lsc, lacpp);
CLR(lacpp->lp_actor.lpi_state,
LACP_STATE_AGGREGATION | LACP_STATE_EXPIRED);
CLR(lacpp->lp_partner.lpi_state, LACP_STATE_AGGREGATION);
}
static void
lacp_port_enable(struct lacp_softc *lsc __LACPDEBUGUSED,
struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
if (!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_AGGREGATION))
LACP_DPRINTF((lsc, lacpp, "disable -> enable\n"));
SET(lacpp->lp_actor.lpi_state, LACP_STATE_AGGREGATION);
lacp_sm_rx_set_expired(lacpp);
}
static void
lacp_sm_rx_timer(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
if (!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_EXPIRED)) {
/* CURRENT -> EXPIRED */
LACP_DPRINTF((lsc, lacpp, "CURRENT -> EXPIRED\n"));
lacp_sm_rx_set_expired(lacpp);
} else {
LACP_DPRINTF((lsc, lacpp, "EXPIRED -> DEFAULTED\n"));
lacp_set_mux(lsc, lacpp, LACP_MUX_DETACHED);
lacp_sm_rx_record_default(lsc, lacpp);
}
}
static void
lacp_sm_ptx_timer(struct lacp_softc *lsc __unused, struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
lacp_sm_assert_ntt(lacpp);
}
static void
lacp_sm_ptx_schedule(struct lacp_port *lacpp)
{
int timeout;
/* no periodic */
if (!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_ACTIVITY) &&
!ISSET(lacpp->lp_partner.lpi_state, LACP_STATE_ACTIVITY)) {
LACP_TIMER_DISARM(lacpp, LACP_TIMER_PERIODIC);
return;
}
if (LACP_TIMER_ISARMED(lacpp, LACP_TIMER_PERIODIC))
return;
timeout = ISSET(lacpp->lp_partner.lpi_state, LACP_STATE_TIMEOUT) ?
LACP_FAST_PERIODIC_TIME : LACP_SLOW_PERIODIC_TIME;
LACP_TIMER_ARM(lacpp, LACP_TIMER_PERIODIC, timeout);
}
static void
lacp_sm_ptx_update_timeout(struct lacp_port *lacpp, uint8_t oldpstate)
{
if (LACP_STATE_EQ(oldpstate, lacpp->lp_partner.lpi_state,
LACP_STATE_TIMEOUT))
return;
LACP_DPRINTF((NULL, lacpp, "partner timeout changed\n"));
LACP_TIMER_DISARM(lacpp, LACP_TIMER_PERIODIC);
/* if timeout has been shorted, assert NTT */
if (ISSET(lacpp->lp_partner.lpi_state, LACP_STATE_TIMEOUT))
lacp_sm_assert_ntt(lacpp);
}
static void
lacp_sm_mux_timer(struct lacp_softc *lsc __LACPDEBUGUSED,
struct lacp_port *lacpp)
{
char buf[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
KASSERT(LACP_LOCKED(lsc));
KASSERT(lacpp->lp_pending > 0);
LACP_AGGREGATOR_STR(lacpp->lp_aggregator, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "aggregator %s, pending %d -> %d\n",
buf, lacpp->lp_pending, lacpp->lp_pending -1));
lacpp->lp_pending--;
}
static void
lacp_sm_rx_update_selected(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *peer_pi)
{
struct lacpdu_peerinfo partner;
char str0[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
char str1[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
if (lacpp->lp_aggregator == NULL)
return;
lacp_peerinfo_partner(lacpp, &partner);
if (lacp_compare_peerinfo(peer_pi, &partner) != 0) {
LACP_PEERINFO_IDSTR(&partner, str0, sizeof(str0));
LACP_PEERINFO_IDSTR(peer_pi, str1, sizeof(str1));
LACP_DPRINTF((lsc, lacpp,
"different peerinfo, %s vs %s\n", str0, str1));
goto do_unselect;
}
if (!LACP_STATE_EQ(lacpp->lp_partner.lpi_state,
peer_pi->lpi_state, LACP_STATE_AGGREGATION)) {
LACP_DPRINTF((lsc, lacpp,
"STATE_AGGREGATION changed %d -> %d\n",
ISSET(lacpp->lp_partner.lpi_state,
LACP_STATE_AGGREGATION) != 0,
ISSET(peer_pi->lpi_state, LACP_STATE_AGGREGATION) != 0));
goto do_unselect;
}
return;
do_unselect:
lacpp->lp_selected = LACP_UNSELECTED;
/* lacpp->lp_aggregator will be released at lacp_set_mux() */
}
static void
lacp_sm_rx_update_ntt(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *my_pi)
{
struct lacpdu_peerinfo actor;
lacp_peerinfo_actor(lsc, lacpp, &actor);
if (lacp_compare_peerinfo(&actor, my_pi) != 0 ||
!LACP_STATE_EQ(lacpp->lp_actor.lpi_state, my_pi->lpi_state,
LACP_STATE_ACTIVITY | LACP_STATE_SYNC | LACP_STATE_AGGREGATION)) {
if (ppsratecheck(&lacpp->lp_last_lacpdu, &lacpp->lp_lacpdu_sent,
(LACP_SENDDU_PPS / LACP_FAST_PERIODIC_TIME)) == 0) {
LACP_DPRINTF((lsc, lacpp,
"skip ntt due to rate limit"));
} else {
LACP_DPRINTF((lsc, lacpp, "assert ntt\n"));
lacp_sm_assert_ntt(lacpp);
}
}
}
static void
lacp_sm_rx(struct lacp_softc *lsc, struct lacp_port *lacpp,
struct lacpdu_peerinfo *my_pi, struct lacpdu_peerinfo *peer_pi)
{
int timeout;
KASSERT(LACP_LOCKED(lsc));
/* check LACP disabled first */
if (!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_AGGREGATION))
return;
/* check loopback condition */
if (memcmp(lsc->lsc_system_mac, peer_pi->lpi_system_mac,
LACP_MAC_LEN) == 0 &&
lsc->lsc_system_prio == peer_pi->lpi_system_prio)
return;
lacp_sm_rx_update_selected(lsc, lacpp, peer_pi);
lacp_sm_rx_update_ntt(lsc, lacpp, my_pi);
lacp_sm_rx_record_peerinfo(lsc, lacpp, my_pi, peer_pi);
timeout = ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_TIMEOUT) ?
LACP_SHORT_TIMEOUT_TIME : LACP_LONG_TIMEOUT_TIME;
LACP_TIMER_ARM(lacpp, LACP_TIMER_CURRENT_WHILE, timeout);
CLR(lacpp->lp_actor.lpi_state, LACP_STATE_EXPIRED);
/* kick transmit machine without timeout. */
lacp_sm_tx(lsc, lacpp);
}
static void
lacp_disable_collecting(struct lacp_port *lacpp)
{
LACP_DPRINTF((NULL, lacpp, "collecting disabled\n"));
CLR(lacpp->lp_actor.lpi_state, LACP_STATE_COLLECTING);
atomic_store_relaxed(&lacpp->lp_collector, false);
}
static void
lacp_enable_collecting(struct lacp_port *lacpp)
{
LACP_DPRINTF((NULL, lacpp, "collecting enabled\n"));
SET(lacpp->lp_actor.lpi_state, LACP_STATE_COLLECTING);
atomic_store_relaxed(&lacpp->lp_collector, true);
}
static void
lacp_update_portmap(struct lacp_softc *lsc)
{
struct lagg_softc *sc;
struct lacp_aggregator *la;
struct lacp_portmap *pm_act, *pm_next;
struct lacp_port *lacpp;
size_t pmap, n;
u_int link;
KASSERT(LACP_LOCKED(lsc));
la = lsc->lsc_aggregator;
pmap = LACP_PORTMAP_ACTIVE(lsc);
pm_act = &lsc->lsc_portmaps[pmap];
pmap = LACP_PORTMAP_NEXT(lsc);
pm_next = &lsc->lsc_portmaps[pmap];
n = 0;
if (la != NULL) {
LIST_FOREACH(lacpp, &la->la_ports, lp_entry_la) {
if (!ISSET(lacpp->lp_actor.lpi_state,
LACP_STATE_DISTRIBUTING)) {
continue;
}
pm_next->pm_ports[n] = lacpp->lp_laggport;
n++;
if (n >= LACP_MAX_PORTS)
break;
}
}
pm_next->pm_count = n;
atomic_store_release(&lsc->lsc_activemap, pmap);
pserialize_perform(lsc->lsc_psz);
LACP_DPRINTF((lsc, NULL, "portmap count updated (%zu -> %zu)\n",
pm_act->pm_count, pm_next->pm_count));
link = lacp_portmap_linkstate(pm_next);
if (link != lacp_portmap_linkstate(pm_act)) {
sc = lsc->lsc_softc;
if_link_state_change(&sc->sc_if, link);
}
lagg_workq_add(lsc->lsc_workq, &lsc->lsc_work_linkspeed);
/* cleanup */
pm_act->pm_count = 0;
memset(pm_act->pm_ports, 0, sizeof(pm_act->pm_ports));
}
static void
lacp_disable_distributing(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_portmap *pm;
bool do_update;
size_t act, i;
int s;
KASSERT(LACP_LOCKED(lsc));
if (ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_DISTRIBUTING)) {
LAGG_LOG(lsc->lsc_softc, LOG_INFO,
"disable distributing on %s\n", LACP_PORT_XNAME(lacpp));
CLR(lacpp->lp_actor.lpi_state, LACP_STATE_DISTRIBUTING);
}
s = pserialize_read_enter();
act = LACP_PORTMAP_ACTIVE(lsc);
pm = &lsc->lsc_portmaps[act];
do_update = false;
for (i = 0; i < pm->pm_count; i++) {
if (pm->pm_ports[i] == lacpp->lp_laggport) {
do_update = true;
break;
}
}
pserialize_read_exit(s);
if (do_update)
lacp_update_portmap(lsc);
}
static void
lacp_enable_distributing(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
KASSERT(LACP_LOCKED(lsc));
KASSERT(lacp_isactive(lsc, lacpp));
LAGG_LOG(lsc->lsc_softc, LOG_INFO,
"enable distributing on %s\n", LACP_PORT_XNAME(lacpp));
SET(lacpp->lp_actor.lpi_state, LACP_STATE_DISTRIBUTING);
lacp_suppress_distributing(lsc);
lacp_update_portmap(lsc);
}
static void
lacp_select_active_aggregator(struct lacp_softc *lsc)
{
struct lacp_aggregator *la, *best_la;
char str[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
KASSERT(LACP_LOCKED(lsc));
la = lsc->lsc_aggregator;
if (la != NULL && la->la_attached_port > 0) {
best_la = la;
} else {
best_la = NULL;
}
TAILQ_FOREACH(la, &lsc->lsc_aggregators, la_q) {
if (la->la_attached_port <= 0)
continue;
if (best_la == NULL ||
LACP_SYS_PRI(la) < LACP_SYS_PRI(best_la))
best_la = la;
}
if (best_la != lsc->lsc_aggregator) {
LACP_DPRINTF((lsc, NULL, "active aggregator changed\n"));
if (lsc->lsc_aggregator != NULL) {
LACP_AGGREGATOR_STR(lsc->lsc_aggregator,
str, sizeof(str));
} else {
snprintf(str, sizeof(str), "(null)");
}
LACP_DPRINTF((lsc, NULL, "old aggregator=%s\n", str));
if (best_la != NULL) {
LACP_AGGREGATOR_STR(best_la, str, sizeof(str));
} else {
snprintf(str, sizeof(str), "(null)");
}
LACP_DPRINTF((lsc, NULL, "new aggregator=%s\n", str));
lsc->lsc_aggregator = best_la;
}
}
static void
lacp_port_attached(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_aggregator *la;
KASSERT(LACP_LOCKED(lsc));
if (ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_SYNC))
return;
la = lacpp->lp_aggregator;
KASSERT(la != NULL);
KASSERT(la->la_attached_port >= 0);
SET(lacpp->lp_actor.lpi_state, LACP_STATE_SYNC);
la->la_attached_port++;
lacp_select_active_aggregator(lsc);
}
static void
lacp_port_detached(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_aggregator *la;
KASSERT(LACP_LOCKED(lsc));
if (!ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_SYNC))
return;
la = lacpp->lp_aggregator;
KASSERT(la != NULL);
KASSERT(la->la_attached_port > 0);
CLR(lacpp->lp_actor.lpi_state, LACP_STATE_SYNC);
la->la_attached_port--;
lacp_select_active_aggregator(lsc);
}
static int
lacp_set_mux(struct lacp_softc *lsc, struct lacp_port *lacpp,
enum lacp_mux_state new_state)
{
struct lagg_softc *sc;
struct ifnet *ifp;
KASSERT(LACP_LOCKED(lsc));
sc = lacpp->lp_laggport->lp_softc;
ifp = &sc->sc_if;
if (lacpp->lp_mux_state == new_state)
return -1;
switch (new_state) {
case LACP_MUX_DETACHED:
lacp_port_detached(lsc, lacpp);
lacp_disable_distributing(lsc, lacpp);
lacp_disable_collecting(lacpp);
lacp_sm_assert_ntt(lacpp);
/* cancel timer */
if (LACP_TIMER_ISARMED(lacpp, LACP_TIMER_WAIT_WHILE)) {
KASSERT(lacpp->lp_pending > 0);
lacpp->lp_pending--;
LACP_TIMER_DISARM(lacpp, LACP_TIMER_WAIT_WHILE);
}
lacp_unselect(lsc, lacpp);
break;
case LACP_MUX_WAITING:
LACP_TIMER_ARM(lacpp, LACP_TIMER_WAIT_WHILE,
LACP_AGGREGATE_WAIT_TIME);
lacpp->lp_pending++;
break;
case LACP_MUX_STANDBY:
#ifdef LACP_STANDBY_SYNCED
lacp_port_attached(lsc, lacpp);
lacp_disable_collecting(lacpp);
lacp_sm_assert_ntt(lacpp);
#endif
break;
case LACP_MUX_ATTACHED:
lacp_port_attached(lsc, lacpp);
lacp_disable_collecting(lacpp);
lacp_sm_assert_ntt(lacpp);
break;
case LACP_MUX_COLLECTING:
lacp_enable_collecting(lacpp);
lacp_disable_distributing(lsc, lacpp);
lacp_sm_assert_ntt(lacpp);
break;
case LACP_MUX_DISTRIBUTING:
lacp_enable_distributing(lsc, lacpp);
break;
case LACP_MUX_INIT:
default:
panic("%s: unknown state", ifp->if_xname);
}
LACP_DPRINTF((lsc, lacpp, "mux_state %d -> %d\n",
lacpp->lp_mux_state, new_state));
lacpp->lp_mux_state = new_state;
return 0;
}
static void
lacp_sm_mux(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_aggregator *la __diagused;
enum lacp_mux_state next_state;
enum lacp_selected selected;
bool p_sync, p_collecting;
p_sync = ISSET(lacpp->lp_partner.lpi_state, LACP_STATE_SYNC);
p_collecting = ISSET(lacpp->lp_partner.lpi_state,
LACP_STATE_COLLECTING);
do {
next_state = lacpp->lp_mux_state;
la = lacpp->lp_aggregator;
selected = lacpp->lp_selected;
KASSERT(la != NULL ||
lacpp->lp_mux_state == LACP_MUX_DETACHED);
switch (lacpp->lp_mux_state) {
case LACP_MUX_DETACHED:
if (selected != LACP_UNSELECTED)
next_state = LACP_MUX_WAITING;
break;
case LACP_MUX_WAITING:
KASSERTMSG((lacpp->lp_pending > 0 ||
!LACP_TIMER_ISARMED(lacpp, LACP_TIMER_WAIT_WHILE)),
"lp_pending=%d, timer=%d", lacpp->lp_pending,
!LACP_TIMER_ISARMED(lacpp, LACP_TIMER_WAIT_WHILE));
if (selected == LACP_UNSELECTED) {
next_state = LACP_MUX_DETACHED;
} else if (lacpp->lp_pending == 0) {
if (selected == LACP_SELECTED) {
next_state = LACP_MUX_ATTACHED;
} else if (selected == LACP_STANDBY) {
next_state = LACP_MUX_STANDBY;
} else {
next_state = LACP_MUX_DETACHED;
}
}
break;
case LACP_MUX_STANDBY:
if (selected == LACP_SELECTED) {
next_state = LACP_MUX_ATTACHED;
} else if (selected != LACP_STANDBY) {
next_state = LACP_MUX_DETACHED;
}
break;
case LACP_MUX_ATTACHED:
if (selected != LACP_SELECTED) {
if (selected == LACP_STANDBY)
LAGG_LOG(lsc->lsc_softc, LOG_INFO,
"detaching %s\n",
LACP_PORT_XNAME(lacpp));
next_state = LACP_MUX_DETACHED;
} else if (lacp_isactive(lsc, lacpp) && p_sync) {
next_state = LACP_MUX_COLLECTING;
}
break;
case LACP_MUX_COLLECTING:
if (selected != LACP_SELECTED ||
!lacp_isactive(lsc, lacpp)
|| !p_sync) {
next_state = LACP_MUX_ATTACHED;
} else if (p_collecting) {
next_state = LACP_MUX_DISTRIBUTING;
}
break;
case LACP_MUX_DISTRIBUTING:
if (selected != LACP_SELECTED ||
!lacp_isactive(lsc, lacpp)
|| !p_sync || !p_collecting) {
next_state = LACP_MUX_COLLECTING;
LACP_DPRINTF((lsc, lacpp,
"Interface stopped DISTRIBUTING,"
" possible flapping\n"));
}
break;
case LACP_MUX_INIT:
default:
panic("%s: unknown state",
lsc->lsc_softc->sc_if.if_xname);
}
} while (lacp_set_mux(lsc, lacpp, next_state) == 0);
}
static bool
lacp_aggregator_is_match(struct lacp_aggregator_systemid *a,
struct lacp_aggregator_systemid *b)
{
if (a->sid_prio != b->sid_prio)
return false;
if (a->sid_key != b->sid_key)
return false;
if (memcmp(a->sid_mac, b->sid_mac, sizeof(a->sid_mac)) != 0)
return false;
return true;
}
static void
lacp_selected_update(struct lacp_softc *lsc, struct lacp_aggregator *la)
{
struct lacp_port *lacpp;
enum lacp_selected next_selected;
const char *msg;
size_t nselected;
uint64_t linkspeed;
KASSERT(LACP_LOCKED(lsc));
lacpp = LIST_FIRST(&la->la_ports);
if (lacpp == NULL)
return;
linkspeed = lacpp->lp_linkspeed;
nselected = 0;
LIST_FOREACH(lacpp, &la->la_ports, lp_entry_la) {
if (lacpp->lp_selected == LACP_UNSELECTED)
continue;
next_selected = LACP_SELECTED;
msg = " is selected";
if (nselected >= lsc->lsc_max_ports) {
next_selected = LACP_STANDBY;
msg = " is standby because of too many active ports";
}
if (!lsc->lsc_multi_linkspeed &&
linkspeed != lacpp->lp_linkspeed) {
next_selected = LACP_STANDBY;
msg = " is standby because of link speed mismatch";
}
if (lacpp->lp_selected != next_selected) {
lacpp->lp_selected = next_selected;
LAGG_LOG(lsc->lsc_softc, LOG_INFO,
"%s%s\n", LACP_PORT_XNAME(lacpp), msg);
}
if (lacpp->lp_selected == LACP_SELECTED)
nselected++;
}
}
static void
lacp_select(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_aggregator *la;
struct lacp_aggregator_systemid *sid;
struct lacp_port *lacpp0;
char buf[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
if (lacpp->lp_aggregator != NULL)
return;
/* If we haven't heard from our peer, skip this step. */
if (ISSET(lacpp->lp_actor.lpi_state, LACP_STATE_DEFAULTED))
return
KASSERT(!LACP_TIMER_ISARMED(lacpp, LACP_TIMER_WAIT_WHILE));
sid = &lacpp->lp_aggregator_sidbuf;
TAILQ_FOREACH(la, &lsc->lsc_aggregators, la_q) {
if (lacp_aggregator_is_match(&la->la_sid, sid))
break;
}
if (la == NULL) {
la = kmem_zalloc(sizeof(*la), KM_NOSLEEP);
if (la == NULL) {
LACP_DPRINTF((lsc, lacpp,
"couldn't allocate aggregator\n"));
/* will retry the next tick. */
return;
}
LIST_INIT(&la->la_ports);
la->la_sid = *sid;
TAILQ_INSERT_TAIL(&lsc->lsc_aggregators, la, la_q);
LACP_DPRINTF((lsc, lacpp, "a new aggregator created\n"));
} else {
LACP_DPRINTF((lsc, lacpp, "aggregator found\n"));
}
KASSERT(la != NULL);
LACP_AGGREGATOR_STR(la, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "aggregator lagid=%s\n", buf));
lacpp->lp_aggregator = la;
lacpp->lp_selected = LACP_READY;
LIST_FOREACH(lacpp0, &la->la_ports, lp_entry_la) {
if (lacp_port_priority_max(lacpp0, lacpp) == lacpp) {
LIST_INSERT_BEFORE(lacpp0, lacpp, lp_entry_la);
break;
}
if (LIST_NEXT(lacpp0, lp_entry_la) == NULL) {
LIST_INSERT_AFTER(lacpp0, lacpp, lp_entry_la);
break;
}
}
if (lacpp0 == NULL)
LIST_INSERT_HEAD(&la->la_ports, lacpp, lp_entry_la);
lacp_selected_update(lsc, la);
}
static void
lacp_unselect(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct lacp_aggregator *la;
char buf[LACP_SYSTEMIDSTR_LEN] __LACPDEBUGUSED;
bool remove_actaggr;
KASSERT(LACP_LOCKED(lsc));
KASSERT(!LACP_TIMER_ISARMED(lacpp, LACP_TIMER_WAIT_WHILE));
la = lacpp->lp_aggregator;
lacpp->lp_selected = LACP_UNSELECTED;
if (la == NULL)
return;
KASSERT(!LIST_EMPTY(&la->la_ports));
LACP_AGGREGATOR_STR(la, buf, sizeof(buf));
LACP_DPRINTF((lsc, lacpp, "unselect aggregator lagid=%s\n", buf));
LIST_REMOVE(lacpp, lp_entry_la);
lacpp->lp_aggregator = NULL;
if (LIST_EMPTY(&la->la_ports)) {
remove_actaggr = false;
if (la == lsc->lsc_aggregator) {
LACP_DPRINTF((lsc, NULL, "remove active aggregator\n"));
lsc->lsc_aggregator = NULL;
remove_actaggr = true;
}
TAILQ_REMOVE(&lsc->lsc_aggregators, la, la_q);
kmem_free(la, sizeof(*la));
if (remove_actaggr)
lacp_select_active_aggregator(lsc);
} else {
lacp_selected_update(lsc, la);
}
}
static void
lacp_suppress_distributing(struct lacp_softc *lsc)
{
struct lacp_aggregator *la;
struct lacp_port *lacpp;
bool marker_scheduled;
KASSERT(LACP_LOCKED(lsc));
la = lsc->lsc_aggregator;
marker_scheduled = false;
LIST_FOREACH(lacpp, &la->la_ports, lp_entry_la) {
if (ISSET(lacpp->lp_actor.lpi_state,
LACP_STATE_DISTRIBUTING)) {
lagg_workq_add(lsc->lsc_workq,
&lacpp->lp_work_marker);
marker_scheduled = true;
}
}
lsc->lsc_suppress_distributing = marker_scheduled;
LACP_PTIMER_ARM(lsc, LACP_PTIMER_DISTRIBUTING,
LACP_TRANSIT_DELAY);
}
static void
lacp_distributing_timer(struct lacp_softc *lsc)
{
KASSERT(LACP_LOCKED(lsc));
if (lsc->lsc_suppress_distributing) {
LACP_DPRINTF((lsc, NULL,
"disable suppress distributing\n"));
lsc->lsc_suppress_distributing = false;
}
}
static struct mbuf *
lacp_markerdu_mbuf(struct lacp_softc *lsc, struct lacp_port *lacpp)
{
struct ifnet *ifp_port;
struct mbuf *m;
struct markerdu *mdu;
struct markerdu_info *mi;
KASSERT(LACP_LOCKED(lsc));
ifp_port = lacpp->lp_laggport->lp_ifp;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL) {
lsc->lsc_mgethdr_failed.ev_count++;
return NULL;
}
m->m_pkthdr.len = m->m_len = sizeof(*mdu);
m_reset_rcvif(m);
mdu = mtod(m, struct markerdu *);
memset(mdu, 0, sizeof(*mdu));
m->m_flags |= M_MCAST;
memcpy(mdu->mdu_eh.ether_dhost, ethermulticastaddr_slowprotocols,
ETHER_ADDR_LEN);
memcpy(mdu->mdu_eh.ether_shost, CLLADDR(ifp_port->if_sadl),
ETHER_ADDR_LEN);
mdu->mdu_eh.ether_type = ntohs(ETHERTYPE_SLOWPROTOCOLS);
mdu->mdu_sph.sph_subtype = SLOWPROTOCOLS_SUBTYPE_MARKER;
mdu->mdu_sph.sph_version = 1;
mi = &mdu->mdu_info;
tlv_set(&mdu->mdu_tlv_info, MARKER_TYPE_INFO,
sizeof(*mi));
mi->mi_rq_port = lacpp->lp_actor.lpi_portno;
mi->mi_rq_xid = htonl(lacpp->lp_marker_xid);
memcpy(mi->mi_rq_system, lsc->lsc_system_mac, LACP_MAC_LEN);
mdu->mdu_tlv_term.tlv_type = MARKER_TYPE_TERMINATE;
mdu->mdu_tlv_term.tlv_length = 0;
return m;
}
static void
lacp_marker_work(struct lagg_work *lw, void *xlsc)
{
struct lacp_softc *lsc;
struct lacp_port *lacpp;
struct lagg_port *lp;
struct markerdu *mdu;
struct mbuf *m;
struct psref psref;
int bound;
lsc = xlsc;
lacpp = container_of(lw, struct lacp_port, lp_work_marker);
LACP_LOCK(lsc);
lacpp->lp_marker_xid++;
m = lacp_markerdu_mbuf(lsc, lacpp);
if (m == NULL) {
LACP_UNLOCK(lsc);
return;
}
SET(lacpp->lp_flags, LACP_PORT_MARK);
lp = lacpp->lp_laggport;
bound = curlwp_bind();
lagg_port_getref(lp, &psref);
LACP_UNLOCK(lsc);
if (LACP_ISDUMPING(lsc)) {
lacp_dprintf(lsc, lacpp, "markerdu transmit\n");
mdu = mtod(m, struct markerdu *);
lacp_dump_markertlv(&mdu->mdu_info, NULL);
}
lagg_port_xmit(lp, m);
lagg_port_putref(lp, &psref);
curlwp_bindx(bound);
}
static void
lacp_dump_lacpdutlv(const struct lacpdu_peerinfo *pi_actor,
const struct lacpdu_peerinfo *pi_partner,
const struct lacpdu_collectorinfo *lci)
{
char str[LACP_STATESTR_LEN];
if (pi_actor != NULL) {
lacp_peerinfo_idstr(pi_actor, str, sizeof(str));
printf("actor=%s\n", str);
lacp_state_str(pi_actor->lpi_state,
str, sizeof(str));
printf("actor.state=%s portno=%d portprio=0x%04x\n",
str,
ntohs(pi_actor->lpi_port_no),
ntohs(pi_actor->lpi_port_prio));
} else {
printf("no actor info\n");
}
if (pi_partner != NULL) {
lacp_peerinfo_idstr(pi_partner, str, sizeof(str));
printf("partner=%s\n", str);
lacp_state_str(pi_partner->lpi_state,
str, sizeof(str));
printf("partner.state=%s portno=%d portprio=0x%04x\n",
str,
ntohs(pi_partner->lpi_port_no),
ntohs(pi_partner->lpi_port_prio));
} else {
printf("no partner info\n");
}
if (lci != NULL) {
printf("maxdelay=%d\n", ntohs(lci->lci_maxdelay));
} else {
printf("no collector info\n");
}
}
static void
lacp_dump_markertlv(const struct markerdu_info *mi_info,
const struct markerdu_info *mi_res)
{
if (mi_info != NULL) {
printf("marker info: port=%d, sys=%s, id=%u\n",
ntohs(mi_info->mi_rq_port),
ether_sprintf(mi_info->mi_rq_system),
ntohl(mi_info->mi_rq_xid));
}
if (mi_res != NULL) {
printf("marker resp: port=%d, sys=%s, id=%u\n",
ntohs(mi_res->mi_rq_port),
ether_sprintf(mi_res->mi_rq_system),
ntohl(mi_res->mi_rq_xid));
}
}
/*
* lacp_linkstate:
* callback on link state changed.
* enable, disable or reset LACP processing on the physical port.
*/
static void
lacp_linkstate(struct lagg_proto_softc *xlsc, struct lagg_port *lp)
{
IFNET_ASSERT_UNLOCKED(lp->lp_ifp);
IFNET_LOCK(lp->lp_ifp);
lacp_linkstate_ifnet_locked(xlsc, lp);
IFNET_UNLOCK(lp->lp_ifp);
}
static void
lacp_linkspeed_work(struct lagg_work *lw __unused, void *xlsc)
{
struct lacp_softc *lsc = (struct lacp_softc *)xlsc;
struct lagg_softc *sc = lsc->lsc_softc;
struct lacp_portmap *pm;
struct lagg_port *lp;
struct lacp_port *lacpp;
uint64_t linkspeed;
size_t act, i;
linkspeed = 0;
LACP_LOCK(lsc);
act = LACP_PORTMAP_ACTIVE(lsc);
pm = &lsc->lsc_portmaps[act];
for (i = 0; i < pm->pm_count; i++) {
lp = pm->pm_ports[i];
lacpp = lp->lp_proto_ctx;
linkspeed = MAX(linkspeed, lacpp->lp_linkspeed);
}
LACP_UNLOCK(lsc);
LAGG_LOCK(sc);
lagg_set_linkspeed(sc, linkspeed);
LAGG_UNLOCK(sc);
}
