/*      $NetBSD: if_agr.c,v 1.57 2024/06/29 12:11:12 riastradh Exp $    */

/*-
 * Copyright (c)2005 YAMAMOTO Takashi,
 * 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_agr.c,v 1.57 2024/06/29 12:11:12 riastradh Exp $");

#ifdef _KERNEL_OPT
#include "opt_inet.h"
#endif

#include <sys/param.h>
#include <sys/callout.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/sockio.h>
#include <sys/proc.h>   /* XXX for curproc */
#include <sys/kauth.h>
#include <sys/xcall.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/atomic.h>

#include <net/bpf.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/if_ether.h>
#include <net/if_vlanvar.h>

#if defined(INET)
#include <netinet/in.h>
#include <netinet/if_inarp.h>
#endif

#include <net/agr/if_agrvar.h>
#include <net/agr/if_agrvar_impl.h>
#include <net/agr/if_agrioctl.h>
#include <net/agr/if_agrsubr.h>
#include <net/agr/if_agrethervar.h>

#include "ioconf.h"

static int agr_clone_create(struct if_clone *, int);
static int agr_clone_destroy(struct ifnet *);
static void agr_start(struct ifnet *);
static int agr_setconfig(struct agr_softc *, const struct agrreq *);
static int agr_getconfig(struct agr_softc *, struct agrreq *);
static int agr_getportlist(struct agr_softc *, struct agrreq *);
static int agr_addport(struct ifnet *, struct ifnet *);
static int agr_remport(struct ifnet *, struct ifnet *);
static int agrreq_copyin(const void *, struct agrreq *);
static int agrreq_copyout(void *, struct agrreq *);
static int agr_ioctl(struct ifnet *, u_long, void *);
static struct agr_port *agr_select_tx_port(struct agr_softc *, struct mbuf *);
static int agr_ioctl_filter(struct ifnet *, u_long, void *);
static void agr_reset_iftype(struct ifnet *);
static int agr_config_promisc(struct agr_softc *);
static int agrport_config_promisc_callback(struct agr_port *, void *);
static int agrport_config_promisc(struct agr_port *, bool);
static int agrport_cleanup(struct agr_softc *, struct agr_port *);

static int agr_enter(struct agr_softc *);
static void agr_exit(struct agr_softc *);
static int agr_pause(struct agr_softc *);
static void agr_evacuate(struct agr_softc *);
static void agr_sync(void);
static void agr_ports_lock(struct agr_softc *);
static void agr_ports_unlock(struct agr_softc *);
static bool agr_ports_enter(struct agr_softc *);
static void agr_ports_exit(struct agr_softc *);

static struct if_clone agr_cloner =
    IF_CLONE_INITIALIZER("agr", agr_clone_create, agr_clone_destroy);

static u_int agr_count;

/*
 * EXPORTED FUNCTIONS
 */

/*
 * agrattch: device attach routine.
 */

void
agrattach(int count)
{

        /*
         * Nothing to do here, initialization is handled by the
         * module initialization code in agrinit() below).
         */
}

static void
agrinit(void)
{
        if_clone_attach(&agr_cloner);
}

static int
agrdetach(void)
{
        int error = 0;

        if (agr_count != 0)
                error = EBUSY;

        if (error == 0)
                if_clone_detach(&agr_cloner);

        return error;
}

/*
 * agr_input: frame collector.
 */

void
agr_input(struct ifnet *ifp_port, struct mbuf *m)
{
        struct ethercom *ec = (struct ethercom *)ifp_port;
        struct agr_port *port;
        struct ifnet *ifp;

        port = ifp_port->if_lagg;
        KASSERT(port);
        ifp = port->port_agrifp;
        if ((port->port_flags & AGRPORT_COLLECTING) == 0) {
                m_freem(m);
                if_statinc(ifp, if_ierrors);
                return;
        }

        m_set_rcvif(m, ifp);

        /*
         * If VLANs are configured on the interface, check to
         * see if the device performed the decapsulation and
         * provided us with the tag.
         */
        if (ec->ec_nvlans && vlan_has_tag(m) &&
            EVL_VLANOFTAG(vlan_get_tag(m)) != 0) {
                MODULE_HOOK_CALL(if_vlan_vlan_input_hook, (ifp, m),
                    m, m);
                if (m == NULL)
                        return;
        }

        if_percpuq_enqueue(ifp->if_percpuq, m);
}

