]> git.proxmox.com Git - mirror_frr.git/blame - bgpd/bgp_evpn_mh.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #10481 from mobash-rasool/pim-doc
[mirror_frr.git] / bgpd / bgp_evpn_mh.c
CommitLineData
185fb14a
AK		 1/* EVPN Multihoming procedures
2 *
3 * Copyright (C) 2019 Cumulus Networks, Inc.
c44ab6f1 4 * Anuradha Karuppiah
185fb14a
AK		 5 *
6 * This file is part of FRR.
7 *
8 * FRRouting is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2, or (at your option) any
11 * later version.
12 *
13 * FRRouting is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 */
19
20#include <zebra.h>
21
22#include "command.h"
23#include "filter.h"
24#include "prefix.h"
25#include "log.h"
26#include "memory.h"
27#include "stream.h"
28#include "hash.h"
29#include "jhash.h"
30#include "zclient.h"
31
23d0a753
DA		 32#include "lib/printfrr.h"
33
185fb14a
AK		 34#include "bgpd/bgp_attr_evpn.h"
35#include "bgpd/bgpd.h"
36#include "bgpd/bgp_table.h"
37#include "bgpd/bgp_route.h"
38#include "bgpd/bgp_attr.h"
39#include "bgpd/bgp_mplsvpn.h"
40#include "bgpd/bgp_evpn.h"
41#include "bgpd/bgp_evpn_private.h"
42#include "bgpd/bgp_evpn_mh.h"
43#include "bgpd/bgp_ecommunity.h"
44#include "bgpd/bgp_encap_types.h"
45#include "bgpd/bgp_debug.h"
46#include "bgpd/bgp_errors.h"
47#include "bgpd/bgp_aspath.h"
48#include "bgpd/bgp_zebra.h"
49#include "bgpd/bgp_addpath.h"
c44ab6f1 50#include "bgpd/bgp_label.h"
c589d847 51#include "bgpd/bgp_nht.h"
6348981a 52#include "bgpd/bgp_mpath.h"
23aa35ad 53#include "bgpd/bgp_trace.h"
c44ab6f1
AK		 54
55static void bgp_evpn_local_es_down(struct bgp *bgp,
56 struct bgp_evpn_es *es);
57static void bgp_evpn_local_type1_evi_route_del(struct bgp *bgp,
58 struct bgp_evpn_es *es);
59static struct bgp_evpn_es_vtep *bgp_evpn_es_vtep_add(struct bgp *bgp,
74e2bd89
AK		 60 struct bgp_evpn_es *es,
61 struct in_addr vtep_ip,
62 bool esr, uint8_t df_alg,
63 uint16_t df_pref);
c44ab6f1
AK		 64static void bgp_evpn_es_vtep_del(struct bgp *bgp,
65 struct bgp_evpn_es *es, struct in_addr vtep_ip, bool esr);
66static void bgp_evpn_es_cons_checks_pend_add(struct bgp_evpn_es *es);
67static void bgp_evpn_es_cons_checks_pend_del(struct bgp_evpn_es *es);
333ad64b
AK		 68static struct bgp_evpn_es_evi *
69bgp_evpn_local_es_evi_do_del(struct bgp_evpn_es_evi *es_evi);
c589d847
AK		 70static uint32_t bgp_evpn_es_get_active_vtep_cnt(struct bgp_evpn_es *es);
71static void bgp_evpn_l3nhg_update_on_vtep_chg(struct bgp_evpn_es *es);
26c03e43
AK		 72static struct bgp_evpn_es *bgp_evpn_es_new(struct bgp *bgp, const esi_t *esi);
73static void bgp_evpn_es_free(struct bgp_evpn_es *es, const char *caller);
60605cbc 74static void bgp_evpn_path_es_unlink(struct bgp_path_es_info *es_info);
74efb822
AK		 75static void bgp_evpn_mac_update_on_es_local_chg(struct bgp_evpn_es *es,
76 bool is_local);
c44ab6f1
AK		 77
78esi_t zero_esi_buf, *zero_esi = &zero_esi_buf;
8fc2ffb3 79static int bgp_evpn_run_consistency_checks(struct thread *t);
090efa2f
AK		 80static void bgp_evpn_path_nh_info_free(struct bgp_path_evpn_nh_info *nh_info);
81static void bgp_evpn_path_nh_unlink(struct bgp_path_evpn_nh_info *nh_info);
c44ab6f1
AK		 82
83/******************************************************************************
84 * per-ES (Ethernet Segment) routing table
85 *
86 * Following routes are added to the ES's routing table -
87 * 1. Local and remote ESR (Type-4)
88 * 2. Local EAD-per-ES (Type-1).
89 *
90 * Key for these routes is {ESI, VTEP-IP} so the path selection is practically
91 * a no-op i.e. all paths lead to same VTEP-IP (i.e. result in the same VTEP
92 * being added to same ES).
93 *
94 * Note the following routes go into the VNI routing table (instead of the
95 * ES routing table) -
96 * 1. Remote EAD-per-ES
97 * 2. Local and remote EAD-per-EVI
185fb14a 98 */
185fb14a 99
c44ab6f1
AK		 100/* Calculate the best path for a multi-homing (Type-1 or Type-4) route
101 * installed in the ES's routing table.
185fb14a 102 */
c44ab6f1 103static int bgp_evpn_es_route_select_install(struct bgp *bgp,
09319b4e
DS		 104 struct bgp_evpn_es *es,
105 struct bgp_dest *dest)
185fb14a
AK		 106{
107 int ret = 0;
108 afi_t afi = AFI_L2VPN;
109 safi_t safi = SAFI_EVPN;
110 struct bgp_path_info *old_select; /* old best */
111 struct bgp_path_info *new_select; /* new best */
112 struct bgp_path_info_pair old_and_new;
113
114 /* Compute the best path. */
09319b4e
DS		 115 bgp_best_selection(bgp, dest, &bgp->maxpaths[afi][safi], &old_and_new,
116 afi, safi);
185fb14a
AK		 117 old_select = old_and_new.old;
118 new_select = old_and_new.new;
119
120 /*
121 * If the best path hasn't changed - see if something needs to be
122 * updated
123 */
124 if (old_select && old_select == new_select
09319b4e
DS		 125 && old_select->type == ZEBRA_ROUTE_BGP
126 && old_select->sub_type == BGP_ROUTE_IMPORTED
127 && !CHECK_FLAG(dest->flags, BGP_NODE_USER_CLEAR)
128 && !CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
129 && !bgp_addpath_is_addpath_used(&bgp->tx_addpath, afi, safi)) {
185fb14a 130 if (bgp_zebra_has_route_changed(old_select)) {
74e2bd89
AK		 131 bgp_evpn_es_vtep_add(bgp, es, old_select->attr->nexthop,
132 true /*esr*/,
133 old_select->attr->df_alg,
134 old_select->attr->df_pref);
185fb14a
AK		 135 }
136 UNSET_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG);
09319b4e 137 bgp_zebra_clear_route_change_flags(dest);
185fb14a
AK		 138 return ret;
139 }
140
141 /* If the user did a "clear" this flag will be set */
09319b4e 142 UNSET_FLAG(dest->flags, BGP_NODE_USER_CLEAR);
185fb14a 143
c44ab6f1 144 /* bestpath has changed; update relevant fields and install or uninstall
185fb14a
AK		 145 * into the zebra RIB.
146 */
147 if (old_select || new_select)
09319b4e 148 bgp_bump_version(dest);
185fb14a
AK		 149
150 if (old_select)
09319b4e 151 bgp_path_info_unset_flag(dest, old_select, BGP_PATH_SELECTED);
185fb14a 152 if (new_select) {
09319b4e
DS		 153 bgp_path_info_set_flag(dest, new_select, BGP_PATH_SELECTED);
154 bgp_path_info_unset_flag(dest, new_select,
155 BGP_PATH_ATTR_CHANGED);
185fb14a
AK		 156 UNSET_FLAG(new_select->flags, BGP_PATH_MULTIPATH_CHG);
157 }
158
159 if (new_select && new_select->type == ZEBRA_ROUTE_BGP
c44ab6f1 160 && new_select->sub_type == BGP_ROUTE_IMPORTED) {
74e2bd89
AK		 161 bgp_evpn_es_vtep_add(bgp, es, new_select->attr->nexthop,
162 true /*esr */, new_select->attr->df_alg,
163 new_select->attr->df_pref);
185fb14a
AK		 164 } else {
165 if (old_select && old_select->type == ZEBRA_ROUTE_BGP
c44ab6f1
AK		 166 && old_select->sub_type == BGP_ROUTE_IMPORTED)
167 bgp_evpn_es_vtep_del(
168 bgp, es, old_select->attr->nexthop,
169 true /*esr*/);
185fb14a
AK		 170 }
171
172 /* Clear any route change flags. */
09319b4e 173 bgp_zebra_clear_route_change_flags(dest);
185fb14a
AK		 174
175 /* Reap old select bgp_path_info, if it has been removed */
176 if (old_select && CHECK_FLAG(old_select->flags, BGP_PATH_REMOVED))
09319b4e 177 bgp_path_info_reap(dest, old_select);
185fb14a
AK		 178
179 return ret;
180}
181
c44ab6f1
AK		 182/* Install Type-1/Type-4 route entry in the per-ES routing table */
183static int bgp_evpn_es_route_install(struct bgp *bgp,
184 struct bgp_evpn_es *es, struct prefix_evpn *p,
185 struct bgp_path_info *parent_pi)
186{
187 int ret = 0;
09319b4e 188 struct bgp_dest *dest = NULL;
c44ab6f1
AK		 189 struct bgp_path_info *pi = NULL;
190 struct attr *attr_new = NULL;
191
192 /* Create (or fetch) route within the VNI.
193 * NOTE: There is no RD here.
194 */
09319b4e 195 dest = bgp_node_get(es->route_table, (struct prefix *)p);
c44ab6f1
AK		 196
197 /* Check if route entry is already present. */
09319b4e 198 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
c44ab6f1
AK		 199 if (pi->extra
200 && (struct bgp_path_info *)pi->extra->parent ==
201 parent_pi)
202 break;
203
204 if (!pi) {
205 /* Add (or update) attribute to hash. */
206 attr_new = bgp_attr_intern(parent_pi->attr);
207
208 /* Create new route with its attribute. */
209 pi = info_make(parent_pi->type, BGP_ROUTE_IMPORTED, 0,
09319b4e 210 parent_pi->peer, attr_new, dest);
c44ab6f1
AK		 211 SET_FLAG(pi->flags, BGP_PATH_VALID);
212 bgp_path_info_extra_get(pi);
213 pi->extra->parent = bgp_path_info_lock(parent_pi);
09319b4e
DS		 214 bgp_dest_lock_node((struct bgp_dest *)parent_pi->net);
215 bgp_path_info_add(dest, pi);
c44ab6f1
AK		 216 } else {
217 if (attrhash_cmp(pi->attr, parent_pi->attr)
218 && !CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)) {
09319b4e 219 bgp_dest_unlock_node(dest);
c44ab6f1
AK		 220 return 0;
221 }
222 /* The attribute has changed. */
223 /* Add (or update) attribute to hash. */
224 attr_new = bgp_attr_intern(parent_pi->attr);
225
226 /* Restore route, if needed. */
227 if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED))
09319b4e 228 bgp_path_info_restore(dest, pi);
c44ab6f1
AK		 229
230 /* Mark if nexthop has changed. */
231 if (!IPV4_ADDR_SAME(&pi->attr->nexthop, &attr_new->nexthop))
232 SET_FLAG(pi->flags, BGP_PATH_IGP_CHANGED);
233
234 /* Unintern existing, set to new. */
235 bgp_attr_unintern(&pi->attr);
236 pi->attr = attr_new;
237 pi->uptime = bgp_clock();
238 }
239
240 /* Perform route selection and update zebra, if required. */
09319b4e 241 ret = bgp_evpn_es_route_select_install(bgp, es, dest);
c44ab6f1 242
09319b4e 243 bgp_dest_unlock_node(dest);
c44ab6f1
AK		 244
245 return ret;
246}
247
248/* Uninstall Type-1/Type-4 route entry from the ES routing table */
249static int bgp_evpn_es_route_uninstall(struct bgp *bgp, struct bgp_evpn_es *es,
250 struct prefix_evpn *p, struct bgp_path_info *parent_pi)
251{
252 int ret;
09319b4e 253 struct bgp_dest *dest;
c44ab6f1
AK		 254 struct bgp_path_info *pi;
255
256 if (!es->route_table)
257 return 0;
258
259 /* Locate route within the ESI.
260 * NOTE: There is no RD here.
261 */
09319b4e
DS		 262 dest = bgp_node_lookup(es->route_table, (struct prefix *)p);
263 if (!dest)
c44ab6f1
AK		 264 return 0;
265
266 /* Find matching route entry. */
09319b4e 267 for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
c44ab6f1
AK		 268 if (pi->extra
269 && (struct bgp_path_info *)pi->extra->parent ==
270 parent_pi)
271 break;
272
e71ad4b6
DA		 273 if (!pi) {
274 bgp_dest_unlock_node(dest);
c44ab6f1 275 return 0;
e71ad4b6 276 }
c44ab6f1
AK		 277
278 /* Mark entry for deletion */
09319b4e 279 bgp_path_info_delete(dest, pi);
c44ab6f1
AK		 280
281 /* Perform route selection and update zebra, if required. */
09319b4e 282 ret = bgp_evpn_es_route_select_install(bgp, es, dest);
c44ab6f1
AK		 283
284 /* Unlock route node. */
09319b4e 285 bgp_dest_unlock_node(dest);
c44ab6f1
AK		 286
287 return ret;
288}
289
290/* Install or unistall a Tyoe-4 route in the per-ES routing table */
291int bgp_evpn_es_route_install_uninstall(struct bgp *bgp, struct bgp_evpn_es *es,
292 afi_t afi, safi_t safi, struct prefix_evpn *evp,
293 struct bgp_path_info *pi, int install)
294{
295 int ret = 0;
296
297 if (install)
298 ret = bgp_evpn_es_route_install(bgp, es, evp, pi);
299 else
300 ret = bgp_evpn_es_route_uninstall(bgp, es, evp, pi);
301
302 if (ret) {
303 flog_err(
304 EC_BGP_EVPN_FAIL,
305 "%u: Failed to %s EVPN %s route in ESI %s",
306 bgp->vrf_id,
307 install ? "install" : "uninstall",
308 "ES", es->esi_str);
309 return ret;
310 }
311 return 0;
312}
313
314/* Delete (and withdraw) local routes for specified ES from global and ES table.
315 * Also remove all remote routes from the per ES table. Invoked when ES
316 * is deleted.
185fb14a 317 */
c44ab6f1
AK		 318static void bgp_evpn_es_route_del_all(struct bgp *bgp, struct bgp_evpn_es *es)
319{
09319b4e 320 struct bgp_dest *dest;
c44ab6f1
AK		 321 struct bgp_path_info *pi, *nextpi;
322
323 /* de-activate the ES */
324 bgp_evpn_local_es_down(bgp, es);
325 bgp_evpn_local_type1_evi_route_del(bgp, es);
326
327 /* Walk this ES's routing table and delete all routes. */
09319b4e
DS		 328 for (dest = bgp_table_top(es->route_table); dest;
329 dest = bgp_route_next(dest)) {
330 for (pi = bgp_dest_get_bgp_path_info(dest);
331 (pi != NULL) && (nextpi = pi->next, 1); pi = nextpi) {
332 bgp_path_info_delete(dest, pi);
333 bgp_path_info_reap(dest, pi);
c44ab6f1
AK		 334 }
335 }
336}
337
338/*****************************************************************************
339 * Base APIs for creating MH routes (Type-1 or Type-4) on local ethernet
340 * segment updates.
341 */
342
343/* create or update local EVPN type1/type4 route entry.
344 *
345 * This could be in -
346 * the ES table if ESR/EAD-ES (or)
347 * the VNI table if EAD-EVI (or)
348 * the global table if ESR/EAD-ES/EAD-EVI
349 *
350 * Note: vpn is applicable only to EAD-EVI routes (NULL for EAD-ES and
351 * ESR).
352 */
d60f63f0
AD		 353int bgp_evpn_mh_route_update(struct bgp *bgp, struct bgp_evpn_es *es,
354 struct bgpevpn *vpn, afi_t afi, safi_t safi,
355 struct bgp_dest *dest, struct attr *attr, int add,
356 struct bgp_path_info **ri, int *route_changed)
185fb14a 357{
185fb14a
AK		 358 struct bgp_path_info *tmp_pi = NULL;
359 struct bgp_path_info *local_pi = NULL; /* local route entry if any */
360 struct bgp_path_info *remote_pi = NULL; /* remote route entry if any */
361 struct attr *attr_new = NULL;
c44ab6f1 362 struct prefix_evpn *evp;
185fb14a
AK		 363
364 *ri = NULL;
752eed47 365 evp = (struct prefix_evpn *)bgp_dest_get_prefix(dest);
c44ab6f1 366 *route_changed = 1;
185fb14a
AK		 367
368 /* locate the local and remote entries if any */
09319b4e 369 for (tmp_pi = bgp_dest_get_bgp_path_info(dest); tmp_pi;
185fb14a
AK		 370 tmp_pi = tmp_pi->next) {
371 if (tmp_pi->peer == bgp->peer_self
c44ab6f1
AK		 372 && tmp_pi->type == ZEBRA_ROUTE_BGP
373 && tmp_pi->sub_type == BGP_ROUTE_STATIC)
185fb14a
AK		 374 local_pi = tmp_pi;
375 if (tmp_pi->type == ZEBRA_ROUTE_BGP
c44ab6f1
AK		 376 && tmp_pi->sub_type == BGP_ROUTE_IMPORTED
377 && CHECK_FLAG(tmp_pi->flags, BGP_PATH_VALID))
185fb14a
AK		 378 remote_pi = tmp_pi;
379 }
380
c44ab6f1
AK		 381 /* we don't expect to see a remote_ri at this point as
382 * an ES route has {esi, vtep_ip} as the key in the ES-rt-table
383 * in the VNI-rt-table.
185fb14a
AK		 384 */
385 if (remote_pi) {
386 flog_err(
23d0a753
DA		 387 EC_BGP_ES_INVALID,
388 "%u ERROR: local es route for ESI: %s Vtep %pI4 also learnt from remote",
d60f63f0
AD		 389 bgp->vrf_id, es ? es->esi_str : "Null",
390 &es->originator_ip);
185fb14a
AK		 391 return -1;
392 }
393
394 if (!local_pi && !add)
395 return 0;
396
397 /* create or update the entry */
398 if (!local_pi) {
399
400 /* Add or update attribute to hash */
401 attr_new = bgp_attr_intern(attr);
402
403 /* Create new route with its attribute. */
404 tmp_pi = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0,
09319b4e 405 bgp->peer_self, attr_new, dest);
185fb14a
AK		 406 SET_FLAG(tmp_pi->flags, BGP_PATH_VALID);
407
c44ab6f1
AK		 408 if (evp->prefix.route_type == BGP_EVPN_AD_ROUTE) {
409 bgp_path_info_extra_get(tmp_pi);
410 tmp_pi->extra->num_labels = 1;
411 if (vpn)
412 vni2label(vpn->vni, &tmp_pi->extra->label[0]);
413 else
414 tmp_pi->extra->label[0] = 0;
415 }
416
185fb14a 417 /* add the newly created path to the route-node */
09319b4e 418 bgp_path_info_add(dest, tmp_pi);
185fb14a
AK		 419 } else {
420 tmp_pi = local_pi;
421 if (attrhash_cmp(tmp_pi->attr, attr)
c44ab6f1 422 && !CHECK_FLAG(tmp_pi->flags, BGP_PATH_REMOVED))
185fb14a
AK		 423 *route_changed = 0;
424 else {
425 /* The attribute has changed.
426 * Add (or update) attribute to hash.
427 */
428 attr_new = bgp_attr_intern(attr);
09319b4e
DS		 429 bgp_path_info_set_flag(dest, tmp_pi,
430 BGP_PATH_ATTR_CHANGED);
185fb14a
AK		 431
432 /* Restore route, if needed. */
433 if (CHECK_FLAG(tmp_pi->flags, BGP_PATH_REMOVED))
09319b4e 434 bgp_path_info_restore(dest, tmp_pi);
185fb14a
AK		 435
436 /* Unintern existing, set to new. */
437 bgp_attr_unintern(&tmp_pi->attr);
438 tmp_pi->attr = attr_new;
439 tmp_pi->uptime = bgp_clock();
440 }
441 }
442
c44ab6f1
AK		 443 if (*route_changed) {
444 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
23d0a753
DA		 445 zlog_debug(
446 "local ES %s vni %u route-type %s nexthop %pI4 updated",
d60f63f0 447 es ? es->esi_str : "Null", vpn ? vpn->vni : 0,
23d0a753
DA		 448 evp->prefix.route_type == BGP_EVPN_ES_ROUTE
449 ? "esr"
450 : (vpn ? "ead-evi" : "ead-es"),
451 &attr->mp_nexthop_global_in);
c44ab6f1
AK		 452 }
453
185fb14a
AK		 454 /* Return back the route entry. */
455 *ri = tmp_pi;
456 return 0;
457}
458
c44ab6f1
AK		 459/* Delete local EVPN ESR (type-4) and EAD (type-1) route
460 *
461 * Note: vpn is applicable only to EAD-EVI routes (NULL for EAD-ES and
462 * ESR).
463 */
464static int bgp_evpn_mh_route_delete(struct bgp *bgp, struct bgp_evpn_es *es,
465 struct bgpevpn *vpn, struct prefix_evpn *p)
185fb14a 466{
185fb14a
AK		 467 afi_t afi = AFI_L2VPN;
468 safi_t safi = SAFI_EVPN;
c44ab6f1 469 struct bgp_path_info *pi;
09319b4e
DS		 470 struct bgp_dest *dest = NULL; /* dest in esi table */
471 struct bgp_dest *global_dest = NULL; /* dest in global table */
c44ab6f1
AK		 472 struct bgp_table *rt_table;
473 struct prefix_rd *prd;
185fb14a 474
c44ab6f1
AK		 475 if (vpn) {
476 rt_table = vpn->route_table;
477 prd = &vpn->prd;
478 } else {
479 rt_table = es->route_table;
480 prd = &es->prd;
481 }
185fb14a 482
c44ab6f1
AK		 483 /* First, locate the route node within the ESI or VNI.
484 * If it doesn't exist, ther is nothing to do.
485 * Note: there is no RD here.
486 */
09319b4e
DS		 487 dest = bgp_node_lookup(rt_table, (struct prefix *)p);
488 if (!dest)
c44ab6f1 489 return 0;
185fb14a 490
c44ab6f1 491 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
23d0a753
DA		 492 zlog_debug(
493 "local ES %s vni %u route-type %s nexthop %pI4 delete",
494 es->esi_str, vpn ? vpn->vni : 0,
495 p->prefix.route_type == BGP_EVPN_ES_ROUTE
496 ? "esr"
497 : (vpn ? "ead-evi" : "ead-es"),
498 &es->originator_ip);
185fb14a 499
c44ab6f1
AK		 500 /* Next, locate route node in the global EVPN routing table.
501 * Note that this table is a 2-level tree (RD-level + Prefix-level)
502 */
09319b4e
DS		 503 global_dest =
504 bgp_global_evpn_node_lookup(bgp->rib[afi][safi], afi, safi,
505 (const struct prefix_evpn *)p, prd);
506 if (global_dest) {
185fb14a 507
c44ab6f1 508 /* Delete route entry in the global EVPN table. */
09319b4e 509 delete_evpn_route_entry(bgp, afi, safi, global_dest, &pi);
185fb14a
AK		 510
511 /* Schedule for processing - withdraws to peers happen from
512 * this table.
513 */
514 if (pi)
09319b4e
DS		 515 bgp_process(bgp, global_dest, afi, safi);
516 bgp_dest_unlock_node(global_dest);
185fb14a
AK		 517 }
518
519 /*
c44ab6f1 520 * Delete route entry in the ESI or VNI routing table.
185fb14a
AK		 521 * This can just be removed.
522 */
09319b4e 523 delete_evpn_route_entry(bgp, afi, safi, dest, &pi);
185fb14a 524 if (pi)
09319b4e
DS		 525 bgp_path_info_reap(dest, pi);
526 bgp_dest_unlock_node(dest);
185fb14a
AK		 527 return 0;
528}
529
d60f63f0
AD		 530/*
531 * This function is called when the VNI RD changes.
532 * Delete all EAD/EVI local routes for this VNI from the global routing table.
533 * These routes are scheduled for withdraw from peers.
534 */
535int delete_global_ead_evi_routes(struct bgp *bgp, struct bgpevpn *vpn)
536{
537 afi_t afi;
538 safi_t safi;
539 struct bgp_dest *rdrn, *rn;
540 struct bgp_table *table;
541 struct bgp_path_info *pi;
542
543 afi = AFI_L2VPN;
544 safi = SAFI_EVPN;
545
546 /* Find the RD node for the VNI in the global table */
547 rdrn = bgp_node_lookup(bgp->rib[afi][safi], (struct prefix *)&vpn->prd);
548 if (rdrn && bgp_dest_has_bgp_path_info_data(rdrn)) {
549 table = bgp_dest_get_bgp_table_info(rdrn);
550
551 /*
552 * Iterate over all the routes in this table and delete EAD/EVI
553 * routes
554 */
555 for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) {
556 struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p;
557
558 if (evp->prefix.route_type != BGP_EVPN_AD_ROUTE)
559 continue;
560
561 delete_evpn_route_entry(bgp, afi, safi, rn, &pi);
562 if (pi)
563 bgp_process(bgp, rn, afi, safi);
564 }
565 }
566
567 /* Unlock RD node. */
568 if (rdrn)
569 bgp_dest_unlock_node(rdrn);
570
571 return 0;
572}
573
c44ab6f1
AK		 574/*****************************************************************************
575 * Ethernet Segment (Type-4) Routes
74e2bd89
AK		 576 * ESRs are used for DF election. Currently service-carving described in
577 * RFC 7432 is NOT supported. Instead preference based DF election is
578 * used by default.
579 * Reference: draft-ietf-bess-evpn-pref-df
185fb14a 580 */
c44ab6f1
AK		 581/* Build extended community for EVPN ES (type-4) route */
582static void bgp_evpn_type4_route_extcomm_build(struct bgp_evpn_es *es,
583 struct attr *attr)
185fb14a 584{
c44ab6f1
AK		 585 struct ecommunity ecom_encap;
586 struct ecommunity ecom_es_rt;
74e2bd89 587 struct ecommunity ecom_df;
c44ab6f1
AK		 588 struct ecommunity_val eval;
589 struct ecommunity_val eval_es_rt;
74e2bd89 590 struct ecommunity_val eval_df;
c44ab6f1
AK		 591 bgp_encap_types tnl_type;
592 struct ethaddr mac;
185fb14a 593
c44ab6f1
AK		 594 /* Encap */
595 tnl_type = BGP_ENCAP_TYPE_VXLAN;
596 memset(&ecom_encap, 0, sizeof(ecom_encap));
597 encode_encap_extcomm(tnl_type, &eval);
598 ecom_encap.size = 1;
34540b0d 599 ecom_encap.unit_size = ECOMMUNITY_SIZE;
c44ab6f1
AK		 600 ecom_encap.val = (uint8_t *)eval.val;
601 attr->ecommunity = ecommunity_dup(&ecom_encap);
185fb14a 602
c44ab6f1
AK		 603 /* ES import RT */
604 memset(&mac, 0, sizeof(struct ethaddr));
605 memset(&ecom_es_rt, 0, sizeof(ecom_es_rt));
606 es_get_system_mac(&es->esi, &mac);
607 encode_es_rt_extcomm(&eval_es_rt, &mac);
608 ecom_es_rt.size = 1;
34540b0d 609 ecom_es_rt.unit_size = ECOMMUNITY_SIZE;
c44ab6f1
AK		 610 ecom_es_rt.val = (uint8_t *)eval_es_rt.val;
611 attr->ecommunity =
612 ecommunity_merge(attr->ecommunity, &ecom_es_rt);
185fb14a 613
74e2bd89
AK		 614 /* DF election extended community */
615 memset(&ecom_df, 0, sizeof(ecom_df));
616 encode_df_elect_extcomm(&eval_df, es->df_pref);
617 ecom_df.size = 1;
618 ecom_df.val = (uint8_t *)eval_df.val;
619 attr->ecommunity = ecommunity_merge(attr->ecommunity, &ecom_df);
620
c44ab6f1 621 attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
185fb14a
AK		 622}
623
c44ab6f1
AK		 624/* Create or update local type-4 route */
625static int bgp_evpn_type4_route_update(struct bgp *bgp,
626 struct bgp_evpn_es *es, struct prefix_evpn *p)
185fb14a
AK		 627{
628 int ret = 0;
c44ab6f1
AK		 629 int route_changed = 0;
630 afi_t afi = AFI_L2VPN;
631 safi_t safi = SAFI_EVPN;
632 struct attr attr;
633 struct attr *attr_new = NULL;
09319b4e 634 struct bgp_dest *dest = NULL;
185fb14a 635 struct bgp_path_info *pi = NULL;
185fb14a 636
c44ab6f1
AK		 637 memset(&attr, 0, sizeof(struct attr));
638
639 /* Build path-attribute for this route. */
640 bgp_attr_default_set(&attr, BGP_ORIGIN_IGP);
641 attr.nexthop = es->originator_ip;
642 attr.mp_nexthop_global_in = es->originator_ip;
643 attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
644
645 /* Set up extended community. */
646 bgp_evpn_type4_route_extcomm_build(es, &attr);
647
648 /* First, create (or fetch) route node within the ESI. */
649 /* NOTE: There is no RD here. */
09319b4e 650 dest = bgp_node_get(es->route_table, (struct prefix *)p);
185fb14a 651
c44ab6f1 652 /* Create or update route entry. */
09319b4e
DS		 653 ret = bgp_evpn_mh_route_update(bgp, es, NULL, afi, safi, dest, &attr, 1,
654 &pi, &route_changed);
ec779825 655 if (ret != 0)
23d0a753
DA		 656 flog_err(
657 EC_BGP_ES_INVALID,
658 "%u ERROR: Failed to updated ES route ESI: %s VTEP %pI4",
659 bgp->vrf_id, es->esi_str, &es->originator_ip);
185fb14a 660
c44ab6f1
AK		 661 assert(pi);
662 attr_new = pi->attr;
185fb14a 663
c44ab6f1
AK		 664 /* Perform route selection;
665 * this is just to set the flags correctly
666 * as local route in the ES always wins.
667 */
09319b4e
DS		 668 bgp_evpn_es_route_select_install(bgp, es, dest);
669 bgp_dest_unlock_node(dest);
185fb14a 670
c44ab6f1
AK		 671 /* If this is a new route or some attribute has changed, export the
672 * route to the global table. The route will be advertised to peers
673 * from there. Note that this table is a 2-level tree (RD-level +
674 * Prefix-level) similar to L3VPN routes.
675 */
676 if (route_changed) {
677 struct bgp_path_info *global_pi;
185fb14a 678
09319b4e
DS		 679 dest = bgp_global_evpn_node_get(bgp->rib[afi][safi], afi, safi,
680 p, &es->prd);
681 bgp_evpn_mh_route_update(bgp, es, NULL, afi, safi, dest,
682 attr_new, 1, &global_pi,
683 &route_changed);
185fb14a 684
c44ab6f1 685 /* Schedule for processing and unlock node. */
09319b4e
DS		 686 bgp_process(bgp, dest, afi, safi);
687 bgp_dest_unlock_node(dest);
185fb14a
AK		 688 }
689
c44ab6f1
AK		 690 /* Unintern temporary. */
691 aspath_unintern(&attr.aspath);
692 return 0;
185fb14a
AK		 693}
694
c44ab6f1
AK		 695/* Delete local type-4 route */
696static int bgp_evpn_type4_route_delete(struct bgp *bgp,
697 struct bgp_evpn_es *es, struct prefix_evpn *p)
185fb14a 698{
c44ab6f1
AK		 699 return bgp_evpn_mh_route_delete(bgp, es, NULL /* l2vni */, p);
700}
185fb14a 701
c44ab6f1
AK		 702/* Process remote/received EVPN type-4 route (advertise or withdraw) */
703int bgp_evpn_type4_route_process(struct peer *peer, afi_t afi, safi_t safi,
704 struct attr *attr, uint8_t *pfx, int psize,
705 uint32_t addpath_id)
706{
707 int ret;
708 esi_t esi;
709 uint8_t ipaddr_len;
710 struct in_addr vtep_ip;
711 struct prefix_rd prd;
712 struct prefix_evpn p;
185fb14a 713
c44ab6f1
AK		 714 /* Type-4 route should be either 23 or 35 bytes
715 * RD (8), ESI (10), ip-len (1), ip (4 or 16)
185fb14a 716 */
c44ab6f1
AK		 717 if (psize != BGP_EVPN_TYPE4_V4_PSIZE &&
718 psize != BGP_EVPN_TYPE4_V6_PSIZE) {
719 flog_err(EC_BGP_EVPN_ROUTE_INVALID,
720 "%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
721 peer->bgp->vrf_id, peer->host, psize);
722 return -1;
723 }
185fb14a 724
c44ab6f1
AK		 725 /* Make prefix_rd */
726 prd.family = AF_UNSPEC;
727 prd.prefixlen = 64;
728 memcpy(&prd.val, pfx, RD_BYTES);
729 pfx += RD_BYTES;
185fb14a 730
c44ab6f1
AK		 731 /* get the ESI */
732 memcpy(&esi, pfx, ESI_BYTES);
733 pfx += ESI_BYTES;
185fb14a 734
185fb14a 735
c44ab6f1
AK		 736 /* Get the IP. */
737 ipaddr_len = *pfx++;
738 if (ipaddr_len == IPV4_MAX_BITLEN) {
739 memcpy(&vtep_ip, pfx, IPV4_MAX_BYTELEN);
740 } else {
741 flog_err(
742 EC_BGP_EVPN_ROUTE_INVALID,
743 "%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
744 peer->bgp->vrf_id, peer->host, ipaddr_len);
745 return -1;
746 }
185fb14a 747
c44ab6f1
AK		 748 build_evpn_type4_prefix(&p, &esi, vtep_ip);
749 /* Process the route. */
750 if (attr) {
751 ret = bgp_update(peer, (struct prefix *)&p, addpath_id, attr,
752 afi, safi, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL,
753 &prd, NULL, 0, 0, NULL);
754 } else {
755 ret = bgp_withdraw(peer, (struct prefix *)&p, addpath_id, attr,
756 afi, safi, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL,
757 &prd, NULL, 0, NULL);
758 }
185fb14a
AK		 759 return ret;
760}
761
c44ab6f1
AK		 762/* Check if a prefix belongs to the local ES */
763static bool bgp_evpn_type4_prefix_match(struct prefix_evpn *p,
764 struct bgp_evpn_es *es)
185fb14a 765{
c44ab6f1
AK		 766 return (p->prefix.route_type == BGP_EVPN_ES_ROUTE) &&
767 !memcmp(&p->prefix.es_addr.esi, &es->esi, sizeof(esi_t));
185fb14a
AK		 768}
769
c44ab6f1
AK		 770/* Import remote ESRs on local ethernet segment add */
771static int bgp_evpn_type4_remote_routes_import(struct bgp *bgp,
772 struct bgp_evpn_es *es, bool install)
185fb14a
AK		 773{
774 int ret;
775 afi_t afi;
776 safi_t safi;
09319b4e 777 struct bgp_dest *rd_dest, *dest;
185fb14a
AK		 778 struct bgp_table *table;
779 struct bgp_path_info *pi;
780
781 afi = AFI_L2VPN;
782 safi = SAFI_EVPN;
783
c44ab6f1
AK		 784 /* Walk entire global routing table and evaluate routes which could be
785 * imported into this Ethernet Segment.
185fb14a 786 */
09319b4e
DS		 787 for (rd_dest = bgp_table_top(bgp->rib[afi][safi]); rd_dest;
788 rd_dest = bgp_route_next(rd_dest)) {
789 table = bgp_dest_get_bgp_table_info(rd_dest);
185fb14a
AK		 790 if (!table)
791 continue;
792
09319b4e
DS		 793 for (dest = bgp_table_top(table); dest;
794 dest = bgp_route_next(dest)) {
795 struct prefix_evpn *evp =
752eed47 796 (struct prefix_evpn *)bgp_dest_get_prefix(dest);
185fb14a 797
09319b4e
DS		 798 for (pi = bgp_dest_get_bgp_path_info(dest); pi;
799 pi = pi->next) {
185fb14a
AK		 800 /*
801 * Consider "valid" remote routes applicable for
802 * this ES.
803 */
804 if (!(CHECK_FLAG(pi->flags, BGP_PATH_VALID)
c44ab6f1
AK		 805 && pi->type == ZEBRA_ROUTE_BGP
806 && pi->sub_type == BGP_ROUTE_NORMAL))
185fb14a
AK		 807 continue;
808
c44ab6f1 809 if (!bgp_evpn_type4_prefix_match(evp, es))
185fb14a
AK		 810 continue;
811
812 if (install)
c44ab6f1
AK		 813 ret = bgp_evpn_es_route_install(
814 bgp, es, evp, pi);
185fb14a 815 else
c44ab6f1
AK		 816 ret = bgp_evpn_es_route_uninstall(
817 bgp, es, evp, pi);
185fb14a
AK		 818
819 if (ret) {
820 flog_err(
2dbe669b
DA		 821 EC_BGP_EVPN_FAIL,
822 "Failed to %s EVPN %pFX route in ESI %s",
823 install ? "install"
185fb14a 824 : "uninstall",
2dbe669b 825 evp, es->esi_str);
dc52bece
DS		 826
827 bgp_dest_unlock_node(rd_dest);
828 bgp_dest_unlock_node(dest);
185fb14a
AK		 829 return ret;
830 }
831 }
832 }
833 }
834 return 0;
835}
836
c44ab6f1
AK		 837/*****************************************************************************
838 * Ethernet Auto Discovery (EAD/Type-1) route handling
839 * There are two types of EAD routes -
840 * 1. EAD-per-ES - Key: {ESI, ET=0xffffffff}
841 * 2. EAD-per-EVI - Key: {ESI, ET=0}
185fb14a 842 */
185fb14a 843
c44ab6f1
AK		 844/* Extended communities associated with EAD-per-ES */
845static void bgp_evpn_type1_es_route_extcomm_build(struct bgp_evpn_es *es,
846 struct attr *attr)
185fb14a 847{
c44ab6f1
AK		 848 struct ecommunity ecom_encap;
849 struct ecommunity ecom_esi_label;
850 struct ecommunity_val eval;
851 struct ecommunity_val eval_esi_label;
852 bgp_encap_types tnl_type;
853 struct listnode *evi_node, *rt_node;
854 struct ecommunity *ecom;
855 struct bgp_evpn_es_evi *es_evi;
185fb14a 856
c44ab6f1
AK		 857 /* Encap */
858 tnl_type = BGP_ENCAP_TYPE_VXLAN;
859 memset(&ecom_encap, 0, sizeof(ecom_encap));
860 encode_encap_extcomm(tnl_type, &eval);
861 ecom_encap.size = 1;
34540b0d 862 ecom_encap.unit_size = ECOMMUNITY_SIZE;
c44ab6f1
AK		 863 ecom_encap.val = (uint8_t *)eval.val;
864 attr->ecommunity = ecommunity_dup(&ecom_encap);
185fb14a 865
c44ab6f1
AK		 866 /* ESI label */
867 encode_esi_label_extcomm(&eval_esi_label,
868 false /*single_active*/);
869 ecom_esi_label.size = 1;
34540b0d 870 ecom_esi_label.unit_size = ECOMMUNITY_SIZE;
c44ab6f1
AK		 871 ecom_esi_label.val = (uint8_t *)eval_esi_label.val;
872 attr->ecommunity =
873 ecommunity_merge(attr->ecommunity, &ecom_esi_label);
874
875 /* Add export RTs for all L2-VNIs associated with this ES */
876 /* XXX - suppress EAD-ES advertisment if there are no EVIs associated
877 * with it.
878 */
879 for (ALL_LIST_ELEMENTS_RO(es->es_evi_list,
880 evi_node, es_evi)) {
881 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
882 continue;
883 for (ALL_LIST_ELEMENTS_RO(es_evi->vpn->export_rtl,
884 rt_node, ecom))
885 attr->ecommunity = ecommunity_merge(attr->ecommunity,
886 ecom);
887 }
888
889 attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
890}
891
892/* Extended communities associated with EAD-per-EVI */
893static void bgp_evpn_type1_evi_route_extcomm_build(struct bgp_evpn_es *es,
894 struct bgpevpn *vpn, struct attr *attr)
895{
896 struct ecommunity ecom_encap;
897 struct ecommunity_val eval;
898 bgp_encap_types tnl_type;
899 struct listnode *rt_node;
900 struct ecommunity *ecom;
901
902 /* Encap */
903 tnl_type = BGP_ENCAP_TYPE_VXLAN;
904 memset(&ecom_encap, 0, sizeof(ecom_encap));
905 encode_encap_extcomm(tnl_type, &eval);
906 ecom_encap.size = 1;
7659ad68 907 ecom_encap.unit_size = ECOMMUNITY_SIZE;
c44ab6f1
AK		 908 ecom_encap.val = (uint8_t *)eval.val;
909 attr->ecommunity = ecommunity_dup(&ecom_encap);
910
911 /* Add export RTs for the L2-VNI */
912 for (ALL_LIST_ELEMENTS_RO(vpn->export_rtl, rt_node, ecom))
913 attr->ecommunity = ecommunity_merge(attr->ecommunity, ecom);
914
915 attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
916}
917
918/* Update EVPN EAD (type-1) route -
919 * vpn - valid for EAD-EVI routes and NULL for EAD-ES routes
920 */
921static int bgp_evpn_type1_route_update(struct bgp *bgp,
922 struct bgp_evpn_es *es, struct bgpevpn *vpn,
923 struct prefix_evpn *p)
924{
925 int ret = 0;
926 afi_t afi = AFI_L2VPN;
927 safi_t safi = SAFI_EVPN;
928 struct attr attr;
929 struct attr *attr_new = NULL;
09319b4e 930 struct bgp_dest *dest = NULL;
c44ab6f1
AK		 931 struct bgp_path_info *pi = NULL;
932 int route_changed = 0;
933 struct prefix_rd *global_rd;
934
935 memset(&attr, 0, sizeof(struct attr));
936
937 /* Build path-attribute for this route. */
938 bgp_attr_default_set(&attr, BGP_ORIGIN_IGP);
939 attr.nexthop = es->originator_ip;
940 attr.mp_nexthop_global_in = es->originator_ip;
941 attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
942
943 if (vpn) {
944 /* EAD-EVI route update */
945 /* MPLS label */
946 vni2label(vpn->vni, &(attr.label));
947
948 /* Set up extended community */
949 bgp_evpn_type1_evi_route_extcomm_build(es, vpn, &attr);
950
951 /* First, create (or fetch) route node within the VNI. */
09319b4e 952 dest = bgp_node_get(vpn->route_table, (struct prefix *)p);
c44ab6f1
AK		 953
954 /* Create or update route entry. */
09319b4e
DS		 955 ret = bgp_evpn_mh_route_update(bgp, es, vpn, afi, safi, dest,
956 &attr, 1, &pi, &route_changed);
ec779825 957 if (ret != 0)
23d0a753
DA		 958 flog_err(
959 EC_BGP_ES_INVALID,
960 "%u Failed to update EAD-EVI route ESI: %s VNI %u VTEP %pI4",
961 bgp->vrf_id, es->esi_str, vpn->vni,
962 &es->originator_ip);
c44ab6f1
AK		 963 global_rd = &vpn->prd;
964 } else {
965 /* EAD-ES route update */
966 /* MPLS label is 0 for EAD-ES route */
967
968 /* Set up extended community */
969 bgp_evpn_type1_es_route_extcomm_build(es, &attr);
970
971 /* First, create (or fetch) route node within the ES. */
972 /* NOTE: There is no RD here. */
973 /* XXX: fragment ID must be included as a part of the prefix. */
09319b4e 974 dest = bgp_node_get(es->route_table, (struct prefix *)p);
c44ab6f1
AK		 975
976 /* Create or update route entry. */
09319b4e
DS		 977 ret = bgp_evpn_mh_route_update(bgp, es, vpn, afi, safi, dest,
978 &attr, 1, &pi, &route_changed);
c44ab6f1 979 if (ret != 0) {
23d0a753
DA		 980 flog_err(
981 EC_BGP_ES_INVALID,
982 "%u ERROR: Failed to updated EAD-EVI route ESI: %s VTEP %pI4",
983 bgp->vrf_id, es->esi_str, &es->originator_ip);
c44ab6f1
AK		 984 }
985 global_rd = &es->prd;
986 }
987
988
989 assert(pi);
990 attr_new = pi->attr;
991
992 /* Perform route selection;
993 * this is just to set the flags correctly as local route in
994 * the ES always wins.
995 */
09319b4e
DS		 996 evpn_route_select_install(bgp, vpn, dest);
997 bgp_dest_unlock_node(dest);
c44ab6f1
AK		 998
999 /* If this is a new route or some attribute has changed, export the
1000 * route to the global table. The route will be advertised to peers
1001 * from there. Note that this table is a 2-level tree (RD-level +
1002 * Prefix-level) similar to L3VPN routes.
1003 */
1004 if (route_changed) {
1005 struct bgp_path_info *global_pi;
1006
09319b4e
DS		 1007 dest = bgp_global_evpn_node_get(bgp->rib[afi][safi], afi, safi,
1008 p, global_rd);
1009 bgp_evpn_mh_route_update(bgp, es, vpn, afi, safi, dest,
1010 attr_new, 1, &global_pi,
1011 &route_changed);
c44ab6f1
AK		 1012
1013 /* Schedule for processing and unlock node. */
09319b4e
DS		 1014 bgp_process(bgp, dest, afi, safi);
1015 bgp_dest_unlock_node(dest);
c44ab6f1
AK		 1016 }
1017
1018 /* Unintern temporary. */
1019 aspath_unintern(&attr.aspath);
1020 return 0;
1021}
1022
9c49ac74
AD		 1023/*
1024 * This function is called when the export RT for a VNI changes.
1025 * Update all type-1 local routes for this VNI from VNI/ES tables and the global
1026 * table and advertise these routes to peers.
1027 */
1028
1029void update_type1_routes_for_evi(struct bgp *bgp, struct bgpevpn *vpn)
1030{
1031 struct prefix_evpn p;
1032 struct bgp_evpn_es *es;
1033 struct bgp_evpn_es_evi *es_evi;
1034 struct bgp_evpn_es_evi *es_evi_next;
1035
1036 RB_FOREACH_SAFE(es_evi, bgp_es_evi_rb_head,
1037 &vpn->es_evi_rb_tree, es_evi_next) {
1038 es = es_evi->es;
1039
1040 /* Update EAD-ES */
1041 if (CHECK_FLAG(es->flags, BGP_EVPNES_OPER_UP)) {
1042 build_evpn_type1_prefix(&p, BGP_EVPN_AD_ES_ETH_TAG,
1043 &es->esi, es->originator_ip);
1044 if (bgp_evpn_type1_route_update(bgp, es, NULL, &p))
1045 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
1046 "%u: EAD-ES route update failure for ESI %s VNI %u",
1047 bgp->vrf_id, es->esi_str,
1048 es_evi->vpn->vni);
1049 }
1050
1051 /* Update EAD-EVI */
1052 if (CHECK_FLAG(es->flags, BGP_EVPNES_ADV_EVI)) {
1053 build_evpn_type1_prefix(&p, BGP_EVPN_AD_EVI_ETH_TAG,
1054 &es->esi, es->originator_ip);
1055 if (bgp_evpn_type1_route_update(bgp, es, es_evi->vpn,
1056 &p))
1057 flog_err(EC_BGP_EVPN_ROUTE_DELETE,
1058 "%u: EAD-EVI route update failure for ESI %s VNI %u",
1059 bgp->vrf_id, es->esi_str,
1060 es_evi->vpn->vni);
1061 }
1062 }
1063}
1064
c44ab6f1
AK		 1065/* Delete local Type-1 route */
1066static int bgp_evpn_type1_es_route_delete(struct bgp *bgp,
1067 struct bgp_evpn_es *es, struct prefix_evpn *p)
1068{
1069 return bgp_evpn_mh_route_delete(bgp, es, NULL /* l2vni */, p);
1070}
1071
1072static int bgp_evpn_type1_evi_route_delete(struct bgp *bgp,
1073 struct bgp_evpn_es *es, struct bgpevpn *vpn,
1074 struct prefix_evpn *p)
1075{
1076 return bgp_evpn_mh_route_delete(bgp, es, vpn, p);
1077}
1078
1079/* Generate EAD-EVI for all VNIs */
1080static void bgp_evpn_local_type1_evi_route_add(struct bgp *bgp,
1081 struct bgp_evpn_es *es)
1082{
1083 struct listnode *evi_node;
1084 struct prefix_evpn p;
1085 struct bgp_evpn_es_evi *es_evi;
1086
fe8293c3
AK		 1087 /* EAD-per-EVI routes have been suppressed */
1088 if (!bgp_mh_info->ead_evi_tx)
1089 return;
1090
c44ab6f1
AK		 1091 if (CHECK_FLAG(es->flags, BGP_EVPNES_ADV_EVI))
1092 /* EAD-EVI route add for this ES is already done */
1093 return;
1094
1095 SET_FLAG(es->flags, BGP_EVPNES_ADV_EVI);
1096 build_evpn_type1_prefix(&p, BGP_EVPN_AD_EVI_ETH_TAG,
1097 &es->esi, es->originator_ip);
1098
1099 for (ALL_LIST_ELEMENTS_RO(es->es_evi_list, evi_node, es_evi)) {
1100 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
1101 continue;
1102 if (bgp_evpn_type1_route_update(bgp, es, es_evi->vpn, &p))
1103 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
1104 "%u: Type4 route creation failure for ESI %s",
1105 bgp->vrf_id, es->esi_str);
1106 }
1107}
1108
1109/*
1110 * Withdraw EAD-EVI for all VNIs
1111 */
1112static void bgp_evpn_local_type1_evi_route_del(struct bgp *bgp,
1113 struct bgp_evpn_es *es)
1114{
1115 struct listnode *evi_node;
1116 struct prefix_evpn p;
1117 struct bgp_evpn_es_evi *es_evi;
1118
1119 /* Delete and withdraw locally learnt EAD-EVI route */
1120 if (!CHECK_FLAG(es->flags, BGP_EVPNES_ADV_EVI))
1121 /* EAD-EVI route has not been advertised for this ES */
1122 return;
1123
1124 UNSET_FLAG(es->flags, BGP_EVPNES_ADV_EVI);
1125 build_evpn_type1_prefix(&p, BGP_EVPN_AD_EVI_ETH_TAG,
1126 &es->esi, es->originator_ip);
1127 for (ALL_LIST_ELEMENTS_RO(es->es_evi_list, evi_node, es_evi)) {
1128 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
1129 continue;
1130 if (bgp_evpn_mh_route_delete(bgp, es, es_evi->vpn, &p))
1131 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
1132 "%u: Type4 route creation failure for ESI %s",
1133 bgp->vrf_id, es->esi_str);
1134 }
1135}
185fb14a
AK		 1136
1137/*
c44ab6f1 1138 * Process received EVPN type-1 route (advertise or withdraw).
185fb14a 1139 */
c44ab6f1
AK		 1140int bgp_evpn_type1_route_process(struct peer *peer, afi_t afi, safi_t safi,
1141 struct attr *attr, uint8_t *pfx, int psize,
1142 uint32_t addpath_id)
185fb14a
AK		 1143{
1144 int ret;
c44ab6f1 1145 struct prefix_rd prd;
185fb14a 1146 esi_t esi;
c44ab6f1
AK		 1147 uint32_t eth_tag;
1148 mpls_label_t label;
185fb14a 1149 struct in_addr vtep_ip;
185fb14a
AK		 1150 struct prefix_evpn p;
1151
c44ab6f1 1152 if (psize != BGP_EVPN_TYPE1_PSIZE) {
185fb14a 1153 flog_err(EC_BGP_EVPN_ROUTE_INVALID,
c44ab6f1
AK		 1154 "%u:%s - Rx EVPN Type-1 NLRI with invalid length %d",
1155 peer->bgp->vrf_id, peer->host, psize);
185fb14a
AK		 1156 return -1;
1157 }
1158
1159 /* Make prefix_rd */
1160 prd.family = AF_UNSPEC;
1161 prd.prefixlen = 64;
c44ab6f1
AK		 1162 memcpy(&prd.val, pfx, RD_BYTES);
1163 pfx += RD_BYTES;
185fb14a
AK		 1164
1165 /* get the ESI */
1166 memcpy(&esi, pfx, ESI_BYTES);
1167 pfx += ESI_BYTES;
1168
c44ab6f1
AK		 1169 /* Copy Ethernet Tag */
1170 memcpy(&eth_tag, pfx, EVPN_ETH_TAG_BYTES);
1171 eth_tag = ntohl(eth_tag);
1172 pfx += EVPN_ETH_TAG_BYTES;
185fb14a 1173
c44ab6f1 1174 memcpy(&label, pfx, BGP_LABEL_BYTES);
185fb14a 1175
c44ab6f1
AK		 1176 /* EAD route prefix doesn't include the nexthop in the global
1177 * table
1178 */
3a6290bd 1179 vtep_ip.s_addr = INADDR_ANY;
c44ab6f1 1180 build_evpn_type1_prefix(&p, eth_tag, &esi, vtep_ip);
185fb14a
AK		 1181 /* Process the route. */
1182 if (attr) {
1183 ret = bgp_update(peer, (struct prefix *)&p, addpath_id, attr,
c44ab6f1
AK		 1184 afi, safi, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL,
1185 &prd, NULL, 0, 0, NULL);
185fb14a
AK		 1186 } else {
1187 ret = bgp_withdraw(peer, (struct prefix *)&p, addpath_id, attr,
c44ab6f1
AK		 1188 afi, safi, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL,
1189 &prd, NULL, 0, NULL);
185fb14a
AK		 1190 }
1191 return ret;
1192}
1193
c44ab6f1
AK		 1194/*****************************************************************************/
1195/* Ethernet Segment Management
1196 * 1. Ethernet Segment is a collection of links attached to the same
1197 * server (MHD) or switch (MHN)
1198 * 2. An Ethernet Segment can span multiple PEs and is identified by the
1199 * 10-byte ES-ID.
1200 * 3. Local ESs are configured in zebra and sent to BGP
1201 * 4. Remote ESs are created by BGP when one or more ES-EVIs reference it i.e.
1202 * created on first reference and release on last de-reference
1203 * 5. An ES can be both local and remote. Infact most local ESs are expected
1204 * to have an ES peer.
1205 */
1206
1207/* A list of remote VTEPs is maintained for each ES. This list includes -
1208 * 1. VTEPs for which we have imported the ESR i.e. ES-peers
1209 * 2. VTEPs that have an "active" ES-EVI VTEP i.e. EAD-per-ES and EAD-per-EVI
1210 * have been imported into one or more VNIs
185fb14a 1211 */
c44ab6f1
AK		 1212static int bgp_evpn_es_vtep_cmp(void *p1, void *p2)
1213{
1214 const struct bgp_evpn_es_vtep *es_vtep1 = p1;
1215 const struct bgp_evpn_es_vtep *es_vtep2 = p2;
1216
1217 return es_vtep1->vtep_ip.s_addr - es_vtep2->vtep_ip.s_addr;
1218}
1219
1220static struct bgp_evpn_es_vtep *bgp_evpn_es_vtep_new(struct bgp_evpn_es *es,
1221 struct in_addr vtep_ip)
1222{
1223 struct bgp_evpn_es_vtep *es_vtep;
1224
1225 es_vtep = XCALLOC(MTYPE_BGP_EVPN_ES_VTEP, sizeof(*es_vtep));
1226
1227 es_vtep->es = es;
1228 es_vtep->vtep_ip.s_addr = vtep_ip.s_addr;
23aa35ad
AK		 1229 inet_ntop(AF_INET, &es_vtep->vtep_ip, es_vtep->vtep_str,
1230 sizeof(es_vtep->vtep_str));
c44ab6f1
AK		 1231 listnode_init(&es_vtep->es_listnode, es_vtep);
1232 listnode_add_sort(es->es_vtep_list, &es_vtep->es_listnode);
1233
1234 return es_vtep;
1235}
1236
1237static void bgp_evpn_es_vtep_free(struct bgp_evpn_es_vtep *es_vtep)
1238{
1239 struct bgp_evpn_es *es = es_vtep->es;
1240
1241 if (CHECK_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ESR) ||
1242 es_vtep->evi_cnt)
1243 /* as long as there is some reference we can't free it */
1244 return;
1245
1246 list_delete_node(es->es_vtep_list, &es_vtep->es_listnode);
1247 XFREE(MTYPE_BGP_EVPN_ES_VTEP, es_vtep);
1248}
1249
1250/* check if VTEP is already part of the list */
1251static struct bgp_evpn_es_vtep *bgp_evpn_es_vtep_find(struct bgp_evpn_es *es,
1252 struct in_addr vtep_ip)
1253{
1254 struct listnode *node = NULL;
1255 struct bgp_evpn_es_vtep *es_vtep;
1256
1257 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node, es_vtep)) {
1258 if (es_vtep->vtep_ip.s_addr == vtep_ip.s_addr)
1259 return es_vtep;
1260 }
1261 return NULL;
1262}
1263
1264/* Send the remote ES to zebra for NHG programming */
1265static int bgp_zebra_send_remote_es_vtep(struct bgp *bgp,
1266 struct bgp_evpn_es_vtep *es_vtep, bool add)
1267{
1268 struct bgp_evpn_es *es = es_vtep->es;
1269 struct stream *s;
74e2bd89 1270 uint32_t flags = 0;
c44ab6f1
AK		 1271
1272 /* Check socket. */
1273 if (!zclient || zclient->sock < 0)
1274 return 0;
1275
1276 /* Don't try to register if Zebra doesn't know of this instance. */
1277 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp)) {
1278 if (BGP_DEBUG(zebra, ZEBRA))
1279 zlog_debug("No zebra instance, not installing remote es %s",
1280 es->esi_str);
1281 return 0;
1282 }
1283
74e2bd89
AK		 1284 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR)
1285 flags |= ZAPI_ES_VTEP_FLAG_ESR_RXED;
1286
c44ab6f1
AK		 1287 s = zclient->obuf;
1288 stream_reset(s);
1289
1290 zclient_create_header(s,
1291 add ? ZEBRA_REMOTE_ES_VTEP_ADD : ZEBRA_REMOTE_ES_VTEP_DEL,
1292 bgp->vrf_id);
1293 stream_put(s, &es->esi, sizeof(esi_t));
1294 stream_put_ipv4(s, es_vtep->vtep_ip.s_addr);
74e2bd89
AK		 1295 if (add) {
1296 stream_putl(s, flags);
1297 stream_putc(s, es_vtep->df_alg);
1298 stream_putw(s, es_vtep->df_pref);
1299 }
c44ab6f1
AK		 1300
1301 stream_putw_at(s, 0, stream_get_endp(s));
1302
1303 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 1304 zlog_debug("Tx %s Remote ESI %s VTEP %pI4", add ? "ADD" : "DEL",
1305 es->esi_str, &es_vtep->vtep_ip);
c44ab6f1 1306
23aa35ad
AK		 1307 frrtrace(3, frr_bgp, evpn_mh_vtep_zsend, add, es, es_vtep);
1308
c44ab6f1
AK		 1309 return zclient_send_message(zclient);
1310}
1311
1312static void bgp_evpn_es_vtep_re_eval_active(struct bgp *bgp,
74e2bd89
AK		 1313 struct bgp_evpn_es_vtep *es_vtep,
1314 bool param_change)
c44ab6f1
AK		 1315{
1316 bool old_active;
1317 bool new_active;
1318
d4980edf 1319 old_active = CHECK_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE);
c44ab6f1
AK		 1320 /* currently we need an active EVI reference to use the VTEP as
1321 * a nexthop. this may change...
1322 */
1323 if (es_vtep->evi_cnt)
1324 SET_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE);
1325 else
1326 UNSET_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE);
1327
d4980edf 1328 new_active = CHECK_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE);
c44ab6f1 1329
74e2bd89 1330 if ((old_active != new_active) || (new_active && param_change)) {
c44ab6f1 1331
74e2bd89
AK		 1332 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1333 zlog_debug("es %s vtep %pI4 %s df %u/%u",
1334 es_vtep->es->esi_str, &es_vtep->vtep_ip,
1335 new_active ? "active" : "inactive",
1336 es_vtep->df_alg, es_vtep->df_pref);
c44ab6f1 1337
74e2bd89
AK		 1338 /* send remote ES to zebra */
1339 bgp_zebra_send_remote_es_vtep(bgp, es_vtep, new_active);
c44ab6f1 1340
8bcb09a1
AK		 1341 /* The NHG is updated first for efficient failover handling.
1342 * Note the NHG can be de-activated while there are bgp
1343 * routes referencing it. Zebra is capable of handling that
1344 * elegantly by holding the NHG till all routes using it are
1345 * removed.
26c03e43 1346 */
8bcb09a1 1347 bgp_evpn_l3nhg_update_on_vtep_chg(es_vtep->es);
74e2bd89
AK		 1348 /* queue up the es for background consistency checks */
1349 bgp_evpn_es_cons_checks_pend_add(es_vtep->es);
1350 }
c44ab6f1
AK		 1351}
1352
1353static struct bgp_evpn_es_vtep *bgp_evpn_es_vtep_add(struct bgp *bgp,
74e2bd89
AK		 1354 struct bgp_evpn_es *es,
1355 struct in_addr vtep_ip,
1356 bool esr, uint8_t df_alg,
1357 uint16_t df_pref)
c44ab6f1
AK		 1358{
1359 struct bgp_evpn_es_vtep *es_vtep;
74e2bd89 1360 bool param_change = false;
c44ab6f1
AK		 1361
1362 es_vtep = bgp_evpn_es_vtep_find(es, vtep_ip);
1363
1364 if (!es_vtep)
1365 es_vtep = bgp_evpn_es_vtep_new(es, vtep_ip);
1366
1367 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
74e2bd89
AK		 1368 zlog_debug("es %s vtep %pI4 add %s df %u/%u",
1369 es_vtep->es->esi_str, &es_vtep->vtep_ip,
1370 esr ? "esr" : "ead", df_alg, df_pref);
c44ab6f1 1371
74e2bd89 1372 if (esr) {
c44ab6f1 1373 SET_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ESR);
74e2bd89
AK		 1374 if ((es_vtep->df_pref != df_pref)
1375 || (es_vtep->df_alg != df_alg)) {
1376 param_change = true;
1377 es_vtep->df_pref = df_pref;
1378 es_vtep->df_alg = df_alg;
1379 }
1380 } else {
c44ab6f1 1381 ++es_vtep->evi_cnt;
74e2bd89 1382 }
c44ab6f1 1383
74e2bd89 1384 bgp_evpn_es_vtep_re_eval_active(bgp, es_vtep, param_change);
c44ab6f1
AK		 1385
1386 return es_vtep;
1387}
1388
1389static void bgp_evpn_es_vtep_do_del(struct bgp *bgp,
1390 struct bgp_evpn_es_vtep *es_vtep, bool esr)
1391{
74e2bd89
AK		 1392 bool param_change = false;
1393
c44ab6f1 1394 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 1395 zlog_debug("es %s vtep %pI4 del %s", es_vtep->es->esi_str,
1396 &es_vtep->vtep_ip, esr ? "esr" : "ead");
c44ab6f1
AK		 1397 if (esr) {
1398 UNSET_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ESR);
74e2bd89
AK		 1399 if (es_vtep->df_pref || es_vtep->df_alg) {
1400 param_change = true;
1401 es_vtep->df_pref = 0;
1402 es_vtep->df_alg = 0;
1403 }
c44ab6f1
AK		 1404 } else {
1405 if (es_vtep->evi_cnt)
1406 --es_vtep->evi_cnt;
1407 }
1408
74e2bd89 1409 bgp_evpn_es_vtep_re_eval_active(bgp, es_vtep, param_change);
c44ab6f1
AK		 1410 bgp_evpn_es_vtep_free(es_vtep);
1411}
1412
1413static void bgp_evpn_es_vtep_del(struct bgp *bgp,
1414 struct bgp_evpn_es *es, struct in_addr vtep_ip, bool esr)
1415{
1416 struct bgp_evpn_es_vtep *es_vtep;
1417
1418 es_vtep = bgp_evpn_es_vtep_find(es, vtep_ip);
1419 if (es_vtep)
1420 bgp_evpn_es_vtep_do_del(bgp, es_vtep, esr);
1421}
1422
26c03e43 1423/********************** ES MAC-IP paths *************************************
58bff4d1
AK		 1424 * 1. Local MAC-IP routes in the VNI routing table are linked to the
1425 * destination ES (macip_evi_path_list) for efficient updates on ES oper
1426 * state changes.
1427 * 2. Non-local MAC-IP routes in the global routing table are linked to
1428 * the detination for efficient updates on -
1429 * a. VTEP add/del - this results in a L3NHG update.
1430 * b. ES-VRF add/del - this may result in the host route being migrated to
1431 * L3NHG or vice versa (flat multipath list).
26c03e43 1432 ****************************************************************************/
60605cbc 1433static void bgp_evpn_path_es_info_free(struct bgp_path_es_info *es_info)
26c03e43
AK		 1434{
1435 bgp_evpn_path_es_unlink(es_info);
1436 XFREE(MTYPE_BGP_EVPN_PATH_ES_INFO, es_info);
1437}
1438
60605cbc
AK		 1439void bgp_evpn_path_mh_info_free(struct bgp_path_mh_info *mh_info)
1440{
1441 if (mh_info->es_info)
1442 bgp_evpn_path_es_info_free(mh_info->es_info);
090efa2f
AK		 1443 if (mh_info->nh_info)
1444 bgp_evpn_path_nh_info_free(mh_info->nh_info);
60605cbc
AK		 1445 XFREE(MTYPE_BGP_EVPN_PATH_MH_INFO, mh_info);
1446}
1447
26c03e43
AK		 1448static struct bgp_path_es_info *
1449bgp_evpn_path_es_info_new(struct bgp_path_info *pi, vni_t vni)
1450{
1451 struct bgp_path_info_extra *e;
60605cbc
AK		 1452 struct bgp_path_mh_info *mh_info;
1453 struct bgp_path_es_info *es_info;
26c03e43
AK		 1454
1455 e = bgp_path_info_extra_get(pi);
1456
60605cbc
AK		 1457 /* If mh_info doesn't exist allocate it */
1458 mh_info = e->mh_info;
1459 if (!mh_info)
1460 e->mh_info = mh_info = XCALLOC(MTYPE_BGP_EVPN_PATH_MH_INFO,
1461 sizeof(struct bgp_path_mh_info));
1462
26c03e43 1463 /* If es_info doesn't exist allocate it */
60605cbc
AK		 1464 es_info = mh_info->es_info;
1465 if (!es_info) {
1466 mh_info->es_info = es_info =
1467 XCALLOC(MTYPE_BGP_EVPN_PATH_ES_INFO,
1468 sizeof(struct bgp_path_es_info));
1469 es_info->vni = vni;
1470 es_info->pi = pi;
26c03e43
AK		 1471 }
1472
60605cbc 1473 return es_info;
26c03e43
AK		 1474}
1475
60605cbc 1476static void bgp_evpn_path_es_unlink(struct bgp_path_es_info *es_info)
26c03e43
AK		 1477{
1478 struct bgp_evpn_es *es = es_info->es;
1479 struct bgp_path_info *pi;
26c03e43
AK		 1480
1481 if (!es)
1482 return;
1483
1484 pi = es_info->pi;
1485 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
229587fb
AK		 1486 zlog_debug("vni %u path %pFX unlinked from es %s", es_info->vni,
1487 &pi->net->p, es->esi_str);
26c03e43 1488
58bff4d1
AK		 1489 if (es_info->vni)
1490 list_delete_node(es->macip_evi_path_list,
1491 &es_info->es_listnode);
1492 else
1493 list_delete_node(es->macip_global_path_list,
1494 &es_info->es_listnode);
74efb822 1495
26c03e43
AK		 1496 es_info->es = NULL;
1497
1498 /* if there are no other references against the ES it
1499 * needs to be freed
1500 */
1501 bgp_evpn_es_free(es, __func__);
1502
1503 /* Note we don't free the path es_info on unlink; it will be freed up
1504 * along with the path.
1505 */
1506}
1507
1508void bgp_evpn_path_es_link(struct bgp_path_info *pi, vni_t vni, esi_t *esi)
1509{
1510 struct bgp_path_es_info *es_info;
1511 struct bgp_evpn_es *es;
58bff4d1 1512 struct bgp *bgp_evpn;
26c03e43 1513
60605cbc
AK		 1514 es_info = (pi->extra && pi->extra->mh_info)
1515 ? pi->extra->mh_info->es_info
1516 : NULL;
26c03e43
AK		 1517 /* if the esi is zero just unlink the path from the old es */
1518 if (!esi || !memcmp(esi, zero_esi, sizeof(*esi))) {
1519 if (es_info)
1520 bgp_evpn_path_es_unlink(es_info);
1521 return;
1522 }
1523
58bff4d1 1524 bgp_evpn = bgp_get_evpn();
26c03e43
AK		 1525 if (!bgp_evpn)
1526 return;
1527
1528 /* setup es_info against the path if it doesn't aleady exist */
1529 if (!es_info)
1530 es_info = bgp_evpn_path_es_info_new(pi, vni);
1531
1532 /* find-create ES */
1533 es = bgp_evpn_es_find(esi);
1534 if (!es)
f61fbf21 1535 es = bgp_evpn_es_new(bgp_evpn, esi);
26c03e43
AK		 1536
1537 /* dup check */
1538 if (es_info->es == es)
1539 return;
1540
1541 /* unlink old ES if any */
1542 bgp_evpn_path_es_unlink(es_info);
1543
1544 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
229587fb
AK		 1545 zlog_debug("vni %u path %pFX linked to es %s", vni, &pi->net->p,
1546 es->esi_str);
26c03e43
AK		 1547
1548 /* link mac-ip path to the new destination ES */
1549 es_info->es = es;
1550 listnode_init(&es_info->es_listnode, es_info);
58bff4d1
AK		 1551 if (es_info->vni)
1552 listnode_add(es->macip_evi_path_list, &es_info->es_listnode);
1553 else
1554 listnode_add(es->macip_global_path_list, &es_info->es_listnode);
26c03e43
AK		 1555}
1556
74efb822
AK		 1557static bool bgp_evpn_is_macip_path(struct bgp_path_info *pi)
1558{
1559 struct prefix_evpn *evp;
1560
1561 /* Only MAC-IP routes need to be linked (MAC-only routes can be
1562 * skipped) as these lists are maintained for managing
1563 * host routes in the tenant VRF
1564 */
1565 evp = (struct prefix_evpn *)&pi->net->p;
1566 return is_evpn_prefix_ipaddr_v4(evp) || is_evpn_prefix_ipaddr_v6(evp);
1567}
1568
58bff4d1
AK		 1569/* When a remote ES is added to a VRF, routes using that as
1570 * a destination need to be migrated to a L3NHG or viceversa.
1571 * This is done indirectly by re-attempting an install of the
1572 * route in the associated VRFs. As a part of the VRF install use
1573 * of l3 NHG is evaluated and this results in the
1574 * attr.es_flag ATTR_ES_USE_L3_NHG being set or cleared.
36dd4574
AK		 1575 */
1576static void
1577bgp_evpn_es_path_update_on_es_vrf_chg(struct bgp_evpn_es_vrf *es_vrf,
58bff4d1 1578 const char *reason)
26c03e43
AK		 1579{
1580 struct listnode *node;
1581 struct bgp_path_es_info *es_info;
1582 struct bgp_path_info *pi;
58bff4d1 1583 struct bgp_evpn_es *es = es_vrf->es;
26c03e43 1584
36dd4574
AK		 1585 if (!bgp_mh_info->host_routes_use_l3nhg)
1586 return;
1587
26c03e43 1588 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
58bff4d1
AK		 1589 zlog_debug("update paths linked to es %s on es-vrf %s %s",
1590 es->esi_str, es_vrf->bgp_vrf->name, reason);
26c03e43 1591
58bff4d1 1592 for (ALL_LIST_ELEMENTS_RO(es->macip_global_path_list, node, es_info)) {
26c03e43 1593 pi = es_info->pi;
26c03e43 1594
74efb822
AK		 1595 if (!bgp_evpn_is_macip_path(pi))
1596 continue;
1597
26c03e43 1598 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
2eef4f20 1599 zlog_debug(
58bff4d1
AK		 1600 "update path %pFX linked to es %s on vrf chg",
1601 &pi->net->p, es->esi_str);
1602 bgp_evpn_route_entry_install_if_vrf_match(es_vrf->bgp_vrf, pi,
1603 1);
26c03e43
AK		 1604 }
1605}
1606
c44ab6f1
AK		 1607/* compare ES-IDs for the global ES RB tree */
1608static int bgp_es_rb_cmp(const struct bgp_evpn_es *es1,
1609 const struct bgp_evpn_es *es2)
1610{
1611 return memcmp(&es1->esi, &es2->esi, ESI_BYTES);
1612}
1613RB_GENERATE(bgp_es_rb_head, bgp_evpn_es, rb_node, bgp_es_rb_cmp);
1614
1615struct bgp_evpn_es *bgp_evpn_es_find(const esi_t *esi)
185fb14a 1616{
c44ab6f1 1617 struct bgp_evpn_es tmp;
185fb14a 1618
185fb14a 1619 memcpy(&tmp.esi, esi, sizeof(esi_t));
c44ab6f1 1620 return RB_FIND(bgp_es_rb_head, &bgp_mh_info->es_rb_tree, &tmp);
185fb14a
AK		 1621}
1622
c44ab6f1 1623static struct bgp_evpn_es *bgp_evpn_es_new(struct bgp *bgp, const esi_t *esi)
185fb14a 1624{
c44ab6f1 1625 struct bgp_evpn_es *es;
185fb14a
AK		 1626
1627 if (!bgp)
1628 return NULL;
1629
c44ab6f1 1630 es = XCALLOC(MTYPE_BGP_EVPN_ES, sizeof(struct bgp_evpn_es));
185fb14a 1631
c44ab6f1 1632 /* set the ESI */
185fb14a 1633 memcpy(&es->esi, esi, sizeof(esi_t));
185fb14a
AK		 1634
1635 /* Initialise the VTEP list */
c44ab6f1
AK		 1636 es->es_vtep_list = list_new();
1637 listset_app_node_mem(es->es_vtep_list);
1638 es->es_vtep_list->cmp = bgp_evpn_es_vtep_cmp;
185fb14a 1639
c44ab6f1 1640 esi_to_str(&es->esi, es->esi_str, sizeof(es->esi_str));
185fb14a 1641
c44ab6f1 1642 /* Initialize the ES routing table */
185fb14a
AK		 1643 es->route_table = bgp_table_init(bgp, AFI_L2VPN, SAFI_EVPN);
1644
c44ab6f1
AK		 1645 /* Add to rb_tree */
1646 if (RB_INSERT(bgp_es_rb_head, &bgp_mh_info->es_rb_tree, es)) {
185fb14a
AK		 1647 XFREE(MTYPE_BGP_EVPN_ES, es);
1648 return NULL;
1649 }
1650
c44ab6f1
AK		 1651 /* Initialise the ES-EVI list */
1652 es->es_evi_list = list_new();
1653 listset_app_node_mem(es->es_evi_list);
1654
c589d847
AK		 1655 /* Initialise the ES-VRF list used for L3NHG management */
1656 es->es_vrf_list = list_new();
1657 listset_app_node_mem(es->es_vrf_list);
1658
26c03e43 1659 /* Initialise the route list used for efficient event handling */
d656e0ae
AK		 1660 es->macip_evi_path_list = list_new();
1661 listset_app_node_mem(es->macip_evi_path_list);
58bff4d1
AK		 1662 es->macip_global_path_list = list_new();
1663 listset_app_node_mem(es->macip_global_path_list);
26c03e43 1664
c44ab6f1
AK		 1665 QOBJ_REG(es, bgp_evpn_es);
1666
185fb14a
AK		 1667 return es;
1668}
1669
c44ab6f1 1670/* Free a given ES -
185fb14a
AK		 1671 * This just frees appropriate memory, caller should have taken other
1672 * needed actions.
1673 */
45a859f1 1674static void bgp_evpn_es_free(struct bgp_evpn_es *es, const char *caller)
185fb14a 1675{
26c03e43 1676 if ((es->flags & (BGP_EVPNES_LOCAL | BGP_EVPNES_REMOTE))
58bff4d1
AK		 1677 || listcount(es->macip_evi_path_list)
1678 || listcount(es->macip_global_path_list))
c44ab6f1
AK		 1679 return;
1680
45a859f1
AK		 1681 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1682 zlog_debug("%s: es %s free", caller, es->esi_str);
1683
c44ab6f1
AK		 1684 /* cleanup resources maintained against the ES */
1685 list_delete(&es->es_evi_list);
c589d847 1686 list_delete(&es->es_vrf_list);
c44ab6f1 1687 list_delete(&es->es_vtep_list);
d656e0ae 1688 list_delete(&es->macip_evi_path_list);
58bff4d1 1689 list_delete(&es->macip_global_path_list);
185fb14a 1690 bgp_table_unlock(es->route_table);
c44ab6f1
AK		 1691
1692 /* remove the entry from various databases */
1693 RB_REMOVE(bgp_es_rb_head, &bgp_mh_info->es_rb_tree, es);
1694 bgp_evpn_es_cons_checks_pend_del(es);
1695
185fb14a
AK		 1696 QOBJ_UNREG(es);
1697 XFREE(MTYPE_BGP_EVPN_ES, es);
1698}
1699
74efb822
AK		 1700static inline bool bgp_evpn_is_es_local_and_non_bypass(struct bgp_evpn_es *es)
1701{
1702 return (es->flags & BGP_EVPNES_LOCAL)
1703 && !(es->flags & BGP_EVPNES_BYPASS);
1704}
1705
c44ab6f1
AK		 1706/* init local info associated with the ES */
1707static void bgp_evpn_es_local_info_set(struct bgp *bgp, struct bgp_evpn_es *es)
185fb14a 1708{
c44ab6f1 1709 char buf[BGP_EVPN_PREFIX_RD_LEN];
74efb822
AK		 1710 bool old_is_local;
1711 bool is_local;
185fb14a 1712
c44ab6f1
AK		 1713 if (CHECK_FLAG(es->flags, BGP_EVPNES_LOCAL))
1714 return;
185fb14a 1715
74efb822 1716 old_is_local = bgp_evpn_is_es_local_and_non_bypass(es);
c44ab6f1 1717 SET_FLAG(es->flags, BGP_EVPNES_LOCAL);
74efb822 1718
c44ab6f1
AK		 1719 listnode_init(&es->es_listnode, es);
1720 listnode_add(bgp_mh_info->local_es_list, &es->es_listnode);
185fb14a 1721
c44ab6f1
AK		 1722 /* auto derive RD for this es */
1723 bf_assign_index(bm->rd_idspace, es->rd_id);
1724 es->prd.family = AF_UNSPEC;
1725 es->prd.prefixlen = 64;
23d0a753 1726 snprintfrr(buf, sizeof(buf), "%pI4:%hu", &bgp->router_id, es->rd_id);
c44ab6f1 1727 (void)str2prefix_rd(buf, &es->prd);
74efb822
AK		 1728
1729 is_local = bgp_evpn_is_es_local_and_non_bypass(es);
1730 if (old_is_local != is_local)
1731 bgp_evpn_mac_update_on_es_local_chg(es, is_local);
c44ab6f1
AK		 1732}
1733
1734/* clear any local info associated with the ES */
d57e0c05 1735static void bgp_evpn_es_local_info_clear(struct bgp_evpn_es *es, bool finish)
c44ab6f1 1736{
74efb822
AK		 1737 bool old_is_local;
1738 bool is_local;
1739
c44ab6f1
AK		 1740 if (!CHECK_FLAG(es->flags, BGP_EVPNES_LOCAL))
1741 return;
185fb14a 1742
74efb822 1743 old_is_local = bgp_evpn_is_es_local_and_non_bypass(es);
c44ab6f1 1744 UNSET_FLAG(es->flags, BGP_EVPNES_LOCAL);
185fb14a 1745
74efb822 1746 is_local = bgp_evpn_is_es_local_and_non_bypass(es);
d57e0c05 1747 if (!finish && (old_is_local != is_local))
74efb822
AK		 1748 bgp_evpn_mac_update_on_es_local_chg(es, is_local);
1749
c44ab6f1
AK		 1750 /* remove from the ES local list */
1751 list_delete_node(bgp_mh_info->local_es_list, &es->es_listnode);
1752
1753 bf_release_index(bm->rd_idspace, es->rd_id);
1754
45a859f1 1755 bgp_evpn_es_free(es, __func__);
185fb14a
AK		 1756}
1757
c44ab6f1
AK		 1758/* eval remote info associated with the ES */
1759static void bgp_evpn_es_remote_info_re_eval(struct bgp_evpn_es *es)
1760{
1761 if (es->remote_es_evi_cnt) {
1762 SET_FLAG(es->flags, BGP_EVPNES_REMOTE);
1763 } else {
1764 if (CHECK_FLAG(es->flags, BGP_EVPNES_REMOTE)) {
1765 UNSET_FLAG(es->flags, BGP_EVPNES_REMOTE);
45a859f1 1766 bgp_evpn_es_free(es, __func__);
c44ab6f1
AK		 1767 }
1768 }
1769}
1770
70524092
AK		 1771/* If ES is present and local it needs to be active/oper-up for
1772 * including L3 EC
1773 */
1774bool bgp_evpn_es_add_l3_ecomm_ok(esi_t *esi)
74be8313 1775{
70524092
AK		 1776 struct bgp_evpn_es *es;
1777
1778 if (!esi || !bgp_mh_info->suppress_l3_ecomm_on_inactive_es)
1779 return true;
1780
1781 es = bgp_evpn_es_find(esi);
1782
1783 return (!es || !(es->flags & BGP_EVPNES_LOCAL)
1784 || bgp_evpn_local_es_is_active(es));
1785}
1786
74efb822
AK		 1787static bool bgp_evpn_is_valid_local_path(struct bgp_path_info *pi)
1788{
1789 return (CHECK_FLAG(pi->flags, BGP_PATH_VALID)
1790 && pi->type == ZEBRA_ROUTE_BGP
1791 && pi->sub_type == BGP_ROUTE_STATIC);
1792}
1793
d656e0ae
AK		 1794/* Update all local MAC-IP routes in the VNI routing table associated
1795 * with the ES. When the ES is down the routes are advertised without
1796 * the L3 extcomm
70524092
AK		 1797 */
1798static void bgp_evpn_mac_update_on_es_oper_chg(struct bgp_evpn_es *es)
1799{
1800 struct listnode *node;
1801 struct bgp_path_es_info *es_info;
1802 struct bgp_path_info *pi;
70524092
AK		 1803 struct bgp *bgp;
1804 struct bgpevpn *vpn;
1805
1806 if (!bgp_mh_info->suppress_l3_ecomm_on_inactive_es)
1807 return;
1808
1809 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1810 zlog_debug("update paths linked to es %s on oper chg",
1811 es->esi_str);
1812
1813 bgp = bgp_get_evpn();
d656e0ae 1814 for (ALL_LIST_ELEMENTS_RO(es->macip_evi_path_list, node, es_info)) {
70524092 1815 pi = es_info->pi;
74efb822
AK		 1816
1817 if (!bgp_evpn_is_valid_local_path(pi))
70524092
AK		 1818 continue;
1819
74efb822 1820 if (!bgp_evpn_is_macip_path(pi))
70524092
AK		 1821 continue;
1822
1823 vpn = bgp_evpn_lookup_vni(bgp, es_info->vni);
1824 if (!vpn)
1825 continue;
1826
1827 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
58bff4d1 1828 zlog_debug(
70545a29
AK		 1829 "update path %d %pFX linked to es %s on oper chg",
1830 es_info->vni, &pi->net->p, es->esi_str);
70524092
AK		 1831
1832 bgp_evpn_update_type2_route_entry(bgp, vpn, pi->net, pi,
1833 __func__);
1834 }
74be8313
AK		 1835}
1836
74efb822
AK		 1837static bool bgp_evpn_is_valid_bgp_path(struct bgp_path_info *pi)
1838{
1839 return (CHECK_FLAG(pi->flags, BGP_PATH_VALID)
1840 && pi->type == ZEBRA_ROUTE_BGP
1841 && pi->sub_type == BGP_ROUTE_NORMAL);
1842}
1843
1844/* If an ES is no longer local (or becomes local) we need to re-install
1845 * paths using that ES as destination. This is needed as the criteria
1846 * for best path selection has changed.
1847 */
1848static void bgp_evpn_mac_update_on_es_local_chg(struct bgp_evpn_es *es,
1849 bool is_local)
1850{
1851 struct listnode *node;
1852 struct bgp_path_es_info *es_info;
1853 struct bgp_path_info *pi;
74efb822
AK		 1854 bool tmp_local;
1855 struct attr *attr_new;
1856 struct attr attr_tmp;
1857
1858 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1859 zlog_debug("update paths linked to es %s on chg to %s",
1860 es->esi_str, is_local ? "local" : "non-local");
1861
1862 for (ALL_LIST_ELEMENTS_RO(es->macip_global_path_list, node, es_info)) {
1863 pi = es_info->pi;
1864
1865 /* Consider "valid" remote routes */
1866 if (!bgp_evpn_is_valid_bgp_path(pi))
1867 continue;
1868
1869 if (!pi->attr)
1870 continue;
1871
1872 tmp_local = !!(pi->attr->es_flags & ATTR_ES_IS_LOCAL);
1873 if (tmp_local == is_local)
1874 continue;
1875
1876 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
1877 zlog_debug(
70545a29
AK		 1878 "update path %pFX linked to es %s on chg to %s",
1879 &pi->net->p, es->esi_str,
1880 is_local ? "local" : "non-local");
74efb822
AK		 1881
1882 attr_tmp = *pi->attr;
1883 if (is_local)
1884 attr_tmp.es_flags |= ATTR_ES_IS_LOCAL;
1885 else
1886 attr_tmp.es_flags &= ~ATTR_ES_IS_LOCAL;
1887 attr_new = bgp_attr_intern(&attr_tmp);
1888 bgp_attr_unintern(&pi->attr);
1889 pi->attr = attr_new;
1890 bgp_evpn_import_type2_route(pi, 1);
1891 }
1892}
1893
74be8313
AK		 1894static void bgp_evpn_local_es_deactivate(struct bgp *bgp,
1895 struct bgp_evpn_es *es)
185fb14a 1896{
185fb14a 1897 struct prefix_evpn p;
c44ab6f1 1898 int ret;
185fb14a 1899
c44ab6f1
AK		 1900 /* withdraw ESR */
1901 /* Delete and withdraw locally learnt ES route */
1902 build_evpn_type4_prefix(&p, &es->esi, es->originator_ip);
1903 ret = bgp_evpn_type4_route_delete(bgp, es, &p);
1904 if (ret) {
1905 flog_err(EC_BGP_EVPN_ROUTE_DELETE,
1906 "%u failed to delete type-4 route for ESI %s",
1907 bgp->vrf_id, es->esi_str);
185fb14a
AK		 1908 }
1909
c44ab6f1
AK		 1910 /* withdraw EAD-EVI */
1911 if (!bgp_mh_info->ead_evi_adv_for_down_links)
1912 bgp_evpn_local_type1_evi_route_del(bgp, es);
185fb14a 1913
c44ab6f1
AK		 1914 /* withdraw EAD-ES */
1915 build_evpn_type1_prefix(&p, BGP_EVPN_AD_ES_ETH_TAG,
1916 &es->esi, es->originator_ip);
1917 ret = bgp_evpn_type1_es_route_delete(bgp, es, &p);
1918 if (ret) {
1919 flog_err(EC_BGP_EVPN_ROUTE_DELETE,
1920 "%u failed to delete type-1 route for ESI %s",
1921 bgp->vrf_id, es->esi_str);
1922 }
70524092
AK		 1923
1924 bgp_evpn_mac_update_on_es_oper_chg(es);
c44ab6f1
AK		 1925}
1926
74be8313
AK		 1927/* Process ES link oper-down by withdrawing ES-EAD and ESR */
1928static void bgp_evpn_local_es_down(struct bgp *bgp, struct bgp_evpn_es *es)
c44ab6f1 1929{
74be8313 1930 bool old_active;
c44ab6f1 1931
74be8313
AK		 1932 if (!CHECK_FLAG(es->flags, BGP_EVPNES_OPER_UP))
1933 return;
c44ab6f1 1934
74be8313
AK		 1935 old_active = bgp_evpn_local_es_is_active(es);
1936 UNSET_FLAG(es->flags, BGP_EVPNES_OPER_UP);
1937
1938 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1939 zlog_debug("local es %s down", es->esi_str);
1940
1941 if (old_active)
1942 bgp_evpn_local_es_deactivate(bgp, es);
1943}
1944
1945static void bgp_evpn_local_es_activate(struct bgp *bgp, struct bgp_evpn_es *es,
1946 bool regen_ead, bool regen_esr)
1947{
1948 struct prefix_evpn p;
c44ab6f1 1949
74e2bd89
AK		 1950 if (regen_esr) {
1951 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1952 zlog_debug("local es %s generate ESR", es->esi_str);
1953 /* generate ESR */
1954 build_evpn_type4_prefix(&p, &es->esi, es->originator_ip);
1955 if (bgp_evpn_type4_route_update(bgp, es, &p))
1956 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
1957 "%u: Type4 route creation failure for ESI %s",
1958 bgp->vrf_id, es->esi_str);
1959 }
c44ab6f1 1960
74e2bd89
AK		 1961 if (regen_ead) {
1962 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1963 zlog_debug("local es %s generate EAD", es->esi_str);
1964 /* generate EAD-EVI */
1965 bgp_evpn_local_type1_evi_route_add(bgp, es);
c44ab6f1 1966
74e2bd89
AK		 1967 /* generate EAD-ES */
1968 build_evpn_type1_prefix(&p, BGP_EVPN_AD_ES_ETH_TAG, &es->esi,
1969 es->originator_ip);
d934e491 1970 (void)bgp_evpn_type1_route_update(bgp, es, NULL, &p);
74e2bd89 1971 }
70524092
AK		 1972
1973 bgp_evpn_mac_update_on_es_oper_chg(es);
c44ab6f1
AK		 1974}
1975
74be8313
AK		 1976/* Process ES link oper-up by generating ES-EAD and ESR */
1977static void bgp_evpn_local_es_up(struct bgp *bgp, struct bgp_evpn_es *es,
1978 bool regen_esr)
1979{
1980 bool regen_ead = false;
1981 bool active = false;
1982
1983 if (!CHECK_FLAG(es->flags, BGP_EVPNES_OPER_UP)) {
1984 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
1985 zlog_debug("local es %s up", es->esi_str);
1986
1987 SET_FLAG(es->flags, BGP_EVPNES_OPER_UP);
1988 regen_esr = true;
1989 regen_ead = true;
1990 }
1991
1992 active = bgp_evpn_local_es_is_active(es);
1993 if (active && (regen_ead || regen_esr))
1994 bgp_evpn_local_es_activate(bgp, es, regen_ead, regen_esr);
1995}
1996
1997/* If an ethernet segment is in LACP bypass we cannot advertise
1998 * reachability to it i.e. EAD-per-ES and ESR is not advertised in
1999 * bypass state.
2000 * PS: EAD-per-EVI will continue to be advertised
2001 */
2002static void bgp_evpn_local_es_bypass_update(struct bgp *bgp,
2003 struct bgp_evpn_es *es, bool bypass)
2004{
2005 bool old_bypass = !!(es->flags & BGP_EVPNES_BYPASS);
2006 bool old_active;
2007 bool new_active;
74efb822
AK		 2008 bool old_is_local;
2009 bool is_local;
74be8313
AK		 2010
2011 if (bypass == old_bypass)
2012 return;
2013
2014 old_active = bgp_evpn_local_es_is_active(es);
74efb822 2015 old_is_local = bgp_evpn_is_es_local_and_non_bypass(es);
74be8313
AK		 2016 if (bypass)
2017 SET_FLAG(es->flags, BGP_EVPNES_BYPASS);
2018 else
2019 UNSET_FLAG(es->flags, BGP_EVPNES_BYPASS);
2020
2021 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2022 zlog_debug("local es %s bypass %s", es->esi_str,
2023 bypass ? "set" : "clear");
2024
2025 new_active = bgp_evpn_local_es_is_active(es);
2026 if (old_active != new_active) {
2027 if (new_active)
2028 bgp_evpn_local_es_activate(bgp, es, true, true);
2029 else
2030 bgp_evpn_local_es_deactivate(bgp, es);
2031 }
74efb822
AK		 2032
2033 is_local = bgp_evpn_is_es_local_and_non_bypass(es);
2034 if (old_is_local != is_local)
2035 bgp_evpn_mac_update_on_es_local_chg(es, is_local);
74be8313
AK		 2036}
2037
c44ab6f1
AK		 2038static void bgp_evpn_local_es_do_del(struct bgp *bgp, struct bgp_evpn_es *es)
2039{
2040 struct bgp_evpn_es_evi *es_evi;
2041 struct listnode *evi_node, *evi_next_node;
2042
2043 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2044 zlog_debug("del local es %s", es->esi_str);
2045
2046 /* Delete all local EVPN ES routes from ESI table
2047 * and schedule for processing (to withdraw from peers))
2048 */
2049 bgp_evpn_es_route_del_all(bgp, es);
2050
2051 /* release all local ES EVIs associated with the ES */
2052 for (ALL_LIST_ELEMENTS(es->es_evi_list, evi_node,
2053 evi_next_node, es_evi)) {
2054 bgp_evpn_local_es_evi_do_del(es_evi);
2055 }
2056
2057 /* Clear local info associated with the ES and free it up if there is
2058 * no remote reference
2059 */
d57e0c05 2060 bgp_evpn_es_local_info_clear(es, false);
c44ab6f1
AK		 2061}
2062
74efb822 2063bool bgp_evpn_is_esi_local_and_non_bypass(esi_t *esi)
7904e9fd
AK		 2064{
2065 struct bgp_evpn_es *es = NULL;
2066
2067 /* Lookup ESI hash - should exist. */
2068 es = bgp_evpn_es_find(esi);
74efb822
AK		 2069
2070 return es && bgp_evpn_is_es_local_and_non_bypass(es);
7904e9fd
AK		 2071}
2072
c44ab6f1
AK		 2073int bgp_evpn_local_es_del(struct bgp *bgp, esi_t *esi)
2074{
2075 struct bgp_evpn_es *es = NULL;
2076
2077 /* Lookup ESI hash - should exist. */
2078 es = bgp_evpn_es_find(esi);
2079 if (!es) {
eaf80288
DA		 2080 flog_warn(EC_BGP_EVPN_ESI, "%u: ES missing at local ES DEL",
2081 bgp->vrf_id);
c44ab6f1
AK		 2082 return -1;
2083 }
2084
2085 bgp_evpn_local_es_do_del(bgp, es);
2086 return 0;
2087}
2088
2089/* Handle device to ES id association. Results in the creation of a local
2090 * ES.
2091 */
2092int bgp_evpn_local_es_add(struct bgp *bgp, esi_t *esi,
74e2bd89 2093 struct in_addr originator_ip, bool oper_up,
74be8313 2094 uint16_t df_pref, bool bypass)
c44ab6f1
AK		 2095{
2096 char buf[ESI_STR_LEN];
2097 struct bgp_evpn_es *es;
2098 bool new_es = true;
74e2bd89 2099 bool regen_esr = false;
c44ab6f1
AK		 2100
2101 /* create the new es */
2102 es = bgp_evpn_es_find(esi);
2103 if (es) {
2104 if (CHECK_FLAG(es->flags, BGP_EVPNES_LOCAL))
2105 new_es = false;
2106 } else {
2107 es = bgp_evpn_es_new(bgp, esi);
2108 if (!es) {
2109 flog_err(EC_BGP_ES_CREATE,
2110 "%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
2111 bgp->vrf_id, esi_to_str(esi, buf, sizeof(buf)));
2112 return -1;
2113 }
2114 }
2115
2116 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
74be8313
AK		 2117 zlog_debug("add local es %s orig-ip %pI4 df_pref %u %s",
2118 es->esi_str, &originator_ip, df_pref,
2119 bypass ? "bypass" : "");
c44ab6f1
AK		 2120
2121 es->originator_ip = originator_ip;
74e2bd89
AK		 2122 if (df_pref != es->df_pref) {
2123 es->df_pref = df_pref;
2124 regen_esr = true;
2125 }
c44ab6f1
AK		 2126 bgp_evpn_es_local_info_set(bgp, es);
2127
2128 /* import all remote Type-4 routes in the ES table */
2129 if (new_es)
2130 bgp_evpn_type4_remote_routes_import(bgp, es,
2131 true /* install */);
2132
2133 /* create and advertise EAD-EVI routes for the ES -
2134 * XXX - till an ES-EVI reference is created there is really nothing to
2135 * advertise
2136 */
2137 if (bgp_mh_info->ead_evi_adv_for_down_links)
2138 bgp_evpn_local_type1_evi_route_add(bgp, es);
2139
74be8313
AK		 2140 bgp_evpn_local_es_bypass_update(bgp, es, bypass);
2141
c44ab6f1
AK		 2142 /* If the ES link is operationally up generate EAD-ES. EAD-EVI
2143 * can be generated even if the link is inactive.
2144 */
2145 if (oper_up)
74e2bd89 2146 bgp_evpn_local_es_up(bgp, es, regen_esr);
c44ab6f1
AK		 2147 else
2148 bgp_evpn_local_es_down(bgp, es);
2149
2150 return 0;
2151}
2152
9e0c2fd1
AK		 2153static char *bgp_evpn_es_vteps_str(char *vtep_str, struct bgp_evpn_es *es,
2154 uint8_t vtep_str_size)
c44ab6f1
AK		 2155{
2156 char vtep_flag_str[BGP_EVPN_FLAG_STR_SZ];
2157 struct listnode *node;
2158 struct bgp_evpn_es_vtep *es_vtep;
2159 bool first = true;
ec779825 2160 char ip_buf[INET6_ADDRSTRLEN];
c44ab6f1
AK		 2161
2162 vtep_str[0] = '\0';
2163 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node, es_vtep)) {
2164 vtep_flag_str[0] = '\0';
23d0a753 2165
c44ab6f1 2166 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR)
9e0c2fd1 2167 strlcat(vtep_flag_str, "E", sizeof(vtep_flag_str));
c44ab6f1 2168 if (es_vtep->flags & BGP_EVPNES_VTEP_ACTIVE)
9e0c2fd1 2169 strlcat(vtep_flag_str, "A", sizeof(vtep_flag_str));
c44ab6f1
AK		 2170
2171 if (!strlen(vtep_flag_str))
9e0c2fd1
AK		 2172 strlcat(vtep_flag_str, "-", sizeof(vtep_flag_str));
2173 if (first)
c44ab6f1 2174 first = false;
9e0c2fd1
AK		 2175 else
2176 strlcat(vtep_str, ",", vtep_str_size);
23d0a753 2177 strlcat(vtep_str,
ec779825
AK		 2178 inet_ntop(AF_INET, &es_vtep->vtep_ip, ip_buf,
2179 sizeof(ip_buf)),
23d0a753 2180 vtep_str_size);
9e0c2fd1
AK		 2181 strlcat(vtep_str, "(", vtep_str_size);
2182 strlcat(vtep_str, vtep_flag_str, vtep_str_size);
2183 strlcat(vtep_str, ")", vtep_str_size);
c44ab6f1
AK		 2184 }
2185
2186 return vtep_str;
2187}
2188
c44ab6f1
AK		 2189static void bgp_evpn_es_json_vtep_fill(json_object *json_vteps,
2190 struct bgp_evpn_es_vtep *es_vtep)
2191{
2192 json_object *json_vtep_entry;
2193 json_object *json_flags;
2194
2195 json_vtep_entry = json_object_new_object();
2196
c949c771
DA		 2197 json_object_string_addf(json_vtep_entry, "vtep_ip", "%pI4",
2198 &es_vtep->vtep_ip);
c44ab6f1
AK		 2199 if (es_vtep->flags & (BGP_EVPNES_VTEP_ESR |
2200 BGP_EVPNES_VTEP_ACTIVE)) {
2201 json_flags = json_object_new_array();
2202 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR)
2203 json_array_string_add(json_flags, "esr");
2204 if (es_vtep->flags & BGP_EVPNES_VTEP_ACTIVE)
2205 json_array_string_add(json_flags, "active");
2206 json_object_object_add(json_vtep_entry, "flags", json_flags);
74e2bd89
AK		 2207 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR) {
2208 json_object_int_add(json_vtep_entry, "dfPreference",
2209 es_vtep->df_pref);
2210 json_object_int_add(json_vtep_entry, "dfAlgorithm",
2211 es_vtep->df_pref);
2212 }
c44ab6f1
AK		 2213 }
2214
2215 json_object_array_add(json_vteps,
2216 json_vtep_entry);
2217}
2218
74e2bd89
AK		 2219static void bgp_evpn_es_vteps_show_detail(struct vty *vty,
2220 struct bgp_evpn_es *es)
2221{
2222 char vtep_flag_str[BGP_EVPN_FLAG_STR_SZ];
2223 struct listnode *node;
2224 struct bgp_evpn_es_vtep *es_vtep;
2225 char alg_buf[EVPN_DF_ALG_STR_LEN];
2226
2227 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node, es_vtep)) {
2228 vtep_flag_str[0] = '\0';
2229 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR)
2230 strlcat(vtep_flag_str, "E", sizeof(vtep_flag_str));
2231 if (es_vtep->flags & BGP_EVPNES_VTEP_ACTIVE)
2232 strlcat(vtep_flag_str, "A", sizeof(vtep_flag_str));
2233
2234 if (!strlen(vtep_flag_str))
2235 strlcat(vtep_flag_str, "-", sizeof(vtep_flag_str));
2236
ec779825 2237 vty_out(vty, " %pI4 flags: %s", &es_vtep->vtep_ip,
74e2bd89
AK		 2238 vtep_flag_str);
2239
2240 if (es_vtep->flags & BGP_EVPNES_VTEP_ESR)
2241 vty_out(vty, " df_alg: %s df_pref: %u\n",
2242 evpn_es_df_alg2str(es_vtep->df_alg, alg_buf,
2243 sizeof(alg_buf)),
2244 es_vtep->df_pref);
2245 else
2246 vty_out(vty, "\n");
2247 }
2248}
2249
c44ab6f1
AK		 2250static void bgp_evpn_es_show_entry(struct vty *vty,
2251 struct bgp_evpn_es *es, json_object *json)
2252{
2253 char buf1[RD_ADDRSTRLEN];
2254 struct listnode *node;
2255 struct bgp_evpn_es_vtep *es_vtep;
2256
2257 if (json) {
2258 json_object *json_vteps;
2259 json_object *json_types;
2260
2261 json_object_string_add(json, "esi", es->esi_str);
2262 json_object_string_add(json, "rd",
2263 prefix_rd2str(&es->prd, buf1,
2264 sizeof(buf1)));
2265
2266 if (es->flags & (BGP_EVPNES_LOCAL | BGP_EVPNES_REMOTE)) {
2267 json_types = json_object_new_array();
2268 if (es->flags & BGP_EVPNES_LOCAL)
2269 json_array_string_add(json_types, "local");
2270 if (es->flags & BGP_EVPNES_REMOTE)
2271 json_array_string_add(json_types, "remote");
2272 json_object_object_add(json, "type", json_types);
2273 }
2274
2275 if (listcount(es->es_vtep_list)) {
2276 json_vteps = json_object_new_array();
2277 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list,
2278 node, es_vtep)) {
2279 bgp_evpn_es_json_vtep_fill(json_vteps, es_vtep);
2280 }
2281 json_object_object_add(json, "vteps", json_vteps);
2282 }
2283 json_object_int_add(json, "vniCount",
2284 listcount(es->es_evi_list));
2285 } else {
2286 char type_str[4];
2287 char vtep_str[ES_VTEP_LIST_STR_SZ + BGP_EVPN_VTEPS_FLAG_STR_SZ];
2288
2289 type_str[0] = '\0';
74be8313
AK		 2290 if (es->flags & BGP_EVPNES_BYPASS)
2291 strlcat(type_str, "B", sizeof(type_str));
c44ab6f1 2292 if (es->flags & BGP_EVPNES_LOCAL)
9e0c2fd1 2293 strlcat(type_str, "L", sizeof(type_str));
c44ab6f1 2294 if (es->flags & BGP_EVPNES_REMOTE)
9e0c2fd1 2295 strlcat(type_str, "R", sizeof(type_str));
c44ab6f1 2296 if (es->inconsistencies)
9e0c2fd1 2297 strlcat(type_str, "I", sizeof(type_str));
c44ab6f1 2298
9e0c2fd1 2299 bgp_evpn_es_vteps_str(vtep_str, es, sizeof(vtep_str));
c44ab6f1
AK		 2300
2301 if (es->flags & BGP_EVPNES_LOCAL)
2302 prefix_rd2str(&es->prd, buf1, sizeof(buf1));
2303 else
9e0c2fd1 2304 strlcpy(buf1, "-", sizeof(buf1));
c44ab6f1
AK		 2305
2306 vty_out(vty, "%-30s %-5s %-21s %-8d %s\n",
2307 es->esi_str, type_str, buf1,
2308 listcount(es->es_evi_list), vtep_str);
2309 }
2310}
2311
2312static void bgp_evpn_es_show_entry_detail(struct vty *vty,
2313 struct bgp_evpn_es *es, json_object *json)
2314{
2315 if (json) {
2316 json_object *json_flags;
2317 json_object *json_incons;
74e2bd89
AK		 2318 json_object *json_vteps;
2319 struct listnode *node;
2320 struct bgp_evpn_es_vtep *es_vtep;
c44ab6f1
AK		 2321
2322 /* Add the "brief" info first */
2323 bgp_evpn_es_show_entry(vty, es, json);
74be8313
AK		 2324 if (es->flags
2325 & (BGP_EVPNES_OPER_UP | BGP_EVPNES_ADV_EVI
2326 | BGP_EVPNES_BYPASS)) {
c44ab6f1
AK		 2327 json_flags = json_object_new_array();
2328 if (es->flags & BGP_EVPNES_OPER_UP)
2329 json_array_string_add(json_flags, "up");
2330 if (es->flags & BGP_EVPNES_ADV_EVI)
2331 json_array_string_add(json_flags,
2332 "advertiseEVI");
74be8313
AK		 2333 if (es->flags & BGP_EVPNES_BYPASS)
2334 json_array_string_add(json_flags, "bypass");
c44ab6f1
AK		 2335 json_object_object_add(json, "flags", json_flags);
2336 }
c949c771
DA		 2337 json_object_string_addf(json, "originator_ip", "%pI4",
2338 &es->originator_ip);
c44ab6f1
AK		 2339 json_object_int_add(json, "remoteVniCount",
2340 es->remote_es_evi_cnt);
229587fb
AK		 2341 json_object_int_add(json, "vrfCount",
2342 listcount(es->es_vrf_list));
2343 json_object_int_add(json, "macipPathCount",
d656e0ae 2344 listcount(es->macip_evi_path_list));
58bff4d1
AK		 2345 json_object_int_add(json, "macipGlobalPathCount",
2346 listcount(es->macip_global_path_list));
c44ab6f1
AK		 2347 json_object_int_add(json, "inconsistentVniVtepCount",
2348 es->incons_evi_vtep_cnt);
74e2bd89
AK		 2349 if (listcount(es->es_vtep_list)) {
2350 json_vteps = json_object_new_array();
2351 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node,
2352 es_vtep)) {
2353 bgp_evpn_es_json_vtep_fill(json_vteps, es_vtep);
2354 }
2355 json_object_object_add(json, "vteps", json_vteps);
2356 }
c44ab6f1
AK		 2357 if (es->inconsistencies) {
2358 json_incons = json_object_new_array();
2359 if (es->inconsistencies & BGP_EVPNES_INCONS_VTEP_LIST)
2360 json_array_string_add(json_incons,
2361 "vni-vtep-mismatch");
2362 json_object_object_add(json, "inconsistencies",
2363 json_incons);
2364 }
2365 } else {
2366 char incons_str[BGP_EVPNES_INCONS_STR_SZ];
2367 char type_str[4];
c44ab6f1
AK		 2368 char buf1[RD_ADDRSTRLEN];
2369
2370 type_str[0] = '\0';
2371 if (es->flags & BGP_EVPNES_LOCAL)
9e0c2fd1 2372 strlcat(type_str, "L", sizeof(type_str));
c44ab6f1 2373 if (es->flags & BGP_EVPNES_REMOTE)
9e0c2fd1 2374 strlcat(type_str, "R", sizeof(type_str));
c44ab6f1 2375
c44ab6f1
AK		 2376 if (es->flags & BGP_EVPNES_LOCAL)
2377 prefix_rd2str(&es->prd, buf1, sizeof(buf1));
2378 else
9e0c2fd1 2379 strlcpy(buf1, "-", sizeof(buf1));
c44ab6f1
AK		 2380
2381 vty_out(vty, "ESI: %s\n", es->esi_str);
2382 vty_out(vty, " Type: %s\n", type_str);
2383 vty_out(vty, " RD: %s\n", buf1);
23d0a753 2384 vty_out(vty, " Originator-IP: %pI4\n", &es->originator_ip);
74e2bd89
AK		 2385 if (es->flags & BGP_EVPNES_LOCAL)
2386 vty_out(vty, " Local ES DF preference: %u\n",
2387 es->df_pref);
74be8313
AK		 2388 if (es->flags & BGP_EVPNES_BYPASS)
2389 vty_out(vty, " LACP bypass: on\n");
c44ab6f1
AK		 2390 vty_out(vty, " VNI Count: %d\n", listcount(es->es_evi_list));
2391 vty_out(vty, " Remote VNI Count: %d\n",
2392 es->remote_es_evi_cnt);
229587fb 2393 vty_out(vty, " VRF Count: %d\n", listcount(es->es_vrf_list));
58bff4d1 2394 vty_out(vty, " MACIP EVI Path Count: %d\n",
d656e0ae 2395 listcount(es->macip_evi_path_list));
58bff4d1
AK		 2396 vty_out(vty, " MACIP Global Path Count: %d\n",
2397 listcount(es->macip_global_path_list));
c44ab6f1
AK		 2398 vty_out(vty, " Inconsistent VNI VTEP Count: %d\n",
2399 es->incons_evi_vtep_cnt);
2400 if (es->inconsistencies) {
2401 incons_str[0] = '\0';
2402 if (es->inconsistencies & BGP_EVPNES_INCONS_VTEP_LIST)
9e0c2fd1
AK		 2403 strlcat(incons_str, "vni-vtep-mismatch",
2404 sizeof(incons_str));
c44ab6f1 2405 } else {
9e0c2fd1 2406 strlcpy(incons_str, "-", sizeof(incons_str));
c44ab6f1
AK		 2407 }
2408 vty_out(vty, " Inconsistencies: %s\n",
2409 incons_str);
74e2bd89
AK		 2410 if (listcount(es->es_vtep_list)) {
2411 vty_out(vty, " VTEPs:\n");
2412 bgp_evpn_es_vteps_show_detail(vty, es);
2413 }
c44ab6f1
AK		 2414 vty_out(vty, "\n");
2415 }
2416}
2417
2418/* Display all ESs */
2419void bgp_evpn_es_show(struct vty *vty, bool uj, bool detail)
2420{
2421 struct bgp_evpn_es *es;
9c7edc03 2422 json_object *json_array = NULL;
c44ab6f1
AK		 2423 json_object *json = NULL;
2424
2425 if (uj) {
2426 /* create an array of ESs */
2427 json_array = json_object_new_array();
2428 } else {
2429 if (!detail) {
2430 vty_out(vty,
74be8313 2431 "ES Flags: B - bypass, L local, R remote, I inconsistent\n");
c44ab6f1
AK		 2432 vty_out(vty,
2433 "VTEP Flags: E ESR/Type-4, A active nexthop\n");
2434 vty_out(vty,
2435 "%-30s %-5s %-21s %-8s %s\n",
2436 "ESI", "Flags", "RD", "#VNIs", "VTEPs");
2437 }
2438 }
2439
2440 RB_FOREACH(es, bgp_es_rb_head, &bgp_mh_info->es_rb_tree) {
2441 if (uj)
2442 /* create a separate json object for each ES */
2443 json = json_object_new_object();
2444 if (detail)
2445 bgp_evpn_es_show_entry_detail(vty, es, json);
2446 else
2447 bgp_evpn_es_show_entry(vty, es, json);
2448 /* add ES to the json array */
2449 if (uj)
2450 json_object_array_add(json_array, json);
2451 }
2452
2453 /* print the array of json-ESs */
c48349e3 2454 if (uj)
75eeda93 2455 vty_json(vty, json_array);
c44ab6f1
AK		 2456}
2457
2458/* Display specific ES */
2459void bgp_evpn_es_show_esi(struct vty *vty, esi_t *esi, bool uj)
2460{
2461 struct bgp_evpn_es *es;
2462 json_object *json = NULL;
2463
2464 if (uj)
2465 json = json_object_new_object();
2466
2467 es = bgp_evpn_es_find(esi);
2468 if (es) {
2469 bgp_evpn_es_show_entry_detail(vty, es, json);
2470 } else {
2471 if (!uj)
2472 vty_out(vty, "ESI not found\n");
2473 }
2474
c48349e3 2475 if (uj)
75eeda93 2476 vty_json(vty, json);
c44ab6f1
AK		 2477}
2478
c589d847
AK		 2479/*****************************************************************************/
2480/* Ethernet Segment to VRF association -
2481 * 1. Each ES-EVI entry is associated with a tenant VRF. This associaton
2482 * triggers the creation of an ES-VRF entry.
2483 * 2. The ES-VRF entry is maintained for the purpose of L3-NHG creation
2484 * 3. Type-2/MAC-IP routes are imported into a tenant VRF and programmed as
2485 * a /32 or host route entry in the dataplane. If the destination of
2486 * the host route is a remote-ES the route is programmed with the
2487 * corresponding (keyed in by {vrf,ES-id}) L3-NHG.
2488 * 4. The reason for this indirection (route->L3-NHG, L3-NHG->list-of-VTEPs)
2489 * is to avoid route updates to the dplane when a remote-ES link flaps i.e.
2490 * instead of updating all the dependent routes the NHG's contents are updated.
2491 * This reduces the amount of datplane updates (nhg updates vs. route updates)
2492 * allowing for a faster failover.
2493 *
2494 * XXX - can the L3 SVI index change without change in vpn->bgp_vrf
2495 * association? If yes we need to handle that by updating all the L3 NHGs
2496 * in that VRF.
2497 */
2498/******************************** L3 NHG management *************************/
8bcb09a1
AK		 2499static void bgp_evpn_l3nhg_zebra_add_v4_or_v6(struct bgp_evpn_es_vrf *es_vrf,
2500 bool v4_nhg)
c589d847 2501{
8bcb09a1
AK		 2502 uint32_t nhg_id = v4_nhg ? es_vrf->nhg_id : es_vrf->v6_nhg_id;
2503 struct bgp_evpn_es *es = es_vrf->es;
c589d847
AK		 2504 struct listnode *node;
2505 struct bgp_evpn_es_vtep *es_vtep;
8bcb09a1
AK		 2506 struct nexthop nh;
2507 struct zapi_nexthop *api_nh;
2508 struct zapi_nhg api_nhg = {};
2509
2510 /* Skip installation of L3-NHG if host routes used */
2511 if (!nhg_id)
2512 return;
c589d847
AK		 2513
2514 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1
AK		 2515 zlog_debug("es %s vrf %u %s nhg %u to zebra", es->esi_str,
2516 es_vrf->bgp_vrf->vrf_id,
2517 v4_nhg ? "v4_nhg" : "v6_nhg", nhg_id);
2518
23aa35ad
AK		 2519 frrtrace(4, frr_bgp, evpn_mh_nhg_zsend, true, v4_nhg, nhg_id, es_vrf);
2520
8bcb09a1
AK		 2521 /* only the gateway ip changes for each NH. rest of the params
2522 * are constant
2523 */
2524 memset(&nh, 0, sizeof(nh));
2525 nh.vrf_id = es_vrf->bgp_vrf->vrf_id;
2526 nh.flags = NEXTHOP_FLAG_ONLINK;
2527 nh.ifindex = es_vrf->bgp_vrf->l3vni_svi_ifindex;
2528 nh.weight = 1;
2529 nh.type =
2530 v4_nhg ? NEXTHOP_TYPE_IPV4_IFINDEX : NEXTHOP_TYPE_IPV6_IFINDEX;
2531
2532 api_nhg.id = nhg_id;
c589d847 2533 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node, es_vtep)) {
8bcb09a1
AK		 2534 if (!CHECK_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE))
2535 continue;
2536
719b209c
MS		 2537 /* Don't overrun the zapi buffer. */
2538 if (api_nhg.nexthop_num == MULTIPATH_NUM)
2539 break;
2540
8bcb09a1
AK		 2541 /* overwrite the gw */
2542 if (v4_nhg)
2543 nh.gate.ipv4 = es_vtep->vtep_ip;
2544 else
2545 ipv4_to_ipv4_mapped_ipv6(&nh.gate.ipv6,
2546 es_vtep->vtep_ip);
2547
2548 /* convert to zapi format */
2549 api_nh = &api_nhg.nexthops[api_nhg.nexthop_num];
2550 zapi_nexthop_from_nexthop(api_nh, &nh);
2551
2552 ++api_nhg.nexthop_num;
2553 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2554 zlog_debug("nhg %u vtep %pI4 l3-svi %d", api_nhg.id,
2555 &es_vtep->vtep_ip,
2556 es_vrf->bgp_vrf->l3vni_svi_ifindex);
23aa35ad
AK		 2557
2558 frrtrace(3, frr_bgp, evpn_mh_nh_zsend, nhg_id, es_vtep, es_vrf);
c589d847
AK		 2559 }
2560
8bcb09a1
AK		 2561 if (!api_nhg.nexthop_num)
2562 return;
2563
8bcb09a1 2564 zclient_nhg_send(zclient, ZEBRA_NHG_ADD, &api_nhg);
c589d847
AK		 2565}
2566
8bcb09a1
AK		 2567static bool bgp_evpn_l3nhg_zebra_ok(struct bgp_evpn_es_vrf *es_vrf)
2568{
2569 if (!bgp_mh_info->host_routes_use_l3nhg && !bgp_mh_info->install_l3nhg)
2570 return false;
2571
2572 /* Check socket. */
2573 if (!zclient || zclient->sock < 0)
2574 return false;
2575
2576 return true;
2577}
2578
2579static void bgp_evpn_l3nhg_zebra_add(struct bgp_evpn_es_vrf *es_vrf)
c589d847 2580{
8bcb09a1
AK		 2581 if (!bgp_evpn_l3nhg_zebra_ok(es_vrf))
2582 return;
2583
2584 bgp_evpn_l3nhg_zebra_add_v4_or_v6(es_vrf, true /*v4_nhg*/);
2585 bgp_evpn_l3nhg_zebra_add_v4_or_v6(es_vrf, false /*v4_nhg*/);
2586}
2587
2588static void bgp_evpn_l3nhg_zebra_del_v4_or_v6(struct bgp_evpn_es_vrf *es_vrf,
2589 bool v4_nhg)
2590{
2591 struct zapi_nhg api_nhg = {};
2592
2593 api_nhg.id = v4_nhg ? es_vrf->nhg_id : es_vrf->v6_nhg_id;
2594
2595 /* Skip installation of L3-NHG if host routes used */
2596 if (!api_nhg.id)
2597 return;
2598
c589d847 2599 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1 2600 zlog_debug("es %s vrf %u %s nhg %u to zebra",
c589d847 2601 es_vrf->es->esi_str, es_vrf->bgp_vrf->vrf_id,
8bcb09a1
AK		 2602 v4_nhg ? "v4_nhg" : "v6_nhg", api_nhg.id);
2603
23aa35ad
AK		 2604
2605 frrtrace(4, frr_bgp, evpn_mh_nhg_zsend, false, v4_nhg, api_nhg.id,
2606 es_vrf);
2607
8bcb09a1
AK		 2608 zclient_nhg_send(zclient, ZEBRA_NHG_DEL, &api_nhg);
2609}
c589d847 2610
8bcb09a1
AK		 2611static void bgp_evpn_l3nhg_zebra_del(struct bgp_evpn_es_vrf *es_vrf)
2612{
2613 if (!bgp_evpn_l3nhg_zebra_ok(es_vrf))
2614 return;
2615
2616 bgp_evpn_l3nhg_zebra_del_v4_or_v6(es_vrf, true /*v4_nhg*/);
2617 bgp_evpn_l3nhg_zebra_del_v4_or_v6(es_vrf, false /*v4_nhg*/);
c589d847
AK		 2618}
2619
2620static void bgp_evpn_l3nhg_deactivate(struct bgp_evpn_es_vrf *es_vrf)
2621{
2622 if (!(es_vrf->flags & BGP_EVPNES_VRF_NHG_ACTIVE))
2623 return;
2624
2625 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1 2626 zlog_debug("es %s vrf %u nhg %u de-activate",
c589d847
AK		 2627 es_vrf->es->esi_str, es_vrf->bgp_vrf->vrf_id,
2628 es_vrf->nhg_id);
2629 bgp_evpn_l3nhg_zebra_del(es_vrf);
2630 es_vrf->flags &= ~BGP_EVPNES_VRF_NHG_ACTIVE;
58bff4d1
AK		 2631 /* MAC-IPs can now be installed via the L3NHG */
2632 bgp_evpn_es_path_update_on_es_vrf_chg(es_vrf, "l3nhg-deactivate");
c589d847
AK		 2633}
2634
2635static void bgp_evpn_l3nhg_activate(struct bgp_evpn_es_vrf *es_vrf, bool update)
2636{
2637 if (!bgp_evpn_es_get_active_vtep_cnt(es_vrf->es)) {
2638 bgp_evpn_l3nhg_deactivate(es_vrf);
2639 return;
2640 }
2641
2642 if (es_vrf->flags & BGP_EVPNES_VRF_NHG_ACTIVE) {
2643 if (!update)
2644 return;
2645 } else {
2646 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1 2647 zlog_debug("es %s vrf %u nhg %u activate",
c589d847
AK		 2648 es_vrf->es->esi_str, es_vrf->bgp_vrf->vrf_id,
2649 es_vrf->nhg_id);
2650 es_vrf->flags |= BGP_EVPNES_VRF_NHG_ACTIVE;
58bff4d1
AK		 2651 /* MAC-IPs can now be installed via the L3NHG */
2652 bgp_evpn_es_path_update_on_es_vrf_chg(es_vrf, "l3nhg_activate");
c589d847
AK		 2653 }
2654
2655 bgp_evpn_l3nhg_zebra_add(es_vrf);
2656}
2657
2658/* when a VTEP is activated or de-activated against an ES associated
2659 * VRFs' NHG needs to be updated
2660 */
2661static void bgp_evpn_l3nhg_update_on_vtep_chg(struct bgp_evpn_es *es)
2662{
2663 struct bgp_evpn_es_vrf *es_vrf;
2664 struct listnode *es_vrf_node;
2665
2666 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2667 zlog_debug("es %s nhg update on vtep chg", es->esi_str);
2668
2669 for (ALL_LIST_ELEMENTS_RO(es->es_vrf_list, es_vrf_node, es_vrf))
2670 bgp_evpn_l3nhg_activate(es_vrf, true /* update */);
2671}
2672
2673/* compare ES-IDs for the ES-VRF RB tree maintained per-VRF */
2674static int bgp_es_vrf_rb_cmp(const struct bgp_evpn_es_vrf *es_vrf1,
2675 const struct bgp_evpn_es_vrf *es_vrf2)
2676{
2677 return memcmp(&es_vrf1->es->esi, &es_vrf2->es->esi, ESI_BYTES);
2678}
2679RB_GENERATE(bgp_es_vrf_rb_head, bgp_evpn_es_vrf, rb_node, bgp_es_vrf_rb_cmp);
2680
2681/* Initialize the ES tables maintained per-tenant vrf */
2682void bgp_evpn_vrf_es_init(struct bgp *bgp_vrf)
2683{
2684 /* Initialize the ES-VRF RB tree */
2685 RB_INIT(bgp_es_vrf_rb_head, &bgp_vrf->es_vrf_rb_tree);
2686}
2687
2688/* find the ES-VRF in the per-VRF RB tree */
2689static struct bgp_evpn_es_vrf *bgp_evpn_es_vrf_find(struct bgp_evpn_es *es,
2690 struct bgp *bgp_vrf)
2691{
2692 struct bgp_evpn_es_vrf es_vrf;
2693
2694 es_vrf.es = es;
2695
2696 return RB_FIND(bgp_es_vrf_rb_head, &bgp_vrf->es_vrf_rb_tree, &es_vrf);
2697}
2698
2699/* allocate a new ES-VRF and setup L3NHG for it */
2700static struct bgp_evpn_es_vrf *bgp_evpn_es_vrf_create(struct bgp_evpn_es *es,
2701 struct bgp *bgp_vrf)
2702{
2703 struct bgp_evpn_es_vrf *es_vrf;
2704
2705 es_vrf = XCALLOC(MTYPE_BGP_EVPN_ES_VRF, sizeof(*es_vrf));
2706
2707 es_vrf->es = es;
2708 es_vrf->bgp_vrf = bgp_vrf;
2709
2710 /* insert into the VRF-ESI rb tree */
2711 if (RB_INSERT(bgp_es_vrf_rb_head, &bgp_vrf->es_vrf_rb_tree, es_vrf)) {
2712 XFREE(MTYPE_BGP_EVPN_ES_VRF, es_vrf);
2713 return NULL;
2714 }
2715
2716 /* add to the ES's VRF list */
2717 listnode_init(&es_vrf->es_listnode, es_vrf);
2718 listnode_add(es->es_vrf_list, &es_vrf->es_listnode);
2719
2720 /* setup the L3 NHG id for the ES */
2721 es_vrf->nhg_id = bgp_l3nhg_id_alloc();
8bcb09a1
AK		 2722 es_vrf->v6_nhg_id = bgp_l3nhg_id_alloc();
2723
c589d847 2724 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1
AK		 2725 zlog_debug("es %s vrf %u nhg %u v6_nhg %d create", es->esi_str,
2726 bgp_vrf->vrf_id, es_vrf->nhg_id, es_vrf->v6_nhg_id);
c589d847
AK		 2727 bgp_evpn_l3nhg_activate(es_vrf, false /* update */);
2728
36dd4574
AK		 2729 /* update paths in the VRF that may already be associated with
2730 * this destination ES
2731 */
58bff4d1 2732 bgp_evpn_es_path_update_on_es_vrf_chg(es_vrf, "es-vrf-create");
36dd4574 2733
c589d847
AK		 2734 return es_vrf;
2735}
2736
2737/* remove the L3-NHG associated with the ES-VRF and free it */
2738static void bgp_evpn_es_vrf_delete(struct bgp_evpn_es_vrf *es_vrf)
2739{
2740 struct bgp_evpn_es *es = es_vrf->es;
2741 struct bgp *bgp_vrf = es_vrf->bgp_vrf;
2742
2743 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
8bcb09a1 2744 zlog_debug("es %s vrf %u nhg %u delete", es->esi_str,
c589d847
AK		 2745 bgp_vrf->vrf_id, es_vrf->nhg_id);
2746
2747 /* Remove the NHG resources */
2748 bgp_evpn_l3nhg_deactivate(es_vrf);
2749 if (es_vrf->nhg_id)
2750 bgp_l3nhg_id_free(es_vrf->nhg_id);
2751 es_vrf->nhg_id = 0;
8bcb09a1
AK		 2752 if (es_vrf->v6_nhg_id)
2753 bgp_l3nhg_id_free(es_vrf->v6_nhg_id);
2754 es_vrf->v6_nhg_id = 0;
c589d847
AK		 2755
2756 /* remove from the ES's VRF list */
2757 list_delete_node(es->es_vrf_list, &es_vrf->es_listnode);
2758
2759 /* remove from the VRF-ESI rb tree */
2760 RB_REMOVE(bgp_es_vrf_rb_head, &bgp_vrf->es_vrf_rb_tree, es_vrf);
2761
d656e0ae
AK		 2762 /* update paths in the VRF that may already be associated with
2763 * this destination ES
2764 */
58bff4d1 2765 bgp_evpn_es_path_update_on_es_vrf_chg(es_vrf, "es-vrf-delete");
d656e0ae 2766
c589d847
AK		 2767 XFREE(MTYPE_BGP_EVPN_ES_VRF, es_vrf);
2768}
2769
2770/* deref and delete if there are no references */
2771void bgp_evpn_es_vrf_deref(struct bgp_evpn_es_evi *es_evi)
2772{
2773 struct bgp_evpn_es_vrf *es_vrf = es_evi->es_vrf;
2774
2775 if (!es_vrf)
2776 return;
2777
2778 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2779 zlog_debug("es-evi %s vni %u vrf %u de-ref",
2780 es_evi->es->esi_str, es_evi->vpn->vni,
2781 es_vrf->bgp_vrf->vrf_id);
2782
2783 es_evi->es_vrf = NULL;
2784 if (es_vrf->ref_cnt)
2785 --es_vrf->ref_cnt;
2786
2787 if (!es_vrf->ref_cnt)
2788 bgp_evpn_es_vrf_delete(es_vrf);
2789}
2790
2791/* find or create and reference */
2792void bgp_evpn_es_vrf_ref(struct bgp_evpn_es_evi *es_evi, struct bgp *bgp_vrf)
2793{
2794 struct bgp_evpn_es *es = es_evi->es;
2795 struct bgp_evpn_es_vrf *es_vrf = es_evi->es_vrf;
2796 struct bgp *old_bgp_vrf = NULL;
2797
2798 if (es_vrf)
2799 old_bgp_vrf = es_vrf->bgp_vrf;
2800
2801 if (old_bgp_vrf == bgp_vrf)
2802 return;
2803
2804 /* deref the old ES-VRF */
2805 bgp_evpn_es_vrf_deref(es_evi);
2806
2807 if (!bgp_vrf)
2808 return;
2809
2810 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2811 zlog_debug("es-evi %s vni %u vrf %u ref", es_evi->es->esi_str,
2812 es_evi->vpn->vni, bgp_vrf->vrf_id);
2813
2814 /* find-create the new ES-VRF */
2815 es_vrf = bgp_evpn_es_vrf_find(es, bgp_vrf);
2816 if (!es_vrf)
2817 es_vrf = bgp_evpn_es_vrf_create(es, bgp_vrf);
2818 if (!es_vrf)
2819 return;
2820
2821 es_evi->es_vrf = es_vrf;
2822 ++es_vrf->ref_cnt;
2823}
2824
2825/* When the L2-VNI is associated with a L3-VNI/VRF update all the
2826 * associated ES-EVI entries
2827 */
2828void bgp_evpn_es_evi_vrf_deref(struct bgpevpn *vpn)
2829{
2830 struct bgp_evpn_es_evi *es_evi;
2831
2832 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2833 zlog_debug("es-vrf de-ref for vni %u", vpn->vni);
2834
2835 RB_FOREACH (es_evi, bgp_es_evi_rb_head, &vpn->es_evi_rb_tree)
2836 bgp_evpn_es_vrf_deref(es_evi);
2837}
2838void bgp_evpn_es_evi_vrf_ref(struct bgpevpn *vpn)
2839{
2840 struct bgp_evpn_es_evi *es_evi;
2841
2842 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
2843 zlog_debug("es-vrf ref for vni %u", vpn->vni);
2844
2845 RB_FOREACH (es_evi, bgp_es_evi_rb_head, &vpn->es_evi_rb_tree)
2846 bgp_evpn_es_vrf_ref(es_evi, vpn->bgp_vrf);
2847}
2848
58bff4d1
AK		 2849/* 1. If ES-VRF is not present install the host route with the exploded/flat
2850 * multi-path list.
2851 * 2. If ES-VRF is present -
2852 * - if L3NHG has not been activated for the ES-VRF (this could be because
2853 * all the PEs attached to the VRF are down) do not install the route
2854 * in zebra.
2855 * - if L3NHG has been activated install the route via that L3NHG
2856 */
2857void bgp_evpn_es_vrf_use_nhg(struct bgp *bgp_vrf, esi_t *esi, bool *use_l3nhg,
2858 bool *is_l3nhg_active,
2859 struct bgp_evpn_es_vrf **es_vrf_p)
36dd4574
AK		 2860{
2861 struct bgp_evpn_es *es;
2862 struct bgp_evpn_es_vrf *es_vrf;
2863
2864 if (!bgp_mh_info->host_routes_use_l3nhg)
58bff4d1 2865 return;
36dd4574
AK		 2866
2867 es = bgp_evpn_es_find(esi);
2868 if (!es)
58bff4d1 2869 return;
36dd4574
AK		 2870
2871 es_vrf = bgp_evpn_es_vrf_find(es, bgp_vrf);
2872 if (!es_vrf)
58bff4d1
AK		 2873 return;
2874
2875 *use_l3nhg = true;
2876 if (es_vrf->flags & BGP_EVPNES_VRF_NHG_ACTIVE)
2877 *is_l3nhg_active = true;
36dd4574
AK		 2878 if (es_vrf_p)
2879 *es_vrf_p = es_vrf;
36dd4574
AK		 2880}
2881
6348981a
AK		 2882/* returns false if legacy-exploded mp needs to be used for route install */
2883bool bgp_evpn_path_es_use_nhg(struct bgp *bgp_vrf, struct bgp_path_info *pi,
2884 uint32_t *nhg_p)
2885{
2886 esi_t *esi;
36dd4574 2887 struct bgp_evpn_es_vrf *es_vrf = NULL;
6348981a
AK		 2888 struct bgp_path_info *parent_pi;
2889 struct bgp_node *rn;
2890 struct prefix_evpn *evp;
2891 struct bgp_path_info *mpinfo;
58bff4d1
AK		 2892 bool use_l3nhg = false;
2893 bool is_l3nhg_active = false;
6348981a
AK		 2894
2895 *nhg_p = 0;
2896
9f570418
AK		 2897 /* we don't support NHG for routes leaked from another VRF yet */
2898 if (pi->extra && pi->extra->bgp_orig)
2899 return false;
2900
6348981a
AK		 2901 parent_pi = get_route_parent_evpn(pi);
2902 if (!parent_pi)
2903 return false;
2904
2905 rn = parent_pi->net;
2906 if (!rn)
2907 return false;
2908
2909 evp = (struct prefix_evpn *)&rn->p;
2910 if (evp->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE)
2911 return false;
2912
6348981a
AK		 2913 /* non-es path, use legacy-exploded multipath */
2914 esi = bgp_evpn_attr_get_esi(parent_pi->attr);
2915 if (!memcmp(esi, zero_esi, sizeof(*esi)))
2916 return false;
2917
58bff4d1
AK		 2918 bgp_evpn_es_vrf_use_nhg(bgp_vrf, esi, &use_l3nhg, &is_l3nhg_active,
2919 &es_vrf);
2920
36dd4574 2921 /* L3NHG support is disabled, use legacy-exploded multipath */
58bff4d1 2922 if (!use_l3nhg)
36dd4574
AK		 2923 return false;
2924
2925 /* if the NHG has not been installed we cannot install the route yet,
2926 * return a 0-NHG to indicate that
6348981a 2927 */
58bff4d1 2928 if (!is_l3nhg_active)
6348981a
AK		 2929 return true;
2930
2931 /* this needs to be set the v6NHG if v6route */
8bcb09a1 2932 if (is_evpn_prefix_ipaddr_v6(evp))
6348981a
AK		 2933 *nhg_p = es_vrf->v6_nhg_id;
2934 else
2935 *nhg_p = es_vrf->nhg_id;
2936
2937 for (mpinfo = bgp_path_info_mpath_next(pi); mpinfo;
2938 mpinfo = bgp_path_info_mpath_next(mpinfo)) {
36dd4574 2939 /* if any of the paths have a different ESI we can't use
6348981a
AK		 2940 * the NHG associated with the ES. fallback to legacy-exploded
2941 * multipath
2942 */
2943 if (memcmp(esi, bgp_evpn_attr_get_esi(mpinfo->attr),
2944 sizeof(*esi)))
2945 return false;
2946 }
2947
2948 return true;
2949}
2950
229587fb
AK		 2951static void bgp_evpn_es_vrf_show_entry(struct vty *vty,
2952 struct bgp_evpn_es_vrf *es_vrf,
2953 json_object *json)
2954{
2955 struct bgp_evpn_es *es = es_vrf->es;
2956 struct bgp *bgp_vrf = es_vrf->bgp_vrf;
2957
2958 if (json) {
2959 json_object *json_types;
2960
2961 json_object_string_add(json, "esi", es->esi_str);
2962 json_object_string_add(json, "vrf", bgp_vrf->name);
2963
2964 if (es_vrf->flags & (BGP_EVPNES_VRF_NHG_ACTIVE)) {
2965 json_types = json_object_new_array();
2966 if (es_vrf->flags & BGP_EVPNES_VRF_NHG_ACTIVE)
2967 json_array_string_add(json_types, "active");
2968 json_object_object_add(json, "flags", json_types);
2969 }
2970
2971 json_object_int_add(json, "ipv4NHG", es_vrf->nhg_id);
2972 json_object_int_add(json, "ipv6NHG", es_vrf->v6_nhg_id);
2973 json_object_int_add(json, "refCount", es_vrf->ref_cnt);
2974 } else {
2975 char flags_str[4];
2976
2977 flags_str[0] = '\0';
2978 if (es_vrf->flags & BGP_EVPNES_VRF_NHG_ACTIVE)
2979 strlcat(flags_str, "A", sizeof(flags_str));
2980
2981 vty_out(vty, "%-30s %-15s %-5s %-8u %-8u %u\n", es->esi_str,
2982 bgp_vrf->name, flags_str, es_vrf->nhg_id,
2983 es_vrf->v6_nhg_id, es_vrf->ref_cnt);
2984 }
2985}
2986
2987static void bgp_evpn_es_vrf_show_es(struct vty *vty, json_object *json_array,
2988 struct bgp_evpn_es *es)
2989{
2990 json_object *json = NULL;
2991 struct listnode *es_vrf_node;
2992 struct bgp_evpn_es_vrf *es_vrf;
2993
2994 for (ALL_LIST_ELEMENTS_RO(es->es_vrf_list, es_vrf_node, es_vrf)) {
2995 /* create a separate json object for each ES-VRF */
2996 if (json_array)
2997 json = json_object_new_object();
2998 bgp_evpn_es_vrf_show_entry(vty, es_vrf, json);
2999 /* add ES-VRF to the json array */
3000 if (json_array)
3001 json_object_array_add(json_array, json);
3002 }
3003}
3004
3005/* Display all ES VRFs */
3006void bgp_evpn_es_vrf_show(struct vty *vty, bool uj, struct bgp_evpn_es *es)
3007{
3008 json_object *json_array = NULL;
3009
3010 if (uj) {
3011 /* create an array of ESs */
3012 json_array = json_object_new_array();
3013 } else {
3014 vty_out(vty, "ES-VRF Flags: A Active\n");
3015 vty_out(vty, "%-30s %-15s %-5s %-8s %-8s %s\n", "ESI", "VRF",
3016 "Flags", "IPv4-NHG", "IPv6-NHG", "Ref");
3017 }
3018
3019 if (es) {
3020 bgp_evpn_es_vrf_show_es(vty, json_array, es);
3021 } else {
3022 RB_FOREACH (es, bgp_es_rb_head, &bgp_mh_info->es_rb_tree)
3023 bgp_evpn_es_vrf_show_es(vty, json_array, es);
3024 }
3025
3026 /* print the array of json-ESs */
c48349e3 3027 if (uj)
75eeda93 3028 vty_json(vty, json_array);
229587fb
AK		 3029}
3030
3031/* Display specific ES VRF */
3032void bgp_evpn_es_vrf_show_esi(struct vty *vty, esi_t *esi, bool uj)
3033{
3034 struct bgp_evpn_es *es;
3035
3036 es = bgp_evpn_es_find(esi);
3037 if (es) {
3038 bgp_evpn_es_vrf_show(vty, uj, es);
3039 } else {
3040 if (!uj)
3041 vty_out(vty, "ESI not found\n");
3042 }
3043}
3044
c44ab6f1
AK		 3045/*****************************************************************************/
3046/* Ethernet Segment to EVI association -
3047 * 1. The ES-EVI entry is maintained as a RB tree per L2-VNI
3048 * (bgpevpn->es_evi_rb_tree).
3049 * 2. Each local ES-EVI entry is rxed from zebra and then used by BGP to
3050 * advertises an EAD-EVI (Type-1 EVPN) route
3051 * 3. The remote ES-EVI is created when a bgp_evpn_es_evi_vtep references
3052 * it.
3053 */
3054
3055/* A list of remote VTEPs is maintained for each ES-EVI. This list includes -
3056 * 1. VTEPs for which we have imported the EAD-per-ES Type1 route
3057 * 2. VTEPs for which we have imported the EAD-per-EVI Type1 route
3058 * VTEPs for which both routes have been rxed are activated. Activation
3059 * creates a NHG in the parent ES.
3060 */
3061static int bgp_evpn_es_evi_vtep_cmp(void *p1, void *p2)
3062{
3063 const struct bgp_evpn_es_evi_vtep *evi_vtep1 = p1;
3064 const struct bgp_evpn_es_evi_vtep *evi_vtep2 = p2;
3065
3066 return evi_vtep1->vtep_ip.s_addr - evi_vtep2->vtep_ip.s_addr;
3067}
3068
3069static struct bgp_evpn_es_evi_vtep *bgp_evpn_es_evi_vtep_new(
3070 struct bgp_evpn_es_evi *es_evi, struct in_addr vtep_ip)
3071{
3072 struct bgp_evpn_es_evi_vtep *evi_vtep;
3073
3074 evi_vtep = XCALLOC(MTYPE_BGP_EVPN_ES_EVI_VTEP, sizeof(*evi_vtep));
3075
3076 evi_vtep->es_evi = es_evi;
3077 evi_vtep->vtep_ip.s_addr = vtep_ip.s_addr;
3078 listnode_init(&evi_vtep->es_evi_listnode, evi_vtep);
3079 listnode_add_sort(es_evi->es_evi_vtep_list, &evi_vtep->es_evi_listnode);
3080
3081 return evi_vtep;
3082}
3083
3084static void bgp_evpn_es_evi_vtep_free(struct bgp_evpn_es_evi_vtep *evi_vtep)
3085{
3086 struct bgp_evpn_es_evi *es_evi = evi_vtep->es_evi;
3087
3088 if (evi_vtep->flags & (BGP_EVPN_EVI_VTEP_EAD))
3089 /* as long as there is some reference we can't free it */
3090 return;
3091
3092 list_delete_node(es_evi->es_evi_vtep_list, &evi_vtep->es_evi_listnode);
3093 XFREE(MTYPE_BGP_EVPN_ES_EVI_VTEP, evi_vtep);
3094}
3095
3096/* check if VTEP is already part of the list */
3097static struct bgp_evpn_es_evi_vtep *bgp_evpn_es_evi_vtep_find(
3098 struct bgp_evpn_es_evi *es_evi, struct in_addr vtep_ip)
3099{
3100 struct listnode *node = NULL;
3101 struct bgp_evpn_es_evi_vtep *evi_vtep;
3102
3103 for (ALL_LIST_ELEMENTS_RO(es_evi->es_evi_vtep_list, node, evi_vtep)) {
3104 if (evi_vtep->vtep_ip.s_addr == vtep_ip.s_addr)
3105 return evi_vtep;
3106 }
3107 return NULL;
3108}
3109
3110/* A VTEP can be added as "active" attach to an ES if EAD-per-ES and
3111 * EAD-per-EVI routes are rxed from it.
3112 */
3113static void bgp_evpn_es_evi_vtep_re_eval_active(struct bgp *bgp,
3114 struct bgp_evpn_es_evi_vtep *evi_vtep)
3115{
3116 bool old_active;
3117 bool new_active;
fe8293c3 3118 uint32_t ead_activity_flags;
c44ab6f1 3119
d4980edf 3120 old_active = CHECK_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE);
c44ab6f1 3121
fe8293c3
AK		 3122 if (bgp_mh_info->ead_evi_rx)
3123 /* Both EAD-per-ES and EAD-per-EVI routes must be rxed from a PE
3124 * before it can be activated.
3125 */
3126 ead_activity_flags = BGP_EVPN_EVI_VTEP_EAD;
3127 else
3128 /* EAD-per-ES is sufficent to activate the PE */
3129 ead_activity_flags = BGP_EVPN_EVI_VTEP_EAD_PER_ES;
3130
3131 if ((evi_vtep->flags & ead_activity_flags) == ead_activity_flags)
c44ab6f1
AK		 3132 SET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE);
3133 else
3134 UNSET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE);
3135
d4980edf 3136 new_active = CHECK_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE);
c44ab6f1
AK		 3137
3138 if (old_active == new_active)
3139 return;
3140
3141 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 3142 zlog_debug("es %s evi %u vtep %pI4 %s",
3143 evi_vtep->es_evi->es->esi_str,
3144 evi_vtep->es_evi->vpn->vni, &evi_vtep->vtep_ip,
3145 new_active ? "active" : "inactive");
c44ab6f1
AK		 3146
3147 /* add VTEP to parent es */
3148 if (new_active) {
3149 struct bgp_evpn_es_vtep *es_vtep;
3150
3151 es_vtep = bgp_evpn_es_vtep_add(bgp, evi_vtep->es_evi->es,
74e2bd89
AK		 3152 evi_vtep->vtep_ip, false /*esr*/,
3153 0, 0);
c44ab6f1
AK		 3154 evi_vtep->es_vtep = es_vtep;
3155 } else {
3156 if (evi_vtep->es_vtep) {
3157 bgp_evpn_es_vtep_do_del(bgp, evi_vtep->es_vtep,
3158 false /*esr*/);
3159 evi_vtep->es_vtep = NULL;
3160 }
3161 }
3162 /* queue up the parent es for background consistency checks */
3163 bgp_evpn_es_cons_checks_pend_add(evi_vtep->es_evi->es);
3164}
3165
3166static void bgp_evpn_es_evi_vtep_add(struct bgp *bgp,
3167 struct bgp_evpn_es_evi *es_evi, struct in_addr vtep_ip,
3168 bool ead_es)
3169{
3170 struct bgp_evpn_es_evi_vtep *evi_vtep;
3171
3172 evi_vtep = bgp_evpn_es_evi_vtep_find(es_evi, vtep_ip);
3173
3174 if (!evi_vtep)
3175 evi_vtep = bgp_evpn_es_evi_vtep_new(es_evi, vtep_ip);
3176
3177 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 3178 zlog_debug("add es %s evi %u vtep %pI4 %s",
3179 evi_vtep->es_evi->es->esi_str,
3180 evi_vtep->es_evi->vpn->vni, &evi_vtep->vtep_ip,
3181 ead_es ? "ead_es" : "ead_evi");
c44ab6f1
AK		 3182
3183 if (ead_es)
3184 SET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_EAD_PER_ES);
3185 else
3186 SET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_EAD_PER_EVI);
3187
3188 bgp_evpn_es_evi_vtep_re_eval_active(bgp, evi_vtep);
3189}
3190
3191static void bgp_evpn_es_evi_vtep_del(struct bgp *bgp,
3192 struct bgp_evpn_es_evi *es_evi, struct in_addr vtep_ip,
3193 bool ead_es)
3194{
3195 struct bgp_evpn_es_evi_vtep *evi_vtep;
3196
3197 evi_vtep = bgp_evpn_es_evi_vtep_find(es_evi, vtep_ip);
3198 if (!evi_vtep)
3199 return;
3200
3201 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 3202 zlog_debug("del es %s evi %u vtep %pI4 %s",
3203 evi_vtep->es_evi->es->esi_str,
3204 evi_vtep->es_evi->vpn->vni, &evi_vtep->vtep_ip,
3205 ead_es ? "ead_es" : "ead_evi");
c44ab6f1
AK		 3206
3207 if (ead_es)
3208 UNSET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_EAD_PER_ES);
3209 else
3210 UNSET_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_EAD_PER_EVI);
3211
3212 bgp_evpn_es_evi_vtep_re_eval_active(bgp, evi_vtep);
3213 bgp_evpn_es_evi_vtep_free(evi_vtep);
3214}
3215
3216/* compare ES-IDs for the ES-EVI RB tree maintained per-VNI */
3217static int bgp_es_evi_rb_cmp(const struct bgp_evpn_es_evi *es_evi1,
3218 const struct bgp_evpn_es_evi *es_evi2)
3219{
3220 return memcmp(&es_evi1->es->esi, &es_evi2->es->esi, ESI_BYTES);
3221}
3222RB_GENERATE(bgp_es_evi_rb_head, bgp_evpn_es_evi, rb_node, bgp_es_evi_rb_cmp);
3223
3224/* find the ES-EVI in the per-L2-VNI RB tree */
3225static struct bgp_evpn_es_evi *bgp_evpn_es_evi_find(struct bgp_evpn_es *es,
3226 struct bgpevpn *vpn)
3227{
3228 struct bgp_evpn_es_evi es_evi;
3229
3230 es_evi.es = es;
3231
3232 return RB_FIND(bgp_es_evi_rb_head, &vpn->es_evi_rb_tree, &es_evi);
3233}
3234
3235/* allocate a new ES-EVI and insert it into the per-L2-VNI and per-ES
3236 * tables.
3237 */
3238static struct bgp_evpn_es_evi *bgp_evpn_es_evi_new(struct bgp_evpn_es *es,
3239 struct bgpevpn *vpn)
3240{
3241 struct bgp_evpn_es_evi *es_evi;
3242
3243 es_evi = XCALLOC(MTYPE_BGP_EVPN_ES_EVI, sizeof(*es_evi));
3244
3245 es_evi->es = es;
3246 es_evi->vpn = vpn;
3247
3248 /* Initialise the VTEP list */
3249 es_evi->es_evi_vtep_list = list_new();
3250 listset_app_node_mem(es_evi->es_evi_vtep_list);
3251 es_evi->es_evi_vtep_list->cmp = bgp_evpn_es_evi_vtep_cmp;
3252
3253 /* insert into the VNI-ESI rb tree */
3254 if (RB_INSERT(bgp_es_evi_rb_head, &vpn->es_evi_rb_tree, es_evi)) {
3255 XFREE(MTYPE_BGP_EVPN_ES_EVI, es_evi);
3256 return NULL;
3257 }
3258
3259 /* add to the ES's VNI list */
3260 listnode_init(&es_evi->es_listnode, es_evi);
3261 listnode_add(es->es_evi_list, &es_evi->es_listnode);
3262
c589d847
AK		 3263 bgp_evpn_es_vrf_ref(es_evi, vpn->bgp_vrf);
3264
c44ab6f1
AK		 3265 return es_evi;
3266}
3267
3268/* remove the ES-EVI from the per-L2-VNI and per-ES tables and free
3269 * up the memory.
3270 */
333ad64b
AK		 3271static struct bgp_evpn_es_evi *
3272bgp_evpn_es_evi_free(struct bgp_evpn_es_evi *es_evi)
c44ab6f1
AK		 3273{
3274 struct bgp_evpn_es *es = es_evi->es;
3275 struct bgpevpn *vpn = es_evi->vpn;
3276
3277 /* cannot free the element as long as there is a local or remote
3278 * reference
3279 */
3280 if (es_evi->flags & (BGP_EVPNES_EVI_LOCAL | BGP_EVPNES_EVI_REMOTE))
333ad64b 3281 return es_evi;
c44ab6f1 3282
c589d847
AK		 3283 bgp_evpn_es_vrf_deref(es_evi);
3284
c44ab6f1
AK		 3285 /* remove from the ES's VNI list */
3286 list_delete_node(es->es_evi_list, &es_evi->es_listnode);
3287
3288 /* remove from the VNI-ESI rb tree */
3289 RB_REMOVE(bgp_es_evi_rb_head, &vpn->es_evi_rb_tree, es_evi);
3290
3291 /* free the VTEP list */
3292 list_delete(&es_evi->es_evi_vtep_list);
3293
3294 /* remove from the VNI-ESI rb tree */
3295 XFREE(MTYPE_BGP_EVPN_ES_EVI, es_evi);
333ad64b
AK		 3296
3297 return NULL;
c44ab6f1
AK		 3298}
3299
3300/* init local info associated with the ES-EVI */
3301static void bgp_evpn_es_evi_local_info_set(struct bgp_evpn_es_evi *es_evi)
3302{
3303 struct bgpevpn *vpn = es_evi->vpn;
3304
3305 if (CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
3306 return;
3307
3308 SET_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL);
3309 listnode_init(&es_evi->l2vni_listnode, es_evi);
3310 listnode_add(vpn->local_es_evi_list, &es_evi->l2vni_listnode);
3311}
3312
3313/* clear any local info associated with the ES-EVI */
333ad64b
AK		 3314static struct bgp_evpn_es_evi *
3315bgp_evpn_es_evi_local_info_clear(struct bgp_evpn_es_evi *es_evi)
c44ab6f1
AK		 3316{
3317 struct bgpevpn *vpn = es_evi->vpn;
3318
c44ab6f1
AK		 3319 UNSET_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL);
3320 list_delete_node(vpn->local_es_evi_list, &es_evi->l2vni_listnode);
3321
333ad64b 3322 return bgp_evpn_es_evi_free(es_evi);
c44ab6f1
AK		 3323}
3324
3325/* eval remote info associated with the ES */
3326static void bgp_evpn_es_evi_remote_info_re_eval(struct bgp_evpn_es_evi *es_evi)
3327{
3328 struct bgp_evpn_es *es = es_evi->es;
3329
3330 /* if there are remote VTEPs the ES-EVI is classified as "remote" */
3331 if (listcount(es_evi->es_evi_vtep_list)) {
3332 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_REMOTE)) {
3333 SET_FLAG(es_evi->flags, BGP_EVPNES_EVI_REMOTE);
3334 ++es->remote_es_evi_cnt;
3335 /* set remote on the parent es */
3336 bgp_evpn_es_remote_info_re_eval(es);
3337 }
3338 } else {
3339 if (CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_REMOTE)) {
3340 UNSET_FLAG(es_evi->flags, BGP_EVPNES_EVI_REMOTE);
3341 if (es->remote_es_evi_cnt)
3342 --es->remote_es_evi_cnt;
3343 bgp_evpn_es_evi_free(es_evi);
3344 /* check if "remote" can be cleared from the
3345 * parent es.
3346 */
3347 bgp_evpn_es_remote_info_re_eval(es);
3348 }
3349 }
3350}
3351
333ad64b
AK		 3352static struct bgp_evpn_es_evi *
3353bgp_evpn_local_es_evi_do_del(struct bgp_evpn_es_evi *es_evi)
c44ab6f1
AK		 3354{
3355 struct prefix_evpn p;
3356 struct bgp_evpn_es *es = es_evi->es;
3357 struct bgp *bgp;
3358
3359 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
333ad64b 3360 return es_evi;
c44ab6f1
AK		 3361
3362 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
3363 zlog_debug("del local es %s evi %u",
3364 es_evi->es->esi_str,
3365 es_evi->vpn->vni);
3366
3367 bgp = bgp_get_evpn();
3368
3369 if (bgp) {
3370 /* update EAD-ES with new list of VNIs */
74be8313 3371 if (bgp_evpn_local_es_is_active(es)) {
c44ab6f1
AK		 3372 build_evpn_type1_prefix(&p, BGP_EVPN_AD_ES_ETH_TAG,
3373 &es->esi, es->originator_ip);
3374 if (bgp_evpn_type1_route_update(bgp, es, NULL, &p))
3375 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
3376 "%u: EAD-ES route update failure for ESI %s VNI %u",
3377 bgp->vrf_id, es->esi_str,
3378 es_evi->vpn->vni);
3379 }
3380
3381 /* withdraw and delete EAD-EVI */
3382 if (CHECK_FLAG(es->flags, BGP_EVPNES_ADV_EVI)) {
3383 build_evpn_type1_prefix(&p, BGP_EVPN_AD_EVI_ETH_TAG,
3384 &es->esi, es->originator_ip);
3385 if (bgp_evpn_type1_evi_route_delete(bgp,
3386 es, es_evi->vpn, &p))
3387 flog_err(EC_BGP_EVPN_ROUTE_DELETE,
3388 "%u: EAD-EVI route deletion failure for ESI %s VNI %u",
3389 bgp->vrf_id, es->esi_str,
3390 es_evi->vpn->vni);
3391 }
3392 }
3393
333ad64b 3394 return bgp_evpn_es_evi_local_info_clear(es_evi);
c44ab6f1
AK		 3395}
3396
3397int bgp_evpn_local_es_evi_del(struct bgp *bgp, esi_t *esi, vni_t vni)
3398{
3399 struct bgpevpn *vpn;
3400 struct bgp_evpn_es *es;
3401 struct bgp_evpn_es_evi *es_evi;
3402 char buf[ESI_STR_LEN];
3403
3404 es = bgp_evpn_es_find(esi);
3405 if (!es) {
3406 flog_err(
3407 EC_BGP_ES_CREATE,
3408 "%u: Failed to deref VNI %d from ESI %s; ES not present",
3409 bgp->vrf_id, vni,
3410 esi_to_str(esi, buf, sizeof(buf)));
3411 return -1;
3412 }
3413
3414 vpn = bgp_evpn_lookup_vni(bgp, vni);
3415 if (!vpn) {
3416 flog_err(
3417 EC_BGP_ES_CREATE,
3418 "%u: Failed to deref VNI %d from ESI %s; VNI not present",
3419 bgp->vrf_id, vni, es->esi_str);
3420 return -1;
3421 }
3422
3423 es_evi = bgp_evpn_es_evi_find(es, vpn);
3424 if (!es_evi) {
3425 flog_err(
3426 EC_BGP_ES_CREATE,
3427 "%u: Failed to deref VNI %d from ESI %s; ES-VNI not present",
3428 bgp->vrf_id, vni, es->esi_str);
3429 return -1;
3430 }
3431
3432 bgp_evpn_local_es_evi_do_del(es_evi);
3433 return 0;
3434}
3435
3436/* Create ES-EVI and advertise the corresponding EAD routes */
3437int bgp_evpn_local_es_evi_add(struct bgp *bgp, esi_t *esi, vni_t vni)
3438{
3439 struct bgpevpn *vpn;
3440 struct prefix_evpn p;
3441 struct bgp_evpn_es *es;
3442 struct bgp_evpn_es_evi *es_evi;
3443 char buf[ESI_STR_LEN];
3444
3445 es = bgp_evpn_es_find(esi);
3446 if (!es) {
3447 flog_err(
3448 EC_BGP_ES_CREATE,
3449 "%u: Failed to associate VNI %d with ESI %s; ES not present",
3450 bgp->vrf_id, vni,
3451 esi_to_str(esi, buf, sizeof(buf)));
3452 return -1;
3453 }
3454
3455 vpn = bgp_evpn_lookup_vni(bgp, vni);
3456 if (!vpn) {
3457 flog_err(
3458 EC_BGP_ES_CREATE,
3459 "%u: Failed to associate VNI %d with ESI %s; VNI not present",
3460 bgp->vrf_id, vni, es->esi_str);
3461 return -1;
3462 }
3463
3464 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
3465 zlog_debug("add local es %s evi %u",
3466 es->esi_str, vni);
3467
3468 es_evi = bgp_evpn_es_evi_find(es, vpn);
3469
3470 if (es_evi) {
3471 if (CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_LOCAL))
3472 /* dup */
3473 return 0;
3474 } else {
3475 es_evi = bgp_evpn_es_evi_new(es, vpn);
3476 if (!es_evi)
3477 return -1;
3478 }
3479
3480 bgp_evpn_es_evi_local_info_set(es_evi);
3481
3482 /* generate an EAD-EVI for this new VNI */
c44ab6f1 3483 if (CHECK_FLAG(es->flags, BGP_EVPNES_ADV_EVI)) {
fe8293c3
AK		 3484 build_evpn_type1_prefix(&p, BGP_EVPN_AD_EVI_ETH_TAG, &es->esi,
3485 es->originator_ip);
c44ab6f1
AK		 3486 if (bgp_evpn_type1_route_update(bgp, es, vpn, &p))
3487 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
3488 "%u: EAD-EVI route creation failure for ESI %s VNI %u",
3489 bgp->vrf_id, es->esi_str, vni);
3490 }
3491
3492 /* update EAD-ES */
3493 build_evpn_type1_prefix(&p, BGP_EVPN_AD_ES_ETH_TAG,
3494 &es->esi, es->originator_ip);
74be8313 3495 if (bgp_evpn_local_es_is_active(es)) {
c44ab6f1
AK		 3496 if (bgp_evpn_type1_route_update(bgp, es, NULL, &p))
3497 flog_err(EC_BGP_EVPN_ROUTE_CREATE,
3498 "%u: EAD-ES route creation failure for ESI %s VNI %u",
3499 bgp->vrf_id, es->esi_str, vni);
3500 }
3501
3502 return 0;
3503}
3504
3505/* Add remote ES-EVI entry. This is actually the remote VTEP add and the
3506 * ES-EVI is implicity created on first VTEP's reference.
3507 */
3508int bgp_evpn_remote_es_evi_add(struct bgp *bgp, struct bgpevpn *vpn,
3509 const struct prefix_evpn *p)
3510{
3511 char buf[ESI_STR_LEN];
3512 struct bgp_evpn_es *es;
3513 struct bgp_evpn_es_evi *es_evi;
3514 bool ead_es;
3515 const esi_t *esi = &p->prefix.ead_addr.esi;
3516
3517 if (!vpn)
3518 /* local EAD-ES need not be sent back to zebra */
3519 return 0;
3520
3521 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 3522 zlog_debug("add remote %s es %s evi %u vtep %pI4",
3523 p->prefix.ead_addr.eth_tag ? "ead-es" : "ead-evi",
3524 esi_to_str(esi, buf, sizeof(buf)), vpn->vni,
3525 &p->prefix.ead_addr.ip.ipaddr_v4);
c44ab6f1
AK		 3526
3527 es = bgp_evpn_es_find(esi);
3528 if (!es) {
3529 es = bgp_evpn_es_new(bgp, esi);
3530 if (!es) {
3531 flog_err(EC_BGP_ES_CREATE,
3532 "%u: Failed to allocate ES entry for ESI %s - at remote ES Add",
3533 bgp->vrf_id, esi_to_str(esi, buf, sizeof(buf)));
3534 return -1;
3535 }
3536 }
3537
3538 es_evi = bgp_evpn_es_evi_find(es, vpn);
3539 if (!es_evi) {
3540 es_evi = bgp_evpn_es_evi_new(es, vpn);
3541 if (!es_evi) {
45a859f1 3542 bgp_evpn_es_free(es, __func__);
c44ab6f1
AK		 3543 return -1;
3544 }
3545 }
3546
3547 ead_es = !!p->prefix.ead_addr.eth_tag;
3548 bgp_evpn_es_evi_vtep_add(bgp, es_evi, p->prefix.ead_addr.ip.ipaddr_v4,
3549 ead_es);
3550
3551 bgp_evpn_es_evi_remote_info_re_eval(es_evi);
3552 return 0;
3553}
3554
3555/* A remote VTEP has withdrawn. The es-evi-vtep will be deleted and the
3556 * parent es-evi freed up implicitly in last VTEP's deref.
3557 */
3558int bgp_evpn_remote_es_evi_del(struct bgp *bgp, struct bgpevpn *vpn,
3559 const struct prefix_evpn *p)
3560{
3561 char buf[ESI_STR_LEN];
3562 struct bgp_evpn_es *es;
3563 struct bgp_evpn_es_evi *es_evi;
3564 bool ead_es;
3565
3566 if (!vpn)
3567 /* local EAD-ES need not be sent back to zebra */
3568 return 0;
3569
3570 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
23d0a753
DA		 3571 zlog_debug(
3572 "del remote %s es %s evi %u vtep %pI4",
3573 p->prefix.ead_addr.eth_tag ? "ead-es" : "ead-evi",
3574 esi_to_str(&p->prefix.ead_addr.esi, buf, sizeof(buf)),
3575 vpn->vni, &p->prefix.ead_addr.ip.ipaddr_v4);
c44ab6f1
AK		 3576
3577 es = bgp_evpn_es_find(&p->prefix.ead_addr.esi);
2eef4f20
AK		 3578 if (!es) {
3579 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
3580 zlog_debug("del remote %s es %s evi %u vtep %pI4, NO es",
3581 p->prefix.ead_addr.eth_tag ? "ead-es"
3582 : "ead-evi",
3583 esi_to_str(&p->prefix.ead_addr.esi, buf,
3584 sizeof(buf)),
3585 vpn->vni,
3586 &p->prefix.ead_addr.ip.ipaddr_v4);
c44ab6f1 3587 return 0;
2eef4f20 3588 }
c44ab6f1 3589 es_evi = bgp_evpn_es_evi_find(es, vpn);
2eef4f20
AK		 3590 if (!es_evi) {
3591 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
3592 zlog_debug(
3593 "del remote %s es %s evi %u vtep %pI4, NO es-evi",
3594 p->prefix.ead_addr.eth_tag ? "ead-es"
3595 : "ead-evi",
3596 esi_to_str(&p->prefix.ead_addr.esi, buf,
3597 sizeof(buf)),
3598 vpn->vni,
3599 &p->prefix.ead_addr.ip.ipaddr_v4);
c44ab6f1 3600 return 0;
2eef4f20 3601 }
c44ab6f1
AK		 3602
3603 ead_es = !!p->prefix.ead_addr.eth_tag;
3604 bgp_evpn_es_evi_vtep_del(bgp, es_evi, p->prefix.ead_addr.ip.ipaddr_v4,
3605 ead_es);
3606 bgp_evpn_es_evi_remote_info_re_eval(es_evi);
3607 return 0;
3608}
3609
333ad64b
AK		 3610/* If a VNI is being deleted we need to force del all remote VTEPs */
3611static void bgp_evpn_remote_es_evi_flush(struct bgp_evpn_es_evi *es_evi)
3612{
3613 struct listnode *node = NULL;
3614 struct listnode *nnode = NULL;
3615 struct bgp_evpn_es_evi_vtep *evi_vtep;
3616 struct bgp *bgp;
3617
3618 bgp = bgp_get_evpn();
3619 if (!bgp)
3620 return;
3621
3622 /* delete all VTEPs */
3623 for (ALL_LIST_ELEMENTS(es_evi->es_evi_vtep_list, node, nnode,
3624 evi_vtep)) {
3625 evi_vtep->flags &= ~(BGP_EVPN_EVI_VTEP_EAD_PER_ES
3626 | BGP_EVPN_EVI_VTEP_EAD_PER_EVI);
3627 bgp_evpn_es_evi_vtep_re_eval_active(bgp, evi_vtep);
3628 bgp_evpn_es_evi_vtep_free(evi_vtep);
3629 }
3630 /* delete the EVI */
3631 bgp_evpn_es_evi_remote_info_re_eval(es_evi);
3632}
3633
c44ab6f1
AK		 3634/* Initialize the ES tables maintained per-L2_VNI */
3635void bgp_evpn_vni_es_init(struct bgpevpn *vpn)
3636{
3637 /* Initialize the ES-EVI RB tree */
3638 RB_INIT(bgp_es_evi_rb_head, &vpn->es_evi_rb_tree);
3639
3640 /* Initialize the local list maintained for quick walks by type */
3641 vpn->local_es_evi_list = list_new();
3642 listset_app_node_mem(vpn->local_es_evi_list);
3643}
3644
3645/* Cleanup the ES info maintained per-L2_VNI */
3646void bgp_evpn_vni_es_cleanup(struct bgpevpn *vpn)
3647{
3648 struct bgp_evpn_es_evi *es_evi;
3649 struct bgp_evpn_es_evi *es_evi_next;
3650
3651 RB_FOREACH_SAFE(es_evi, bgp_es_evi_rb_head,
3652 &vpn->es_evi_rb_tree, es_evi_next) {
333ad64b
AK		 3653 es_evi = bgp_evpn_local_es_evi_do_del(es_evi);
3654 if (es_evi)
3655 bgp_evpn_remote_es_evi_flush(es_evi);
c44ab6f1
AK		 3656 }
3657
3658 list_delete(&vpn->local_es_evi_list);
3659}
3660
3661static char *bgp_evpn_es_evi_vteps_str(char *vtep_str,
9e0c2fd1
AK		 3662 struct bgp_evpn_es_evi *es_evi,
3663 uint8_t vtep_str_size)
c44ab6f1
AK		 3664{
3665 char vtep_flag_str[BGP_EVPN_FLAG_STR_SZ];
3666 struct listnode *node;
3667 struct bgp_evpn_es_evi_vtep *evi_vtep;
3668 bool first = true;
ec779825 3669 char ip_buf[INET6_ADDRSTRLEN];
c44ab6f1
AK		 3670
3671 vtep_str[0] = '\0';
3672 for (ALL_LIST_ELEMENTS_RO(es_evi->es_evi_vtep_list, node, evi_vtep)) {
3673 vtep_flag_str[0] = '\0';
3674 if (evi_vtep->flags & BGP_EVPN_EVI_VTEP_EAD_PER_ES)
9e0c2fd1 3675 strlcat(vtep_flag_str, "E", sizeof(vtep_flag_str));
c44ab6f1 3676 if (evi_vtep->flags & BGP_EVPN_EVI_VTEP_EAD_PER_EVI)
9e0c2fd1 3677 strlcat(vtep_flag_str, "V", sizeof(vtep_flag_str));
c44ab6f1 3678
9e0c2fd1
AK		 3679 if (!strnlen(vtep_flag_str, sizeof(vtep_flag_str)))
3680 strlcpy(vtep_flag_str, "-", sizeof(vtep_flag_str));
3681 if (first)
c44ab6f1 3682 first = false;
9e0c2fd1
AK		 3683 else
3684 strlcat(vtep_str, ",", vtep_str_size);
23d0a753 3685 strlcat(vtep_str,
ec779825
AK		 3686 inet_ntop(AF_INET, &evi_vtep->vtep_ip, ip_buf,
3687 sizeof(ip_buf)),
23d0a753 3688 vtep_str_size);
9e0c2fd1
AK		 3689 strlcat(vtep_str, "(", vtep_str_size);
3690 strlcat(vtep_str, vtep_flag_str, vtep_str_size);
3691 strlcat(vtep_str, ")", vtep_str_size);
c44ab6f1
AK		 3692 }
3693
3694 return vtep_str;
3695}
3696
3697static void bgp_evpn_es_evi_json_vtep_fill(json_object *json_vteps,
3698 struct bgp_evpn_es_evi_vtep *evi_vtep)
3699{
3700 json_object *json_vtep_entry;
3701 json_object *json_flags;
3702
3703 json_vtep_entry = json_object_new_object();
3704
c949c771
DA		 3705 json_object_string_addf(json_vtep_entry, "vtep_ip", "%pI4",
3706 &evi_vtep->vtep_ip);
c44ab6f1
AK		 3707 if (evi_vtep->flags & (BGP_EVPN_EVI_VTEP_EAD_PER_ES |
3708 BGP_EVPN_EVI_VTEP_EAD_PER_EVI)) {
3709 json_flags = json_object_new_array();
3710 if (evi_vtep->flags & BGP_EVPN_EVI_VTEP_EAD_PER_ES)
3711 json_array_string_add(json_flags, "ead-per-es");
3712 if (evi_vtep->flags & BGP_EVPN_EVI_VTEP_EAD_PER_EVI)
b37ff319 3713 json_array_string_add(json_flags, "ead-per-evi");
c44ab6f1
AK		 3714 json_object_object_add(json_vtep_entry,
3715 "flags", json_flags);
3716 }
3717
3718 json_object_array_add(json_vteps,
3719 json_vtep_entry);
3720}
3721
3722static void bgp_evpn_es_evi_show_entry(struct vty *vty,
3723 struct bgp_evpn_es_evi *es_evi, json_object *json)
3724{
3725 struct listnode *node;
3726 struct bgp_evpn_es_evi_vtep *evi_vtep;
3727
3728 if (json) {
3729 json_object *json_vteps;
3730 json_object *json_types;
3731
3732 json_object_string_add(json, "esi", es_evi->es->esi_str);
3733 json_object_int_add(json, "vni", es_evi->vpn->vni);
3734
3735 if (es_evi->flags & (BGP_EVPNES_EVI_LOCAL |
3736 BGP_EVPNES_EVI_REMOTE)) {
3737 json_types = json_object_new_array();
3738 if (es_evi->flags & BGP_EVPNES_EVI_LOCAL)
3739 json_array_string_add(json_types, "local");
3740 if (es_evi->flags & BGP_EVPNES_EVI_REMOTE)
3741 json_array_string_add(json_types, "remote");
3742 json_object_object_add(json, "type", json_types);
3743 }
3744
3745 if (listcount(es_evi->es_evi_vtep_list)) {
3746 json_vteps = json_object_new_array();
3747 for (ALL_LIST_ELEMENTS_RO(es_evi->es_evi_vtep_list,
3748 node, evi_vtep)) {
3749 bgp_evpn_es_evi_json_vtep_fill(json_vteps,
3750 evi_vtep);
3751 }
3752 json_object_object_add(json, "vteps", json_vteps);
3753 }
3754 } else {
3755 char type_str[4];
3756 char vtep_str[ES_VTEP_LIST_STR_SZ + BGP_EVPN_VTEPS_FLAG_STR_SZ];
3757
3758 type_str[0] = '\0';
3759 if (es_evi->flags & BGP_EVPNES_EVI_LOCAL)
9e0c2fd1 3760 strlcat(type_str, "L", sizeof(type_str));
c44ab6f1 3761 if (es_evi->flags & BGP_EVPNES_EVI_REMOTE)
9e0c2fd1 3762 strlcat(type_str, "R", sizeof(type_str));
c44ab6f1 3763 if (es_evi->flags & BGP_EVPNES_EVI_INCONS_VTEP_LIST)
9e0c2fd1 3764 strlcat(type_str, "I", sizeof(type_str));
c44ab6f1 3765
9e0c2fd1 3766 bgp_evpn_es_evi_vteps_str(vtep_str, es_evi, sizeof(vtep_str));
c44ab6f1
AK		 3767
3768 vty_out(vty, "%-8d %-30s %-5s %s\n",
3769 es_evi->vpn->vni, es_evi->es->esi_str,
3770 type_str, vtep_str);
3771 }
3772}
3773
3774static void bgp_evpn_es_evi_show_entry_detail(struct vty *vty,
3775 struct bgp_evpn_es_evi *es_evi, json_object *json)
3776{
3777 if (json) {
3778 json_object *json_flags;
3779
3780 /* Add the "brief" info first */
3781 bgp_evpn_es_evi_show_entry(vty, es_evi, json);
3782 if (es_evi->flags & BGP_EVPNES_EVI_INCONS_VTEP_LIST) {
3783 json_flags = json_object_new_array();
3784 json_array_string_add(json_flags, "es-vtep-mismatch");
3785 json_object_object_add(json, "flags", json_flags);
3786 }
3787 } else {
3788 char vtep_str[ES_VTEP_LIST_STR_SZ + BGP_EVPN_VTEPS_FLAG_STR_SZ];
3789 char type_str[4];
3790
3791 type_str[0] = '\0';
3792 if (es_evi->flags & BGP_EVPNES_EVI_LOCAL)
9e0c2fd1 3793 strlcat(type_str, "L", sizeof(type_str));
c44ab6f1 3794 if (es_evi->flags & BGP_EVPNES_EVI_REMOTE)
9e0c2fd1 3795 strlcat(type_str, "R", sizeof(type_str));
c44ab6f1 3796
9e0c2fd1 3797 bgp_evpn_es_evi_vteps_str(vtep_str, es_evi, sizeof(vtep_str));
c44ab6f1 3798 if (!strlen(vtep_str))
9e0c2fd1 3799 strlcpy(vtep_str, "-", sizeof(type_str));
c44ab6f1
AK		 3800
3801 vty_out(vty, "VNI: %d ESI: %s\n",
3802 es_evi->vpn->vni, es_evi->es->esi_str);
3803 vty_out(vty, " Type: %s\n", type_str);
3804 vty_out(vty, " Inconsistencies: %s\n",
3805 (es_evi->flags & BGP_EVPNES_EVI_INCONS_VTEP_LIST) ?
3806 "es-vtep-mismatch":"-");
3807 vty_out(vty, " VTEPs: %s\n", vtep_str);
3808 vty_out(vty, "\n");
3809 }
3810}
3811
3812static void bgp_evpn_es_evi_show_one_vni(struct bgpevpn *vpn, struct vty *vty,
3813 json_object *json_array, bool detail)
3814{
3815 struct bgp_evpn_es_evi *es_evi;
3816 json_object *json = NULL;
3817
3818 RB_FOREACH(es_evi, bgp_es_evi_rb_head, &vpn->es_evi_rb_tree) {
3819 if (json_array)
3820 /* create a separate json object for each ES */
3821 json = json_object_new_object();
3822 if (detail)
3823 bgp_evpn_es_evi_show_entry_detail(vty, es_evi, json);
3824 else
3825 bgp_evpn_es_evi_show_entry(vty, es_evi, json);
3826 /* add ES to the json array */
3827 if (json_array)
3828 json_object_array_add(json_array, json);
3829 }
3830}
3831
3832struct es_evi_show_ctx {
3833 struct vty *vty;
3834 json_object *json;
3835 int detail;
3836};
3837
3838static void bgp_evpn_es_evi_show_one_vni_hash_cb(struct hash_bucket *bucket,
3839 void *ctxt)
3840{
3841 struct bgpevpn *vpn = (struct bgpevpn *)bucket->data;
3842 struct es_evi_show_ctx *wctx = (struct es_evi_show_ctx *)ctxt;
3843
3844 bgp_evpn_es_evi_show_one_vni(vpn, wctx->vty, wctx->json, wctx->detail);
3845}
3846
3847/* Display all ES EVIs */
3848void bgp_evpn_es_evi_show(struct vty *vty, bool uj, bool detail)
3849{
3850 json_object *json_array = NULL;
3851 struct es_evi_show_ctx wctx;
3852 struct bgp *bgp;
3853
3854 if (uj) {
3855 /* create an array of ES-EVIs */
3856 json_array = json_object_new_array();
3857 }
3858
3859 wctx.vty = vty;
3860 wctx.json = json_array;
3861 wctx.detail = detail;
3862
3863 bgp = bgp_get_evpn();
3864
3865 if (!json_array && !detail) {
3866 vty_out(vty, "Flags: L local, R remote, I inconsistent\n");
3867 vty_out(vty, "VTEP-Flags: E EAD-per-ES, V EAD-per-EVI\n");
3868 vty_out(vty, "%-8s %-30s %-5s %s\n",
3869 "VNI", "ESI", "Flags", "VTEPs");
3870 }
3871
3872 if (bgp)
3873 hash_iterate(bgp->vnihash,
3874 (void (*)(struct hash_bucket *,
3875 void *))bgp_evpn_es_evi_show_one_vni_hash_cb,
3876 &wctx);
c48349e3 3877 if (uj)
75eeda93 3878 vty_json(vty, json_array);
c44ab6f1
AK		 3879}
3880
3881/* Display specific ES EVI */
3882void bgp_evpn_es_evi_show_vni(struct vty *vty, vni_t vni,
3883 bool uj, bool detail)
3884{
3885 struct bgpevpn *vpn = NULL;
3886 json_object *json_array = NULL;
3887 struct bgp *bgp;
3888
3889 if (uj) {
3890 /* create an array of ES-EVIs */
3891 json_array = json_object_new_array();
3892 }
3893
3894 bgp = bgp_get_evpn();
3895 if (bgp)
3896 vpn = bgp_evpn_lookup_vni(bgp, vni);
3897
3898 if (vpn) {
3899 if (!json_array && !detail) {
3900 vty_out(vty, "Flags: L local, R remote, I inconsistent\n");
3901 vty_out(vty, "VTEP-Flags: E EAD-per-ES, V EAD-per-EVI\n");
3902 vty_out(vty, "%-8s %-30s %-5s %s\n",
3903 "VNI", "ESI", "Flags", "VTEPs");
3904 }
3905
3906 bgp_evpn_es_evi_show_one_vni(vpn, vty, json_array, detail);
3907 } else {
3908 if (!uj)
3909 vty_out(vty, "VNI not found\n");
3910 }
3911
c48349e3 3912 if (uj)
75eeda93 3913 vty_json(vty, json_array);
c44ab6f1
AK		 3914}
3915
3916/*****************************************************************************
3917 * Ethernet Segment Consistency checks
3918 * Consistency checking is done to detect misconfig or mis-cabling. When
3919 * an inconsistency is detected it is simply logged (and displayed via
3920 * show commands) at this point. A more drastic action can be executed (based
3921 * on user config) in the future.
3922 */
8fc2ffb3
AK		 3923static void bgp_evpn_es_cons_checks_timer_start(void)
3924{
3925 if (!bgp_mh_info->consistency_checking || bgp_mh_info->t_cons_check)
3926 return;
3927
3928 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
3929 zlog_debug("periodic consistency checking started");
3930
3931 thread_add_timer(bm->master, bgp_evpn_run_consistency_checks, NULL,
3932 BGP_EVPN_CONS_CHECK_INTERVAL,
3933 &bgp_mh_info->t_cons_check);
3934}
3935
c44ab6f1
AK		 3936/* queue up the es for background consistency checks */
3937static void bgp_evpn_es_cons_checks_pend_add(struct bgp_evpn_es *es)
3938{
3939 if (!bgp_mh_info->consistency_checking)
3940 /* consistency checking is not enabled */
3941 return;
3942
3943 if (CHECK_FLAG(es->flags, BGP_EVPNES_CONS_CHECK_PEND))
3944 /* already queued for consistency checking */
3945 return;
3946
8fc2ffb3
AK		 3947 /* start the periodic timer for consistency checks if it is not
3948 * already running */
3949 bgp_evpn_es_cons_checks_timer_start();
3950
c44ab6f1
AK		 3951 SET_FLAG(es->flags, BGP_EVPNES_CONS_CHECK_PEND);
3952 listnode_init(&es->pend_es_listnode, es);
3953 listnode_add_after(bgp_mh_info->pend_es_list,
3954 listtail_unchecked(bgp_mh_info->pend_es_list),
3955 &es->pend_es_listnode);
3956}
3957
3958/* pull the ES from the consistency check list */
3959static void bgp_evpn_es_cons_checks_pend_del(struct bgp_evpn_es *es)
3960{
3961 if (!CHECK_FLAG(es->flags, BGP_EVPNES_CONS_CHECK_PEND))
3962 return;
3963
3964 UNSET_FLAG(es->flags, BGP_EVPNES_CONS_CHECK_PEND);
3965 list_delete_node(bgp_mh_info->pend_es_list,
3966 &es->pend_es_listnode);
3967}
3968
3969/* Number of active VTEPs associated with the ES-per-EVI */
3970static uint32_t bgp_evpn_es_evi_get_active_vtep_cnt(
3971 struct bgp_evpn_es_evi *es_evi)
3972{
3973 struct bgp_evpn_es_evi_vtep *evi_vtep;
3974 struct listnode *node;
3975 uint32_t vtep_cnt = 0;
3976
3977 for (ALL_LIST_ELEMENTS_RO(es_evi->es_evi_vtep_list, node, evi_vtep)) {
3978 if (CHECK_FLAG(evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE))
3979 ++vtep_cnt;
3980 }
3981
3982 return vtep_cnt;
3983}
3984
3985/* Number of active VTEPs associated with the ES */
3986static uint32_t bgp_evpn_es_get_active_vtep_cnt(struct bgp_evpn_es *es)
3987{
3988 struct listnode *node;
3989 uint32_t vtep_cnt = 0;
3990 struct bgp_evpn_es_vtep *es_vtep;
3991
3992 for (ALL_LIST_ELEMENTS_RO(es->es_vtep_list, node, es_vtep)) {
3993 if (CHECK_FLAG(es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE))
3994 ++vtep_cnt;
3995 }
3996
3997 return vtep_cnt;
3998}
3999
4000static struct bgp_evpn_es_vtep *bgp_evpn_es_get_next_active_vtep(
4001 struct bgp_evpn_es *es, struct bgp_evpn_es_vtep *es_vtep)
4002{
4003 struct listnode *node;
4004 struct bgp_evpn_es_vtep *next_es_vtep;
4005
4006 if (es_vtep)
4007 node = listnextnode_unchecked(&es_vtep->es_listnode);
4008 else
4009 node = listhead(es->es_vtep_list);
4010
4011 for (; node; node = listnextnode_unchecked(node)) {
4012 next_es_vtep = listgetdata(node);
4013 if (CHECK_FLAG(next_es_vtep->flags, BGP_EVPNES_VTEP_ACTIVE))
4014 return next_es_vtep;
4015 }
4016
4017 return NULL;
4018}
4019
4020static struct bgp_evpn_es_evi_vtep *bgp_evpn_es_evi_get_next_active_vtep(
4021 struct bgp_evpn_es_evi *es_evi,
4022 struct bgp_evpn_es_evi_vtep *evi_vtep)
4023{
4024 struct listnode *node;
4025 struct bgp_evpn_es_evi_vtep *next_evi_vtep;
4026
4027 if (evi_vtep)
4028 node = listnextnode_unchecked(&evi_vtep->es_evi_listnode);
4029 else
4030 node = listhead(es_evi->es_evi_vtep_list);
4031
4032 for (; node; node = listnextnode_unchecked(node)) {
4033 next_evi_vtep = listgetdata(node);
4034 if (CHECK_FLAG(next_evi_vtep->flags, BGP_EVPN_EVI_VTEP_ACTIVE))
4035 return next_evi_vtep;
4036 }
4037
4038 return NULL;
4039}
4040
4041static void bgp_evpn_es_evi_set_inconsistent(struct bgp_evpn_es_evi *es_evi)
4042{
4043 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_INCONS_VTEP_LIST)) {
4044 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4045 zlog_debug("inconsistency detected - es %s evi %u vtep list mismatch",
4046 es_evi->es->esi_str,
4047 es_evi->vpn->vni);
4048 SET_FLAG(es_evi->flags, BGP_EVPNES_EVI_INCONS_VTEP_LIST);
4049
4050 /* update parent ES with the incosistency setting */
4051 if (!es_evi->es->incons_evi_vtep_cnt &&
4052 BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4053 zlog_debug("inconsistency detected - es %s vtep list mismatch",
4054 es_evi->es->esi_str);
4055 ++es_evi->es->incons_evi_vtep_cnt;
4056 SET_FLAG(es_evi->es->inconsistencies,
4057 BGP_EVPNES_INCONS_VTEP_LIST);
4058 }
4059}
4060
4061static uint32_t bgp_evpn_es_run_consistency_checks(struct bgp_evpn_es *es)
4062{
4063 int proc_cnt = 0;
4064 int es_active_vtep_cnt;
4065 int evi_active_vtep_cnt;
4066 struct bgp_evpn_es_evi *es_evi;
4067 struct listnode *evi_node;
4068 struct bgp_evpn_es_vtep *es_vtep;
4069 struct bgp_evpn_es_evi_vtep *evi_vtep;
4070
4071 /* reset the inconsistencies and re-evaluate */
4072 es->incons_evi_vtep_cnt = 0;
4073 es->inconsistencies = 0;
4074
4075 es_active_vtep_cnt = bgp_evpn_es_get_active_vtep_cnt(es);
4076 for (ALL_LIST_ELEMENTS_RO(es->es_evi_list,
4077 evi_node, es_evi)) {
4078 ++proc_cnt;
4079
4080 /* reset the inconsistencies on the EVI and re-evaluate*/
4081 UNSET_FLAG(es_evi->flags, BGP_EVPNES_EVI_INCONS_VTEP_LIST);
4082
4083 evi_active_vtep_cnt =
4084 bgp_evpn_es_evi_get_active_vtep_cnt(es_evi);
4085 if (es_active_vtep_cnt != evi_active_vtep_cnt) {
4086 bgp_evpn_es_evi_set_inconsistent(es_evi);
4087 continue;
4088 }
4089
4090 if (!es_active_vtep_cnt)
4091 continue;
4092
4093 es_vtep = NULL;
4094 evi_vtep = NULL;
4095 while ((es_vtep = bgp_evpn_es_get_next_active_vtep(
4096 es, es_vtep))) {
4097 evi_vtep = bgp_evpn_es_evi_get_next_active_vtep(es_evi,
4098 evi_vtep);
4099 if (!evi_vtep) {
4100 bgp_evpn_es_evi_set_inconsistent(es_evi);
4101 break;
4102 }
4103 if (es_vtep->vtep_ip.s_addr !=
4104 evi_vtep->vtep_ip.s_addr) {
4105 /* inconsistency detected; set it and move
4106 * to the next evi
4107 */
4108 bgp_evpn_es_evi_set_inconsistent(es_evi);
4109 break;
4110 }
4111 }
4112 }
4113
4114 return proc_cnt;
4115}
4116
4117static int bgp_evpn_run_consistency_checks(struct thread *t)
4118{
4119 int proc_cnt = 0;
4120 int es_cnt = 0;
4121 struct listnode *node;
4122 struct listnode *nextnode;
4123 struct bgp_evpn_es *es;
4124
4125 for (ALL_LIST_ELEMENTS(bgp_mh_info->pend_es_list,
4126 node, nextnode, es)) {
4127 ++es_cnt;
4128 ++proc_cnt;
4129 /* run consistency checks on the ES and remove it from the
4130 * pending list
4131 */
4132 proc_cnt += bgp_evpn_es_run_consistency_checks(es);
4133 bgp_evpn_es_cons_checks_pend_del(es);
4134 if (proc_cnt > 500)
4135 break;
4136 }
4137
4138 /* restart the timer */
4139 thread_add_timer(bm->master, bgp_evpn_run_consistency_checks, NULL,
4140 BGP_EVPN_CONS_CHECK_INTERVAL,
4141 &bgp_mh_info->t_cons_check);
4142
4143 return 0;
4144}
4145
090efa2f
AK		 4146/*****************************************************************************
4147 * EVPN-Nexthop and RMAC management: nexthops associated with Type-2 routes
4148 * that have an ES as destination are consolidated by BGP into a per-VRF
4149 * nh->rmac mapping which is sent to zebra. Zebra installs the nexthop
4150 * as a remote neigh/fdb entry with a dummy (type-1) prefix referencing it.
4151 *
4152 * This handling is needed because Type-2 routes with ES as dest use NHG
4153 * that is setup using EAD routes (i.e. such NHGs do not include the
4154 * RMAC info).
4155 ****************************************************************************/
4156static void bgp_evpn_nh_zebra_update_send(struct bgp_evpn_nh *nh, bool add)
4157{
4158 struct stream *s;
4159 struct bgp *bgp_vrf = nh->bgp_vrf;
4160
4161 /* Check socket. */
4162 if (!zclient || zclient->sock < 0)
4163 return;
4164
4165 /* Don't try to register if Zebra doesn't know of this instance. */
4166 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp_vrf)) {
4167 if (BGP_DEBUG(zebra, ZEBRA))
4168 zlog_debug("No zebra instance, not %s remote nh %s",
4169 add ? "adding" : "deleting", nh->nh_str);
4170 return;
4171 }
4172
4173 s = zclient->obuf;
4174 stream_reset(s);
4175
4176 zclient_create_header(
4177 s, add ? ZEBRA_EVPN_REMOTE_NH_ADD : ZEBRA_EVPN_REMOTE_NH_DEL,
4178 bgp_vrf->vrf_id);
4179 stream_putl(s, bgp_vrf->vrf_id);
4180 stream_put(s, &nh->ip, sizeof(nh->ip));
4181 if (add)
4182 stream_put(s, &nh->rmac, sizeof(nh->rmac));
4183
4184 stream_putw_at(s, 0, stream_get_endp(s));
4185
4186 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES)) {
4187 if (add)
4188 zlog_debug("evpn vrf %s nh %s rmac %pEA add to zebra",
4189 nh->bgp_vrf->name, nh->nh_str, &nh->rmac);
4190 else if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4191 zlog_debug("evpn vrf %s nh %s del to zebra",
4192 nh->bgp_vrf->name, nh->nh_str);
4193 }
4194
23aa35ad
AK		 4195 frrtrace(2, frr_bgp, evpn_mh_nh_rmac_zsend, add, nh);
4196
090efa2f
AK		 4197 zclient_send_message(zclient);
4198}
4199
4200static void bgp_evpn_nh_zebra_update(struct bgp_evpn_nh *nh, bool add)
4201{
4202 if (add && !is_zero_mac(&nh->rmac)) {
4203 nh->flags |= BGP_EVPN_NH_READY_FOR_ZEBRA;
4204 bgp_evpn_nh_zebra_update_send(nh, true);
4205 } else {
4206 if (!(nh->flags & BGP_EVPN_NH_READY_FOR_ZEBRA))
4207 return;
4208 nh->flags &= ~BGP_EVPN_NH_READY_FOR_ZEBRA;
4209 bgp_evpn_nh_zebra_update_send(nh, false);
4210 }
4211}
4212
4213static void *bgp_evpn_nh_alloc(void *p)
4214{
4215 struct bgp_evpn_nh *tmp_n = p;
4216 struct bgp_evpn_nh *n;
4217
4218 n = XCALLOC(MTYPE_BGP_EVPN_NH, sizeof(struct bgp_evpn_nh));
4219 *n = *tmp_n;
4220
4221 return ((void *)n);
4222}
4223
4224static struct bgp_evpn_nh *bgp_evpn_nh_find(struct bgp *bgp_vrf,
4225 struct ipaddr *ip)
4226{
4227 struct bgp_evpn_nh tmp;
4228 struct bgp_evpn_nh *n;
4229
4230 memset(&tmp, 0, sizeof(tmp));
4231 memcpy(&tmp.ip, ip, sizeof(struct ipaddr));
4232 n = hash_lookup(bgp_vrf->evpn_nh_table, &tmp);
4233
4234 return n;
4235}
4236
4237/* Add nexthop entry - implicitly created on first path reference */
4238static struct bgp_evpn_nh *bgp_evpn_nh_add(struct bgp *bgp_vrf,
4239 struct ipaddr *ip,
4240 struct bgp_path_info *pi)
4241{
4242 struct bgp_evpn_nh tmp_n;
4243 struct bgp_evpn_nh *n = NULL;
4244
4245 memset(&tmp_n, 0, sizeof(struct bgp_evpn_nh));
4246 memcpy(&tmp_n.ip, ip, sizeof(struct ipaddr));
4247 n = hash_get(bgp_vrf->evpn_nh_table, &tmp_n, bgp_evpn_nh_alloc);
4248 ipaddr2str(ip, n->nh_str, sizeof(n->nh_str));
4249 n->bgp_vrf = bgp_vrf;
4250
4251 n->pi_list = list_new();
4252 listset_app_node_mem(n->pi_list);
4253
4254 /* Setup ref_pi when the nh is created */
4255 if (CHECK_FLAG(pi->flags, BGP_PATH_VALID) && pi->attr) {
4256 n->ref_pi = pi;
4257 memcpy(&n->rmac, &pi->attr->rmac, ETH_ALEN);
4258 }
4259
4260 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4261 zlog_debug("evpn vrf %s nh %s rmac %pEA add", n->bgp_vrf->name,
4262 n->nh_str, &n->rmac);
4263 bgp_evpn_nh_zebra_update(n, true);
4264 return n;
4265}
4266
4267/* Delete nexthop entry if there are no paths referencing it */
4268static void bgp_evpn_nh_del(struct bgp_evpn_nh *n)
4269{
4270 struct bgp_evpn_nh *tmp_n;
4271 struct bgp *bgp_vrf = n->bgp_vrf;
4272
4273 if (listcount(n->pi_list))
4274 return;
4275
4276 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4277 zlog_debug("evpn vrf %s nh %s del to zebra", bgp_vrf->name,
4278 n->nh_str);
4279
4280 bgp_evpn_nh_zebra_update(n, false);
4281 list_delete(&n->pi_list);
4282 tmp_n = hash_release(bgp_vrf->evpn_nh_table, n);
4283 XFREE(MTYPE_BGP_EVPN_NH, tmp_n);
4284}
4285
4286static unsigned int bgp_evpn_nh_hash_keymake(const void *p)
4287{
4288 const struct bgp_evpn_nh *n = p;
4289 const struct ipaddr *ip = &n->ip;
4290
4291 if (IS_IPADDR_V4(ip))
4292 return jhash_1word(ip->ipaddr_v4.s_addr, 0);
4293
4294 return jhash2(ip->ipaddr_v6.s6_addr32,
4295 array_size(ip->ipaddr_v6.s6_addr32), 0);
4296}
4297
4298static bool bgp_evpn_nh_cmp(const void *p1, const void *p2)
4299{
4300 const struct bgp_evpn_nh *n1 = p1;
4301 const struct bgp_evpn_nh *n2 = p2;
4302
4303 if (n1 == NULL && n2 == NULL)
4304 return true;
4305
4306 if (n1 == NULL || n2 == NULL)
4307 return false;
4308
4309 return (memcmp(&n1->ip, &n2->ip, sizeof(struct ipaddr)) == 0);
4310}
4311
4312void bgp_evpn_nh_init(struct bgp *bgp_vrf)
4313{
4314 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4315 zlog_debug("evpn vrf %s nh init", bgp_vrf->name);
4316 bgp_vrf->evpn_nh_table = hash_create(
4317 bgp_evpn_nh_hash_keymake, bgp_evpn_nh_cmp, "BGP EVPN NH table");
4318}
4319
4320static void bgp_evpn_nh_flush_entry(struct bgp_evpn_nh *nh)
4321{
4322 struct listnode *node;
4323 struct listnode *nnode;
4324 struct bgp_path_evpn_nh_info *nh_info;
4325
4326 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4327 zlog_debug("evpn vrf %s nh %s flush", nh->bgp_vrf->name,
4328 nh->nh_str);
4329
4330 /* force flush paths */
4331 for (ALL_LIST_ELEMENTS(nh->pi_list, node, nnode, nh_info))
4332 bgp_evpn_path_nh_del(nh->bgp_vrf, nh_info->pi);
4333}
4334
4335static void bgp_evpn_nh_flush_cb(struct hash_bucket *bucket, void *ctxt)
4336{
4337 struct bgp_evpn_nh *nh = (struct bgp_evpn_nh *)bucket->data;
4338
4339 bgp_evpn_nh_flush_entry(nh);
4340}
4341
4342void bgp_evpn_nh_finish(struct bgp *bgp_vrf)
4343{
4344 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4345 zlog_debug("evpn vrf %s nh finish", bgp_vrf->name);
4346 hash_iterate(
4347 bgp_vrf->evpn_nh_table,
4348 (void (*)(struct hash_bucket *, void *))bgp_evpn_nh_flush_cb,
4349 NULL);
4350 hash_free(bgp_vrf->evpn_nh_table);
4351 bgp_vrf->evpn_nh_table = NULL;
4352}
4353
4354static void bgp_evpn_nh_update_ref_pi(struct bgp_evpn_nh *nh)
4355{
4356 struct listnode *node;
4357 struct bgp_path_info *pi;
4358 struct bgp_path_evpn_nh_info *nh_info;
4359
4360 if (nh->ref_pi)
4361 return;
4362
4363 for (ALL_LIST_ELEMENTS_RO(nh->pi_list, node, nh_info)) {
4364 pi = nh_info->pi;
4365 if (!CHECK_FLAG(pi->flags, BGP_PATH_VALID) || !pi->attr)
4366 continue;
4367
4368 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4369 zlog_debug("evpn vrf %s nh %s ref_pi update",
4370 nh->bgp_vrf->name, nh->nh_str);
4371 nh->ref_pi = pi;
4372 /* If we have a new pi copy rmac from it and update
4373 * zebra if the new rmac is different
4374 */
4375 if (memcmp(&nh->rmac, &nh->ref_pi->attr->rmac, ETH_ALEN)) {
4376 memcpy(&nh->rmac, &nh->ref_pi->attr->rmac, ETH_ALEN);
4377 bgp_evpn_nh_zebra_update(nh, true);
4378 }
4379 break;
4380 }
4381}
4382
4383static void bgp_evpn_nh_clear_ref_pi(struct bgp_evpn_nh *nh,
4384 struct bgp_path_info *pi)
4385{
4386 if (nh->ref_pi != pi)
4387 return;
4388
4389 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
4390 zlog_debug("evpn vrf %s nh %s ref_pi clear", nh->bgp_vrf->name,
4391 nh->nh_str);
4392 nh->ref_pi = NULL;
4393 /* try to find another ref_pi */
4394 bgp_evpn_nh_update_ref_pi(nh);
4395 /* couldn't find one - clear the old rmac and notify zebra */
4396 if (!nh->ref_pi) {
4397 memset(&nh->rmac, 0, ETH_ALEN);
4398 bgp_evpn_nh_zebra_update(nh, true);
4399 }
4400}
4401
4402static void bgp_evpn_path_nh_info_free(struct bgp_path_evpn_nh_info *nh_info)
4403{
4404 bgp_evpn_path_nh_unlink(nh_info);
4405 XFREE(MTYPE_BGP_EVPN_PATH_NH_INFO, nh_info);
4406}
4407
4408static struct bgp_path_evpn_nh_info *
4409bgp_evpn_path_nh_info_new(struct bgp_path_info *pi)
4410{
4411 struct bgp_path_info_extra *e;
4412 struct bgp_path_mh_info *mh_info;
4413 struct bgp_path_evpn_nh_info *nh_info;
4414
4415 e = bgp_path_info_extra_get(pi);
4416
4417 /* If mh_info doesn't exist allocate it */
4418 mh_info = e->mh_info;
4419 if (!mh_info)
4420 e->mh_info = mh_info = XCALLOC(MTYPE_BGP_EVPN_PATH_MH_INFO,
4421 sizeof(struct bgp_path_mh_info));
4422
4423 /* If nh_info doesn't exist allocate it */
4424 nh_info = mh_info->nh_info;
4425 if (!nh_info) {
4426 mh_info->nh_info = nh_info =
4427 XCALLOC(MTYPE_BGP_EVPN_PATH_NH_INFO,
4428 sizeof(struct bgp_path_evpn_nh_info));
4429 nh_info->pi = pi;
4430 }
4431
4432 return nh_info;
4433}
4434
4435static void bgp_evpn_path_nh_unlink(struct bgp_path_evpn_nh_info *nh_info)
4436{
4437 struct bgp_evpn_nh *nh = nh_info->nh;
4438 struct bgp_path_info *pi;
4439 char prefix_buf[PREFIX_STRLEN];
4440
4441 if (!nh)
4442 return;
4443
4444 pi = nh_info->pi;
4445 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
4446 zlog_debug("path %s unlinked from nh %s %s",
4447 pi->net ? prefix2str(&pi->net->p, prefix_buf,
4448 sizeof(prefix_buf))
4449 : "",
4450 nh->bgp_vrf->name, nh->nh_str);
4451
4452 list_delete_node(nh->pi_list, &nh_info->nh_listnode);
4453
4454 nh_info->nh = NULL;
4455
4456 /* check if the ref_pi need to be updated */
4457 bgp_evpn_nh_clear_ref_pi(nh, pi);
4458
4459 /* if there are no other references against the nh it
4460 * needs to be freed
4461 */
4462 bgp_evpn_nh_del(nh);
4463
4464 /* Note we don't free the path nh_info on unlink; it will be freed up
4465 * along with the path.
4466 */
4467}
4468
4469static void bgp_evpn_path_nh_link(struct bgp *bgp_vrf, struct bgp_path_info *pi)
4470{
4471 struct bgp_path_evpn_nh_info *nh_info;
4472 struct bgp_evpn_nh *nh;
090efa2f
AK		 4473 struct ipaddr ip;
4474
4475 /* EVPN nexthop setup in bgp has been turned off */
4476 if (!bgp_mh_info->bgp_evpn_nh_setup)
4477 return;
4478
4479 if (!bgp_vrf->evpn_nh_table) {
4480 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
70545a29
AK		 4481 zlog_debug("path %pFX linked to vrf %s failed",
4482 &pi->net->p, bgp_vrf->name);
090efa2f
AK		 4483 return;
4484 }
4485
4486 nh_info = (pi->extra && pi->extra->mh_info)
4487 ? pi->extra->mh_info->nh_info
4488 : NULL;
4489
4490 /* if NHG is not being used for this path we don't need to manage the
4491 * nexthops in bgp (they are managed by zebra instead)
4492 */
4493 if (!(pi->attr->es_flags & ATTR_ES_L3_NHG_USE)) {
4494 if (nh_info)
4495 bgp_evpn_path_nh_unlink(nh_info);
4496 return;
4497 }
4498
4499 /* setup nh_info against the path if it doesn't aleady exist */
4500 if (!nh_info)
4501 nh_info = bgp_evpn_path_nh_info_new(pi);
4502
4503 /* find-create nh */
4504 memset(&ip, 0, sizeof(ip));
4505 if (pi->net->p.family == AF_INET6) {
4506 SET_IPADDR_V6(&ip);
4507 memcpy(&ip.ipaddr_v6, &pi->attr->mp_nexthop_global,
4508 sizeof(ip.ipaddr_v6));
4509 } else {
4510 SET_IPADDR_V4(&ip);
4511 memcpy(&ip.ipaddr_v4, &pi->attr->nexthop, sizeof(ip.ipaddr_v4));
4512 }
4513
4514 nh = bgp_evpn_nh_find(bgp_vrf, &ip);
4515 if (!nh)
4516 nh = bgp_evpn_nh_add(bgp_vrf, &ip, pi);
4517
4518 /* dup check */
4519 if (nh_info->nh == nh) {
4520 /* Check if any of the paths are now valid */
4521 bgp_evpn_nh_update_ref_pi(nh);
4522 return;
4523 }
4524
4525 /* unlink old nh if any */
4526 bgp_evpn_path_nh_unlink(nh_info);
4527
4528 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
70545a29
AK		 4529 zlog_debug("path %pFX linked to nh %s %s", &pi->net->p,
4530 nh->bgp_vrf->name, nh->nh_str);
090efa2f
AK		 4531
4532 /* link mac-ip path to the new nh */
4533 nh_info->nh = nh;
4534 listnode_init(&nh_info->nh_listnode, nh_info);
4535 listnode_add(nh->pi_list, &nh_info->nh_listnode);
4536 /* If a new valid path got linked to the nh see if can get the rmac
4537 * from it
4538 */
4539 bgp_evpn_nh_update_ref_pi(nh);
4540 if (BGP_DEBUG(evpn_mh, EVPN_MH_ES)) {
4541 if (!nh->ref_pi)
4542 zlog_debug(
70545a29
AK		 4543 "path %pFX linked to nh %s %s with no valid pi",
4544 &pi->net->p, nh->bgp_vrf->name, nh->nh_str);
090efa2f
AK		 4545 }
4546}
4547
4548void bgp_evpn_path_nh_del(struct bgp *bgp_vrf, struct bgp_path_info *pi)
4549{
4550 struct bgp_path_evpn_nh_info *nh_info;
4551
4552 nh_info = (pi->extra && pi->extra->mh_info)
4553 ? pi->extra->mh_info->nh_info
4554 : NULL;
4555
4556 if (!nh_info)
4557 return;
4558
4559 bgp_evpn_path_nh_unlink(nh_info);
4560}
4561
4562void bgp_evpn_path_nh_add(struct bgp *bgp_vrf, struct bgp_path_info *pi)
4563{
4564 bgp_evpn_path_nh_link(bgp_vrf, pi);
4565}
4566
4567static void bgp_evpn_nh_show_entry(struct bgp_evpn_nh *nh, struct vty *vty,
4568 json_object *json_array)
4569{
4570 json_object *json = NULL;
4571 char mac_buf[ETHER_ADDR_STRLEN];
4572 char prefix_buf[PREFIX_STRLEN];
4573
4574 if (json_array)
4575 /* create a separate json object for each ES */
4576 json = json_object_new_object();
4577
4578 prefix_mac2str(&nh->rmac, mac_buf, sizeof(mac_buf));
4579 if (nh->ref_pi && nh->ref_pi->net)
4580 prefix2str(&nh->ref_pi->net->p, prefix_buf, sizeof(prefix_buf));
4581 else
4582 prefix_buf[0] = '\0';
4583 if (json) {
4584 json_object_string_add(json, "vrf", nh->bgp_vrf->name);
4585 json_object_string_add(json, "ip", nh->nh_str);
4586 json_object_string_add(json, "rmac", mac_buf);
4587 json_object_string_add(json, "basePath", prefix_buf);
4588 json_object_int_add(json, "pathCount", listcount(nh->pi_list));
4589 } else {
4590 vty_out(vty, "%-15s %-15s %-17s %-10d %s\n", nh->bgp_vrf->name,
4591 nh->nh_str, mac_buf, listcount(nh->pi_list),
4592 prefix_buf);
4593 }
4594
4595 /* add ES to the json array */
4596 if (json_array)
4597 json_object_array_add(json_array, json);
4598}
4599
4600struct nh_show_ctx {
4601 struct vty *vty;
4602 json_object *json;
4603};
4604
4605static void bgp_evpn_nh_show_hash_cb(struct hash_bucket *bucket, void *ctxt)
4606{
4607 struct bgp_evpn_nh *nh = (struct bgp_evpn_nh *)bucket->data;
4608 struct nh_show_ctx *wctx = (struct nh_show_ctx *)ctxt;
4609
4610 bgp_evpn_nh_show_entry(nh, wctx->vty, wctx->json);
4611}
4612
4613/* Display all evpn nexthops */
4614void bgp_evpn_nh_show(struct vty *vty, bool uj)
4615{
4616 json_object *json_array = NULL;
4617 struct bgp *bgp_vrf;
4618 struct listnode *node;
4619 struct nh_show_ctx wctx;
4620
4621 if (uj) {
4622 /* create an array of nexthops */
4623 json_array = json_object_new_array();
4624 } else {
4625 vty_out(vty, "%-15s %-15s %-17s %-10s %s\n", "VRF", "IP",
4626 "RMAC", "#Paths", "Base Path");
4627 }
4628
4629 wctx.vty = vty;
4630 wctx.json = json_array;
4631
4632 /* walk through all vrfs */
4633 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_vrf)) {
4634 hash_iterate(bgp_vrf->evpn_nh_table,
4635 (void (*)(struct hash_bucket *,
4636 void *))bgp_evpn_nh_show_hash_cb,
4637 &wctx);
4638 }
4639
4640 /* print the array of json-ESs */
c48349e3 4641 if (uj)
75eeda93 4642 vty_json(vty, json_array);
090efa2f
AK		 4643}
4644
c44ab6f1
AK		 4645/*****************************************************************************/
4646void bgp_evpn_mh_init(void)
4647{
4648 bm->mh_info = XCALLOC(MTYPE_BGP_EVPN_MH_INFO, sizeof(*bm->mh_info));
4649
4650 /* setup ES tables */
4651 RB_INIT(bgp_es_rb_head, &bgp_mh_info->es_rb_tree);
4652 /* local ES list */
4653 bgp_mh_info->local_es_list = list_new();
4654 listset_app_node_mem(bgp_mh_info->local_es_list);
4655 /* list of ESs with pending processing */
4656 bgp_mh_info->pend_es_list = list_new();
4657 listset_app_node_mem(bgp_mh_info->pend_es_list);
4658
fe8293c3
AK		 4659 bgp_mh_info->ead_evi_rx = BGP_EVPN_MH_EAD_EVI_RX_DEF;
4660 bgp_mh_info->ead_evi_tx = BGP_EVPN_MH_EAD_EVI_TX_DEF;
4661
c44ab6f1
AK		 4662 /* config knobs - XXX add cli to control it */
4663 bgp_mh_info->ead_evi_adv_for_down_links = true;
4664 bgp_mh_info->consistency_checking = true;
2867823e
AK		 4665 bgp_mh_info->install_l3nhg = false;
4666 bgp_mh_info->host_routes_use_l3nhg = BGP_EVPN_MH_USE_ES_L3NHG_DEF;
70524092 4667 bgp_mh_info->suppress_l3_ecomm_on_inactive_es = true;
090efa2f 4668 bgp_mh_info->bgp_evpn_nh_setup = true;
c44ab6f1 4669
c44ab6f1
AK		 4670 memset(&zero_esi_buf, 0, sizeof(esi_t));
4671}
4672
4673void bgp_evpn_mh_finish(void)
4674{
4675 struct bgp_evpn_es *es;
4676 struct bgp_evpn_es *es_next;
c44ab6f1 4677
45a859f1
AK		 4678 if (BGP_DEBUG(evpn_mh, EVPN_MH_RT))
4679 zlog_debug("evpn mh finish");
4680
4681 RB_FOREACH_SAFE (es, bgp_es_rb_head, &bgp_mh_info->es_rb_tree,
4682 es_next) {
d57e0c05 4683 bgp_evpn_es_local_info_clear(es, true);
c44ab6f1 4684 }
8fc2ffb3
AK		 4685 if (bgp_mh_info->t_cons_check)
4686 thread_cancel(&bgp_mh_info->t_cons_check);
c44ab6f1
AK		 4687 list_delete(&bgp_mh_info->local_es_list);
4688 list_delete(&bgp_mh_info->pend_es_list);
4689
4690 XFREE(MTYPE_BGP_EVPN_MH_INFO, bgp_mh_info);
4691}
acd1d9bc
AD		 4692
4693/* This function is called when disable-ead-evi-rx knob flaps */
4694void bgp_evpn_switch_ead_evi_rx(void)
4695{
4696 struct bgp *bgp;
4697 struct bgp_evpn_es *es;
4698 struct bgp_evpn_es_evi *es_evi;
4699 struct listnode *evi_node = NULL;
4700 struct listnode *evi_next = NULL;
4701 struct bgp_evpn_es_evi_vtep *vtep;
4702 struct listnode *vtep_node = NULL;
4703 struct listnode *vtep_next = NULL;
4704
4705 bgp = bgp_get_evpn();
4706 if (!bgp)
4707 return;
4708
4709 /*
4710 * Process all the remote es_evi_vteps and reevaluate if the es_evi_vtep
4711 * is active.
4712 */
4713 RB_FOREACH(es, bgp_es_rb_head, &bgp_mh_info->es_rb_tree) {
4714 if (!CHECK_FLAG(es->flags, BGP_EVPNES_REMOTE))
4715 continue;
4716
4717 for (ALL_LIST_ELEMENTS(es->es_evi_list, evi_node, evi_next,
4718 es_evi)) {
4719 if (!CHECK_FLAG(es_evi->flags, BGP_EVPNES_EVI_REMOTE))
4720 continue;
4721
4722 for (ALL_LIST_ELEMENTS(es_evi->es_evi_vtep_list,
4723 vtep_node, vtep_next, vtep))
4724 bgp_evpn_es_evi_vtep_re_eval_active(bgp, vtep);
4725 }
4726 }
4727}
FRRouting mirror