CI testrun

Makefile.am

@@ -158,6 +158,7 @@ include bfdd/subdir.am
 include yang/subdir.am
 include yang/libyang_plugins/subdir.am
 include vrrpd/subdir.am
+include pathd/subdir.am
 
 include vtysh/subdir.am
 include tests/subdir.am

bgpd/bgp_attr.c

@@ -722,7 +722,8 @@ bool attrhash_cmp(const void *p1, const void *p2)
 		    && attr1->nh_lla_ifindex == attr2->nh_lla_ifindex
 		    && attr1->distance == attr2->distance
 		    && srv6_l3vpn_same(attr1->srv6_l3vpn, attr2->srv6_l3vpn)
-		    && srv6_vpn_same(attr1->srv6_vpn, attr2->srv6_vpn))
+		    && srv6_vpn_same(attr1->srv6_vpn, attr2->srv6_vpn)
+		    && attr1->srte_color == attr2->srte_color)
 			return true;
 	}
 

bgpd/bgp_attr.h

@@ -24,6 +24,7 @@
 #include "mpls.h"
 #include "bgp_attr_evpn.h"
 #include "bgpd/bgp_encap_types.h"
+#include "srte.h"
 
 /* Simple bit mapping. */
 #define BITMAP_NBBY 8
@@ -253,6 +254,12 @@ struct attr {
 
 	/* Link bandwidth value, if any. */
 	uint32_t link_bw;
+
+	/* SR-TE Policy Name */
+	char srte_policy[SRTE_POLICY_NAME_MAX_LENGTH];
+
+	/* SR-TE Color */
+	uint32_t srte_color;
 };
 
 /* rmap_change_flags definition */

bgpd/bgp_nexthop.c

@@ -35,7 +35,6 @@
 #include "filter.h"
 
 #include "bgpd/bgpd.h"
-#include "bgpd/bgp_table.h"
 #include "bgpd/bgp_route.h"
 #include "bgpd/bgp_attr.h"
 #include "bgpd/bgp_nexthop.h"
@@ -48,43 +47,86 @@
 
 DEFINE_MTYPE_STATIC(BGPD, MARTIAN_STRING, "BGP Martian Address Intf String");
 
-char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size)
+static inline int bgp_nexthop_cache_compare(const struct bgp_nexthop_cache *a,
+					    const struct bgp_nexthop_cache *b)
 {
-	prefix2str(bgp_node_get_prefix(bnc->node), buf, size);
-	return buf;
+	if (a->srte_color < b->srte_color)
+		return -1;
+	if (a->srte_color > b->srte_color)
+		return 1;
+
+	return prefix_cmp(&a->prefix, &b->prefix);
+}
+
+RB_GENERATE(bgp_nexthop_cache_head, bgp_nexthop_cache, entry,
+	    bgp_nexthop_cache_compare);
+
+const char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size)
+{
+	return prefix2str(&bnc->prefix, buf, size);
 }
 
 void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
 {
 	nexthops_free(bnc->nexthop);
 }
 
-struct bgp_nexthop_cache *bnc_new(void)
+struct bgp_nexthop_cache *bnc_new(struct bgp_nexthop_cache_head *tree,
+				  struct prefix *prefix, uint32_t srte_color)
 {
 	struct bgp_nexthop_cache *bnc;
 
 	bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
 		      sizeof(struct bgp_nexthop_cache));
+	bnc->prefix = *prefix;
+	bnc->srte_color = srte_color;
+	bnc->tree = tree;
 	LIST_INIT(&(bnc->paths));
+	RB_INSERT(bgp_nexthop_cache_head, tree, bnc);
+
 	return bnc;
 }
 
+bool bnc_existing_for_prefix(struct bgp_nexthop_cache *bnc)
+{
+	struct bgp_nexthop_cache *bnc_tmp;
+
+	RB_FOREACH (bnc_tmp, bgp_nexthop_cache_head, bnc->tree) {
+		if (bnc_tmp == bnc)
+			continue;
+		if (prefix_cmp(&bnc->prefix, &bnc_tmp->prefix) == 0)
+			return true;
+	}
+	return false;
+}
+
 void bnc_free(struct bgp_nexthop_cache *bnc)
 {
 	bnc_nexthop_free(bnc);
+	RB_REMOVE(bgp_nexthop_cache_head, bnc->tree, bnc);
 	XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
 }
 
+struct bgp_nexthop_cache *bnc_find(struct bgp_nexthop_cache_head *tree,
+				   struct prefix *prefix, uint32_t srte_color)
+{
+	struct bgp_nexthop_cache bnc = {};
+
+	if (!tree)
+		return NULL;
+
+	bnc.prefix = *prefix;
+	bnc.srte_color = srte_color;
+	return RB_FIND(bgp_nexthop_cache_head, tree, &bnc);
+}
+
 /* Reset and free all BGP nexthop cache. */
