/*      $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@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);
}