1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* BGPd - Mac hash code
* Copyright (C) 2018 Cumulus Networks, Inc.
* Donald Sharp
*/
#include <zebra.h>
#include <jhash.h>
#include <hash.h>
#include <prefix.h>
#include <memory.h>
#include "bgpd/bgpd.h"
#include "bgpd/bgp_mac.h"
#include "bgpd/bgp_memory.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_packet.h"
#include "bgpd/bgp_rd.h"
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_evpn_private.h"
DEFINE_MTYPE_STATIC(BGPD, BSM, "Mac Hash Entry");
DEFINE_MTYPE_STATIC(BGPD, BSM_STRING, "Mac Hash Entry Intf String");
struct bgp_self_mac {
struct ethaddr macaddr;
struct list *ifp_list;
};
static unsigned int bgp_mac_hash_key_make(const void *data)
{
const struct bgp_self_mac *bsm = data;
return jhash(&bsm->macaddr, ETH_ALEN, 0xa5a5dead);
}
static bool bgp_mac_hash_cmp(const void *d1, const void *d2)
{
const struct bgp_self_mac *bsm1 = d1;
const struct bgp_self_mac *bsm2 = d2;
if (memcmp(&bsm1->macaddr, &bsm2->macaddr, ETH_ALEN) == 0)
return true;
return false;
}
void bgp_mac_init(void)
{
bm->self_mac_hash = hash_create(bgp_mac_hash_key_make, bgp_mac_hash_cmp,
"BGP MAC Hash");
}
static void bgp_mac_hash_free(void *data)
{
struct bgp_self_mac *bsm = data;
if (bsm->ifp_list)
list_delete(&bsm->ifp_list);
XFREE(MTYPE_BSM, bsm);
}
void bgp_mac_finish(void)
{
hash_clean_and_free(&bm->self_mac_hash, bgp_mac_hash_free);
}
static void bgp_mac_hash_interface_string_del(void *val)
{
char *data = val;
XFREE(MTYPE_BSM_STRING, data);
}
static void *bgp_mac_hash_alloc(void *p)
{
const struct bgp_self_mac *orig = p;
struct bgp_self_mac *bsm;
bsm = XCALLOC(MTYPE_BSM, sizeof(struct bgp_self_mac));
memcpy(&bsm->macaddr, &orig->macaddr, ETH_ALEN);
bsm->ifp_list = list_new();
bsm->ifp_list->del = bgp_mac_hash_interface_string_del;
return bsm;
}
struct bgp_mac_find_internal {
struct bgp_self_mac *bsm;
const char *ifname;
};
static void bgp_mac_find_ifp_internal(struct hash_bucket *bucket, void *arg)
{
struct bgp_mac_find_internal *bmfi = arg;
struct bgp_self_mac *bsm = bucket->data;
struct listnode *node;
char *name;
for (ALL_LIST_ELEMENTS_RO(bsm->ifp_list, node, name)) {
if (strcmp(name, bmfi->ifname) == 0) {
bmfi->bsm = bsm;
return;
}
}
}
static struct bgp_self_mac *bgp_mac_find_interface_name(const char *ifname)
{
struct bgp_mac_find_internal bmfi;
bmfi.bsm = NULL;
bmfi.ifname = ifname;
hash_iterate(bm->self_mac_hash, bgp_mac_find_ifp_internal, &bmfi);
return bmfi.bsm;
}
static void bgp_process_mac_rescan_table(struct bgp *bgp, struct peer *peer,
struct bgp_table *table,
struct ethaddr *macaddr)
{
struct bgp_dest *pdest, *dest;
struct bgp_path_info *pi;
for (pdest = bgp_table_top(table); pdest;
pdest = bgp_route_next(pdest)) {
struct bgp_table *sub = pdest->info;
const struct prefix *pdest_p = bgp_dest_get_prefix(pdest);
if (!sub)
continue;
for (dest = bgp_table_top(sub); dest;
dest = bgp_route_next(dest)) {
bool dest_affected;
const struct prefix *p = bgp_dest_get_prefix(dest);
struct prefix_evpn *pevpn = (struct prefix_evpn *)dest;
struct prefix_rd prd;
uint32_t num_labels = 0;
mpls_label_t *label_pnt = NULL;
struct bgp_route_evpn *evpn;
if (pevpn->family == AF_EVPN
&& pevpn->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE
&& memcmp(&p->u.prefix_evpn.macip_addr.mac, macaddr,
ETH_ALEN)
== 0)
dest_affected = true;
else
dest_affected = false;
for (pi = dest->info; pi; pi = pi->next) {
if (pi->peer == peer)
break;
}
if (!pi)
continue;
/*
* If the mac address is not the same then
* we don't care and since we are looking
*/
if ((memcmp(&pi->attr->rmac, macaddr, ETH_ALEN) != 0)
&& !dest_affected)
continue;
if (pi->extra)
num_labels = pi->extra->num_labels;
if (num_labels)
label_pnt = &pi->extra->label[0];
prd.family = AF_UNSPEC;
prd.prefixlen = 64;
memcpy(&prd.val, pdest_p->u.val, 8);
if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)) {
if (bgp_debug_update(peer, p, NULL, 1)) {
char pfx_buf[BGP_PRD_PATH_STRLEN];
bgp_debug_rdpfxpath2str(
AFI_L2VPN, SAFI_EVPN, &prd,
p, label_pnt, num_labels,
pi->addpath_rx_id ? 1 : 0,
pi->addpath_rx_id, NULL,
pfx_buf, sizeof(pfx_buf));
zlog_debug(
"%s skip update of %s marked as removed",
peer->host, pfx_buf);
}
continue;
}
memcpy(&evpn, bgp_attr_get_evpn_overlay(pi->attr),
sizeof(evpn));
bgp_update(peer, p, pi->addpath_rx_id, pi->attr,
AFI_L2VPN, SAFI_EVPN, ZEBRA_ROUTE_BGP,
BGP_ROUTE_NORMAL, &prd, label_pnt,
num_labels, 1, evpn);
}
}
}
static void bgp_mac_rescan_evpn_table(struct bgp *bgp, struct ethaddr *macaddr)
{
struct listnode *node;
struct peer *peer;
safi_t safi;
afi_t afi;
afi = AFI_L2VPN;
safi = SAFI_EVPN;
for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
continue;
if (!peer_established(peer))
continue;
if (bgp_debug_update(peer, NULL, NULL, 1))
zlog_debug(
"Processing EVPN MAC interface change on peer %s %s",
peer->host,
CHECK_FLAG(peer->af_flags[afi][safi],
PEER_FLAG_SOFT_RECONFIG)
? "(inbound, soft-reconfig)"
: "");
if (!bgp_soft_reconfig_in(peer, afi, safi)) {
struct bgp_table *table = bgp->rib[afi][safi];
bgp_process_mac_rescan_table(bgp, peer, table, macaddr);
}
}
}
static void bgp_mac_rescan_all_evpn_tables(struct ethaddr *macaddr)
{
struct listnode *node;
struct bgp *bgp;
for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp)) {
struct bgp_table *table = bgp->rib[AFI_L2VPN][SAFI_EVPN];
if (table)
bgp_mac_rescan_evpn_table(bgp, macaddr);
}
}
static void bgp_mac_remove_ifp_internal(struct bgp_self_mac *bsm, char *ifname,
struct ethaddr *macaddr)
{
struct listnode *node = NULL;
char *name;
for (ALL_LIST_ELEMENTS_RO(bsm->ifp_list, node, name)) {
if (strcmp(name, ifname) == 0)
break;
}
if (node) {
list_delete_node(bsm->ifp_list, node);
XFREE(MTYPE_BSM_STRING, name);
}
if (bsm->ifp_list->count == 0) {
struct ethaddr mac = *macaddr;
hash_release(bm->self_mac_hash, bsm);
list_delete(&bsm->ifp_list);
XFREE(MTYPE_BSM, bsm);
bgp_mac_rescan_all_evpn_tables(&mac);
}
}
void bgp_mac_add_mac_entry(struct interface *ifp)
{
struct bgp_self_mac lookup;
struct bgp_self_mac *bsm;
struct bgp_self_mac *old_bsm;
char *ifname;
memcpy(&lookup.macaddr, &ifp->hw_addr, ETH_ALEN);
bsm = hash_get(bm->self_mac_hash, &lookup, bgp_mac_hash_alloc);
/*
* Does this happen to be a move
*/
old_bsm = bgp_mac_find_interface_name(ifp->name);
ifname = XSTRDUP(MTYPE_BSM_STRING, ifp->name);
if (bsm->ifp_list->count == 0) {
listnode_add(bsm->ifp_list, ifname);
if (old_bsm)
bgp_mac_remove_ifp_internal(old_bsm, ifname,
&old_bsm->macaddr);
} else {
/*
* If old mac address is the same as the new,
* then there is nothing to do here
*/
if (old_bsm == bsm) {
XFREE(MTYPE_BSM_STRING, ifname);
return;
}
if (old_bsm)
bgp_mac_remove_ifp_internal(old_bsm, ifp->name,
&old_bsm->macaddr);
listnode_add(bsm->ifp_list, ifname);
}
bgp_mac_rescan_all_evpn_tables(&bsm->macaddr);
}
void bgp_mac_del_mac_entry(struct interface *ifp)
{
struct bgp_self_mac lookup;
struct bgp_self_mac *bsm;
memcpy(&lookup.macaddr, &ifp->hw_addr, ETH_ALEN);
bsm = hash_lookup(bm->self_mac_hash, &lookup);
if (!bsm)
return;
/*
* Write code to allow old mac address to no-longer
* win if we happen to have received it from a peer.
*/
bgp_mac_remove_ifp_internal(bsm, ifp->name, &bsm->macaddr);
}
/* This API checks MAC address against any of local
* assigned (SVIs) MAC address.
* An example: router-mac attribute in any of evpn update
* requires to compare against local mac.
*/
bool bgp_mac_exist(const struct ethaddr *mac)
{
struct bgp_self_mac lookup;
struct bgp_self_mac *bsm;
static uint8_t tmp [ETHER_ADDR_STRLEN] = {0};
if (memcmp(mac, &tmp, ETH_ALEN) == 0)
return false;
memcpy(&lookup.macaddr, mac, ETH_ALEN);
bsm = hash_lookup(bm->self_mac_hash, &lookup);
if (!bsm)
return false;
return true;
}
/* This API checks EVPN type-2 prefix and compares
* mac against any of local assigned (SVIs) MAC
* address.
*/
bool bgp_mac_entry_exists(const struct prefix *p)
{
const struct prefix_evpn *pevpn = (const struct prefix_evpn *)p;
if (pevpn->family != AF_EVPN)
return false;
if (pevpn->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE)
return false;
return bgp_mac_exist(&p->u.prefix_evpn.macip_addr.mac);
}
static void bgp_mac_show_mac_entry(struct hash_bucket *bucket, void *arg)
{
struct vty *vty = arg;
struct bgp_self_mac *bsm = bucket->data;
struct listnode *node;
char *name;
char buf_mac[ETHER_ADDR_STRLEN];
vty_out(vty, "Mac Address: %s ",
prefix_mac2str(&bsm->macaddr, buf_mac, sizeof(buf_mac)));
for (ALL_LIST_ELEMENTS_RO(bsm->ifp_list, node, name))
vty_out(vty, "%s ", name);
vty_out(vty, "\n");
}
void bgp_mac_dump_table(struct vty *vty)
{
hash_iterate(bm->self_mac_hash, bgp_mac_show_mac_entry, vty);
}
|