trace: add lacp support

Add LACP protocol definitions and packet trace formatting to support
debugging and monitoring of link aggregation.

Define the LACP PDU wire format according to IEEE 802.3ad including the
slow protocol subtype, TLV-based actor/partner/collector information,
and terminator. The lacp_participant structure contains system priority,
MAC address, aggregation key, port priority, port number, and state
flags. All multi-byte fields use network byte order with proper packing
and alignment attributes to match the on-wire format.

LACP state flags encode the port's operational state in an 8-bit field:
ACTIVE indicates spontaneous PDU transmission, FAST selects 1-second
intervals versus 30-second slow mode, AGGREGATABLE marks the port as
capable of aggregation, SYNCHRONIZED indicates matching configuration
with the partner, COLLECTING and DISTRIBUTING show the mux machine
state, while DEFAULTED and EXPIRED track timeout conditions.

Extend packet tracing to decode LACP PDUs transmitted on the slow
protocols ethertype. The trace formatter displays actor state flags as
human-readable strings such as "active fast aggreg sync collect distrib"
rather than raw hex values, simplifying protocol troubleshooting.

Signed-off-by: Robin Jarry <[email protected]>

Author: rjarry

modules/infra/datapath/gr_lacp.h

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2025 Robin Jarry
+
+#pragma once
+
+#include <gr_bitops.h>
+
+#include <rte_ether.h>
+
+#include <stdint.h>
+
+// Slow Protocol Subtypes
+typedef enum : uint8_t {
+	LACP_SUBTYPE = 1,
+} slow_subtype_t;
+
+// LACP Version
+
+typedef enum : uint8_t {
+	LACP_VERSION_1 = 1,
+} lacp_version_t;
+
+// LACP TLV Types
+typedef enum : uint8_t {
+	LACP_TYPE_ACTOR = 1,
+	LACP_TYPE_PARTNER = 2,
+	LACP_TYPE_COLLECTOR = 3,
+	LACP_TYPE_TERMINATOR = 0,
+} lacp_type_t;
+
+#define LACP_LEN_ACTOR 20
+#define LACP_LEN_PARTNER 20
+#define LACP_LEN_COLLECTOR 16
+#define LACP_LEN_TERMINATOR 0
+
+// LACP State Bits
+typedef enum : uint8_t {
+	// If set, will spontaneously send LACP packets, else will
+	// only do so when receiving LACP packets from a peer.
+	LACP_STATE_ACTIVE = GR_BIT8(0),
+	// If set, LACP_FAST_PERIOD and LACP_SHORT_TIMEOUT,
+	// else LACP_SLOW_PERIOD and LACP_LONG_TIMEOUT.
+	LACP_STATE_FAST = GR_BIT8(1),
+	// The link is part of a bond.
+	LACP_STATE_AGGREGATABLE = GR_BIT8(2),
+	// System ID and key are in sync.
+	LACP_STATE_SYNCHRONIZED = GR_BIT8(3),
+	// Collecting indicates that the participant’s collector (the receive part
+	// of the mux) is on. If set, it communicates Collecting.
+	LACP_STATE_COLLECTING = GR_BIT8(4),
+	// Distributing indicates that the participant’s distributor (the transmit part
+	// of the mux) is not definitely off. If reset, it indicates Not Distributing.
+	LACP_STATE_DISTRIBUTING = GR_BIT8(5),
+	LACP_STATE_DEFAULTED = GR_BIT8(6),
+	LACP_STATE_EXPIRED = GR_BIT8(7),
+} lacp_state_flags_t;
+
+// LACP Timeouts (in seconds)
+#define LACP_FAST_PERIOD 1
+#define LACP_SLOW_PERIOD 30
+#define LACP_SHORT_TIMEOUT 3
+#define LACP_LONG_TIMEOUT 90
+
+struct lacp_participant {
+	rte_be16_t system_priority;
+	struct rte_ether_addr system_mac;
+	rte_be16_t key;
+	rte_be16_t port_priority;
+	rte_be16_t port_number;
+	lacp_state_flags_t state;
+	uint8_t __padding[3];
+} __rte_packed __rte_aligned(2);
+
+struct lacp_pdu {
+	slow_subtype_t subtype; // LACP_SUBTYPE
+	lacp_version_t version; // LACP_VERSION_1
+
+	// Actor Information
+	lacp_type_t actor_type; // LACP_TYPE_ACTOR
+	uint8_t actor_len; // LACP_LEN_ACTOR
+	struct lacp_participant actor;
+
+	// Partner Information
+	lacp_type_t partner_type; // LACP_TYPE_PARTNER
+	uint8_t partner_len; // LACP_LEN_PARTNER
+	struct lacp_participant partner;
+
+	// Collector Information
+	lacp_type_t collector_type; // LACP_TYPE_COLLECTOR
+	uint8_t collector_len; // LACP_LEN_COLLECTOR
+	rte_be16_t collector_max_delay;
+	uint8_t __reserved[12];
+
+	// Terminator
+	lacp_type_t terminator_type; // LACP_TYPE_TERMINATOR
+	uint8_t terminator_len; // LACP_LEN_TERMINATOR
+	uint8_t __padding[50]; // Pad to minimum frame size
+} __rte_packed __rte_aligned(2);

