xref: /src/sys/net/lagg/if_lagg_lacp.c

/*	$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 <thompsa (at) FreeBSD.org>
 * 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);
}