iface: add bonding support with active-backup mode

Add support for bonding multiple physical ports into a single logical
interface. This initial implementation supports active-backup mode where
only one member port is active at a time for both RX and TX traffic.

The bond interface type can aggregate multiple physical ports. Member
ports forward their received packets to the bond interface when active.
The bond output node selects the active member based on the configured
mode and forwards packets accordingly.

Active member selection in active-backup mode works as follows:

- The primary member is preferred if it is UP and RUNNING
- If the primary is down, the first available UP and RUNNING member
  becomes active
- When member link states change, the bond automatically fails over to
  another member if needed

The bond interface propagates configuration to all members:

- MAC addresses (both primary and additional addresses)
- MTU settings
- Interface flags (promisc, allmulti, up/down)
- VLAN memberships

A new ACTIVE state flag indicates which member is currently handling
traffic. Port interfaces track their bond membership via bond_iface_id.

The RX datapath checks if incoming ports are bond members. If the member
is inactive or not UP, packets are dropped. Active member packets are
forwarded with the iface pointer updated to the bond interface.

The TX datapath uses bond_output node to select the active member and
update the mbuf iface pointer before forwarding to port_output.

Add CLI commands to manage bond interfaces.

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

Author: rjarry

docs/graph.svg

@@ -19,6 +19,7 @@ typedef enum : uint8_t {
 	GR_IFACE_TYPE_PORT,
 	GR_IFACE_TYPE_VLAN,
 	GR_IFACE_TYPE_IPIP,
+	GR_IFACE_TYPE_BOND,
 	GR_IFACE_TYPE_COUNT
 } gr_iface_type_t;
 
