proto_eth_slow.c

Go to the documentation of this file.

/* Copyright 2004 Linux Networx */
#ifdef PROTO_LACP
#if 0
#include "nic.h"
#include "timer.h"
#endif

#define LACP_DEBUG 0

/* Structure definitions originally taken from the linux bond_3ad driver */

#define SLOW_DST_MAC "\x01\x80\xc2\x00\x00\x02"
static const char slow_dest[] = SLOW_DST_MAC;


#define SLOW_SUBTYPE_LACP 1
#define SLOW_SUBTYPE_MARKER 2

struct slow_header {
        uint8_t subtype;
};

struct lacp_info {
        uint16_t system_priority;
        uint8_t  system[ETH_ALEN];
        uint16_t key;
        uint16_t port_priority;
        uint16_t port;
        uint8_t  state;
        uint8_t  reserved[3];
} PACKED;

#define LACP_CMP_LEN (2 + 6 + 2 + 2 + 2)
#define LACP_CP_LEN  (2 + 6 + 2 + 2 + 2 + 1)

/* Link Aggregation Control Protocol(LACP) data unit structure(43.4.2.2 in the 802.3ad standard) */
struct slow_lacp {
        uint8_t  subtype;                      /* = LACP(= 0x01) */
        uint8_t  version_number;
        uint8_t  tlv_type_actor_info;          /* = actor information(type/length/value) */
#define LACP_TLV_TERMINATOR 0
#define LACP_TLV_ACTOR      1
#define LACP_TLV_PARTNER    2
#define LACP_TLV_COLLECTOR  3
        uint8_t  actor_information_length;     /* = 20 */
        struct lacp_info actor;
        uint8_t  tlv_type_partner_info;        /* = partner information */
        uint8_t  partner_information_length;   /* = 20 */
        struct lacp_info partner;
        uint8_t  tlv_type_collector_info;      /* = collector information */
        uint8_t  collector_information_length; /* = 16 */
        uint16_t collector_max_delay;
        uint8_t  reserved_12[12];
        uint8_t  tlv_type_terminator;          /* = terminator */
        uint8_t  terminator_length;            /* = 0 */ 
        uint8_t  reserved_50[50];              /* = 0 */
} PACKED;

/* Marker Protocol Data Unit(PDU) structure(43.5.3.2 in the 802.3ad standard) */
struct slow_marker {
        uint8_t  subtype;                      /* = 0x02  (marker PDU) */
        uint8_t  version_number;               /* = 0x01 */
        uint8_t  tlv_type;
#define MARKER_TLV_TERMINATOR 0                /* marker terminator */
#define MARKER_TLV_INFO       1                /* marker information */
#define MARKER_TLV_RESPONSE   2                /* marker response information */
        uint8_t  marker_length;                /* = 0x16 */
        uint16_t requester_port;               /* The number assigned to the port by the requester */
        uint8_t  requester_system[ETH_ALEN];   /* The requester's system id */
        uint32_t requester_transaction_id;     /* The transaction id allocated by the requester, */
        uint16_t pad;                          /* = 0 */
        uint8_t  tlv_type_terminator;          /* = 0x00 */
        uint8_t  terminator_length;            /* = 0x00 */
        uint8_t  reserved_90[90];              /* = 0 */
} PACKED;

union slow_union {
        struct slow_header header;
        struct slow_lacp lacp;
        struct slow_marker marker;
};

#define FAST_PERIODIC_TIME   (1*TICKS_PER_SEC)
#define SLOW_PERIODIC_TIME   (30*TICKS_PER_SEC)
#define SHORT_TIMEOUT_TIME   (3*FAST_PERIODIC_TIME)
#define LONG_TIMEOUT_TIME    (3*SLOW_PERIODIC_TIME)
#define CHURN_DETECTION_TIME (60*TICKS_PER_SEC)
#define AGGREGATE_WAIT_TIME  (2*TICKS_PER_SEC)

#define LACP_ACTIVITY        (1 << 0)
#define LACP_TIMEOUT         (1 << 1)
#define LACP_AGGREGATION     (1 << 2)
#define LACP_SYNCHRONIZATION (1 << 3)
#define LACP_COLLECTING      (1 << 4)
#define LACP_DISTRIBUTING    (1 << 5)
#define LACP_DEFAULTED       (1 << 6)
#define LACP_EXPIRED         (1 << 7)

