/*      $NetBSD: if_laggproto.h,v 1.20 2023/11/28 05:28:37 yamaguchi Exp $      */

/*
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

#ifndef _NET_LAGG_IF_LAGGPROTO_H_
#define _NET_LAGG_IF_LAGGPROTO_H_

struct lagg_softc;
struct lagg_proto_softc;

#define LAGG_MAX_PORTS  32
#define LAGG_PORT_PRIO  0x8000U

enum lagg_work_state {
        LAGG_WORK_IDLE,
        LAGG_WORK_ENQUEUED,
        LAGG_WORK_STOPPING
};
struct lagg_work {
        struct work      lw_cookie;
        void            (*lw_func)(struct lagg_work *, void *);
        void            *lw_arg;
        int              lw_state;
};

static inline void
lagg_work_set(struct lagg_work *w,
    void (*func)(struct lagg_work *, void *), void *arg)
{

        w->lw_func = func;
        w->lw_arg = arg;
}

struct workqueue *
                lagg_workq_create(const char *, pri_t, int, int);
void            lagg_workq_destroy(struct workqueue *);
void            lagg_workq_add(struct workqueue *, struct lagg_work *);
void            lagg_workq_wait(struct workqueue *, struct lagg_work *);

struct lagg_port {
        struct psref_target      lp_psref;
        struct ifnet            *lp_ifp;        /* physical interface */
        struct lagg_softc       *lp_softc;      /* parent lagg */
        void                    *lp_proto_ctx;
        bool                     lp_ifdetaching;
        bool                     lp_promisc;
        void                    *lp_linkstate_hook;
        void                    *lp_ifdetach_hook;

        uint32_t                 lp_prio;       /* port priority */
        uint32_t                 lp_flags;      /* port flags */

        u_char                   lp_iftype;
        uint8_t                  lp_lladdr[ETHER_ADDR_LEN];
        int                      lp_eccapenable;
        uint64_t                 lp_ifcapenable;
        uint64_t                 lp_mtu;

        int                     (*lp_ioctl)(struct ifnet *, u_long, void *);
        void                    (*lp_input)(struct ifnet *, struct mbuf *);
        int                     (*lp_output)(struct ifnet *, struct mbuf *,
                                    const struct sockaddr *,
                                    const struct rtentry *);

        SIMPLEQ_ENTRY(lagg_port)
                                 lp_entry;
};

struct lagg_proto {
        lagg_proto       pr_num;
        void            (*pr_init)(void);
        void            (*pr_fini)(void);
        int             (*pr_attach)(struct lagg_softc *,
                            struct lagg_proto_softc **);
        void            (*pr_detach)(struct lagg_proto_softc *);
        int             (*pr_up)(struct lagg_proto_softc *);
        void            (*pr_down)(struct lagg_proto_softc *);
        int             (*pr_transmit)(struct lagg_proto_softc *,
                            struct mbuf *);
        struct mbuf *   (*pr_input)(struct lagg_proto_softc *,
                            struct lagg_port *, struct mbuf *);
        int             (*pr_allocport)(struct lagg_proto_softc *,
                            struct lagg_port *);
        void            (*pr_freeport)(struct lagg_proto_softc *,
                            struct lagg_port *);
        void            (*pr_startport)(struct lagg_proto_softc *,
                            struct lagg_port *);
        void            (*pr_stopport)(struct lagg_proto_softc *,
                            struct lagg_port *);
        void            (*pr_protostat)(struct lagg_proto_softc *,
                            struct laggreqproto *);
        void            (*pr_portstat)(struct lagg_proto_softc *,
                            struct lagg_port *, struct laggreqport *);
        void            (*pr_linkstate)(struct lagg_proto_softc *,
                            struct lagg_port *);
        int             (*pr_ioctl)(struct lagg_proto_softc *,
                            struct laggreqproto *);
};

struct lagg_variant {
        lagg_proto       lv_proto;
        struct lagg_proto_softc
                        *lv_psc;

        struct psref_target     lv_psref;
};

struct lagg_mc_entry {
        LIST_ENTRY(lagg_mc_entry)
                                 mc_entry;
        struct ether_multi      *mc_enm;
        struct sockaddr_storage  mc_addr;
};

struct lagg_vlantag {
        uint16_t         lvt_vtag;
        TAILQ_ENTRY(lagg_vlantag)
                         lvt_entry;
};

