path: root/gpxe/src/core/proto_eth_slow.c

/* 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