#define UNSELECTED 0
#define STANDBY    1
#define SELECTED   2


struct lacp_state {
        struct slow_lacp pkt;
        unsigned long current_while_timer; /* Time when the LACP information expires */
        unsigned long periodic_timer; /* Time when I need to send my partner an update */
};

static struct lacp_state lacp;


#if LACP_DEBUG > 0
static void print_lacp_state(uint8_t state)
{
        printf("%hhx", state);
        if (state & LACP_ACTIVITY) {
                printf(" Activity");
        }
        if (state & LACP_TIMEOUT) {
                printf(" Timeout");
        }
        if (state & LACP_AGGREGATION) {
                printf(" Aggregation");
        }
        if (state & LACP_SYNCHRONIZATION) {
                printf(" Syncronization");
        }
        if (state & LACP_COLLECTING) {
                printf(" Collecting");
        }
        if (state & LACP_DISTRIBUTING) {
                printf(" Distributing");
        }
        if (state & LACP_DEFAULTED) {
                printf(" Defaulted");
        }
        if (state & LACP_EXPIRED) {
                printf(" Expired");
        }
        printf("\n");
}

static inline void print_lacpdu(struct slow_lacp *pkt)
{
        printf("subtype version:  %hhx %hhx\n", 
                pkt->subtype, pkt->version_number);
        printf("actor_tlv %hhx", pkt->tlv_type_actor_info);
        printf(" len: %hhx (\n", pkt->actor_information_length);
        printf(" sys_pri: %hx", ntohs(pkt->actor.system_priority));
        printf(" mac: %!", pkt->actor.system);
        printf(" key: %hx", ntohs(pkt->actor.key));
        printf(" port_pri: %hx", ntohs(pkt->actor.port_priority));
        printf(" port: %hx\n", ntohs(pkt->actor.port));
        printf(" state: ");
        print_lacp_state(pkt->actor.state);
#if LACP_DEBUG > 1
        printf(" reserved:     %hhx %hhx %hhx\n",
                pkt->actor.reserved[0], pkt->actor.reserved[1], pkt->actor.reserved[2]);
#endif
        printf(")\n");
        printf("partner_tlv: %hhx", pkt->tlv_type_partner_info);
        printf(" len: %hhx (\n", pkt->partner_information_length);
        printf(" sys_pri: %hx", ntohs(pkt->partner.system_priority));
        printf(" mac: %!", pkt->partner.system);
        printf(" key: %hx", ntohs(pkt->partner.key));
        printf(" port_pri: %hx", ntohs(pkt->partner.port_priority));
        printf(" port: %hx\n", ntohs(pkt->partner.port));
        printf(" state: ");
        print_lacp_state(pkt->partner.state);
#if LACP_DEBUG > 1
        printf(" reserved:     %hhx %hhx %hhx\n",
                pkt->partner.reserved[0], pkt->partner.reserved[1], pkt->partner.reserved[2]);
#endif
        printf(")\n");
        printf("collector_tlv: %hhx ", pkt->tlv_type_collector_info);
        printf(" len: %hhx (", pkt->collector_information_length);
        printf(" max_delay: %hx", ntohs(pkt->collector_max_delay));
#if LACP_DEBUG > 1
        printf("reserved_12:      %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx\n",
                pkt->reserved_12[0], pkt->reserved_12[1], pkt->reserved_12[2], 
                pkt->reserved_12[3], pkt->reserved_12[4], pkt->reserved_12[5], 
                pkt->reserved_12[6], pkt->reserved_12[7], pkt->reserved_12[8], 
                pkt->reserved_12[9], pkt->reserved_12[10], pkt->reserved_12[11]);
#endif
        printf(" )\n");
        printf("terminator_tlv: %hhx", pkt->tlv_type_terminator);
        printf(" len: %hhx ()\n", pkt->terminator_length);
}

static inline unsigned long lacp_timer_val(unsigned long now, unsigned long when)
{
        return when?(when - now)/TICKS_PER_SEC : 0;
}
static void print_lacp(const char *which, struct slow_lacp *pkt, unsigned long now)
{
        printf("%s\n", which);
        print_lacpdu(pkt);
        printf("timers: c %ds p %ds\n",
                lacp_timer_val(now, lacp.current_while_timer),
                lacp_timer_val(now, lacp.periodic_timer)
                );
        printf("\n");
}
#else /* LACP_DEBUG */
#define print_lacp(which, pkt, now) do {} while(0)
#endif /* LACP_DEBUG */