struct lagg_softc {
        kmutex_t                 sc_lock;
        struct ifmedia           sc_media;
        uint64_t                 sc_media_active;
        u_char                   sc_iftype;

        /* interface link-layer address */
        uint8_t                  sc_lladdr[ETHER_ADDR_LEN];
        /* generated random lladdr */
        uint8_t                  sc_lladdr_rand[ETHER_ADDR_LEN];

        LIST_HEAD(, lagg_mc_entry)
                                 sc_mclist;
        TAILQ_HEAD(, lagg_vlantag)
                                 sc_vtags;
        pserialize_t             sc_psz;
        struct lagg_variant     *sc_var;
        SIMPLEQ_HEAD(, lagg_port)
                                 sc_ports;
        size_t                   sc_nports;
        char                     sc_evgroup[16];
        struct evcnt             sc_novar;

        struct sysctllog        *sc_sysctllog;
        const struct sysctlnode *sc_sysctlnode;
        bool                     sc_hash_mac;
        bool                     sc_hash_ipaddr;
        bool                     sc_hash_ip6addr;
        bool                     sc_hash_tcp;
        bool                     sc_hash_udp;

        /*
         * storage size of sc_if is a variable-length,
         * should be the last
         */
        struct ifnet             sc_if;
};

/*
 * Locking notes:
 * - sc_lock(LAGG_LOCK()) is an adaptive mutex and protects items
 *   of struct lagg_softc
 * - a lock in struct lagg_proto_softc, for example LACP_LOCK(), is
 *   an adaptive mutex and protects member contained in the struct
 * - sc_var is protected by both pselialize (sc_psz) and psref (lv_psref)
 *    - Updates of sc_var is serialized by sc_lock
 * - Items in sc_ports is protected by both psref (lp_psref) and
 *   pserialize contained in struct lagg_proto_softc
 *   - details are described in if_laggport.c and if_lagg_lacp.c
 *   - Updates of items in sc_ports are serialized by sc_lock
 * - an instance referenced by lp_proto_ctx in struct lagg_port is
 *   protected by a lock in struct lagg_proto_softc
 *
 * Locking order:
 * - IFNET_LOCK(sc_if) -> LAGG_LOCK -> ETHER_LOCK(sc_if) -> a lock in
 *   struct lagg_port_softc
 * - IFNET_LOCK(sc_if) -> LAGG_LOCK -> IFNET_LOCK(lp_ifp)
 * - IFNET_LOCK(lp_ifp) -> a lock in struct lagg_proto_softc
 * - Currently, there is no combination of following locks
 *   - IFNET_LOCK(lp_ifp) and ETHER_LOCK(sc_if)
 */
#define LAGG_LOCK(_sc)          mutex_enter(&(_sc)->sc_lock)
#define LAGG_UNLOCK(_sc)        mutex_exit(&(_sc)->sc_lock)
#define LAGG_LOCKED(_sc)        mutex_owned(&(_sc)->sc_lock)
#define LAGG_CLLADDR(_sc)       CLLADDR((_sc)->sc_if.if_sadl)

#define LAGG_PORTS_FOREACH(_sc, _lp)    \
    SIMPLEQ_FOREACH((_lp), &(_sc)->sc_ports, lp_entry)
#define LAGG_PORTS_FIRST(_sc)   SIMPLEQ_FIRST(&(_sc)->sc_ports)
#define LAGG_PORTS_EMPTY(_sc)   SIMPLEQ_EMPTY(&(_sc)->sc_ports)
#define LAGG_PORT_IOCTL(_lp, _cmd, _data)       \
        (_lp)->lp_ioctl == NULL ? ENOTTY :      \
        (_lp)->lp_ioctl((_lp)->lp_ifp, (_cmd), (_data))

static inline const void *
lagg_m_extract(struct mbuf *m, size_t off, size_t reqlen, size_t align,
    void *buf)
{
        ssize_t len;
        const void *rv;

        KASSERT(ISSET(m->m_flags, M_PKTHDR));
        len = off + reqlen;

        if (m->m_pkthdr.len < len) {
                return NULL;
        }

        if (m->m_len >= len &&
            ((uintptr_t)(mtod(m, uint8_t *) + off) % align) == 0) {
                rv = mtod(m, uint8_t *) + off;
        } else {
                m_copydata(m, off, reqlen, buf);
                rv = buf;
        }

        return rv;
}

