/*      $NetBSD: ieee8023ad_lacp_select.c,v 1.6 2021/11/30 01:17:02 yamaguchi 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: ieee8023ad_lacp_select.c,v 1.6 2021/11/30 01:17:02 yamaguchi Exp $");

#include <sys/param.h>
#include <sys/callout.h>
#include <sys/mbuf.h>
#include <sys/systm.h>

#include <net/if.h>
#include <net/if_ether.h>
#include <net/ether_slowprotocols.h>

#include <net/agr/if_agrvar_impl.h>
#include <net/agr/ieee8023_tlv.h>
#include <net/agr/ieee8023ad_lacp.h>
#include <net/agr/ieee8023ad_lacp_impl.h>
#include <net/agr/ieee8023ad_impl.h>
#include <net/agr/ieee8023ad_lacp_debug.h>

/* selection logic */

static void lacp_fill_aggregator_id(struct lacp_aggregator *,
   const struct lacp_port *);
static void lacp_fill_aggregator_id_peer(struct lacp_peerinfo *,
   const struct lacp_peerinfo *);
static bool lacp_aggregator_is_compatible(const struct lacp_aggregator *,
   const struct lacp_port *);
static bool lacp_peerinfo_is_compatible(const struct lacp_peerinfo *,
   const struct lacp_peerinfo *);

static struct lacp_aggregator *lacp_aggregator_get(struct lacp_softc *,
   struct lacp_port *);
static void lacp_aggregator_addref(struct lacp_softc *,
   struct lacp_aggregator *);
static void lacp_aggregator_delref(struct lacp_softc *,
   struct lacp_aggregator *);

static void
lacp_aggregator_addref(struct lacp_softc *lsc, struct lacp_aggregator *la)
{
#if defined(LACP_DEBUG)
       char buf[LACP_LAGIDSTR_MAX+1];
#endif

       LACP_DPRINTF((NULL, "%s: lagid=%s, refcnt %d -> %d\n",
           __func__,
           lacp_format_lagid(&la->la_actor, &la->la_partner,
           buf, sizeof(buf)),
           la->la_refcnt, la->la_refcnt + 1));

       KASSERT(la->la_refcnt > 0);
       la->la_refcnt++;
       KASSERT(la->la_refcnt > la->la_nports);
}

static void
lacp_aggregator_delref(struct lacp_softc *lsc, struct lacp_aggregator *la)
{
#if defined(LACP_DEBUG)
       char buf[LACP_LAGIDSTR_MAX+1];
#endif

       LACP_DPRINTF((NULL, "%s: lagid=%s, refcnt %d -> %d\n",
           __func__,
           lacp_format_lagid(&la->la_actor, &la->la_partner,
           buf, sizeof(buf)),
           la->la_refcnt, la->la_refcnt - 1));

       KASSERT(la->la_refcnt > la->la_nports);
       la->la_refcnt--;
       if (la->la_refcnt > 0) {
               return;
       }

       KASSERT(la->la_refcnt == 0);
       KASSERT(lsc->lsc_active_aggregator != la);

       TAILQ_REMOVE(&lsc->lsc_aggregators, la, la_q);

       free(la, M_DEVBUF);
}

/*
* lacp_aggregator_get: allocate an aggregator.
*/

static struct lacp_aggregator *
lacp_aggregator_get(struct lacp_softc *lsc, struct lacp_port *lp)
{
       struct lacp_aggregator *la;

       la = malloc(sizeof(*la), M_DEVBUF, M_NOWAIT);
       if (la) {
               la->la_refcnt = 1;
               la->la_nports = 0;
               TAILQ_INIT(&la->la_ports);
               la->la_pending = 0;
               TAILQ_INSERT_TAIL(&lsc->lsc_aggregators, la, la_q);
       }

       return la;
}

/*
* lacp_fill_aggregator_id: setup a newly allocated aggregator from a port.
*/