-static void bgp_nexthop_cache_reset(struct bgp_table *table)
+static void bgp_nexthop_cache_reset(struct bgp_nexthop_cache_head *tree)
 {
-	struct bgp_node *rn;
 	struct bgp_nexthop_cache *bnc;
 
-	for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) {
-		bnc = bgp_node_get_bgp_nexthop_info(rn);
-		if (!bnc)
-			continue;
+        while (!RB_EMPTY(bgp_nexthop_cache_head, tree)) {
+                bnc = RB_ROOT(bgp_nexthop_cache_head, tree);
 
 		while (!LIST_EMPTY(&(bnc->paths))) {
 			struct bgp_path_info *path = LIST_FIRST(&(bnc->paths));
@@ -93,8 +135,6 @@ static void bgp_nexthop_cache_reset(struct bgp_table *table)
 		}
 
 		bnc_free(bnc);
-		bgp_node_set_bgp_nexthop_info(rn, NULL);
-		bgp_unlock_node(rn);
 	}
 }
 
@@ -772,29 +812,26 @@ static void bgp_show_nexthops_detail(struct vty *vty, struct bgp *bgp,
 }
 
 static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
-			     struct bgp_node *rn,
 			     struct bgp_nexthop_cache *bnc,
 			     bool specific)
 {
-	char buf[PREFIX2STR_BUFFER];
 	time_t tbuf;
 	struct peer *peer;
-	const struct prefix *p = bgp_node_get_prefix(rn);
 
 	peer = (struct peer *)bnc->nht_info;
 
+	if (bnc->srte_color)
+		vty_out(vty, " SR-TE color %u -", bnc->srte_color);
 	if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
-		vty_out(vty, " %s valid [IGP metric %d], #paths %d",
-			inet_ntop(p->family, &p->u.prefix, buf, sizeof(buf)),
-			bnc->metric, bnc->path_count);
+		vty_out(vty, " %pFX valid [IGP metric %d], #paths %d",
+			&bnc->prefix, bnc->metric, bnc->path_count);
 		if (peer)
 			vty_out(vty, ", peer %s", peer->host);
 		vty_out(vty, "\n");
 		bgp_show_nexthops_detail(vty, bgp, bnc);
 	} else {
-		vty_out(vty, " %s invalid, #paths %d",
-			inet_ntop(p->family, &p->u.prefix, buf, sizeof(buf)),
-			bnc->path_count);
+		vty_out(vty, " %pFX invalid, #paths %d",
+			&bnc->prefix, bnc->path_count);
 		if (peer)
 			vty_out(vty, ", peer %s", peer->host);
 		vty_out(vty, "\n");
@@ -815,29 +852,21 @@ static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
 static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp,
 			      bool import_table)
 {
-	struct bgp_node *rn;
 	struct bgp_nexthop_cache *bnc;
 	afi_t afi;
-	struct bgp_table **table;
+	struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
 
 	if (import_table)
 		vty_out(vty, "Current BGP import check cache:\n");
 	else
 		vty_out(vty, "Current BGP nexthop cache:\n");
 	if (import_table)
-		table = bgp->import_check_table;
+		tree = &bgp->import_check_table;
 	else
-		table = bgp->nexthop_cache_table;
+		tree = &bgp->nexthop_cache_table;
 	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
-		if (!table || !table[afi])
-			continue;
-		for (rn = bgp_table_top(table[afi]); rn;
-		     rn = bgp_route_next(rn)) {
-			bnc = bgp_node_get_bgp_nexthop_info(rn);
-			if (!bnc)
-				continue;
-			bgp_show_nexthop(vty, bgp, rn, bnc, false);
-		}
+		RB_FOREACH (bnc, bgp_nexthop_cache_head, &(*tree)[afi])
+			bgp_show_nexthop(vty, bgp, bnc, false);
 	}
 }
 
@@ -858,27 +887,21 @@ static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
 
 	if (nhopip_str) {
 		struct prefix nhop;
-		struct bgp_table **table;
-		struct bgp_node *rn;
+		struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
 		struct bgp_nexthop_cache *bnc;
 
 		if (!str2prefix(nhopip_str, &nhop)) {
 			vty_out(vty, "nexthop address is malformed\n");
 			return CMD_WARNING;
 		}
-		table = import_table ? \
-			bgp->import_check_table : bgp->nexthop_cache_table;
-		rn = bgp_node_lookup(table[family2afi(nhop.family)], &nhop);
-		if (!rn) {
-			vty_out(vty, "specified nexthop is not found\n");
-			return CMD_SUCCESS;
-		}
-		bnc = bgp_node_get_bgp_nexthop_info(rn);
+		tree = import_table ? \
+			&bgp->import_check_table : &bgp->nexthop_cache_table;
+		bnc = bnc_find(tree[family2afi(nhop.family)], &nhop, 0);
 		if (!bnc) {
 			vty_out(vty, "specified nexthop does not have entry\n");
 			return CMD_SUCCESS;
 		}
-		bgp_show_nexthop(vty, bgp, rn, bnc, true);
+		bgp_show_nexthop(vty, bgp, bnc, true);
 	} else
 		bgp_show_nexthops(vty, bgp, import_table);
 