static inline int
lagg_port_xmit(struct lagg_port *lp, struct mbuf *m)
{

        return if_transmit_lock(lp->lp_ifp, m);
}

static inline bool
lagg_portactive(struct lagg_port *lp)
{
        struct ifnet *ifp;

        ifp = lp->lp_ifp;

        if (ifp->if_link_state != LINK_STATE_DOWN &&
            ISSET(ifp->if_flags, IFF_UP)) {
                return true;
        }

        return false;
}

static inline bool
lagg_debug_enable(struct lagg_softc *sc)
{
        if (__predict_false(ISSET(sc->sc_if.if_flags, IFF_DEBUG)))
                return true;

        return false;
}

#define LAGG_LOG(_sc, _lvl, _fmt, _arg...) do {         \
        if ((_lvl) == LOG_DEBUG &&                      \
            !lagg_debug_enable(_sc))                    \
                break;                                  \
                                                        \
        log((_lvl), "%s: ", (_sc)->sc_if.if_xname);     \
        addlog((_fmt), ##_arg);                         \
} while(0)

void            lagg_port_getref(struct lagg_port *, struct psref *);
void            lagg_port_putref(struct lagg_port *, struct psref *);
void            lagg_output(struct lagg_softc *,
                    struct lagg_port *, struct mbuf *);
uint32_t        lagg_hashmbuf(struct lagg_softc *, struct mbuf *);
void            lagg_set_linkspeed(struct lagg_softc *, uint64_t);

void            lagg_common_detach(struct lagg_proto_softc *);
int             lagg_common_allocport(struct lagg_proto_softc *,
                    struct lagg_port *);
void            lagg_common_freeport(struct lagg_proto_softc *,
                    struct lagg_port *);
void            lagg_common_startport(struct lagg_proto_softc *,
                    struct lagg_port *);
void            lagg_common_stopport(struct lagg_proto_softc *,
                    struct lagg_port *);
void            lagg_common_linkstate_ifnet_locked(struct lagg_proto_softc *,
                    struct lagg_port *);

int             lagg_none_attach(struct lagg_softc *,
                    struct lagg_proto_softc **);

int             lagg_fail_attach(struct lagg_softc *,
                    struct lagg_proto_softc **);
int             lagg_fail_transmit(struct lagg_proto_softc *, struct mbuf *);
struct mbuf *   lagg_fail_input(struct lagg_proto_softc *, struct lagg_port *,
                   struct mbuf *);
void            lagg_fail_portstat(struct lagg_proto_softc *,
                    struct lagg_port *, struct laggreqport *);
int             lagg_fail_ioctl(struct lagg_proto_softc *,
                    struct laggreqproto *);

int             lagg_lb_attach(struct lagg_softc *, struct lagg_proto_softc **);
void            lagg_lb_startport(struct lagg_proto_softc *,
                    struct lagg_port *);
void            lagg_lb_stopport(struct lagg_proto_softc *, struct lagg_port *);
int             lagg_lb_transmit(struct lagg_proto_softc *, struct mbuf *);
struct mbuf *   lagg_lb_input(struct lagg_proto_softc *, struct lagg_port *,
                    struct mbuf *);
void            lagg_lb_portstat(struct lagg_proto_softc *,
                    struct lagg_port *, struct laggreqport *);

int             lacp_attach(struct lagg_softc *, struct lagg_proto_softc **);
void            lacp_detach(struct lagg_proto_softc *);
int             lacp_up(struct lagg_proto_softc *);
void            lacp_down(struct lagg_proto_softc *);
int             lacp_transmit(struct lagg_proto_softc *, struct mbuf *);
struct mbuf *   lacp_input(struct lagg_proto_softc *, struct lagg_port *,
                    struct mbuf *);
int             lacp_allocport(struct lagg_proto_softc *, struct lagg_port *);
void            lacp_freeport(struct lagg_proto_softc *, struct lagg_port *);
void            lacp_startport(struct lagg_proto_softc *, struct lagg_port *);
void            lacp_stopport(struct lagg_proto_softc *, struct lagg_port *);
void            lacp_protostat(struct lagg_proto_softc *,
                    struct laggreqproto *);
void            lacp_portstat(struct lagg_proto_softc *, struct lagg_port *,
                    struct laggreqport *);
void            lacp_linkstate_ifnet_locked(struct lagg_proto_softc *, struct lagg_port *);
int             lacp_ioctl(struct lagg_proto_softc *, struct laggreqproto *);
#endif