@@ -35,6 +36,7 @@ typedef enum : uint16_t {
 // Interface state flags
 typedef enum : uint16_t {
 	GR_IFACE_S_RUNNING = GR_BIT16(0),
+	GR_IFACE_S_ACTIVE = GR_BIT16(1), // Used for bond members
 } gr_iface_state_t;
 
 // Interface reconfig attributes
@@ -90,6 +92,7 @@ struct __gr_iface_info_port_base {
 	uint16_t n_txq;
 	uint16_t rxq_size;
 	uint16_t txq_size;
+	uint16_t bond_iface_id;
 	uint32_t link_speed; //!< Physical link speed in Megabit/sec.
 	struct rte_ether_addr mac;
 };
@@ -115,6 +118,36 @@ struct gr_iface_info_vlan {
 	struct rte_ether_addr mac;
 };
 
+// Bond operational modes
+typedef enum : uint8_t {
+	GR_BOND_MODE_ACTIVE_BACKUP = 1,
+} gr_bond_mode_t;
+
+static inline char *gr_bond_mode_name(gr_bond_mode_t mode) {
+	switch (mode) {
+	case GR_BOND_MODE_ACTIVE_BACKUP:
+		return "active-backup";
+	}
+	return "?";
+}
+
+// Bond reconfig attributes
+#define GR_BOND_SET_MODE GR_BIT64(32)
+#define GR_BOND_SET_MEMBERS GR_BIT64(33)
+#define GR_BOND_SET_PRIMARY GR_BIT64(34)
+#define GR_BOND_SET_MAC GR_BIT64(35)
+
+// Info for GR_IFACE_TYPE_BOND interfaces
+struct gr_iface_info_bond {
+	gr_bond_mode_t mode; // Bond operational mode
+	struct rte_ether_addr mac; // Bond interface MAC address
+
+	// Member port information
+	uint8_t primary_member; // Primary port ID (for active-backup mode)
+	uint8_t n_members; // Number of member ports
+	uint16_t member_iface_ids[8];
+};
+
 struct gr_port_rxq_map {
 	uint16_t iface_id;
 	uint16_t rxq_id;
@@ -331,6 +364,8 @@ static inline const char *gr_iface_type_name(gr_iface_type_t type) {
 		return "vlan";
 	case GR_IFACE_TYPE_IPIP:
 		return "ipip";
+	case GR_IFACE_TYPE_BOND:
+		return "bond";
 	case GR_IFACE_TYPE_COUNT:
 		break;
 	}

modules/infra/api/gr_infra.h

@@ -0,0 +1,281 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2025 Robin Jarry
+
+#include <gr_api.h>
+#include <gr_cli.h>
+#include <gr_cli_iface.h>
+#include <gr_infra.h>
+#include <gr_net_types.h>
+#include <gr_table.h>
+
+#include <ecoli.h>
+#include <libsmartcols.h>
+
+#include <errno.h>
+#include <sys/queue.h>
+
+static int bond_mode_from_str(const char *str, gr_bond_mode_t *mode) {
+	if (strcmp(str, "active-backup") == 0) {
+		*mode = GR_BOND_MODE_ACTIVE_BACKUP;
+		return 0;
+	}
+	return errno_set(EINVAL);
+}
+
+static void bond_show(struct gr_api_client *c, const struct gr_iface *iface) {
+	const struct gr_iface_info_bond *bond = PAYLOAD(iface);
+
+	printf("mode: %s\n", gr_bond_mode_name(bond->mode));
+	printf("mac: " ETH_F "\n", &bond->mac);
+	printf("members:\n");
+	for (uint8_t m = 0; m < bond->n_members; m++) {
+		struct gr_iface *member = iface_from_id(c, bond->member_iface_ids[m]);
+		if (member == NULL)
+			continue;
+
+		printf("  - name: %s\n", member->name);
+		printf("    active: %s\n", (member->state & GR_IFACE_S_ACTIVE) ? "yes" : "no");
+		if (bond->mode == GR_BOND_MODE_ACTIVE_BACKUP && m == bond->primary_member)
+			printf("    primary: true\n");
+		if (member->type == GR_IFACE_TYPE_PORT) {
+			const struct gr_iface_info_port *port;
+			port = (const struct gr_iface_info_port *)member->info;
+			printf("    mac: " ETH_F "\n", &port->mac);
+			if (port->link_speed == UINT32_MAX)
+				printf("    speed: unknown\n");
+			else
+				printf("    speed: %u Mb/s\n", port->link_speed);
+		}
+
+		free(member);
+	}
+}
+
+static void
+bond_list_info(struct gr_api_client *c, const struct gr_iface *iface, char *buf, size_t len) {
+	const struct gr_iface_info_bond *bond = PAYLOAD(iface);
+	struct gr_iface *i = NULL;
+	uint16_t member_iface_id;
+	size_t n = 0;
+
+	errno = 0;
+
+	SAFE_BUF(
+		snprintf,
+		len,
+		"mode=%s mac=" ETH_F " members=%u",
+		gr_bond_mode_name(bond->mode),
+		&bond->mac,
+		bond->n_members
+	);
+
+	switch (bond->mode) {
+	case GR_BOND_MODE_ACTIVE_BACKUP:
+		member_iface_id = bond->member_iface_ids[bond->primary_member];
+		if ((i = iface_from_id(c, member_iface_id)) == NULL)
+			SAFE_BUF(snprintf, len, " primary=%u", member_iface_id);
+		else
+			SAFE_BUF(snprintf, len, " primary=%s", i->name);
+		break;
+	}
+
+err:
+	free(i);
+}
+
+static struct cli_iface_type bond_type = {
+	.type_id = GR_IFACE_TYPE_BOND,
+	.name = "bond",
+	.show = bond_show,
+	.list_info = bond_list_info,
+};
+
+static uint64_t parse_bond_args(
+	struct gr_api_client *c,
+	const struct ec_pnode *p,
+	struct gr_iface *iface,
+	bool update
+) {
+	struct gr_iface_info_bond *bond = (struct gr_iface_info_bond *)iface->info;
+	uint64_t set_attrs;
+	const char *str;
+
+	set_attrs = parse_iface_args(c, p, iface, sizeof(*bond), update);
+
+	if ((str = arg_str(p, "MODE")) != NULL) {
+		if (bond_mode_from_str(str, &bond->mode) < 0)
+			goto err;
+		set_attrs |= GR_BOND_SET_MODE;
+	}
+
+	if (arg_str(p, "MEMBER") != NULL) {
+		const struct ec_pnode *m = NULL;
+		bond->n_members = 0;
+		while ((m = ec_pnode_find_next(p, m, "MEMBER", true)) != NULL) {
+			if (bond->n_members >= ARRAY_DIM(bond->member_iface_ids)) {
+				errno = EUSERS;
+				goto err;
+			}
+			const struct ec_strvec *v = ec_pnode_get_strvec(m);
+			assert(v != NULL);
+			assert(ec_strvec_len(v) == 1);
+			struct gr_iface *member = iface_from_name(c, ec_strvec_val(v, 0));
+			if (member == NULL) {
+				goto err;
+			}
+			bond->member_iface_ids[bond->n_members++] = member->id;
+			free(member);
+		}
+		set_attrs |= GR_BOND_SET_MEMBERS;
+	}
+
+	if ((str = arg_str(p, "PRIMARY")) != NULL) {
+		struct gr_iface *primary = iface_from_name(c, str);
+		if (primary == NULL)
+			goto err;
+
+		uint8_t primary_id = UINT8_MAX;
+		for (uint8_t i = 0; i < bond->n_members; i++) {
+			if (bond->member_iface_ids[i] == primary->id) {
+				primary_id = i;
+				break;
+			}
+		}
+		free(primary);
+		if (primary_id == UINT8_MAX) {
+			errno = ENOLINK;
+			goto err;
+		}
+		bond->primary_member = primary_id;
+		set_attrs |= GR_BOND_SET_MODE;
+	}
+
+	if (arg_eth_addr(p, "MAC", &bond->mac) == 0)
+		set_attrs |= GR_BOND_SET_MAC;
+
+	if (set_attrs == 0)
+		errno = EINVAL;
+
+	return set_attrs;
+err:
+	return 0;
+}
+
+static cmd_status_t bond_add(struct gr_api_client *c, const struct ec_pnode *p) {
+	const struct gr_infra_iface_add_resp *resp;
+	struct gr_infra_iface_add_req *req = NULL;
+	void *resp_ptr = NULL;
+	size_t len;
+
+	len = sizeof(*req) + sizeof(struct gr_iface_info_bond);
+	if ((req = calloc(1, len)) == NULL)
+		goto err;
+
+	req->iface.type = GR_IFACE_TYPE_BOND;
+	req->iface.flags = GR_IFACE_F_UP;
+
+	if (parse_bond_args(c, p, &req->iface, false) == 0)
+		goto err;
+
+	if (gr_api_client_send_recv(c, GR_INFRA_IFACE_ADD, len, req, &resp_ptr) < 0)
+		goto err;
+
+	free(req);
+	resp = resp_ptr;
+	printf("Created interface %u\n", resp->iface_id);
+	free(resp_ptr);
+	return CMD_SUCCESS;
+err:
+	free(req);
+	return CMD_ERROR;
+}
+
+static cmd_status_t bond_set(struct gr_api_client *c, const struct ec_pnode *p) {
+	struct gr_infra_iface_set_req *req = NULL;
+	cmd_status_t ret = CMD_ERROR;
+	size_t len;
+
+	len = sizeof(*req) + sizeof(struct gr_iface_info_bond);
+	if ((req = calloc(1, len)) == NULL)
+		goto out;
+
+	if ((req->set_attrs = parse_bond_args(c, p, &req->iface, true)) == 0)
+		goto out;
+
+	if (gr_api_client_send_recv(c, GR_INFRA_IFACE_SET, len, req, NULL) < 0)
+		goto out;
+
+	ret = CMD_SUCCESS;
+out:
+	free(req);
+	return ret;
+}
+
+#define BOND_ATTRS_CMD "(primary PRIMARY),(mac MAC)"
+#define BOND_ATTRS_ARGS                                                                            \
+	IFACE_ATTRS_ARGS,                                                                          \
+		with_help(                                                                         \
+			"Bond mode.",                                                              \
+			EC_NODE_OR(                                                                \
+				"MODE",                                                            \
+				with_help("Active backup mode.", ec_node_str("", "active-backup")) \
+			)                                                                          \
+		),                                                                                 \
+		with_help(                                                                         \
+			"Primary member.",                                                         \
+			ec_node_dyn("PRIMARY", complete_iface_names, INT2PTR(GR_IFACE_TYPE_PORT))  \
+		),                                                                                 \
+		with_help("Set the bond MAC address.", ec_node_re("MAC", ETH_ADDR_RE))
+
+static int ctx_init(struct ec_node *root) {
+	int ret;
+
+	ret = CLI_COMMAND(
+		INTERFACE_ADD_CTX(root),
+		"bond NAME mode MODE (member MEMBER)+ [" BOND_ATTRS_CMD "]",
+		bond_add,
+		"Create a new bond interface.",
+		with_help("Interface name.", ec_node("any", "NAME")),
+		with_help(
+			"Member port interface.",
+			ec_node_dyn("MEMBER", complete_iface_names, INT2PTR(GR_IFACE_TYPE_PORT))
+		),
+		BOND_ATTRS_ARGS
+	);
+	if (ret < 0)
+		return ret;
+	ret = CLI_COMMAND(
+		INTERFACE_SET_CTX(root),
+		"bond NAME (name NEW_NAME),(member MEMBER)+,(mode MODE)," BOND_ATTRS_CMD,
+		bond_set,
+		"Modify bond parameters.",
+		with_help(
+			"Interface name.",
+			ec_node_dyn("NAME", complete_iface_names, INT2PTR(GR_IFACE_TYPE_BOND))
+		),
+		with_help("New interface name.", ec_node("any", "NEW_NAME")),
+		with_help(
+			"Member port interface.",
+			ec_node_dyn("MEMBER", complete_iface_names, INT2PTR(GR_IFACE_TYPE_PORT))
+		),
+		with_help(
+			"Primary member.",
+			ec_node_dyn("PRIMARY", complete_iface_names, INT2PTR(GR_IFACE_TYPE_PORT))
+		),
+		BOND_ATTRS_ARGS
+	);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static struct cli_context ctx = {
+	.name = "infra bond",
+	.init = ctx_init,
+};
+
+static void __attribute__((constructor, used)) init(void) {
+	cli_context_register(&ctx);
+	register_iface_type(&bond_type);
+}

modules/infra/cli/bond.c

@@ -236,6 +236,8 @@ static cmd_status_t iface_list(struct gr_api_client *c, const struct ec_pnode *p
 			SAFE_BUF(snprintf, sizeof(buf), "down");
 		if (iface->state & GR_IFACE_S_RUNNING)
 			SAFE_BUF(snprintf, sizeof(buf), " running");
+		if (iface->state & GR_IFACE_S_ACTIVE)
+			SAFE_BUF(snprintf, sizeof(buf), " active");
 		if (iface->flags & GR_IFACE_F_PROMISC)
 			SAFE_BUF(snprintf, sizeof(buf), " promisc");
 		if (iface->flags & GR_IFACE_F_ALLMULTI)

modules/infra/cli/iface.c

@@ -4,6 +4,7 @@
 cli_src += files(
   'address.c',
   'affinity.c',
+  'bond.c',
   'events.c',
   'graph.c',
   'iface.c',