blob: 38885095a4fb1b02ff86831dd7cfe573e0116e48 [file] [log] [blame]
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001/*
2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <vnet/adj/adj_nbr.h>
17#include <vnet/adj/adj_internal.h>
18#include <vnet/ethernet/arp_packet.h>
19#include <vnet/fib/fib_walk.h>
20
21/*
22 * Vector Hash tables of neighbour (traditional) adjacencies
23 * Key: interface(for the vector index), address (and its proto),
24 * link-type/ether-type.
25 */
26static BVT(clib_bihash) **adj_nbr_tables[FIB_PROTOCOL_MAX];
27
28// FIXME SIZE APPROPRIATELY. ASK DAVEB.
29#define ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (64 * 64)
30#define ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (32<<20)
31
32
33#define ADJ_NBR_SET_KEY(_key, _lt, _nh) \
34{ \
35 _key.key[0] = (_nh)->as_u64[0]; \
36 _key.key[1] = (_nh)->as_u64[1]; \
37 _key.key[2] = (_lt); \
38}
39
40#define ADJ_NBR_ITF_OK(_proto, _itf) \
41 (((_itf) < vec_len(adj_nbr_tables[_proto])) && \
42 (NULL != adj_nbr_tables[_proto][sw_if_index]))
43
44static void
45adj_nbr_insert (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +010046 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +010047 const ip46_address_t *nh_addr,
48 u32 sw_if_index,
49 adj_index_t adj_index)
50{
51 BVT(clib_bihash_kv) kv;
52
53 if (sw_if_index >= vec_len(adj_nbr_tables[nh_proto]))
54 {
55 vec_validate(adj_nbr_tables[nh_proto], sw_if_index);
56 }
57 if (NULL == adj_nbr_tables[nh_proto][sw_if_index])
58 {
59 adj_nbr_tables[nh_proto][sw_if_index] =
60 clib_mem_alloc_aligned(sizeof(BVT(clib_bihash)),
61 CLIB_CACHE_LINE_BYTES);
Dave Barachb7b92992018-10-17 10:38:51 -040062 clib_memset(adj_nbr_tables[nh_proto][sw_if_index],
Neale Ranns0bfe5d82016-08-25 15:29:12 +010063 0,
64 sizeof(BVT(clib_bihash)));
65
66 BV(clib_bihash_init) (adj_nbr_tables[nh_proto][sw_if_index],
67 "Adjacency Neighbour table",
68 ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS,
69 ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE);
70 }
71
72 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
73 kv.value = adj_index;
74
75 BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 1);
76}
77
78void
Neale Ranns177bbdc2016-11-15 09:46:51 +000079adj_nbr_remove (adj_index_t ai,
80 fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +010081 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +010082 const ip46_address_t *nh_addr,
83 u32 sw_if_index)
84{
85 BVT(clib_bihash_kv) kv;
86
87 if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
88 return;
89
90 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
Neale Ranns177bbdc2016-11-15 09:46:51 +000091 kv.value = ai;
Neale Ranns0bfe5d82016-08-25 15:29:12 +010092
93 BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 0);
94}
95
Florin Corasf9d05682018-04-26 08:26:52 -070096adj_index_t
Neale Ranns0bfe5d82016-08-25 15:29:12 +010097adj_nbr_find (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +010098 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +010099 const ip46_address_t *nh_addr,
100 u32 sw_if_index)
101{
102 BVT(clib_bihash_kv) kv;
103
104 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
105
106 if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
107 return (ADJ_INDEX_INVALID);
108
109 if (BV(clib_bihash_search)(adj_nbr_tables[nh_proto][sw_if_index],
110 &kv, &kv) < 0)
111 {
112 return (ADJ_INDEX_INVALID);
113 }
114 else
115 {
116 return (kv.value);
117 }
118}
119
Neale Rannsb80c5362016-10-08 13:03:40 +0100120static inline u32
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100121adj_get_nd_node (fib_protocol_t proto)
122{
123 switch (proto) {
124 case FIB_PROTOCOL_IP4:
Neale Rannsb80c5362016-10-08 13:03:40 +0100125 return (ip4_arp_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100126 case FIB_PROTOCOL_IP6:
Neale Rannsb80c5362016-10-08 13:03:40 +0100127 return (ip6_discover_neighbor_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100128 case FIB_PROTOCOL_MPLS:
129 break;
130 }
131 ASSERT(0);
Neale Rannsb80c5362016-10-08 13:03:40 +0100132 return (ip4_arp_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100133}
134
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530135/**
136 * @brief Check and set feature flags if o/p interface has any o/p features.
137 */
138static void
139adj_nbr_evaluate_feature (adj_index_t ai)
140{
141 ip_adjacency_t *adj;
142 vnet_feature_main_t *fm = &feature_main;
143 i16 feature_count;
144 u8 arc_index;
145 u32 sw_if_index;
146
147 adj = adj_get(ai);
148
149 switch (adj->ia_link)
150 {
151 case VNET_LINK_IP4:
152 arc_index = ip4_main.lookup_main.output_feature_arc_index;
153 break;
154 case VNET_LINK_IP6:
155 arc_index = ip6_main.lookup_main.output_feature_arc_index;
156 break;
157 case VNET_LINK_MPLS:
158 arc_index = mpls_main.output_feature_arc_index;
159 break;
160 default:
161 return;
162 }
163
164 sw_if_index = adj->rewrite_header.sw_if_index;
AkshayaNadahalli98ab0912017-03-27 17:21:05 +0000165 if (vec_len(fm->feature_count_by_sw_if_index[arc_index]) > sw_if_index)
166 {
167 feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
168 if (feature_count > 0)
169 adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
170 }
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530171
172 return;
173}
174
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100175static ip_adjacency_t*
176adj_nbr_alloc (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100177 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100178 const ip46_address_t *nh_addr,
179 u32 sw_if_index)
180{
181 ip_adjacency_t *adj;
182
183 adj = adj_alloc(nh_proto);
184
185 adj_nbr_insert(nh_proto, link_type, nh_addr,
186 sw_if_index,
Neale Ranns6c3ebcc2016-10-02 21:20:15 +0100187 adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100188
189 /*
190 * since we just added the ADJ we have no rewrite string for it,
191 * so its for ARP
192 */
193 adj->lookup_next_index = IP_LOOKUP_NEXT_ARP;
194 adj->sub_type.nbr.next_hop = *nh_addr;
195 adj->ia_link = link_type;
196 adj->ia_nh_proto = nh_proto;
Neale Rannsb80c5362016-10-08 13:03:40 +0100197 adj->rewrite_header.sw_if_index = sw_if_index;
Neale Ranns1bce5a92018-10-30 06:34:25 -0700198 vnet_rewrite_update_mtu(vnet_get_main(), adj->ia_link,
199 &adj->rewrite_header);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100200
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530201 adj_nbr_evaluate_feature (adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100202 return (adj);
203}
204
205/*
Neale Ranns32e1c012016-11-22 17:07:28 +0000206 * adj_nbr_add_or_lock
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100207 *
208 * Add an adjacency for the neighbour requested.
209 *
210 * The key for an adj is:
211 * - the Next-hops protocol (i.e. v4 or v6)
212 * - the address of the next-hop
213 * - the interface the next-hop is reachable through
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100214 */
215adj_index_t
216adj_nbr_add_or_lock (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100217 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100218 const ip46_address_t *nh_addr,
219 u32 sw_if_index)
220{
221 adj_index_t adj_index;
222 ip_adjacency_t *adj;
223
224 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
225
226 if (ADJ_INDEX_INVALID == adj_index)
227 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100228 vnet_main_t *vnm;
229
230 vnm = vnet_get_main();
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100231 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100232 adj_index = adj_get_index(adj);
233 adj_lock(adj_index);
234
Neale Ranns1855b8e2018-07-11 10:31:26 -0700235 if (ip46_address_is_equal(&ADJ_BCAST_ADDR, nh_addr))
236 {
237 adj->lookup_next_index = IP_LOOKUP_NEXT_BCAST;
238 }
239
Ole Troand7231612018-06-07 10:17:57 +0200240 vnet_rewrite_init(vnm, sw_if_index, link_type,
Neale Rannsb80c5362016-10-08 13:03:40 +0100241 adj_get_nd_node(nh_proto),
242 vnet_tx_node_index_for_sw_interface(vnm, sw_if_index),
243 &adj->rewrite_header);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100244
245 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100246 * we need a rewrite where the destination IP address is converted
247 * to the appropriate link-layer address. This is interface specific.
248 * So ask the interface to do it.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100249 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100250 vnet_update_adjacency_for_sw_interface(vnm, sw_if_index, adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100251 }
252 else
253 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100254 adj_lock(adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100255 }
256
Neale Rannsb80c5362016-10-08 13:03:40 +0100257 return (adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100258}
259
260adj_index_t
261adj_nbr_add_or_lock_w_rewrite (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100262 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100263 const ip46_address_t *nh_addr,
264 u32 sw_if_index,
265 u8 *rewrite)
266{
267 adj_index_t adj_index;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100268
269 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
270
271 if (ADJ_INDEX_INVALID == adj_index)
272 {
Neale Ranns13a08cc2018-11-07 09:25:54 -0800273 ip_adjacency_t *adj;
274
275 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100276 adj->rewrite_header.sw_if_index = sw_if_index;
Neale Ranns13a08cc2018-11-07 09:25:54 -0800277 adj_index = adj_get_index(adj);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100278 }
279
Neale Ranns13a08cc2018-11-07 09:25:54 -0800280 adj_lock(adj_index);
281 adj_nbr_update_rewrite(adj_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100282 ADJ_NBR_REWRITE_FLAG_COMPLETE,
283 rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100284
Neale Ranns13a08cc2018-11-07 09:25:54 -0800285 return (adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100286}
287
288/**
289 * adj_nbr_update_rewrite
290 *
291 * Update the adjacency's rewrite string. A NULL string implies the
292 * rewirte is reset (i.e. when ARP/ND etnry is gone).
293 * NB: the adj being updated may be handling traffic in the DP.
294 */
295void
296adj_nbr_update_rewrite (adj_index_t adj_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100297 adj_nbr_rewrite_flag_t flags,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100298 u8 *rewrite)
299{
300 ip_adjacency_t *adj;
301
302 ASSERT(ADJ_INDEX_INVALID != adj_index);
303
304 adj = adj_get(adj_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100305
306 if (flags & ADJ_NBR_REWRITE_FLAG_COMPLETE)
307 {
308 /*
309 * update the adj's rewrite string and build the arc
310 * from the rewrite node to the interface's TX node
311 */
312 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_REWRITE,
313 adj_get_rewrite_node(adj->ia_link),
314 vnet_tx_node_index_for_sw_interface(
315 vnet_get_main(),
316 adj->rewrite_header.sw_if_index),
317 rewrite);
318 }
319 else
320 {
321 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_ARP,
322 adj_get_nd_node(adj->ia_nh_proto),
323 vnet_tx_node_index_for_sw_interface(
324 vnet_get_main(),
325 adj->rewrite_header.sw_if_index),
326 rewrite);
327 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100328}
329
330/**
331 * adj_nbr_update_rewrite_internal
332 *
333 * Update the adjacency's rewrite string. A NULL string implies the
334 * rewirte is reset (i.e. when ARP/ND etnry is gone).
335 * NB: the adj being updated may be handling traffic in the DP.
336 */
337void
338adj_nbr_update_rewrite_internal (ip_adjacency_t *adj,
Neale Rannsfa5d1982017-02-20 14:19:51 -0800339 ip_lookup_next_t adj_next_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100340 u32 this_node,
341 u32 next_node,
342 u8 *rewrite)
343{
Neale Ranns19c68d22016-12-07 15:38:14 +0000344 ip_adjacency_t *walk_adj;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000345 adj_index_t walk_ai;
346 vlib_main_t * vm;
347 u32 old_next;
Neale Ranns19c68d22016-12-07 15:38:14 +0000348 int do_walk;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000349
350 vm = vlib_get_main();
351 old_next = adj->lookup_next_index;
352
353 walk_ai = adj_get_index(adj);
354 if (VNET_LINK_MPLS == adj->ia_link)
355 {
356 /*
357 * The link type MPLS has no children in the control plane graph, it only
358 * has children in the data-palne graph. The backwalk is up the former.
359 * So we need to walk from its IP cousin.
360 */
361 walk_ai = adj_nbr_find(adj->ia_nh_proto,
362 fib_proto_to_link(adj->ia_nh_proto),
363 &adj->sub_type.nbr.next_hop,
364 adj->rewrite_header.sw_if_index);
365 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100366
367 /*
Neale Ranns19c68d22016-12-07 15:38:14 +0000368 * Don't call the walk re-entrantly
369 */
370 if (ADJ_INDEX_INVALID != walk_ai)
371 {
372 walk_adj = adj_get(walk_ai);
Neale Rannsfa5d1982017-02-20 14:19:51 -0800373 if (ADJ_FLAG_SYNC_WALK_ACTIVE & walk_adj->ia_flags)
Neale Ranns19c68d22016-12-07 15:38:14 +0000374 {
375 do_walk = 0;
376 }
377 else
378 {
379 /*
380 * Prevent re-entrant walk of the same adj
381 */
Neale Rannsfa5d1982017-02-20 14:19:51 -0800382 walk_adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000383 do_walk = 1;
384 }
385 }
386 else
387 {
388 do_walk = 0;
389 }
390
391 /*
392 * lock the adjacencies that are affected by updates this walk will provoke.
393 * Since the aim of the walk is to update children to link to a different
394 * DPO, this adj will no longer be in use and its lock count will drop to 0.
395 * We don't want it to be deleted as part of this endevour.
396 */
397 adj_lock(adj_get_index(adj));
398 adj_lock(walk_ai);
399
400 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100401 * Updating a rewrite string is not atomic;
402 * - the rewrite string is too long to write in one instruction
403 * - when swapping from incomplete to complete, we also need to update
Neale Rannsad95b5d2016-11-10 20:35:14 +0000404 * the VLIB graph next-index of the adj.
Neale Rannsb80c5362016-10-08 13:03:40 +0100405 * ideally we would only want to suspend forwarding via this adj whilst we
406 * do this, but we do not have that level of granularity - it's suspend all
407 * worker threads or nothing.
408 * The other chioces are:
409 * - to mark the adj down and back walk so child load-balances drop this adj
410 * from the set.
411 * - update the next_node index of this adj to point to error-drop
412 * both of which will mean for MAC change we will drop for this adj
Neale Rannsad95b5d2016-11-10 20:35:14 +0000413 * which is not acceptable. However, when the adj changes type (from
414 * complete to incomplete and vice-versa) the child DPOs, which have the
415 * VLIB graph next node index, will be sending packets to the wrong graph
416 * node. So from the options above, updating the next_node of the adj to
417 * be drop will work, but it relies on each graph node v4/v6/mpls, rewrite/
418 * arp/midchain always be valid w.r.t. a mis-match of adj type and node type
419 * (i.e. a rewrite adj in the arp node). This is not enforcable. Getting it
420 * wrong will lead to hard to find bugs since its a race condition. So we
421 * choose the more reliable method of updating the children to use the drop,
422 * then switching adj's type, then updating the children again. Did I mention
423 * that this doesn't happen often...
424 * So we need to distinguish between the two cases:
425 * 1 - mac change
426 * 2 - adj type change
427 */
Neale Ranns19c68d22016-12-07 15:38:14 +0000428 if (do_walk &&
429 old_next != adj_next_index &&
Neale Rannsad95b5d2016-11-10 20:35:14 +0000430 ADJ_INDEX_INVALID != walk_ai)
431 {
432 /*
433 * the adj is changing type. we need to fix all children so that they
434 * stack momentarily on a drop, while the adj changes. If we don't do
435 * this the children will send packets to a VLIB graph node that does
436 * not correspond to the adj's type - and it goes downhill from there.
437 */
438 fib_node_back_walk_ctx_t bw_ctx = {
439 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_DOWN,
440 /*
441 * force this walk to be synchrous. if we don't and a node in the graph
442 * (a heavily shared path-list) chooses to back-ground the walk (make it
443 * async) then it will pause and we will do the adj update below, before
444 * all the children are updated. not good.
445 */
446 .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
447 };
448
449 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
450 }
451
452 /*
453 * If we are just updating the MAC string of the adj (which we also can't
454 * do atomically), then we need to stop packets switching through the adj.
455 * We can't do that on a per-adj basis, so it's all the packets.
456 * If we are updating the type, and we walked back to the children above,
457 * then this barrier serves to flush the queues/frames.
Neale Rannsb80c5362016-10-08 13:03:40 +0100458 */
459 vlib_worker_thread_barrier_sync(vm);
460
461 adj->lookup_next_index = adj_next_index;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100462
463 if (NULL != rewrite)
464 {
465 /*
466 * new rewrite provided.
Neale Rannsb80c5362016-10-08 13:03:40 +0100467 * fill in the adj's rewrite string, and build the VLIB graph arc.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100468 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100469 vnet_rewrite_set_data_internal(&adj->rewrite_header,
470 sizeof(adj->rewrite_data),
471 rewrite,
472 vec_len(rewrite));
Neale Rannsb80c5362016-10-08 13:03:40 +0100473 vec_free(rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100474 }
475 else
476 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100477 vnet_rewrite_clear_data_internal(&adj->rewrite_header,
478 sizeof(adj->rewrite_data));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100479 }
Neale Rannsad95b5d2016-11-10 20:35:14 +0000480 adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(),
481 this_node,
482 next_node);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100483
484 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100485 * done with the rewirte update - let the workers loose.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100486 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100487 vlib_worker_thread_barrier_release(vm);
Neale Rannsad95b5d2016-11-10 20:35:14 +0000488
Neale Ranns19c68d22016-12-07 15:38:14 +0000489 if (do_walk &&
490 (old_next != adj->lookup_next_index) &&
491 (ADJ_INDEX_INVALID != walk_ai))
Neale Rannsad95b5d2016-11-10 20:35:14 +0000492 {
493 /*
494 * backwalk to the children so they can stack on the now updated
495 * adjacency
496 */
497 fib_node_back_walk_ctx_t bw_ctx = {
498 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE,
499 };
500
501 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
502 }
Neale Ranns19c68d22016-12-07 15:38:14 +0000503 /*
504 * Prevent re-entrant walk of the same adj
505 */
506 if (do_walk)
507 {
Neale Rannsfa5d1982017-02-20 14:19:51 -0800508 walk_adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000509 }
510
511 adj_unlock(adj_get_index(adj));
512 adj_unlock(walk_ai);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100513}
514
515typedef struct adj_db_count_ctx_t_ {
516 u64 count;
517} adj_db_count_ctx_t;
518
519static void
520adj_db_count (BVT(clib_bihash_kv) * kvp,
521 void *arg)
522{
523 adj_db_count_ctx_t * ctx = arg;
524 ctx->count++;
525}
526
527u32
528adj_nbr_db_size (void)
529{
530 adj_db_count_ctx_t ctx = {
531 .count = 0,
532 };
533 fib_protocol_t proto;
534 u32 sw_if_index = 0;
535
536 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
537 {
538 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
539 {
540 if (NULL != adj_nbr_tables[proto][sw_if_index])
541 {
542 BV(clib_bihash_foreach_key_value_pair) (
543 adj_nbr_tables[proto][sw_if_index],
544 adj_db_count,
545 &ctx);
546 }
547 }
548 }
549 return (ctx.count);
550}
551
552/**
Neale Rannsb80c5362016-10-08 13:03:40 +0100553 * @brief Context for a walk of the adjacency neighbour DB
554 */
555typedef struct adj_walk_ctx_t_
556{
557 adj_walk_cb_t awc_cb;
558 void *awc_ctx;
559} adj_walk_ctx_t;
560
561static void
562adj_nbr_walk_cb (BVT(clib_bihash_kv) * kvp,
563 void *arg)
564{
565 adj_walk_ctx_t *ctx = arg;
566
567 // FIXME: can't stop early...
568 ctx->awc_cb(kvp->value, ctx->awc_ctx);
569}
570
571void
572adj_nbr_walk (u32 sw_if_index,
573 fib_protocol_t adj_nh_proto,
574 adj_walk_cb_t cb,
575 void *ctx)
576{
577 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
578 return;
579
580 adj_walk_ctx_t awc = {
581 .awc_ctx = ctx,
582 .awc_cb = cb,
583 };
584
585 BV(clib_bihash_foreach_key_value_pair) (
586 adj_nbr_tables[adj_nh_proto][sw_if_index],
587 adj_nbr_walk_cb,
588 &awc);
589}
590
591/**
Neale Rannsb80c5362016-10-08 13:03:40 +0100592 * @brief Walk adjacencies on a link with a given v4 next-hop.
593 * that is visit the adjacencies with different link types.
594 */
595void
596adj_nbr_walk_nh4 (u32 sw_if_index,
597 const ip4_address_t *addr,
598 adj_walk_cb_t cb,
599 void *ctx)
600{
601 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP4, sw_if_index))
602 return;
603
604 ip46_address_t nh = {
605 .ip4 = *addr,
606 };
Neale Ranns580bba72018-04-23 05:31:19 -0700607 vnet_link_t linkt;
608 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100609
Neale Ranns580bba72018-04-23 05:31:19 -0700610 FOR_EACH_VNET_LINK(linkt)
611 {
612 ai = adj_nbr_find (FIB_PROTOCOL_IP4, linkt, &nh, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100613
Neale Ranns580bba72018-04-23 05:31:19 -0700614 if (INDEX_INVALID != ai)
615 cb(ai, ctx);
616 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100617}
618
619/**
620 * @brief Walk adjacencies on a link with a given v6 next-hop.
621 * that is visit the adjacencies with different link types.
622 */
623void
624adj_nbr_walk_nh6 (u32 sw_if_index,
625 const ip6_address_t *addr,
626 adj_walk_cb_t cb,
627 void *ctx)
628{
629 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP6, sw_if_index))
630 return;
631
632 ip46_address_t nh = {
633 .ip6 = *addr,
634 };
Neale Ranns580bba72018-04-23 05:31:19 -0700635 vnet_link_t linkt;
636 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100637
Neale Ranns580bba72018-04-23 05:31:19 -0700638 FOR_EACH_VNET_LINK(linkt)
639 {
640 ai = adj_nbr_find (FIB_PROTOCOL_IP6, linkt, &nh, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100641
Neale Ranns580bba72018-04-23 05:31:19 -0700642 if (INDEX_INVALID != ai)
643 cb(ai, ctx);
644 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100645}
646
647/**
648 * @brief Walk adjacencies on a link with a given next-hop.
649 * that is visit the adjacencies with different link types.
650 */
651void
652adj_nbr_walk_nh (u32 sw_if_index,
653 fib_protocol_t adj_nh_proto,
654 const ip46_address_t *nh,
655 adj_walk_cb_t cb,
656 void *ctx)
657{
658 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
659 return;
660
Neale Ranns580bba72018-04-23 05:31:19 -0700661 vnet_link_t linkt;
662 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100663
Neale Ranns580bba72018-04-23 05:31:19 -0700664 FOR_EACH_VNET_LINK(linkt)
665 {
666 ai = adj_nbr_find (FIB_PROTOCOL_IP4, linkt, nh, sw_if_index);
667
668 if (INDEX_INVALID != ai)
669 cb(ai, ctx);
670 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100671}
672
673/**
Neale Ranns8b37b872016-11-21 12:25:22 +0000674 * Flags associated with the interface state walks
675 */
676typedef enum adj_nbr_interface_flags_t_
677{
678 ADJ_NBR_INTERFACE_UP = (1 << 0),
679} adj_nbr_interface_flags_t;
680
681/**
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100682 * Context for the state change walk of the DB
683 */
684typedef struct adj_nbr_interface_state_change_ctx_t_
685{
686 /**
Neale Ranns8b37b872016-11-21 12:25:22 +0000687 * Flags on the interface
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100688 */
Neale Ranns8b37b872016-11-21 12:25:22 +0000689 adj_nbr_interface_flags_t flags;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100690} adj_nbr_interface_state_change_ctx_t;
691
Neale Rannsb80c5362016-10-08 13:03:40 +0100692static adj_walk_rc_t
693adj_nbr_interface_state_change_one (adj_index_t ai,
Neale Ranns8b37b872016-11-21 12:25:22 +0000694 void *arg)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100695{
696 /*
697 * Back walk the graph to inform the forwarding entries
Neale Ranns8b37b872016-11-21 12:25:22 +0000698 * that this interface state has changed. Do this synchronously
699 * since this is the walk that provides convergence
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100700 */
701 adj_nbr_interface_state_change_ctx_t *ctx = arg;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100702 fib_node_back_walk_ctx_t bw_ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000703 .fnbw_reason = ((ctx->flags & ADJ_NBR_INTERFACE_UP) ?
704 FIB_NODE_BW_REASON_FLAG_INTERFACE_UP :
705 FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN),
706 /*
707 * the force sync applies only as far as the first fib_entry.
708 * And it's the fib_entry's we need to converge away from
709 * the adjacencies on the now down link
710 */
711 .fnbw_flags = (!(ctx->flags & ADJ_NBR_INTERFACE_UP) ?
712 FIB_NODE_BW_FLAG_FORCE_SYNC :
Neale Ranns30d53642018-08-27 07:29:15 -0700713 FIB_NODE_BW_FLAG_NONE),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100714 };
Neale Ranns30d53642018-08-27 07:29:15 -0700715 ip_adjacency_t *adj;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100716
Neale Ranns30d53642018-08-27 07:29:15 -0700717 adj = adj_get(ai);
718
719 adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100720 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
Neale Ranns30d53642018-08-27 07:29:15 -0700721 adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100722
723 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100724}
725
Neale Ranns8b37b872016-11-21 12:25:22 +0000726/**
727 * @brief Registered function for SW interface state changes
728 */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100729static clib_error_t *
Neale Ranns8b37b872016-11-21 12:25:22 +0000730adj_nbr_sw_interface_state_change (vnet_main_t * vnm,
731 u32 sw_if_index,
732 u32 flags)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100733{
734 fib_protocol_t proto;
735
736 /*
737 * walk each adj on the interface and trigger a walk from that adj
738 */
739 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
740 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100741 adj_nbr_interface_state_change_ctx_t ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000742 .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
743 ADJ_NBR_INTERFACE_UP :
744 0),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100745 };
746
Neale Rannsb80c5362016-10-08 13:03:40 +0100747 adj_nbr_walk(sw_if_index, proto,
748 adj_nbr_interface_state_change_one,
749 &ctx);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100750 }
751
752 return (NULL);
753}
754
Neale Ranns8b37b872016-11-21 12:25:22 +0000755VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(
756 adj_nbr_sw_interface_state_change,
757 VNET_ITF_FUNC_PRIORITY_HIGH);
758
759/**
760 * @brief Invoked on each SW interface of a HW interface when the
761 * HW interface state changes
762 */
Neale Ranns0053de62018-05-22 08:40:52 -0700763static walk_rc_t
Neale Ranns8b37b872016-11-21 12:25:22 +0000764adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
765 u32 sw_if_index,
766 void *arg)
767{
768 adj_nbr_interface_state_change_ctx_t *ctx = arg;
769 fib_protocol_t proto;
770
771 /*
772 * walk each adj on the interface and trigger a walk from that adj
773 */
774 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
775 {
776 adj_nbr_walk(sw_if_index, proto,
777 adj_nbr_interface_state_change_one,
778 ctx);
779 }
Neale Ranns0053de62018-05-22 08:40:52 -0700780 return (WALK_CONTINUE);
Neale Ranns8b37b872016-11-21 12:25:22 +0000781}
782
783/**
784 * @brief Registered callback for HW interface state changes
785 */
786static clib_error_t *
787adj_nbr_hw_interface_state_change (vnet_main_t * vnm,
788 u32 hw_if_index,
789 u32 flags)
790{
791 /*
792 * walk SW interface on the HW
793 */
794 adj_nbr_interface_state_change_ctx_t ctx = {
795 .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
796 ADJ_NBR_INTERFACE_UP :
797 0),
798 };
799
800 vnet_hw_interface_walk_sw(vnm, hw_if_index,
801 adj_nbr_hw_sw_interface_state_change,
802 &ctx);
803
804 return (NULL);
805}
806
807VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(
808 adj_nbr_hw_interface_state_change,
809 VNET_ITF_FUNC_PRIORITY_HIGH);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100810
Neale Rannsb80c5362016-10-08 13:03:40 +0100811static adj_walk_rc_t
812adj_nbr_interface_delete_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100813 void *arg)
814{
815 /*
816 * Back walk the graph to inform the forwarding entries
817 * that this interface has been deleted.
818 */
819 fib_node_back_walk_ctx_t bw_ctx = {
820 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
821 };
Neale Ranns30d53642018-08-27 07:29:15 -0700822 ip_adjacency_t *adj;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100823
Neale Ranns30d53642018-08-27 07:29:15 -0700824 adj = adj_get(ai);
825
826 adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100827 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
Neale Ranns30d53642018-08-27 07:29:15 -0700828 adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100829
830 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100831}
832
833/**
834 * adj_nbr_interface_add_del
835 *
836 * Registered to receive interface Add and delete notifications
837 */
838static clib_error_t *
839adj_nbr_interface_add_del (vnet_main_t * vnm,
840 u32 sw_if_index,
841 u32 is_add)
842{
843 fib_protocol_t proto;
844
845 if (is_add)
846 {
847 /*
848 * not interested in interface additions. we will not back walk
849 * to resolve paths through newly added interfaces. Why? The control
850 * plane should have the brains to add interfaces first, then routes.
851 * So the case where there are paths with a interface that matches
852 * one just created is the case where the path resolved through an
853 * interface that was deleted, and still has not been removed. The
854 * new interface added, is NO GUARANTEE that the interface being
855 * added now, even though it may have the same sw_if_index, is the
856 * same interface that the path needs. So tough!
857 * If the control plane wants these routes to resolve it needs to
858 * remove and add them again.
859 */
860 return (NULL);
861 }
862
863 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
864 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100865 adj_nbr_walk(sw_if_index, proto,
866 adj_nbr_interface_delete_one,
867 NULL);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100868 }
869
870 return (NULL);
871
872}
873
874VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del);
875
876
Neale Rannsb80c5362016-10-08 13:03:40 +0100877static adj_walk_rc_t
878adj_nbr_show_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100879 void *arg)
880{
881 vlib_cli_output (arg, "[@%d] %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100882 ai,
883 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100884 FORMAT_IP_ADJACENCY_NONE);
Neale Rannsb80c5362016-10-08 13:03:40 +0100885
886 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100887}
888
889static clib_error_t *
890adj_nbr_show (vlib_main_t * vm,
891 unformat_input_t * input,
892 vlib_cli_command_t * cmd)
893{
894 adj_index_t ai = ADJ_INDEX_INVALID;
Neale Rannsb80c5362016-10-08 13:03:40 +0100895 u32 sw_if_index = ~0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100896
897 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
898 {
899 if (unformat (input, "%d", &ai))
900 ;
Neale Rannsb80c5362016-10-08 13:03:40 +0100901 else if (unformat (input, "%U",
902 unformat_vnet_sw_interface, vnet_get_main(),
903 &sw_if_index))
904 ;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100905 else
906 break;
907 }
908
909 if (ADJ_INDEX_INVALID != ai)
910 {
911 vlib_cli_output (vm, "[@%d] %U",
912 ai,
Neale Rannsb80c5362016-10-08 13:03:40 +0100913 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100914 FORMAT_IP_ADJACENCY_DETAIL);
915 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100916 else if (~0 != sw_if_index)
917 {
918 fib_protocol_t proto;
919
920 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
921 {
922 adj_nbr_walk(sw_if_index, proto,
923 adj_nbr_show_one,
924 vm);
925 }
926 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100927 else
928 {
929 fib_protocol_t proto;
930
931 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
932 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100933 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
934 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100935 adj_nbr_walk(sw_if_index, proto,
936 adj_nbr_show_one,
937 vm);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100938 }
939 }
940 }
941
942 return 0;
943}
944
Neale Rannsb80c5362016-10-08 13:03:40 +0100945/*?
946 * Show all neighbour adjacencies.
947 * @cliexpar
948 * @cliexstart{sh adj nbr}
949 * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
950 * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
951 * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
952 * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
953 * @cliexend
954 ?*/
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100955VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
956 .path = "show adj nbr",
Neale Rannsb80c5362016-10-08 13:03:40 +0100957 .short_help = "show adj nbr [<adj_index>] [interface]",
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100958 .function = adj_nbr_show,
959};
960
961u8*
962format_adj_nbr_incomplete (u8* s, va_list *ap)
963{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400964 index_t index = va_arg(*ap, index_t);
965 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100966 vnet_main_t * vnm = vnet_get_main();
967 ip_adjacency_t * adj = adj_get(index);
968
Neale Ranns924d03a2016-10-19 08:25:46 +0100969 s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100970 s = format (s, ": via %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100971 format_ip46_address, &adj->sub_type.nbr.next_hop,
972 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100973 s = format (s, " %U",
Steven70488ab2018-03-28 17:59:00 -0700974 format_vnet_sw_if_index_name,
975 vnm, adj->rewrite_header.sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100976
977 return (s);
978}
979
980u8*
981format_adj_nbr (u8* s, va_list *ap)
982{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400983 index_t index = va_arg(*ap, index_t);
984 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100985 ip_adjacency_t * adj = adj_get(index);
986
Neale Ranns924d03a2016-10-19 08:25:46 +0100987 s = format (s, "%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100988 s = format (s, " via %U ",
Neale Rannsb80c5362016-10-08 13:03:40 +0100989 format_ip46_address, &adj->sub_type.nbr.next_hop,
990 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100991 s = format (s, "%U",
992 format_vnet_rewrite,
Neale Rannsb069a692017-03-15 12:34:25 -0400993 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100994
995 return (s);
996}
997
998static void
999adj_dpo_lock (dpo_id_t *dpo)
1000{
1001 adj_lock(dpo->dpoi_index);
1002}
1003static void
1004adj_dpo_unlock (dpo_id_t *dpo)
1005{
1006 adj_unlock(dpo->dpoi_index);
1007}
1008
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001009static void
1010adj_mem_show (void)
1011{
1012 fib_show_memory_usage("Adjacency",
1013 pool_elts(adj_pool),
1014 pool_len(adj_pool),
1015 sizeof(ip_adjacency_t));
1016}
1017
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001018const static dpo_vft_t adj_nbr_dpo_vft = {
1019 .dv_lock = adj_dpo_lock,
1020 .dv_unlock = adj_dpo_unlock,
1021 .dv_format = format_adj_nbr,
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001022 .dv_mem_show = adj_mem_show,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001023 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001024};
1025const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1026 .dv_lock = adj_dpo_lock,
1027 .dv_unlock = adj_dpo_unlock,
1028 .dv_format = format_adj_nbr_incomplete,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001029 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001030};
1031
1032/**
1033 * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1034 * object.
1035 *
1036 * this means that these graph nodes are ones from which a nbr is the
1037 * parent object in the DPO-graph.
1038 */
1039const static char* const nbr_ip4_nodes[] =
1040{
Neale Rannsf06aea52016-11-29 06:51:37 -08001041 "ip4-rewrite",
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001042 NULL,
1043};
1044const static char* const nbr_ip6_nodes[] =
1045{
1046 "ip6-rewrite",
1047 NULL,
1048};
1049const static char* const nbr_mpls_nodes[] =
1050{
1051 "mpls-output",
1052 NULL,
1053};
Neale Ranns5e575b12016-10-03 09:40:25 +01001054const static char* const nbr_ethernet_nodes[] =
1055{
1056 "adj-l2-rewrite",
1057 NULL,
1058};
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001059const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1060{
1061 [DPO_PROTO_IP4] = nbr_ip4_nodes,
1062 [DPO_PROTO_IP6] = nbr_ip6_nodes,
1063 [DPO_PROTO_MPLS] = nbr_mpls_nodes,
Neale Ranns5e575b12016-10-03 09:40:25 +01001064 [DPO_PROTO_ETHERNET] = nbr_ethernet_nodes,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001065};
1066
1067const static char* const nbr_incomplete_ip4_nodes[] =
1068{
1069 "ip4-arp",
1070 NULL,
1071};
1072const static char* const nbr_incomplete_ip6_nodes[] =
1073{
1074 "ip6-discover-neighbor",
1075 NULL,
1076};
1077const static char* const nbr_incomplete_mpls_nodes[] =
1078{
1079 "mpls-adj-incomplete",
1080 NULL,
1081};
1082
1083const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1084{
1085 [DPO_PROTO_IP4] = nbr_incomplete_ip4_nodes,
1086 [DPO_PROTO_IP6] = nbr_incomplete_ip6_nodes,
1087 [DPO_PROTO_MPLS] = nbr_incomplete_mpls_nodes,
1088};
1089
1090void
1091adj_nbr_module_init (void)
1092{
1093 dpo_register(DPO_ADJACENCY,
1094 &adj_nbr_dpo_vft,
1095 nbr_nodes);
1096 dpo_register(DPO_ADJACENCY_INCOMPLETE,
1097 &adj_nbr_incompl_dpo_vft,
1098 nbr_incomplete_nodes);
1099}