/*
 * EXPORTED AGR-INTERNAL FUNCTIONS
 */

void
agr_lock(struct agr_softc *sc)
{

        mutex_enter(&sc->sc_lock);
}

void
agr_unlock(struct agr_softc *sc)
{

        mutex_exit(&sc->sc_lock);
}

/*
 * agr_xmit_frame: transmit a pre-built frame.
 */

int
agr_xmit_frame(struct ifnet *ifp_port, struct mbuf *m)
{
        int error;

        struct sockaddr_storage dst0;
        struct sockaddr *dst;
        int hdrlen;

        /*
         * trim off link level header and let if_output re-add it.
         * XXX better to introduce an API to transmit pre-built frames.
         */

        hdrlen = ifp_port->if_hdrlen;
        if (m->m_pkthdr.len < hdrlen) {
                m_freem(m);
                return EINVAL;
        }
        memset(&dst0, 0, sizeof(dst0));
        dst = (struct sockaddr *)&dst0;
        dst->sa_family = pseudo_AF_HDRCMPLT;
        dst->sa_len = hdrlen;
        m_copydata(m, 0, hdrlen, &dst->sa_data);
        m_adj(m, hdrlen);

        error = if_output_lock(ifp_port, ifp_port, m, dst, NULL);

        return error;
}

int
agrport_ioctl(struct agr_port *port, u_long cmd, void *arg)
{
        struct ifnet *ifp = port->port_ifp;

        KASSERT(ifp->if_lagg == (void *)port);
        KASSERT(ifp->if_ioctl == agr_ioctl_filter);

        return (*port->port_ioctl)(ifp, cmd, arg);
}

/*
 * INTERNAL FUNCTIONS
 */
/*
 * Check for vlan attach/detach.
 * ec->ec_nvlans is directly modified by the vlan driver.
 * We keep a local count in sc (sc->sc_nvlans) to detect
 * when the vlan driver attaches or detaches.
 * Note the agr interface must be up for this to work.
 */
static void
agr_vlan_check(struct ifnet *ifp, struct agr_softc *sc)
{
        struct ethercom *ec = (void *)ifp;

        /* vlans in sync? */
        if (sc->sc_nvlans == ec->ec_nvlans) {
                return;
        }

        if (sc->sc_nvlans == 0) {
                /* vlan added */
                agr_port_foreach(sc, agr_vlan_add, NULL);
                sc->sc_nvlans = ec->ec_nvlans;
        } else if (ec->ec_nvlans == 0) {
                bool force_zero = false;
                /* vlan removed */
                agr_port_foreach(sc, agr_vlan_del, &force_zero);
                sc->sc_nvlans = 0;
        }
}

static int
agr_clone_create(struct if_clone *ifc, int unit)
{
        struct agr_softc *sc;
        struct ifnet *ifp;
        int error;

        sc = agr_alloc_softc();
        error = agrtimer_init(sc);
        if (error) {
                agr_free_softc(sc);
                return error;
        }
        TAILQ_INIT(&sc->sc_ports);
        mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NET);
        mutex_init(&sc->sc_entry_mtx, MUTEX_DEFAULT, IPL_NONE);
        cv_init(&sc->sc_insc_cv, "agrsoftc");
        cv_init(&sc->sc_ports_cv, "agrports");
        ifp = &sc->sc_if;
        snprintf(ifp->if_xname, sizeof(ifp->if_xname), "%s%d",
            ifc->ifc_name, unit);

        ifp->if_softc = sc;
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
        ifp->if_start = agr_start;
        ifp->if_ioctl = agr_ioctl;
        IFQ_SET_READY(&ifp->if_snd);

        if_attach(ifp);

        agr_reset_iftype(ifp);
        atomic_inc_uint(&agr_count);
        return 0;
}