static void
lacp_fill_aggregator_id(struct lacp_aggregator *la, const struct lacp_port *lp)
{

       lacp_fill_aggregator_id_peer(&la->la_partner, &lp->lp_partner);
       lacp_fill_aggregator_id_peer(&la->la_actor, &lp->lp_actor);

       la->la_actor.lip_state = lp->lp_state & LACP_STATE_AGGREGATION;
}

static void
lacp_fill_aggregator_id_peer(struct lacp_peerinfo *lpi_aggr,
   const struct lacp_peerinfo *lpi_port)
{

       memset(lpi_aggr, 0, sizeof(*lpi_aggr));
       lpi_aggr->lip_systemid = lpi_port->lip_systemid;
       lpi_aggr->lip_key = lpi_port->lip_key;
}

/*
* lacp_aggregator_is_compatible: check if a port can join to an aggregator.
*/

static bool
lacp_aggregator_is_compatible(const struct lacp_aggregator *la,
   const struct lacp_port *lp)
{

       if (!(lp->lp_state & LACP_STATE_AGGREGATION) ||
           !(lp->lp_partner.lip_state & LACP_STATE_AGGREGATION)) {
               return false;
       }

       if (!(la->la_actor.lip_state & LACP_STATE_AGGREGATION)) {
               return false;
       }

       if (!lacp_peerinfo_is_compatible(&la->la_partner, &lp->lp_partner)) {
               return false;
       }

       if (!lacp_peerinfo_is_compatible(&la->la_actor, &lp->lp_actor)) {
               return false;
       }

       return true;
}

static bool
lacp_peerinfo_is_compatible(const struct lacp_peerinfo *a,
   const struct lacp_peerinfo *b)
{

       if (memcmp(&a->lip_systemid, &b->lip_systemid,
           sizeof(a->lip_systemid))) {
               return false;
       }

       if (memcmp(&a->lip_key, &b->lip_key, sizeof(a->lip_key))) {
               return false;
       }

       return true;
}

/*
* lacp_select: select an aggregator.  create one if necessary.
*/

void
lacp_select(struct lacp_port *lp)
{
       struct lacp_softc *lsc = LACP_SOFTC(AGR_SC_FROM_PORT(lp->lp_agrport));
       struct lacp_aggregator *la;
#if defined(LACP_DEBUG)
       char buf[LACP_LAGIDSTR_MAX+1];
#endif

       if (lp->lp_aggregator) {
               return;
       }

       KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE));

       LACP_DPRINTF((lp, "port lagid=%s\n",
           lacp_format_lagid(&lp->lp_actor, &lp->lp_partner,
           buf, sizeof(buf))));

       TAILQ_FOREACH(la, &lsc->lsc_aggregators, la_q) {
               if (lacp_aggregator_is_compatible(la, lp)) {
                       break;
               }
       }

       if (la == NULL) {
               la = lacp_aggregator_get(lsc, lp);
               if (la == NULL) {
                       LACP_DPRINTF((lp, "aggregator creation failed\n"));

                       /*
                        * will retry on the next tick.
                        */

                       return;
               }
               lacp_fill_aggregator_id(la, lp);
               LACP_DPRINTF((lp, "aggregator created\n"));
       } else {
               LACP_DPRINTF((lp, "compatible aggregator found\n"));
               lacp_aggregator_addref(lsc, la);
       }

       LACP_DPRINTF((lp, "aggregator lagid=%s\n",
           lacp_format_lagid(&la->la_actor, &la->la_partner,
           buf, sizeof(buf))));

       lp->lp_aggregator = la;
       lp->lp_selected = LACP_SELECTED;
}

/*
* lacp_unselect: finish unselect/detach process.
*/

void
lacp_unselect(struct lacp_port *lp)
{
       struct lacp_softc *lsc = LACP_SOFTC(AGR_SC_FROM_PORT(lp->lp_agrport));
       struct lacp_aggregator *la = lp->lp_aggregator;

       KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE));

       if (la == NULL) {
               return;
       }

       lp->lp_aggregator = NULL;
       lacp_aggregator_delref(lsc, la);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.