static void lacp_init_state(const uint8_t *mac)
{
        memset(&lacp, 0, sizeof(lacp));

        /* Initialize the packet constants */
        lacp.pkt.subtype               = 1;
        lacp.pkt.version_number        = 1;


        /* The default state of my interface */
        lacp.pkt.tlv_type_actor_info      = LACP_TLV_ACTOR;
        lacp.pkt.actor_information_length = 0x14;
        lacp.pkt.actor.system_priority    = htons(1);
        memcpy(lacp.pkt.actor.system, mac, ETH_ALEN);
        lacp.pkt.actor.key                = htons(1);
        lacp.pkt.actor.port               = htons(1);
        lacp.pkt.actor.port_priority      = htons(1);
        lacp.pkt.actor.state = 
                LACP_SYNCHRONIZATION |
                LACP_COLLECTING      |
                LACP_DISTRIBUTING    |
                LACP_DEFAULTED;

        /* Set my partner defaults */
        lacp.pkt.tlv_type_partner_info      = LACP_TLV_PARTNER;
        lacp.pkt.partner_information_length = 0x14;
        lacp.pkt.partner.system_priority    = htons(1);
        /* memset(lacp.pkt.parnter_system, 0, ETH_ALEN); */
        lacp.pkt.partner.key                = htons(1);
        lacp.pkt.partner.port               = htons(1);
        lacp.pkt.partner.port_priority      = htons(1);
        lacp.pkt.partner.state =
                LACP_ACTIVITY        |
                LACP_SYNCHRONIZATION |
                LACP_COLLECTING      |
                LACP_DISTRIBUTING    |
                LACP_DEFAULTED;

        lacp.pkt.tlv_type_collector_info      = LACP_TLV_COLLECTOR;
        lacp.pkt.collector_information_length = 0x10;
        lacp.pkt.collector_max_delay          = htons(0x8000); /* ???? */

        lacp.pkt.tlv_type_terminator          = LACP_TLV_TERMINATOR;
        lacp.pkt.terminator_length            = 0;
}

#define LACP_NTT_MASK (LACP_ACTIVITY | LACP_TIMEOUT | \
        LACP_SYNCHRONIZATION | LACP_AGGREGATION)

static inline int lacp_update_ntt(struct slow_lacp *pkt)
{
        int ntt = 0;
        if ((memcmp(&pkt->partner, &lacp.pkt.actor, LACP_CMP_LEN) != 0) ||
                ((pkt->partner.state & LACP_NTT_MASK) != 
                        (lacp.pkt.actor.state & LACP_NTT_MASK)))
        {
                ntt = 1;
        }
        return ntt;
}

static inline void lacp_record_pdu(struct slow_lacp *pkt)
{
        memcpy(&lacp.pkt.partner, &pkt->actor, LACP_CP_LEN);

        lacp.pkt.actor.state &= ~LACP_DEFAULTED;
        lacp.pkt.partner.state &= ~LACP_SYNCHRONIZATION;
        if ((memcmp(&pkt->partner, &lacp.pkt.actor, LACP_CMP_LEN) == 0) &&
                ((pkt->partner.state & LACP_AGGREGATION) ==
                        (lacp.pkt.actor.state & LACP_AGGREGATION)))
        {
                lacp.pkt.partner.state  |= LACP_SYNCHRONIZATION;
        }
        if (!(pkt->actor.state & LACP_AGGREGATION)) {
                lacp.pkt.partner.state |= LACP_SYNCHRONIZATION;
        }

        /* ACTIVITY? */
}

static inline int lacp_timer_expired(unsigned long now, unsigned long when)
{
        return when && (now > when);
}

static inline void lacp_start_periodic_timer(unsigned long now)
{
        if ((lacp.pkt.partner.state & LACP_ACTIVITY) ||
                (lacp.pkt.actor.state & LACP_ACTIVITY)) {
                lacp.periodic_timer = now +
                        (((lacp.pkt.partner.state & LACP_TIMEOUT)?
                                FAST_PERIODIC_TIME : SLOW_PERIODIC_TIME));
        }
}