static void
agr_reset_iftype(struct ifnet *ifp)
{

        ifp->if_type = IFT_OTHER;
        ifp->if_dlt = DLT_NULL;
        ifp->if_addrlen = 0;
        if_alloc_sadl(ifp);
}

static int
agr_clone_destroy(struct ifnet *ifp)
{
        struct agr_softc *sc = ifp->if_softc;
        int error;

        if ((error = agr_pause(sc)) != 0)
                return error;

        if_detach(ifp);
        agrtimer_destroy(sc);
        /* Now that the ifnet has been detached, and our
         * component ifnets are disconnected, there can be
         * no new threads in the softc.  Wait for every
         * thread to get out of the softc.
         */
        agr_evacuate(sc);
        mutex_destroy(&sc->sc_lock);
        mutex_destroy(&sc->sc_entry_mtx);
        cv_destroy(&sc->sc_insc_cv);
        cv_destroy(&sc->sc_ports_cv);
        agr_free_softc(sc);

        atomic_dec_uint(&agr_count);
        return 0;
}

static struct agr_port *
agr_select_tx_port(struct agr_softc *sc, struct mbuf *m)
{

        return (*sc->sc_iftop->iftop_select_tx_port)(sc, m);
}

#if 0 /* "generic" version */
static struct agr_port *
agr_select_tx_port(struct agr_softc *sc, struct mbuf *m)
{
        struct agr_port *port;
        uint32_t hash;

        hash = (*sc->sc_iftop->iftop_hashmbuf)(sc, m);
        if (sc->sc_nports == 0)
                return NULL;
        hash %= sc->sc_nports;
        port = TAILQ_FIRST(&sc->sc_ports);
        KASSERT(port != NULL);
        while (hash--) {
                port = TAILQ_NEXT(port, port_q);
                KASSERT(port != NULL);
        }

        return port;
}
#endif /* 0 */

static void
agr_start(struct ifnet *ifp)
{
        struct agr_softc *sc = ifp->if_softc;
        struct mbuf *m;

        AGR_LOCK(sc);

        while (/* CONSTCOND */ 1) {
                struct agr_port *port;

                IFQ_DEQUEUE(&ifp->if_snd, m);
                if (m == NULL) {
                        break;
                }
                bpf_mtap(ifp, m, BPF_D_OUT);
                port = agr_select_tx_port(sc, m);
                net_stat_ref_t nsr = IF_STAT_GETREF(ifp);
                if (port) {
                        int error;

                        error = agr_xmit_frame(port->port_ifp, m);
                        if (error) {
                                if_statinc_ref(ifp, nsr, if_oerrors);
                        } else {
                                if_statinc_ref(ifp, nsr, if_opackets);
                        }
                } else {
                        m_freem(m);
                        if_statinc_ref(ifp, nsr, if_oerrors);
                }
                IF_STAT_PUTREF(ifp);
        }

        AGR_UNLOCK(sc);
}

static int
agr_setconfig(struct agr_softc *sc, const struct agrreq *ar)
{
        struct ifnet *ifp = &sc->sc_if;
        int cmd = ar->ar_cmd;
        struct ifnet *ifp_port;
        int error = 0;
        char ifname[IFNAMSIZ];

        memset(ifname, 0, sizeof(ifname));
        error = copyin(ar->ar_buf, ifname,
            MIN(ar->ar_buflen, sizeof(ifname) - 1));
        if (error) {
                return error;
        }
        ifp_port = ifunit(ifname);
        if (ifp_port == NULL) {
                return ENOENT;
        }

        agr_ports_lock(sc);
        switch (cmd) {
        case AGRCMD_ADDPORT:
                error = agr_addport(ifp, ifp_port);
                break;

        case AGRCMD_REMPORT:
                error = agr_remport(ifp, ifp_port);
                break;

        default:
                error = EINVAL;
                break;
        }
        agr_ports_unlock(sc);

        return error;
}

