infra: add nexthop group

Add nexthop type "GROUP", which is an aggregation of multiple nexthops.
This may be used for ECMP, in order to configure up to
GR_NEXTHOP_GROUP_MAX nexthop for a route.

In a group, nexthop are added with a relative weight:

grout# nexthop add group id 333 members nh 45 weight 3 nh 42
grout# nexthop type group
VRF  ID   ORIGIN  IFACE  TYPE   INFO
0    333  user           group  id(45/3) id(42/1)

Signed-off-by: Christophe Fontaine <[email protected]>

Author: christophefontaine

docs/graph.svg

@@ -32,6 +32,7 @@ typedef enum : uint8_t {
 	GR_NH_T_DNAT,
 	GR_NH_T_BLACKHOLE,
 	GR_NH_T_REJECT,
+	GR_NH_T_GROUP, // ECMP
 #define GR_NH_T_ALL UINT8_C(0xff)
 } gr_nh_type_t;
 
@@ -99,6 +100,17 @@ struct gr_nexthop_info_l3 {
 	struct rte_ether_addr mac; //!< link-layer address
 };
 
+// Info for GR_NH_T_GROUP nexthops
+struct gr_nexthop_group_member {
+	uint32_t nh_id;
+	uint32_t weight;
+};
+
+struct gr_nexthop_info_group {
+	uint32_t n_members;
+	struct gr_nexthop_group_member members[];
+};
+
 //! Nexthop structure exposed to the API.
 struct gr_nexthop {
 	BASE(gr_nexthop_base);
@@ -166,6 +178,8 @@ static inline const char *gr_nh_type_name(const gr_nh_type_t type) {
 		return "blackhole";
 	case GR_NH_T_REJECT:
 		return "reject";
+	case GR_NH_T_GROUP:
+		return "group";
 	}
 	return "?";
 }

modules/infra/api/gr_nexthop.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <gr_infra.h>
+#include <gr_nexthop.h>
 
 #include <ecoli.h>
 

modules/infra/cli/gr_cli_iface.h

@@ -111,6 +111,19 @@ static ssize_t format_nexthop_info_void(char *, size_t, const void *) {
 	return 0;
 }
 