static inline void lacp_start_current_while_timer(unsigned long now)
{
        lacp.current_while_timer = now +
                ((lacp.pkt.actor.state & LACP_TIMEOUT) ?
                SHORT_TIMEOUT_TIME : LONG_TIMEOUT_TIME);

        lacp.pkt.actor.state &= ~LACP_EXPIRED;
}

static void send_lacp_reports(unsigned long now, int ntt)
{
        if (memcmp(nic.node_addr, lacp.pkt.actor.system, ETH_ALEN) != 0) {
                lacp_init_state(nic.node_addr);
        }
        /* If the remote information has expired I need to take action */
        if (lacp_timer_expired(now, lacp.current_while_timer)) {
                if (!(lacp.pkt.actor.state & LACP_EXPIRED)) {
                        lacp.pkt.partner.state &= ~LACP_SYNCHRONIZATION;
                        lacp.pkt.partner.state |= LACP_TIMEOUT;
                        lacp.pkt.actor.state |= LACP_EXPIRED;
                        lacp.current_while_timer = now + SHORT_TIMEOUT_TIME;
                        ntt = 1;
                }
                else {
                        lacp_init_state(nic.node_addr);
                }
        }
        /* If the periodic timer has expired I need to transmit */
        if (lacp_timer_expired(now, lacp.periodic_timer)) {
                ntt = 1;
                /* Reset by lacp_start_periodic_timer */
        }
        if (ntt) {
                eth_transmit(slow_dest, ETH_P_SLOW, sizeof(lacp.pkt), &lacp.pkt);

                /* Restart the periodic timer */
                lacp_start_periodic_timer(now);

                print_lacp("Trasmitted", &lacp.pkt, now);
        }
}

static inline void send_eth_slow_reports(unsigned long now)
{
        send_lacp_reports(now, 0);
}

static inline void process_eth_slow(unsigned short ptype, unsigned long now)
{
        union slow_union *pkt;
        if ((ptype != ETH_P_SLOW) || 
                (nic.packetlen < (ETH_HLEN + sizeof(pkt->header)))) {
                return;
        }
        pkt = (union slow_union *)&nic.packet[ETH_HLEN];
        if ((pkt->header.subtype == SLOW_SUBTYPE_LACP) &&
                (nic.packetlen >= ETH_HLEN + sizeof(pkt->lacp))) {
                int ntt;
                if (memcmp(nic.node_addr, lacp.pkt.actor.system, ETH_ALEN) != 0) {
                        lacp_init_state(nic.node_addr);
                }
                /* As long as nic.packet is 2 byte aligned all is good */
                print_lacp("Received", &pkt->lacp, now);
                /* I don't actually implement the MUX or SELECT
                 * machines.  
                 *
                 * What logically happens when the client and I
                 * disagree about an aggregator is the current
                 * aggregtator is unselected.  The MUX machine places
                 * me in DETACHED.  The SELECT machine runs and
                 * reslects the same aggregator.  If I go through
                 * these steps fast enough an outside observer can not
                 * notice this.  
                 *
                 * Since the process will not generate any noticeable
                 * effect it does not need an implmenetation.  This
                 * keeps the code simple and the code and binary
                 * size down.
                 */
                /* lacp_update_selected(&pkt->lacp); */
                ntt = lacp_update_ntt(&pkt->lacp);
                lacp_record_pdu(&pkt->lacp);
                lacp_start_current_while_timer(now);
                send_lacp_reports(now, ntt);
        }
        /* If we receive a marker information packet return it */
        else if ((pkt->header.subtype == SLOW_SUBTYPE_MARKER) &&
                (nic.packetlen >= ETH_HLEN + sizeof(pkt->marker)) &&
                (pkt->marker.tlv_type == MARKER_TLV_INFO) &&
                (pkt->marker.marker_length == 0x16)) 
        {
                pkt->marker.tlv_type = MARKER_TLV_RESPONSE;
                eth_transmit(slow_dest, ETH_P_SLOW, 
                        sizeof(pkt->marker), &pkt->marker);
        }

 }
#else

#define send_eth_slow_reports(now)    do {} while(0)
#define process_eth_slow(ptype, now)  do {} while(0)

#endif