static int
agr_getportlist(struct agr_softc *sc, struct agrreq *ar)
{
        struct agr_port *port;
        struct agrportlist apl;
        struct agrportinfo api;
        char *cp = ar->ar_buf;
        size_t bufleft = (cp == NULL) ? 0 : ar->ar_buflen;
        int error;

        if (cp != NULL) {
                memset(&apl, 0, sizeof(apl));
                memset(&api, 0, sizeof(api));

                if (bufleft < sizeof(apl)) {
                        return E2BIG;
                }
                apl.apl_nports = sc->sc_nports;
                error = copyout(&apl, cp, sizeof(apl));
                if (error) {
                        return error;
                }
                cp += sizeof(apl);
        }
        bufleft -= sizeof(apl);

        TAILQ_FOREACH(port, &sc->sc_ports, port_q) {
                if (cp != NULL) {
                        if (bufleft < sizeof(api)) {
                                return E2BIG;
                        }
                        memcpy(api.api_ifname, port->port_ifp->if_xname,
                            sizeof(api.api_ifname));
                        api.api_flags = 0;
                        if (port->port_flags & AGRPORT_COLLECTING) {
                                api.api_flags |= AGRPORTINFO_COLLECTING;
                        }
                        if (port->port_flags & AGRPORT_DISTRIBUTING) {
                                api.api_flags |= AGRPORTINFO_DISTRIBUTING;
                        }
                        error = copyout(&api, cp, sizeof(api));
                        if (error) {
                                return error;
                        }
                        cp += sizeof(api);
                }
                bufleft -= sizeof(api);
        }

        if (cp == NULL) {
                ar->ar_buflen = -bufleft; /* necessary buffer size */
        }

        return 0;
}

static int
agr_getconfig(struct agr_softc *sc, struct agrreq *ar)
{
        int cmd = ar->ar_cmd;
        int error;

        (void)agr_ports_enter(sc);
        switch (cmd) {
        case AGRCMD_PORTLIST:
                error = agr_getportlist(sc, ar);
                break;

        default:
                error = EINVAL;
                break;
        }
        agr_ports_exit(sc);

        return error;
}