+static ssize_t format_nexthop_info_group(char *buf, size_t len, const void *info) {
+	const struct gr_nexthop_info_group *grp = info;
+	ssize_t n = 0;
+
+	for (uint32_t i = 0; i < grp->n_members; i++)
+		SAFE_BUF(
+			snprintf, len, "id(%d/%d) ", grp->members[i].nh_id, grp->members[i].weight
+		);
+	return n;
+err:
+	return -errno;
+}
+
 static struct cli_nexthop_formatter blackhole_formatter = {
 	.name = "blackhole",
 	.type = GR_NH_T_BLACKHOLE,
@@ -123,6 +136,12 @@ static struct cli_nexthop_formatter reject_formatter = {
 	.format = format_nexthop_info_void,
 };
 
+static struct cli_nexthop_formatter group_formatter = {
+	.name = "group",
+	.type = GR_NH_T_GROUP,
+	.format = format_nexthop_info_group,
+};
+
 static int complete_nh_types(
 	struct gr_api_client *,
 	const struct ec_node *node,
@@ -284,6 +303,48 @@ static cmd_status_t nh_del(struct gr_api_client *c, const struct ec_pnode *p) {
 	return CMD_SUCCESS;
 }
 
+static cmd_status_t nh_group_add(struct gr_api_client *c, const struct ec_pnode *p) {
+	const struct ec_pnode *n = ec_pnode_find(p, "MEMBERS");
+	struct gr_nexthop_info_group *group;
+	struct gr_nh_add_req *req = NULL;
+	cmd_status_t ret = CMD_ERROR;
+	size_t len;
+
+	len = sizeof(*req) + sizeof(*group) + ec_pnode_len(n) * sizeof(group->members[0]);
+	if ((req = calloc(1, len)) == NULL)
+		goto out;
+
+	req->exist_ok = true;
+	req->nh.type = GR_NH_T_GROUP;
+	req->nh.origin = GR_NH_ORIGIN_USER;
+
+	if (arg_u32(p, "ID", &req->nh.nh_id) < 0 && errno != ENOENT)
+		goto out;
+
+	group = (struct gr_nexthop_info_group *)req->nh.info;
+
+	while (n) {
+		n = ec_pnode_get_first_child(n);
+		if (arg_u32(n, "NHID", &group->members[group->n_members].nh_id) < 0)
+			goto out;
+		if (arg_u32(n, "WEIGHT", &group->members[group->n_members].weight) < 0) {
+			if (errno == ENOENT)
+				group->members[group->n_members].weight = 1;
+			else
+				goto out;
+		}
+		group->n_members++;
+		n = ec_pnode_next(n);
+	}
+
+	if (gr_api_client_send_recv(c, GR_NH_ADD, len, req, NULL) < 0)
+		goto out;
+	ret = CMD_SUCCESS;
+out:
+	free(req);
+	return ret;
+}
+
 static cmd_status_t nh_list(struct gr_api_client *c, const struct ec_pnode *p) {
 	struct gr_nh_list_req req = {.vrf_id = GR_VRF_ID_ALL, .type = GR_NH_T_ALL};
 	const struct gr_nexthop *nh;
@@ -414,6 +475,29 @@ static int ctx_init(struct ec_node *root) {
 		with_help("Blackhole nexthop.", ec_node_str("blackhole", "blackhole")),
 		with_help("Reject nexthop sending ICMP UNREACH.", ec_node_str("reject", "reject"))
 	);
+	if (ret < 0)
+		return ret;
+	ret = CLI_COMMAND(
+		NEXTHOP_ADD_CTX(root),
+		"group [(id ID)] members MEMBERS",
+		nh_group_add,
+		"Add a new nexthop group.",
+		with_help("Nexthop ID.", ec_node_uint("ID", 1, UINT32_MAX - 1, 10)),
+		with_help(
+			"Nexthop member IDs with relative weights.",
+			ec_node_many(
+				"MEMBERS",
+				EC_NODE_CMD(
+					EC_NO_ID,
+					"nh NHID [weight WEIGHT]",
+					ec_node_uint("NHID", 1, UINT32_MAX - 1, 10),
+					ec_node_uint("WEIGHT", 1, UINT32_MAX - 1, 10)
+				),
+				1,
+				128
+			)
+		)
+	);
 	if (ret < 0)
 		return ret;
 	ret = CLI_COMMAND(
@@ -488,4 +572,5 @@ static void __attribute__((constructor, used)) init(void) {
 	cli_nexthop_formatter_register(&l3_formatter);
 	cli_nexthop_formatter_register(&blackhole_formatter);
 	cli_nexthop_formatter_register(&reject_formatter);
+	cli_nexthop_formatter_register(&group_formatter);
 }

modules/infra/cli/nexthop.c

@@ -54,6 +54,16 @@ struct hoplist {
 	gr_vec struct nexthop **nh;
 };
 
+struct nh_group_member {
+	struct nexthop *nh;
+	uint32_t weight;
+};
+
+GR_NH_TYPE_INFO(GR_NH_T_GROUP, nexthop_info_group, {
+	uint32_t n_members;
+	gr_vec struct nh_group_member *members;
+});
+
 // Lookup a nexthop from the global pool that matches the specified criteria.
 struct nexthop *
 nexthop_lookup(addr_family_t af, uint16_t vrf_id, uint16_t iface_id, const void *addr);

modules/infra/control/gr_nh_control.h

@@ -30,6 +30,7 @@ static struct rte_mempool *pool;
 static struct gr_id_pool *pool_id;
 static struct rte_hash *hash_by_addr;
 static struct rte_hash *hash_by_id;
+gr_vec static struct nexthop **groups = NULL;
 static struct event *ageing_timer;
 static const struct nexthop_af_ops *af_ops[256];
 static const struct nexthop_type_ops *type_ops[256];
@@ -313,6 +314,7 @@ void nexthop_type_ops_register(gr_nh_type_t type, const struct nexthop_type_ops
 	case GR_NH_T_DNAT:
 	case GR_NH_T_BLACKHOLE:
 	case GR_NH_T_REJECT:
+	case GR_NH_T_GROUP:
 		if (ops == NULL)
 			ABORT("invalid type ops");
 		if (type_ops[type] != NULL)
@@ -335,6 +337,7 @@ struct nexthop *nexthop_new(const struct gr_nexthop_base *base, const void *info
 	case GR_NH_T_DNAT:
 	case GR_NH_T_BLACKHOLE:
 	case GR_NH_T_REJECT:
+	case GR_NH_T_GROUP:
 		break;
 	default:
 		ABORT("invalid nexthop type %hhu", base->type);
@@ -483,8 +486,25 @@ struct nexthop *nexthop_lookup_by_id(uint32_t nh_id) {
 	return data;
 }
 
+static void nh_groups_remove_member(const struct nexthop *nh) {
+	struct nexthop_info_group *info;
+	struct nexthop *group;
+
+	gr_vec_foreach (group, groups) {
+		info = nexthop_info_group(group);
+		for (uint32_t i = 0; i < info->n_members; i++) {
+			if (info->members[i].nh == nh) {
+				info->members[i].nh = info->members[info->n_members - 1].nh;
+				info->members[i].weight = info->members[info->n_members - 1].weight;
+				info->n_members--;
+			}
+		}
+	}
+}
+
 void nexthop_routes_cleanup(struct nexthop *nh) {
 	const struct nexthop_af_ops *ops;
+	nh_groups_remove_member(nh);
 	for (unsigned i = 0; i < ARRAY_DIM(af_ops); i++) {
 		ops = af_ops[i];
 		if (ops != NULL)
@@ -495,6 +515,7 @@ void nexthop_routes_cleanup(struct nexthop *nh) {
 static void nh_cleanup_interface_cb(struct nexthop *nh, void *priv) {
 	struct lookup_filter *filter = priv;
 	if (nh->iface_id == filter->iface_id) {
+		nh_groups_remove_member(nh);
 		nexthop_routes_cleanup(nh);
 		while (nh->ref_count)
 			nexthop_decref(nh);
@@ -624,6 +645,7 @@ static void nh_init(struct event_base *ev_base) {
 }
 
 static void nh_fini(struct event_base *) {
+	gr_vec_free(groups);
 	rte_hash_free(hash_by_addr);
 	rte_hash_free(hash_by_id);
 	if (ageing_timer)
@@ -795,11 +817,130 @@ static struct nexthop_type_ops l3_nh_ops = {
 	.to_api = l3_to_api,
 };
 
+static bool group_equal(const struct nexthop *a, const struct nexthop *b) {
+	const struct nexthop_info_group *da = nexthop_info_group(a);
+	const struct nexthop_info_group *db = nexthop_info_group(b);
+
+	if (da->n_members != db->n_members)
+		return false;
+	for (uint32_t i = 0; i < da->n_members; i++)
+		if (da->members[i].nh != db->members[i].nh
+		    || da->members[i].weight != db->members[i].weight)
+			return false;
+	return true;
+}
+
+static void group_list_add(struct nexthop *nh) {
+	struct nexthop *group;
+	bool found = false;
+
+	gr_vec_foreach (group, groups) {
+		if (group == nh)
+			found = true;
+	}
+
+	if (!found)
+		gr_vec_add(groups, nh);
+}
+
+static void group_list_del(const struct nexthop *nh) {
+	struct nexthop *group;
+	gr_vec_foreach (group, groups) {
+		if (group == nh)
+			gr_vec_del_swap(groups, __i);
+	}
+}
+
+static void group_free(struct nexthop *nh) {
+	struct nexthop_info_group *pvt = nexthop_info_group(nh);
+
+	for (uint32_t i = 0; i < pvt->n_members; i++)
+		nexthop_decref(pvt->members[i].nh);
+	rte_free(pvt->members);
+	group_list_del(nh);
+}
+
+static int group_import_info(struct nexthop *nh, const void *info) {
+	struct nexthop_info_group *pvt = nexthop_info_group(nh);
+	const struct gr_nexthop_info_group *group = info;
+	struct nh_group_member *members, *tmp;
+	uint32_t count;
+
+	members = rte_zmalloc(
+		__func__,
+		sizeof(*pvt) + group->n_members * sizeof(pvt->members[0]),
+		RTE_CACHE_LINE_SIZE
+	);
+	if (members == NULL)
+		return errno_set(ENOMEM);
+
+	for (uint32_t i = 0; i < group->n_members; i++) {
+		struct nexthop *nh = nexthop_lookup_by_id(group->members[i].nh_id);
+		if (nh) {
+			members[i].nh = nh;
+			members[i].weight = group->members[i].weight;
+		} else {
+			rte_free(members);
+			return errno_set(ENOENT);
+		}
+	}
+
+	for (uint32_t i = 0; i < group->n_members; i++)
+		nexthop_incref(members[i].nh);
+
+	count = pvt->n_members;
+	tmp = pvt->members;
+	pvt->n_members = group->n_members;
+	pvt->members = members;
+
+	for (uint32_t i = 0; i < count; i++)
+		nexthop_decref(members[i].nh);
+
+	rte_rcu_qsbr_synchronize(gr_datapath_rcu(), RTE_QSBR_THRID_INVALID);
+	rte_free(tmp);
+
+	group_list_add(nh);
+	return 0;
+}
+
+static struct gr_nexthop *group_to_api(const struct nexthop *nh, size_t *len) {
+	const struct nexthop_info_group *group_priv = nexthop_info_group(nh);
+	struct gr_nexthop_info_group *group_pub;
+	struct gr_nexthop *pub;
+	*len = sizeof(*pub) + sizeof(*group_pub)
+		+ group_priv->n_members * sizeof(group_priv->members[0]);
+
+	pub = malloc(*len);
+	if (pub == NULL) {
+		len = 0;
+		return errno_set_null(ENOMEM);
+	}
+
+	pub->base = nh->base;
+	group_pub = (struct gr_nexthop_info_group *)pub->info;
+
+	group_pub->n_members = group_priv->n_members;
+	for (uint32_t i = 0; i < group_pub->n_members; i++) {
+		group_pub->members[i].nh_id = group_priv->members[i].nh->nh_id;
+		group_pub->members[i].weight = group_priv->members[i].weight;
+	}
+
+	return pub;
+}
+
+static struct nexthop_type_ops group_nh_ops = {
+	.equal = group_equal,
+	.free = group_free,
+	.import_info = group_import_info,
+	.to_api = group_to_api,
+};
+
 RTE_INIT(init) {
 	gr_event_register_serializer(&nh_serializer);
 	gr_register_module(&module);
 	rte_telemetry_register_cmd(
 		"/grout/nexthop/stats", telemetry_nexthop_stats_get, "Get nexthop statistics"
 	);
 	nexthop_type_ops_register(GR_NH_T_L3, &l3_nh_ops);
+	nexthop_type_ops_register(GR_NH_T_GROUP, &group_nh_ops);
 }

modules/infra/control/nexthop.c

@@ -16,6 +16,8 @@ grcli nexthop add l3 iface p0 address ba4:f00::1 mac ba:d0:ca:ca:00:02
 grcli nexthop add l3 iface p1 address 4.3.2.1 mac ba:d0:ca:ca:00:01
 grcli nexthop add blackhole id 666
 grcli nexthop add reject id 123456
+grcli nexthop add group id 333 members nh 42 weight 102
+grcli nexthop add group id 333 members nh 45 nh 47
 grcli address add 10.0.0.1/24 iface p0
 grcli address add 10.1.0.1/24 iface p1
 grcli route add 0.0.0.0/0 via 10.0.0.2
@@ -40,6 +42,7 @@ grcli stats show hardware
 grcli nexthop del 42
 grcli nexthop del 666
 grcli nexthop del 123456
+grcli nexthop del 333
 
 grcli interface del p0
 grcli interface del p1