@@ -965,12 +988,10 @@ void bgp_scan_init(struct bgp *bgp)
 	afi_t afi;
 
 	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
-		bgp->nexthop_cache_table[afi] =
-			bgp_table_init(bgp, afi, SAFI_UNICAST);
+		RB_INIT(bgp_nexthop_cache_head, &bgp->nexthop_cache_table[afi]);
+		RB_INIT(bgp_nexthop_cache_head, &bgp->import_check_table[afi]);
 		bgp->connected_table[afi] = bgp_table_init(bgp, afi,
 			SAFI_UNICAST);
-		bgp->import_check_table[afi] =
-			bgp_table_init(bgp, afi, SAFI_UNICAST);
 	}
 }
 
@@ -987,16 +1008,12 @@ void bgp_scan_finish(struct bgp *bgp)
 
 	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
 		/* Only the current one needs to be reset. */
-		bgp_nexthop_cache_reset(bgp->nexthop_cache_table[afi]);
-		bgp_table_unlock(bgp->nexthop_cache_table[afi]);
-		bgp->nexthop_cache_table[afi] = NULL;
+		bgp_nexthop_cache_reset(&bgp->nexthop_cache_table[afi]);
+		bgp_nexthop_cache_reset(&bgp->import_check_table[afi]);
 
 		bgp->connected_table[afi]->route_table->cleanup =
 			bgp_connected_cleanup;
 		bgp_table_unlock(bgp->connected_table[afi]);
 		bgp->connected_table[afi] = NULL;
-
-		bgp_table_unlock(bgp->import_check_table[afi]);
-		bgp->import_check_table[afi] = NULL;
 	}
 }

bgpd/bgp_nexthop.h

@@ -24,6 +24,7 @@
 #include "if.h"
 #include "queue.h"
 #include "prefix.h"
+#include "openbsd-tree.h"
 
 #define NEXTHOP_FAMILY(nexthop_len)                                            \
 	(((nexthop_len) == 4 || (nexthop_len) == 12                            \
@@ -38,6 +39,9 @@
 
 /* BGP nexthop cache value structure. */
 struct bgp_nexthop_cache {
+	/* RB-tree entry. */
+	RB_ENTRY(bgp_nexthop_cache) entry;
+
 	/* IGP route's metric. */
 	uint32_t metric;
 
@@ -61,12 +65,19 @@ struct bgp_nexthop_cache {
 #define BGP_NEXTHOP_METRIC_CHANGED    (1 << 1)
 #define BGP_NEXTHOP_CONNECTED_CHANGED (1 << 2)
 
-	struct bgp_node *node;
+	/* Back pointer to the cache tree this entry belongs to. */
+	struct bgp_nexthop_cache_head *tree;
+
+	uint32_t srte_color;
+	struct prefix prefix;
 	void *nht_info; /* In BGP, peer session */
 	LIST_HEAD(path_list, bgp_path_info) paths;
 	unsigned int path_count;
 	struct bgp *bgp;
 };
+RB_HEAD(bgp_nexthop_cache_head, bgp_nexthop_cache);
+RB_PROTOTYPE(bgp_nexthop_cache_head, bgp_nexthop_cache, entry,
+	     bgp_nexthop_cache_compare);
 
 /* Own tunnel-ip address structure */
 struct tip_addr {
@@ -79,6 +90,12 @@ struct bgp_addrv6 {
 	struct list *ifp_name_list;
 };
 
+/* Forward declaration(s). */
+struct peer;
+struct update_subgroup;
+struct bgp_node;
+struct attr;
+
 extern void bgp_connected_add(struct bgp *bgp, struct connected *c);
 extern void bgp_connected_delete(struct bgp *bgp, struct connected *c);
 extern bool bgp_subgrp_multiaccess_check_v4(struct in_addr nexthop,
@@ -94,10 +111,16 @@ extern int bgp_config_write_scan_time(struct vty *);
 extern bool bgp_nexthop_self(struct bgp *bgp, afi_t afi, uint8_t type,
 			     uint8_t sub_type, struct attr *attr,
 			     struct bgp_node *rn);
-extern struct bgp_nexthop_cache *bnc_new(void);
+extern struct bgp_nexthop_cache *bnc_new(struct bgp_nexthop_cache_head *tree,
+					 struct prefix *prefix,
+					 uint32_t srte_color);
+extern bool bnc_existing_for_prefix(struct bgp_nexthop_cache *bnc);
 extern void bnc_free(struct bgp_nexthop_cache *bnc);
+extern struct bgp_nexthop_cache *bnc_find(struct bgp_nexthop_cache_head *tree,
+					  struct prefix *prefix,
+					  uint32_t srte_color);
 extern void bnc_nexthop_free(struct bgp_nexthop_cache *bnc);
-extern char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size);
+extern const char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size);
 extern void bgp_scan_init(struct bgp *bgp);
 extern void bgp_scan_finish(struct bgp *bgp);
 extern void bgp_scan_vty_init(void);