static int
agr_addport(struct ifnet *ifp, struct ifnet *ifp_port)
{
        const struct ifaddr *ifa;
        struct agr_softc *sc = ifp->if_softc;
        struct agr_port *port = NULL;
        int error = 0;
        int s;

        if (ifp_port->if_ioctl == NULL) {
                error = EOPNOTSUPP;
                goto out;
        }

        if (ifp_port->if_lagg) {
                error = EBUSY;
                goto out;
        }

        if (ifp_port->if_start == agr_start) {
                error = EINVAL;
                goto out;
        }

        port = malloc(sizeof(*port) + ifp_port->if_addrlen, M_DEVBUF,
            M_WAITOK | M_ZERO);
        if (port == NULL) {
                error = ENOMEM;
                goto out;
        }
        port->port_flags = AGRPORT_LARVAL;

        s = pserialize_read_enter();
        IFADDR_READER_FOREACH(ifa, ifp_port) {
                if (ifa->ifa_addr->sa_family != AF_LINK) {
                        pserialize_read_exit(s);
                        error = EBUSY;
                        goto out;
                }
        }
        pserialize_read_exit(s);

        if (sc->sc_nports == 0) {
                switch (ifp_port->if_type) {
                case IFT_ETHER:
                        sc->sc_iftop = &agrether_ops;
                        break;

                default:
                        error = EPROTONOSUPPORT; /* XXX */
                        goto out;
                }

                error = (*sc->sc_iftop->iftop_ctor)(sc, ifp_port);
                if (error)
                        goto out;
                agrtimer_start(sc);
        } else {
                if (ifp->if_type != ifp_port->if_type) {
                        error = EINVAL;
                        goto out;
                }
                if (ifp->if_addrlen != ifp_port->if_addrlen) {
                        error = EINVAL;
                        goto out;
                }
        }

        memcpy(port->port_origlladdr, CLLADDR(ifp_port->if_sadl),
            ifp_port->if_addrlen);

        /*
         * start to modify ifp_port.
         */

        /*
         * XXX this should probably be SIOCALIFADDR but that doesn't 
         * appear to work (ENOTTY). We want to change the mac address
         * of each port to that of the first port. No need for arps 
         * since there are no inet addresses assigned to the ports.
         */
        IFNET_LOCK(ifp_port);
        error = if_addr_init(ifp_port, ifp->if_dl, true);
        IFNET_UNLOCK(ifp_port);

        if (error) {
                printf("%s: if_addr_init error %d\n", __func__, error);
                goto cleanup;
        }
        port->port_flags |= AGRPORT_LADDRCHANGED;

        ifp->if_type = ifp_port->if_type;
        AGR_LOCK(sc);

        port->port_ifp = ifp_port;
        ifp_port->if_lagg = port;
        port->port_agrifp = ifp;
        TAILQ_INSERT_TAIL(&sc->sc_ports, port, port_q);
        sc->sc_nports++;

        port->port_ioctl = ifp_port->if_ioctl;
        ifp_port->if_ioctl = agr_ioctl_filter;

        port->port_flags |= AGRPORT_ATTACHED;

        AGR_UNLOCK(sc);

        error = (*sc->sc_iftop->iftop_portinit)(sc, port);
        if (error) {
                printf("%s: portinit error %d\n", __func__, error);
                goto cleanup;
        }

        agrport_config_promisc(port, (ifp->if_flags & IFF_PROMISC) != 0);
        error = (*sc->sc_iftop->iftop_configmulti_port)(sc, port, true);
        if (error) {
                printf("%s: configmulti error %d\n", __func__, error);
                goto cleanup;
        }

        AGR_LOCK(sc);
        port->port_flags &= ~AGRPORT_LARVAL;
        AGR_UNLOCK(sc);
out:
        if (error && port) {
                free(port, M_DEVBUF);
        }
        if (error == 0)
                ifp->if_flags |= IFF_RUNNING;
        return error;

cleanup:
        if (agrport_cleanup(sc, port)) {
                printf("%s: error on cleanup\n", __func__);

                port = NULL; /* XXX */
        }

        if (sc->sc_nports == 0) {
                KASSERT(TAILQ_EMPTY(&sc->sc_ports));
                agrtimer_stop(sc);
                (*sc->sc_iftop->iftop_dtor)(sc);
                sc->sc_iftop = NULL;
                agr_reset_iftype(ifp);
        } else {
                KASSERT(!TAILQ_EMPTY(&sc->sc_ports));
        }

        goto out;
}

static int
agr_remport(struct ifnet *ifp, struct ifnet *ifp_port)
{
        struct agr_softc *sc = ifp->if_softc;
        struct agr_port *port;
        int error = 0;

        if (ifp_port->if_lagg == NULL) {
                error = ENOENT;
                return error;
        }

        port = ifp_port->if_lagg;
        if (port->port_agrifp != ifp) {
                error = EINVAL;
                return error;
        }

        KASSERT(sc->sc_nports > 0);

        AGR_LOCK(sc);
        port->port_flags |= AGRPORT_DETACHING;
        AGR_UNLOCK(sc);

        error = (*sc->sc_iftop->iftop_portfini)(sc, port);
        if (error) {
                /* XXX XXX */
                printf("%s: portfini error %d\n", __func__, error);
                goto out;
        }

        error = (*sc->sc_iftop->iftop_configmulti_port)(sc, port, false);
        if (error) {
                /* XXX XXX */
                printf("%s: configmulti_port error %d\n", __func__, error);
                goto out;
        }

        error = agrport_cleanup(sc, port);
        if (error) {
                /* XXX XXX */
                printf("%s: agrport_cleanup error %d\n", __func__, error);
                goto out;
        }

        free(port, M_DEVBUF);

out:
        if (sc->sc_nports == 0) {
                KASSERT(TAILQ_EMPTY(&sc->sc_ports));
                agrtimer_stop(sc);
                (*sc->sc_iftop->iftop_dtor)(sc);
                sc->sc_iftop = NULL;
                /* XXX should purge all addresses? */
                agr_reset_iftype(ifp);
        } else {
                KASSERT(!TAILQ_EMPTY(&sc->sc_ports));
        }

        return error;
}