modules/infra/datapath/gr_trace.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <gr_icmp6.h>
+#include <gr_lacp.h>
 
 #include <rte_arp.h>
 #include <rte_icmp.h>
@@ -40,6 +41,8 @@ int eth_type_format(char *buf, size_t len, rte_be16_t type);
 
 int trace_arp_format(char *buf, size_t len, const struct rte_arp_hdr *, size_t data_len);
 
+int trace_lacp_format(char *buf, size_t len, const struct lacp_pdu *, size_t data_len);
+
 int trace_ip_format(char *buf, size_t len, const struct rte_ipv4_hdr *, size_t data_len);
 
 int trace_ip6_format(char *buf, size_t len, const struct rte_ipv6_hdr *, size_t data_len);

modules/infra/datapath/trace.c

@@ -4,6 +4,7 @@
 #include <gr_eth.h>
 #include <gr_graph.h>
 #include <gr_icmp6.h>
+#include <gr_lacp.h>
 #include <gr_log.h>
 #include <gr_macro.h>
 #include <gr_mbuf.h>
@@ -124,6 +125,31 @@ int trace_arp_format(char *buf, size_t len, const struct rte_arp_hdr *arp, size_
 	return snprintf(buf, len, "opcode=%u", rte_be_to_cpu_16(arp->arp_opcode));
 }
 
+int trace_lacp_format(char *buf, size_t len, const struct lacp_pdu *lacp, size_t /*data_len*/) {
+	size_t n = 0;
+
+	if (lacp->actor.state & LACP_STATE_ACTIVE)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "active");
+	if (lacp->actor.state & LACP_STATE_FAST)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "fast");
+	if (lacp->actor.state & LACP_STATE_AGGREGATABLE)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "aggreg");
+	if (lacp->actor.state & LACP_STATE_SYNCHRONIZED)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "sync");
+	if (lacp->actor.state & LACP_STATE_COLLECTING)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "collect");
+	if (lacp->actor.state & LACP_STATE_DISTRIBUTING)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "distrib");
+	if (lacp->actor.state & LACP_STATE_DEFAULTED)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "fault");
+	if (lacp->actor.state & LACP_STATE_EXPIRED)
+		SAFE_BUF(snprintf, len, "%s%s", n > 0 ? " " : "", "expired");
+
+	return n;
+err:
+	return -1;
+}
+
 int trace_ip_format(char *buf, size_t len, const struct rte_ipv4_hdr *ip, size_t /*data_len*/) {
 	ip4_addr_t src = ip->src_addr;
 	ip4_addr_t dst = ip->dst_addr;
@@ -528,9 +554,13 @@ void trace_log_packet(const struct rte_mbuf *m, const char *node, const char *if
 	case RTE_BE16(RTE_ETHER_TYPE_MPLS):
 		SAFE_BUF(snprintf, sizeof(buf), " / MPLS");
 		break;
-	case RTE_BE16(RTE_ETHER_TYPE_SLOW):
-		SAFE_BUF(snprintf, sizeof(buf), " / LACP");
+	case RTE_BE16(RTE_ETHER_TYPE_SLOW): {
+		const struct lacp_pdu *lacp;
+		lacp = rte_pktmbuf_mtod_offset(m, const struct lacp_pdu *, offset);
+		SAFE_BUF(snprintf, sizeof(buf), " / LACP ");
+		SAFE_BUF(trace_lacp_format, sizeof(buf), lacp, sizeof(*lacp));
 		break;
+	}
 	default:
 		SAFE_BUF(snprintf, sizeof(buf), " type=");
 		SAFE_BUF(eth_type_format, sizeof(buf), ether_type);