Line data Source code
1 : /*
2 : * Zebra EVPN Neighbor Data structures and definitions
3 : * These are "internal" to this function.
4 : * Copyright (C) 2016, 2017 Cumulus Networks, Inc.
5 : * Copyright (C) 2020 Volta Networks.
6 : *
7 : * This file is part of FRR.
8 : *
9 : * FRR is free software; you can redistribute it and/or modify it
10 : * under the terms of the GNU General Public License as published by the
11 : * Free Software Foundation; either version 2, or (at your option) any
12 : * later version.
13 : *
14 : * FRR is distributed in the hope that it will be useful, but
15 : * WITHOUT ANY WARRANTY; without even the implied warranty of
16 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 : * General Public License for more details.
18 : *
19 : * You should have received a copy of the GNU General Public License
20 : * along with FRR; see the file COPYING. If not, write to the Free
21 : * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22 : * 02111-1307, USA.
23 : */
24 :
25 : #ifndef _ZEBRA_EVPN_NEIGH_H
26 : #define _ZEBRA_EVPN_NEIGH_H
27 :
28 : #ifdef __cplusplus
29 : extern "C" {
30 : #endif
31 :
32 : #define IS_ZEBRA_NEIGH_ACTIVE(n) (n->state == ZEBRA_NEIGH_ACTIVE)
33 :
34 : #define IS_ZEBRA_NEIGH_INACTIVE(n) (n->state == ZEBRA_NEIGH_INACTIVE)
35 :
36 : #define ZEBRA_NEIGH_SET_ACTIVE(n) n->state = ZEBRA_NEIGH_ACTIVE
37 :
38 : #define ZEBRA_NEIGH_SET_INACTIVE(n) n->state = ZEBRA_NEIGH_INACTIVE
39 :
40 : /*
41 : * Neighbor hash table.
42 : *
43 : * This table contains the neighbors (IP to MAC bindings) pertaining to
44 : * this VNI. This includes local neighbors learnt on the attached VLAN
45 : * device that maps to this VNI as well as remote neighbors learnt and
46 : * installed by BGP.
47 : * Local neighbors will be known against the VLAN device (SVI); however,
48 : * it is sufficient for zebra to maintain against the VNI. The correct
49 : * VNI will be obtained as zebra maintains the mapping (of VLAN to VNI).
50 : */
51 : struct zebra_neigh {
52 : /* IP address. */
53 : struct ipaddr ip;
54 :
55 : /* MAC address. */
56 : struct ethaddr emac;
57 :
58 : /* Back pointer to MAC. Only applicable to hosts in a L2-VNI. */
59 : struct zebra_mac *mac;
60 :
61 : /* Underlying interface. */
62 : ifindex_t ifindex;
63 :
64 : struct zebra_evpn *zevpn;
65 :
66 : uint32_t flags;
67 : #define ZEBRA_NEIGH_LOCAL 0x01
68 : #define ZEBRA_NEIGH_REMOTE 0x02
69 : #define ZEBRA_NEIGH_REMOTE_NH 0x04 /* neigh entry for remote vtep */
70 : #define ZEBRA_NEIGH_DEF_GW 0x08
71 : #define ZEBRA_NEIGH_ROUTER_FLAG 0x10
72 : #define ZEBRA_NEIGH_DUPLICATE 0x20
73 : #define ZEBRA_NEIGH_SVI_IP 0x40
74 : /* rxed from an ES peer */
75 : #define ZEBRA_NEIGH_ES_PEER_ACTIVE 0x80
76 : /* rxed from an ES peer as a proxy advertisement */
77 : #define ZEBRA_NEIGH_ES_PEER_PROXY 0x100
78 : /* We have not been able to independently establish that the host
79 : * is local connected
80 : */
81 : #define ZEBRA_NEIGH_LOCAL_INACTIVE 0x200
82 : #define ZEBRA_NEIGH_ALL_LOCAL_FLAGS \
83 : (ZEBRA_NEIGH_LOCAL | ZEBRA_NEIGH_LOCAL_INACTIVE)
84 : #define ZEBRA_NEIGH_ALL_PEER_FLAGS \
85 : (ZEBRA_NEIGH_ES_PEER_PROXY | ZEBRA_NEIGH_ES_PEER_ACTIVE)
86 :
87 : enum zebra_neigh_state state;
88 :
89 : /* Remote VTEP IP - applicable only for remote neighbors. */
90 : struct in_addr r_vtep_ip;
91 :
92 : /*
93 : * Mobility sequence numbers associated with this entry. The rem_seq
94 : * represents the sequence number from the client (BGP) for the most
95 : * recent add or update of this entry while the loc_seq represents
96 : * the sequence number informed (or to be informed) by zebra to BGP
97 : * for this entry.
98 : */
99 : uint32_t rem_seq;
100 : uint32_t loc_seq;
101 :
102 : /* list of hosts pointing to this remote NH entry */
103 : struct host_rb_tree_entry host_rb;
104 :
105 : /* Duplicate ip detection */
106 : uint32_t dad_count;
107 :
108 : struct thread *dad_ip_auto_recovery_timer;
109 :
110 : struct timeval detect_start_time;
111 :
112 : time_t dad_dup_detect_time;
113 :
114 : time_t uptime;
115 :
116 : /* used for ageing out the PEER_ACTIVE flag */
117 : struct thread *hold_timer;
118 : };
119 :
120 : /*
121 : * Context for neighbor hash walk - used by callbacks.
122 : */
123 : struct neigh_walk_ctx {
124 : struct zebra_evpn *zevpn; /* VNI hash */
125 : struct zebra_vrf *zvrf; /* VRF - for client notification. */
126 : int uninstall; /* uninstall from kernel? */
127 : int upd_client; /* uninstall from client? */
128 :
129 : uint32_t flags;
130 : #define DEL_LOCAL_NEIGH 0x1
131 : #define DEL_REMOTE_NEIGH 0x2
132 : #define DEL_ALL_NEIGH (DEL_LOCAL_NEIGH | DEL_REMOTE_NEIGH)
133 : #define DEL_REMOTE_NEIGH_FROM_VTEP 0x4
134 : #define SHOW_REMOTE_NEIGH_FROM_VTEP 0x8
135 :
136 : struct in_addr r_vtep_ip; /* To walk neighbors from specific VTEP */
137 :
138 : struct vty *vty; /* Used by VTY handlers */
139 : uint32_t count; /* Used by VTY handlers */
140 : uint8_t addr_width; /* Used by VTY handlers */
141 : struct json_object *json; /* Used for JSON Output */
142 : };
143 :
144 : /**************************** SYNC neigh handling **************************/
145 0 : static inline bool zebra_evpn_neigh_is_static(struct zebra_neigh *neigh)
146 : {
147 0 : return !!(neigh->flags & ZEBRA_NEIGH_ALL_PEER_FLAGS);
148 : }
149 :
150 0 : static inline bool zebra_evpn_neigh_is_ready_for_bgp(struct zebra_neigh *n)
151 : {
152 0 : bool mac_ready;
153 0 : bool neigh_ready;
154 :
155 0 : mac_ready = !!(n->mac->flags & ZEBRA_MAC_LOCAL);
156 0 : neigh_ready =
157 0 : ((n->flags & ZEBRA_NEIGH_LOCAL) && IS_ZEBRA_NEIGH_ACTIVE(n)
158 : && (!(n->flags & ZEBRA_NEIGH_LOCAL_INACTIVE)
159 0 : || (n->flags & ZEBRA_NEIGH_ES_PEER_ACTIVE)))
160 : ? true
161 0 : : false;
162 :
163 0 : return mac_ready && neigh_ready;
164 : }
165 :
166 0 : static inline void zebra_evpn_neigh_stop_hold_timer(struct zebra_neigh *n)
167 : {
168 0 : if (!n->hold_timer)
169 : return;
170 :
171 0 : if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
172 0 : zlog_debug("sync-neigh vni %u ip %pIA mac %pEA 0x%x hold stop",
173 : n->zevpn->vni, &n->ip, &n->emac, n->flags);
174 0 : THREAD_OFF(n->hold_timer);
175 : }
176 :
177 : void zebra_evpn_sync_neigh_static_chg(struct zebra_neigh *n, bool old_n_static,
178 : bool new_n_static, bool defer_n_dp,
179 : bool defer_mac_dp, const char *caller);
180 :
181 0 : static inline bool zebra_evpn_neigh_clear_sync_info(struct zebra_neigh *n)
182 : {
183 0 : bool old_n_static = false;
184 0 : bool new_n_static = false;
185 :
186 0 : if (n->flags & ZEBRA_NEIGH_ALL_PEER_FLAGS) {
187 0 : if (IS_ZEBRA_DEBUG_EVPN_MH_NEIGH)
188 0 : zlog_debug("sync-neigh vni %u ip %pIA mac %pEA 0x%x clear",
189 : n->zevpn->vni, &n->ip, &n->emac, n->flags);
190 :
191 0 : old_n_static = zebra_evpn_neigh_is_static(n);
192 0 : UNSET_FLAG(n->flags, ZEBRA_NEIGH_ALL_PEER_FLAGS);
193 0 : new_n_static = zebra_evpn_neigh_is_static(n);
194 0 : if (old_n_static != new_n_static)
195 0 : zebra_evpn_sync_neigh_static_chg(
196 : n, old_n_static, new_n_static,
197 : true /*defer_dp)*/, false /*defer_mac_dp*/,
198 : __func__);
199 : }
200 0 : zebra_evpn_neigh_stop_hold_timer(n);
201 :
202 : /* if the neigh static flag changed inform that a dp
203 : * re-install maybe needed
204 : */
205 0 : return old_n_static != new_n_static;
206 : }
207 :
208 : int remote_neigh_count(struct zebra_mac *zmac);
209 :
210 : int neigh_list_cmp(void *p1, void *p2);
211 : struct hash *zebra_neigh_db_create(const char *desc);
212 : uint32_t num_dup_detected_neighs(struct zebra_evpn *zevpn);
213 : void zebra_evpn_find_neigh_addr_width(struct hash_bucket *bucket, void *ctxt);
214 : int remote_neigh_count(struct zebra_mac *zmac);
215 : int zebra_evpn_rem_neigh_install(struct zebra_evpn *zevpn,
216 : struct zebra_neigh *n, bool was_static);
217 : void zebra_evpn_install_neigh_hash(struct hash_bucket *bucket, void *ctxt);
218 : int zebra_evpn_neigh_send_add_to_client(vni_t vni, const struct ipaddr *ip,
219 : const struct ethaddr *macaddr,
220 : struct zebra_mac *zmac,
221 : uint32_t neigh_flags, uint32_t seq);
222 : int zebra_evpn_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
223 : struct ethaddr *macaddr, uint32_t flags,
224 : int state, bool force);
225 : bool zebra_evpn_neigh_is_bgp_seq_ok(struct zebra_evpn *zevpn,
226 : struct zebra_neigh *n,
227 : const struct ethaddr *macaddr, uint32_t seq,
228 : bool sync);
229 : int zebra_evpn_neigh_del(struct zebra_evpn *zevpn, struct zebra_neigh *n);
230 : void zebra_evpn_sync_neigh_del(struct zebra_neigh *n);
231 : struct zebra_neigh *zebra_evpn_proc_sync_neigh_update(
232 : struct zebra_evpn *zevpn, struct zebra_neigh *n, uint16_t ipa_len,
233 : const struct ipaddr *ipaddr, uint8_t flags, uint32_t seq,
234 : const esi_t *esi, struct zebra_mac *mac);
235 : void zebra_evpn_neigh_del_all(struct zebra_evpn *zevpn, int uninstall,
236 : int upd_client, uint32_t flags);
237 : struct zebra_neigh *zebra_evpn_neigh_lookup(struct zebra_evpn *zevpn,
238 : const struct ipaddr *ip);
239 :
240 : int zebra_evpn_rem_neigh_install(struct zebra_evpn *zevpn,
241 : struct zebra_neigh *n, bool was_static);
242 : void zebra_evpn_process_neigh_on_remote_mac_add(struct zebra_evpn *zevpn,
243 : struct zebra_mac *zmac);
244 : void zebra_evpn_process_neigh_on_local_mac_del(struct zebra_evpn *zevpn,
245 : struct zebra_mac *zmac);
246 : void zebra_evpn_process_neigh_on_local_mac_change(struct zebra_evpn *zevpn,
247 : struct zebra_mac *zmac,
248 : bool seq_change,
249 : bool es_change);
250 : void zebra_evpn_process_neigh_on_remote_mac_del(struct zebra_evpn *zevpn,
251 : struct zebra_mac *zmac);
252 : int zebra_evpn_local_neigh_update(struct zebra_evpn *zevpn,
253 : struct interface *ifp,
254 : const struct ipaddr *ip,
255 : const struct ethaddr *macaddr, bool is_router,
256 : bool local_inactive, bool dp_static);
257 : int zebra_evpn_remote_neigh_update(struct zebra_evpn *zevpn,
258 : struct interface *ifp,
259 : const struct ipaddr *ip,
260 : const struct ethaddr *macaddr,
261 : uint16_t state);
262 : void zebra_evpn_send_neigh_to_client(struct zebra_evpn *zevpn);
263 : void zebra_evpn_clear_dup_neigh_hash(struct hash_bucket *bucket, void *ctxt);
264 : void zebra_evpn_print_neigh(struct zebra_neigh *n, void *ctxt,
265 : json_object *json);
266 : void zebra_evpn_print_neigh_hash(struct hash_bucket *bucket, void *ctxt);
267 : void zebra_evpn_print_neigh_hdr(struct vty *vty, struct neigh_walk_ctx *wctx);
268 : void zebra_evpn_print_neigh_hash_detail(struct hash_bucket *bucket, void *ctxt);
269 : void zebra_evpn_print_dad_neigh_hash(struct hash_bucket *bucket, void *ctxt);
270 : void zebra_evpn_print_dad_neigh_hash_detail(struct hash_bucket *bucket,
271 : void *ctxt);
272 : void zebra_evpn_neigh_remote_macip_add(struct zebra_evpn *zevpn,
273 : struct zebra_vrf *zvrf,
274 : const struct ipaddr *ipaddr,
275 : struct zebra_mac *mac,
276 : struct in_addr vtep_ip, uint8_t flags,
277 : uint32_t seq);
278 : int zebra_evpn_neigh_gw_macip_add(struct interface *ifp,
279 : struct zebra_evpn *zevpn, struct ipaddr *ip,
280 : struct zebra_mac *mac);
281 : void zebra_evpn_neigh_remote_uninstall(struct zebra_evpn *zevpn,
282 : struct zebra_vrf *zvrf,
283 : struct zebra_neigh *n,
284 : struct zebra_mac *mac,
285 : const struct ipaddr *ipaddr);
286 : int zebra_evpn_neigh_del_ip(struct zebra_evpn *zevpn, const struct ipaddr *ip);
287 :
288 :
289 : #ifdef __cplusplus
290 : }
291 : #endif
292 :
293 : #endif /*_ZEBRA_EVPN_NEIGH_H */
|