static int
agrport_cleanup(struct agr_softc *sc, struct agr_port *port)
{
        struct ifnet *ifp_port = port->port_ifp;
        int error;
        int result = 0;

        error = agrport_config_promisc(port, false);
        if (error) {
                printf("%s: config_promisc error %d\n", __func__, error);
                result = error;
        }

        if ((port->port_flags & AGRPORT_LADDRCHANGED)) {
#if 0
                memcpy(LLADDR(ifp_port->if_sadl), port->port_origlladdr,
                    ifp_port->if_addrlen);
                if (ifp_port->if_init != NULL) {
                        error = if_init(ifp_port);
                }
#else
                union {
                        struct sockaddr sa;
                        struct sockaddr_dl sdl;
                        struct sockaddr_storage ss;
                } u;
                struct ifaddr ifa;

                sockaddr_dl_init(&u.sdl, sizeof(u.ss),
                    0, ifp_port->if_type, NULL, 0,
                    port->port_origlladdr, ifp_port->if_addrlen);
                memset(&ifa, 0, sizeof(ifa));
                ifa.ifa_addr = &u.sa;
                error = agrport_ioctl(port, SIOCINITIFADDR, &ifa);
#endif
                if (error) {
                        printf("%s: if_init error %d\n", __func__, error);
                        result = error;
                } else {
                        port->port_flags &= ~AGRPORT_LADDRCHANGED;
                }
        }

        AGR_LOCK(sc);
        if ((port->port_flags & AGRPORT_ATTACHED)) {
                ifp_port->if_lagg = NULL;

                TAILQ_REMOVE(&sc->sc_ports, port, port_q);
                sc->sc_nports--;

                KASSERT(ifp_port->if_ioctl == agr_ioctl_filter);
                ifp_port->if_ioctl = port->port_ioctl;

                port->port_flags &= ~AGRPORT_ATTACHED;
        }
        AGR_UNLOCK(sc);

        return result;
}

static int
agr_ioctl_multi(struct ifnet *ifp, u_long cmd, struct ifreq *ifr)
{
        struct agr_softc *sc = ifp->if_softc;
        int error;

        error = (*sc->sc_iftop->iftop_configmulti_ifreq)(sc, ifr,
            (cmd == SIOCADDMULTI));

        return error;
}

/*
 * XXX an incomplete hack; can't filter ioctls handled ifioctl().
 *
 * the intention here is to prevent operations on underlying interfaces
 * so that their states are not changed in the way that agr(4) doesn't
 * expect.  cf. the BUGS section in the agr(4) manual page.
 */
static int
agr_ioctl_filter(struct ifnet *ifp, u_long cmd, void *arg)
{
        struct agr_port *port = ifp->if_lagg;
        int error;

        KASSERT(port);

        switch (cmd) {
        case SIOCADDMULTI: /* add m'cast addr */
        case SIOCAIFADDR: /* add/chg IF alias */
        case SIOCALIFADDR: /* add IF addr */
        case SIOCDELMULTI: /* del m'cast addr */
        case SIOCDIFADDR: /* delete IF addr */
        case SIOCDIFPHYADDR: /* delete gif addrs */
        case SIOCDLIFADDR: /* delete IF addr */
        case SIOCINITIFADDR:
        case SIOCSDRVSPEC: /* set driver-specific parameters */
        case SIOCSIFADDR: /* set ifnet address */
        case SIOCSIFBRDADDR: /* set broadcast addr */
        case SIOCSIFDSTADDR: /* set p-p address */
        case SIOCSIFGENERIC: /* generic IF set op */
        case SIOCSIFMEDIA: /* set net media */
        case SIOCSIFMETRIC: /* set IF metric */
        case SIOCSIFMTU: /* set ifnet mtu */
        case SIOCSIFNETMASK: /* set net addr mask */
        case SIOCSIFPHYADDR: /* set gif address */
        case SIOCSLIFPHYADDR: /* set gif addrs */
        case SIOCSVH: /* set carp param */
                error = EBUSY;
                break;
        case SIOCSIFCAP: /* XXX */
        case SIOCSIFFLAGS: /* XXX */
        default:
                error = agrport_ioctl(port, cmd, arg);
                break;
        }
        return error;
}

static int
agrreq_copyin(const void *ubuf, struct agrreq *ar)
{
        int error;
                        
        error = copyin(ubuf, ar, sizeof(*ar));
        if (error) {
                return error;
        }

        if (ar->ar_version != AGRREQ_VERSION) {
                return EINVAL;
        }

        return 0;
}

static int
agrreq_copyout(void *ubuf, struct agrreq *ar)
{
        int error;
                        
        KASSERT(ar->ar_version == AGRREQ_VERSION);

        error = copyout(ar, ubuf, sizeof(*ar));
        if (error) {
                return error;
        }

        return 0;
}

/* Make sure that if any interrupt handlers are out of the softc. */
static void
agr_sync(void)
{

        if (!mp_online)
                return;

        xc_barrier(0);
}

static int
agr_pause(struct agr_softc *sc)
{
        int error;

        mutex_enter(&sc->sc_entry_mtx);
        if ((error = sc->sc_noentry) != 0)
                goto out;

        sc->sc_noentry = EBUSY;

        while (sc->sc_insc != 0)
                cv_wait(&sc->sc_insc_cv, &sc->sc_entry_mtx);

        if (sc->sc_nports == 0) {
                sc->sc_noentry = ENXIO;
        } else {
                sc->sc_noentry = 0;
                error = EBUSY;
        }
        cv_broadcast(&sc->sc_insc_cv);
out:
        mutex_exit(&sc->sc_entry_mtx);
        return error;
}

static void
agr_evacuate(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        cv_broadcast(&sc->sc_insc_cv);
        while (sc->sc_insc != 0 || sc->sc_paused != 0)
                cv_wait(&sc->sc_insc_cv, &sc->sc_entry_mtx);
        mutex_exit(&sc->sc_entry_mtx);

        agr_sync();
}

static int
agr_enter(struct agr_softc *sc)
{
        int error;

        mutex_enter(&sc->sc_entry_mtx);
        sc->sc_paused++;
        while ((error = sc->sc_noentry) == EBUSY)
                cv_wait(&sc->sc_insc_cv, &sc->sc_entry_mtx);
        sc->sc_paused--;
        if (error == 0)
                sc->sc_insc++;
        mutex_exit(&sc->sc_entry_mtx);

        return error;
}

static void
agr_exit(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        if (--sc->sc_insc == 0)
                cv_signal(&sc->sc_insc_cv);
        mutex_exit(&sc->sc_entry_mtx);
}

static bool
agr_ports_enter(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        while (sc->sc_wrports)
                cv_wait(&sc->sc_ports_cv, &sc->sc_entry_mtx);
        sc->sc_rdports++;
        mutex_exit(&sc->sc_entry_mtx);

        return true;
}

static void
agr_ports_exit(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        if (--sc->sc_rdports == 0)
                cv_signal(&sc->sc_ports_cv);
        mutex_exit(&sc->sc_entry_mtx);
}

static void
agr_ports_lock(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        while (sc->sc_rdports != 0)
                cv_wait(&sc->sc_ports_cv, &sc->sc_entry_mtx);
        sc->sc_wrports = true;
        mutex_exit(&sc->sc_entry_mtx);
}

static void
agr_ports_unlock(struct agr_softc *sc)
{
        mutex_enter(&sc->sc_entry_mtx);
        sc->sc_wrports = false;
        cv_signal(&sc->sc_ports_cv);
        mutex_exit(&sc->sc_entry_mtx);
}

static int
agr_ioctl(struct ifnet *ifp, const u_long cmd, void *data)
{
        struct agr_softc *sc = ifp->if_softc;
        struct ifreq *ifr = (struct ifreq *)data;
        struct ifaddr *ifa = (struct ifaddr *)data;
        struct agrreq ar;
        int error;
        bool in_ports = false;
        int s;

        if ((error = agr_enter(sc)) != 0)
                return error;

        s = splnet();

        switch (cmd) {
        case SIOCINITIFADDR:
                in_ports = agr_ports_enter(sc);
                if (sc->sc_nports == 0) {
                        error = EINVAL;
                        break;
                }
                ifp->if_flags |= IFF_UP;
                switch (ifa->ifa_addr->sa_family) {
#if defined(INET)
                case AF_INET:
                        arp_ifinit(ifp, ifa);
                        break;
#endif
                default:
                        break;
                }
                break;

#if 0 /* notyet */
        case SIOCSIFMTU:
#endif

        case SIOCSIFFLAGS:
                /*
                 * Check for a change in vlan status.  This ioctl is the
                 * only way we can tell that a vlan has attached or detached.
                 * Note the agr interface must be up.
                 */
                agr_vlan_check(ifp, sc);

                if ((error = ifioctl_common(ifp, cmd, data)) != 0)
                        break;
                agr_config_promisc(sc);
                break;

        case SIOCSETAGR:
                splx(s);
                error = kauth_authorize_network(kauth_cred_get(),
                    KAUTH_NETWORK_INTERFACE,
                    KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd,
                    NULL);
                if (!error) {
                        error = agrreq_copyin(ifr->ifr_data, &ar);
                }
                if (!error) {
                        error = agr_setconfig(sc, &ar);
                }
                s = splnet();
                break;

        case SIOCGETAGR:
                splx(s);
                error = agrreq_copyin(ifr->ifr_data, &ar);
                if (!error) {
                        error = agr_getconfig(sc, &ar);
                }
                if (!error) {
                        error = agrreq_copyout(ifr->ifr_data, &ar);
                }
                s = splnet();
                break;

        case SIOCADDMULTI:
        case SIOCDELMULTI:
                in_ports = agr_ports_enter(sc);
                if (sc->sc_nports == 0)
                        error = EINVAL;
                else
                        error = agr_ioctl_multi(ifp, cmd, ifr);
                break;

        default:
                error = ifioctl_common(ifp, cmd, data);
                break;
        }

        if (in_ports)
                agr_ports_exit(sc);

        splx(s);

        agr_exit(sc);

        return error;
}

static int
agr_config_promisc(struct agr_softc *sc)
{
        int error;

        agr_port_foreach(sc, agrport_config_promisc_callback, &error);

        return error;
}

static int
agrport_config_promisc_callback(struct agr_port *port, void *arg)
{
        struct agr_softc *sc = AGR_SC_FROM_PORT(port);
        int *errorp = arg;
        int error;
        bool promisc;

        promisc = (sc->sc_if.if_flags & IFF_PROMISC) != 0;

        error = agrport_config_promisc(port, promisc);
        if (error) {
                *errorp = error;
        }

        return 0;
}

static int
agrport_config_promisc(struct agr_port *port, bool promisc)
{
        int error;

        if (( promisc && (port->port_flags & AGRPORT_PROMISC) != 0) ||
            (!promisc && (port->port_flags & AGRPORT_PROMISC) == 0)) {
                return 0;
        }

        error = ifpromisc(port->port_ifp, promisc);
        if (error == 0) {
                if (promisc) {
                        port->port_flags |= AGRPORT_PROMISC;
                } else {
                        port->port_flags &= ~AGRPORT_PROMISC;
                }
        }

        return error;
}

/*
 * Module infrastructure
 */
#include <net/if_module.h>

IF_MODULE(MODULE_CLASS_DRIVER, agr, NULL)