blob: 3f73ff9f1d2e1c7ce81b184758ddf9649d7bed7c [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
Neale Rannsae809832018-11-23 09:00:27 -080021#include <vppinfra/bihash_24_8.h>
22
Neale Ranns0bfe5d82016-08-25 15:29:12 +010023/*
24 * Vector Hash tables of neighbour (traditional) adjacencies
25 * Key: interface(for the vector index), address (and its proto),
26 * link-type/ether-type.
27 */
28static BVT(clib_bihash) **adj_nbr_tables[FIB_PROTOCOL_MAX];
29
30// FIXME SIZE APPROPRIATELY. ASK DAVEB.
31#define ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (64 * 64)
32#define ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (32<<20)
33
34
35#define ADJ_NBR_SET_KEY(_key, _lt, _nh) \
36{ \
37 _key.key[0] = (_nh)->as_u64[0]; \
38 _key.key[1] = (_nh)->as_u64[1]; \
39 _key.key[2] = (_lt); \
40}
41
42#define ADJ_NBR_ITF_OK(_proto, _itf) \
43 (((_itf) < vec_len(adj_nbr_tables[_proto])) && \
44 (NULL != adj_nbr_tables[_proto][sw_if_index]))
45
46static void
47adj_nbr_insert (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +010048 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +010049 const ip46_address_t *nh_addr,
50 u32 sw_if_index,
51 adj_index_t adj_index)
52{
53 BVT(clib_bihash_kv) kv;
54
55 if (sw_if_index >= vec_len(adj_nbr_tables[nh_proto]))
56 {
57 vec_validate(adj_nbr_tables[nh_proto], sw_if_index);
58 }
59 if (NULL == adj_nbr_tables[nh_proto][sw_if_index])
60 {
61 adj_nbr_tables[nh_proto][sw_if_index] =
62 clib_mem_alloc_aligned(sizeof(BVT(clib_bihash)),
63 CLIB_CACHE_LINE_BYTES);
Dave Barachb7b92992018-10-17 10:38:51 -040064 clib_memset(adj_nbr_tables[nh_proto][sw_if_index],
Neale Ranns0bfe5d82016-08-25 15:29:12 +010065 0,
66 sizeof(BVT(clib_bihash)));
67
68 BV(clib_bihash_init) (adj_nbr_tables[nh_proto][sw_if_index],
69 "Adjacency Neighbour table",
70 ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS,
71 ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE);
72 }
73
74 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
75 kv.value = adj_index;
76
77 BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 1);
78}
79
80void
Neale Ranns177bbdc2016-11-15 09:46:51 +000081adj_nbr_remove (adj_index_t ai,
82 fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +010083 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +010084 const ip46_address_t *nh_addr,
85 u32 sw_if_index)
86{
87 BVT(clib_bihash_kv) kv;
88
89 if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
90 return;
91
92 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
Neale Ranns177bbdc2016-11-15 09:46:51 +000093 kv.value = ai;
Neale Ranns0bfe5d82016-08-25 15:29:12 +010094
95 BV(clib_bihash_add_del) (adj_nbr_tables[nh_proto][sw_if_index], &kv, 0);
96}
97
Florin Corasf9d05682018-04-26 08:26:52 -070098adj_index_t
Neale Ranns0bfe5d82016-08-25 15:29:12 +010099adj_nbr_find (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100100 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100101 const ip46_address_t *nh_addr,
102 u32 sw_if_index)
103{
104 BVT(clib_bihash_kv) kv;
105
106 ADJ_NBR_SET_KEY(kv, link_type, nh_addr);
107
108 if (!ADJ_NBR_ITF_OK(nh_proto, sw_if_index))
109 return (ADJ_INDEX_INVALID);
110
111 if (BV(clib_bihash_search)(adj_nbr_tables[nh_proto][sw_if_index],
112 &kv, &kv) < 0)
113 {
114 return (ADJ_INDEX_INVALID);
115 }
116 else
117 {
118 return (kv.value);
119 }
120}
121
Neale Rannsb80c5362016-10-08 13:03:40 +0100122static inline u32
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100123adj_get_nd_node (fib_protocol_t proto)
124{
125 switch (proto) {
126 case FIB_PROTOCOL_IP4:
Neale Rannsb80c5362016-10-08 13:03:40 +0100127 return (ip4_arp_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100128 case FIB_PROTOCOL_IP6:
Neale Rannsb80c5362016-10-08 13:03:40 +0100129 return (ip6_discover_neighbor_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100130 case FIB_PROTOCOL_MPLS:
131 break;
132 }
133 ASSERT(0);
Neale Rannsb80c5362016-10-08 13:03:40 +0100134 return (ip4_arp_node.index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100135}
136
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530137/**
138 * @brief Check and set feature flags if o/p interface has any o/p features.
139 */
140static void
141adj_nbr_evaluate_feature (adj_index_t ai)
142{
143 ip_adjacency_t *adj;
144 vnet_feature_main_t *fm = &feature_main;
145 i16 feature_count;
146 u8 arc_index;
147 u32 sw_if_index;
148
149 adj = adj_get(ai);
150
151 switch (adj->ia_link)
152 {
153 case VNET_LINK_IP4:
154 arc_index = ip4_main.lookup_main.output_feature_arc_index;
155 break;
156 case VNET_LINK_IP6:
157 arc_index = ip6_main.lookup_main.output_feature_arc_index;
158 break;
159 case VNET_LINK_MPLS:
160 arc_index = mpls_main.output_feature_arc_index;
161 break;
162 default:
163 return;
164 }
165
166 sw_if_index = adj->rewrite_header.sw_if_index;
AkshayaNadahalli98ab0912017-03-27 17:21:05 +0000167 if (vec_len(fm->feature_count_by_sw_if_index[arc_index]) > sw_if_index)
168 {
169 feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
170 if (feature_count > 0)
171 adj->rewrite_header.flags |= VNET_REWRITE_HAS_FEATURES;
172 }
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530173
174 return;
175}
176
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100177static ip_adjacency_t*
178adj_nbr_alloc (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100179 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100180 const ip46_address_t *nh_addr,
181 u32 sw_if_index)
182{
183 ip_adjacency_t *adj;
184
185 adj = adj_alloc(nh_proto);
186
187 adj_nbr_insert(nh_proto, link_type, nh_addr,
188 sw_if_index,
Neale Ranns6c3ebcc2016-10-02 21:20:15 +0100189 adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100190
191 /*
192 * since we just added the ADJ we have no rewrite string for it,
193 * so its for ARP
194 */
195 adj->lookup_next_index = IP_LOOKUP_NEXT_ARP;
196 adj->sub_type.nbr.next_hop = *nh_addr;
197 adj->ia_link = link_type;
198 adj->ia_nh_proto = nh_proto;
Neale Rannsb80c5362016-10-08 13:03:40 +0100199 adj->rewrite_header.sw_if_index = sw_if_index;
Neale Ranns1bce5a92018-10-30 06:34:25 -0700200 vnet_rewrite_update_mtu(vnet_get_main(), adj->ia_link,
201 &adj->rewrite_header);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100202
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530203 adj_nbr_evaluate_feature (adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100204 return (adj);
205}
206
207/*
Neale Ranns32e1c012016-11-22 17:07:28 +0000208 * adj_nbr_add_or_lock
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100209 *
210 * Add an adjacency for the neighbour requested.
211 *
212 * The key for an adj is:
213 * - the Next-hops protocol (i.e. v4 or v6)
214 * - the address of the next-hop
215 * - the interface the next-hop is reachable through
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100216 */
217adj_index_t
218adj_nbr_add_or_lock (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100219 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100220 const ip46_address_t *nh_addr,
221 u32 sw_if_index)
222{
223 adj_index_t adj_index;
224 ip_adjacency_t *adj;
225
226 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
227
228 if (ADJ_INDEX_INVALID == adj_index)
229 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100230 vnet_main_t *vnm;
231
232 vnm = vnet_get_main();
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100233 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100234 adj_index = adj_get_index(adj);
235 adj_lock(adj_index);
236
Neale Ranns1855b8e2018-07-11 10:31:26 -0700237 if (ip46_address_is_equal(&ADJ_BCAST_ADDR, nh_addr))
238 {
239 adj->lookup_next_index = IP_LOOKUP_NEXT_BCAST;
240 }
241
Ole Troand7231612018-06-07 10:17:57 +0200242 vnet_rewrite_init(vnm, sw_if_index, link_type,
Neale Rannsb80c5362016-10-08 13:03:40 +0100243 adj_get_nd_node(nh_proto),
244 vnet_tx_node_index_for_sw_interface(vnm, sw_if_index),
245 &adj->rewrite_header);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100246
247 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100248 * we need a rewrite where the destination IP address is converted
249 * to the appropriate link-layer address. This is interface specific.
250 * So ask the interface to do it.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100251 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100252 vnet_update_adjacency_for_sw_interface(vnm, sw_if_index, adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100253 }
254 else
255 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100256 adj_lock(adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100257 }
258
Neale Rannsb80c5362016-10-08 13:03:40 +0100259 return (adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100260}
261
262adj_index_t
263adj_nbr_add_or_lock_w_rewrite (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100264 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100265 const ip46_address_t *nh_addr,
266 u32 sw_if_index,
267 u8 *rewrite)
268{
269 adj_index_t adj_index;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100270
271 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
272
273 if (ADJ_INDEX_INVALID == adj_index)
274 {
Neale Ranns13a08cc2018-11-07 09:25:54 -0800275 ip_adjacency_t *adj;
276
277 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100278 adj->rewrite_header.sw_if_index = sw_if_index;
Neale Ranns13a08cc2018-11-07 09:25:54 -0800279 adj_index = adj_get_index(adj);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100280 }
281
Neale Ranns13a08cc2018-11-07 09:25:54 -0800282 adj_lock(adj_index);
283 adj_nbr_update_rewrite(adj_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100284 ADJ_NBR_REWRITE_FLAG_COMPLETE,
285 rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100286
Neale Ranns13a08cc2018-11-07 09:25:54 -0800287 return (adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100288}
289
290/**
291 * adj_nbr_update_rewrite
292 *
293 * Update the adjacency's rewrite string. A NULL string implies the
294 * rewirte is reset (i.e. when ARP/ND etnry is gone).
295 * NB: the adj being updated may be handling traffic in the DP.
296 */
297void
298adj_nbr_update_rewrite (adj_index_t adj_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100299 adj_nbr_rewrite_flag_t flags,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100300 u8 *rewrite)
301{
302 ip_adjacency_t *adj;
303
304 ASSERT(ADJ_INDEX_INVALID != adj_index);
305
306 adj = adj_get(adj_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100307
308 if (flags & ADJ_NBR_REWRITE_FLAG_COMPLETE)
309 {
310 /*
311 * update the adj's rewrite string and build the arc
312 * from the rewrite node to the interface's TX node
313 */
314 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_REWRITE,
315 adj_get_rewrite_node(adj->ia_link),
316 vnet_tx_node_index_for_sw_interface(
317 vnet_get_main(),
318 adj->rewrite_header.sw_if_index),
319 rewrite);
320 }
321 else
322 {
323 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_ARP,
324 adj_get_nd_node(adj->ia_nh_proto),
325 vnet_tx_node_index_for_sw_interface(
326 vnet_get_main(),
327 adj->rewrite_header.sw_if_index),
328 rewrite);
329 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100330}
331
332/**
333 * adj_nbr_update_rewrite_internal
334 *
335 * Update the adjacency's rewrite string. A NULL string implies the
336 * rewirte is reset (i.e. when ARP/ND etnry is gone).
337 * NB: the adj being updated may be handling traffic in the DP.
338 */
339void
340adj_nbr_update_rewrite_internal (ip_adjacency_t *adj,
Neale Rannsfa5d1982017-02-20 14:19:51 -0800341 ip_lookup_next_t adj_next_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100342 u32 this_node,
343 u32 next_node,
344 u8 *rewrite)
345{
Neale Ranns19c68d22016-12-07 15:38:14 +0000346 ip_adjacency_t *walk_adj;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000347 adj_index_t walk_ai;
348 vlib_main_t * vm;
349 u32 old_next;
Neale Ranns19c68d22016-12-07 15:38:14 +0000350 int do_walk;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000351
352 vm = vlib_get_main();
353 old_next = adj->lookup_next_index;
354
355 walk_ai = adj_get_index(adj);
356 if (VNET_LINK_MPLS == adj->ia_link)
357 {
358 /*
359 * The link type MPLS has no children in the control plane graph, it only
360 * has children in the data-palne graph. The backwalk is up the former.
361 * So we need to walk from its IP cousin.
362 */
363 walk_ai = adj_nbr_find(adj->ia_nh_proto,
364 fib_proto_to_link(adj->ia_nh_proto),
365 &adj->sub_type.nbr.next_hop,
366 adj->rewrite_header.sw_if_index);
367 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100368
369 /*
Neale Ranns19c68d22016-12-07 15:38:14 +0000370 * Don't call the walk re-entrantly
371 */
372 if (ADJ_INDEX_INVALID != walk_ai)
373 {
374 walk_adj = adj_get(walk_ai);
Neale Rannsfa5d1982017-02-20 14:19:51 -0800375 if (ADJ_FLAG_SYNC_WALK_ACTIVE & walk_adj->ia_flags)
Neale Ranns19c68d22016-12-07 15:38:14 +0000376 {
377 do_walk = 0;
378 }
379 else
380 {
381 /*
382 * Prevent re-entrant walk of the same adj
383 */
Neale Rannsfa5d1982017-02-20 14:19:51 -0800384 walk_adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000385 do_walk = 1;
386 }
387 }
388 else
389 {
390 do_walk = 0;
391 }
392
393 /*
394 * lock the adjacencies that are affected by updates this walk will provoke.
395 * Since the aim of the walk is to update children to link to a different
396 * DPO, this adj will no longer be in use and its lock count will drop to 0.
397 * We don't want it to be deleted as part of this endevour.
398 */
399 adj_lock(adj_get_index(adj));
400 adj_lock(walk_ai);
401
402 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100403 * Updating a rewrite string is not atomic;
404 * - the rewrite string is too long to write in one instruction
405 * - when swapping from incomplete to complete, we also need to update
Neale Rannsad95b5d2016-11-10 20:35:14 +0000406 * the VLIB graph next-index of the adj.
Neale Rannsb80c5362016-10-08 13:03:40 +0100407 * ideally we would only want to suspend forwarding via this adj whilst we
408 * do this, but we do not have that level of granularity - it's suspend all
409 * worker threads or nothing.
410 * The other chioces are:
411 * - to mark the adj down and back walk so child load-balances drop this adj
412 * from the set.
413 * - update the next_node index of this adj to point to error-drop
414 * both of which will mean for MAC change we will drop for this adj
Neale Rannsad95b5d2016-11-10 20:35:14 +0000415 * which is not acceptable. However, when the adj changes type (from
416 * complete to incomplete and vice-versa) the child DPOs, which have the
417 * VLIB graph next node index, will be sending packets to the wrong graph
418 * node. So from the options above, updating the next_node of the adj to
419 * be drop will work, but it relies on each graph node v4/v6/mpls, rewrite/
420 * arp/midchain always be valid w.r.t. a mis-match of adj type and node type
421 * (i.e. a rewrite adj in the arp node). This is not enforcable. Getting it
422 * wrong will lead to hard to find bugs since its a race condition. So we
423 * choose the more reliable method of updating the children to use the drop,
424 * then switching adj's type, then updating the children again. Did I mention
425 * that this doesn't happen often...
426 * So we need to distinguish between the two cases:
427 * 1 - mac change
428 * 2 - adj type change
429 */
Neale Ranns19c68d22016-12-07 15:38:14 +0000430 if (do_walk &&
431 old_next != adj_next_index &&
Neale Rannsad95b5d2016-11-10 20:35:14 +0000432 ADJ_INDEX_INVALID != walk_ai)
433 {
434 /*
435 * the adj is changing type. we need to fix all children so that they
436 * stack momentarily on a drop, while the adj changes. If we don't do
437 * this the children will send packets to a VLIB graph node that does
438 * not correspond to the adj's type - and it goes downhill from there.
439 */
440 fib_node_back_walk_ctx_t bw_ctx = {
441 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_DOWN,
442 /*
443 * force this walk to be synchrous. if we don't and a node in the graph
444 * (a heavily shared path-list) chooses to back-ground the walk (make it
445 * async) then it will pause and we will do the adj update below, before
446 * all the children are updated. not good.
447 */
448 .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
449 };
450
451 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
452 }
453
454 /*
455 * If we are just updating the MAC string of the adj (which we also can't
456 * do atomically), then we need to stop packets switching through the adj.
457 * We can't do that on a per-adj basis, so it's all the packets.
458 * If we are updating the type, and we walked back to the children above,
459 * then this barrier serves to flush the queues/frames.
Neale Rannsb80c5362016-10-08 13:03:40 +0100460 */
461 vlib_worker_thread_barrier_sync(vm);
462
463 adj->lookup_next_index = adj_next_index;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100464
465 if (NULL != rewrite)
466 {
467 /*
468 * new rewrite provided.
Neale Rannsb80c5362016-10-08 13:03:40 +0100469 * fill in the adj's rewrite string, and build the VLIB graph arc.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100470 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100471 vnet_rewrite_set_data_internal(&adj->rewrite_header,
472 sizeof(adj->rewrite_data),
473 rewrite,
474 vec_len(rewrite));
Neale Rannsb80c5362016-10-08 13:03:40 +0100475 vec_free(rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100476 }
477 else
478 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100479 vnet_rewrite_clear_data_internal(&adj->rewrite_header,
480 sizeof(adj->rewrite_data));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100481 }
Neale Rannsad95b5d2016-11-10 20:35:14 +0000482 adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(),
483 this_node,
484 next_node);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100485
486 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100487 * done with the rewirte update - let the workers loose.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100488 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100489 vlib_worker_thread_barrier_release(vm);
Neale Rannsad95b5d2016-11-10 20:35:14 +0000490
Neale Ranns19c68d22016-12-07 15:38:14 +0000491 if (do_walk &&
492 (old_next != adj->lookup_next_index) &&
493 (ADJ_INDEX_INVALID != walk_ai))
Neale Rannsad95b5d2016-11-10 20:35:14 +0000494 {
495 /*
496 * backwalk to the children so they can stack on the now updated
497 * adjacency
498 */
499 fib_node_back_walk_ctx_t bw_ctx = {
500 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE,
501 };
502
503 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
504 }
Neale Ranns19c68d22016-12-07 15:38:14 +0000505 /*
506 * Prevent re-entrant walk of the same adj
507 */
508 if (do_walk)
509 {
Neale Rannsfa5d1982017-02-20 14:19:51 -0800510 walk_adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000511 }
512
513 adj_unlock(adj_get_index(adj));
514 adj_unlock(walk_ai);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100515}
516
517typedef struct adj_db_count_ctx_t_ {
518 u64 count;
519} adj_db_count_ctx_t;
520
521static void
522adj_db_count (BVT(clib_bihash_kv) * kvp,
523 void *arg)
524{
525 adj_db_count_ctx_t * ctx = arg;
526 ctx->count++;
527}
528
529u32
530adj_nbr_db_size (void)
531{
532 adj_db_count_ctx_t ctx = {
533 .count = 0,
534 };
535 fib_protocol_t proto;
536 u32 sw_if_index = 0;
537
538 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
539 {
540 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
541 {
542 if (NULL != adj_nbr_tables[proto][sw_if_index])
543 {
544 BV(clib_bihash_foreach_key_value_pair) (
545 adj_nbr_tables[proto][sw_if_index],
546 adj_db_count,
547 &ctx);
548 }
549 }
550 }
551 return (ctx.count);
552}
553
554/**
Neale Rannsb80c5362016-10-08 13:03:40 +0100555 * @brief Context for a walk of the adjacency neighbour DB
556 */
557typedef struct adj_walk_ctx_t_
558{
559 adj_walk_cb_t awc_cb;
560 void *awc_ctx;
561} adj_walk_ctx_t;
562
563static void
564adj_nbr_walk_cb (BVT(clib_bihash_kv) * kvp,
565 void *arg)
566{
567 adj_walk_ctx_t *ctx = arg;
568
569 // FIXME: can't stop early...
570 ctx->awc_cb(kvp->value, ctx->awc_ctx);
571}
572
573void
574adj_nbr_walk (u32 sw_if_index,
575 fib_protocol_t adj_nh_proto,
576 adj_walk_cb_t cb,
577 void *ctx)
578{
579 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
580 return;
581
582 adj_walk_ctx_t awc = {
583 .awc_ctx = ctx,
584 .awc_cb = cb,
585 };
586
587 BV(clib_bihash_foreach_key_value_pair) (
588 adj_nbr_tables[adj_nh_proto][sw_if_index],
589 adj_nbr_walk_cb,
590 &awc);
591}
592
593/**
Neale Rannsb80c5362016-10-08 13:03:40 +0100594 * @brief Walk adjacencies on a link with a given v4 next-hop.
595 * that is visit the adjacencies with different link types.
596 */
597void
598adj_nbr_walk_nh4 (u32 sw_if_index,
599 const ip4_address_t *addr,
600 adj_walk_cb_t cb,
601 void *ctx)
602{
603 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP4, sw_if_index))
604 return;
605
606 ip46_address_t nh = {
607 .ip4 = *addr,
608 };
Neale Ranns580bba72018-04-23 05:31:19 -0700609 vnet_link_t linkt;
610 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100611
Neale Ranns580bba72018-04-23 05:31:19 -0700612 FOR_EACH_VNET_LINK(linkt)
613 {
614 ai = adj_nbr_find (FIB_PROTOCOL_IP4, linkt, &nh, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100615
Neale Ranns580bba72018-04-23 05:31:19 -0700616 if (INDEX_INVALID != ai)
617 cb(ai, ctx);
618 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100619}
620
621/**
622 * @brief Walk adjacencies on a link with a given v6 next-hop.
623 * that is visit the adjacencies with different link types.
624 */
625void
626adj_nbr_walk_nh6 (u32 sw_if_index,
627 const ip6_address_t *addr,
628 adj_walk_cb_t cb,
629 void *ctx)
630{
631 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP6, sw_if_index))
632 return;
633
634 ip46_address_t nh = {
635 .ip6 = *addr,
636 };
Neale Ranns580bba72018-04-23 05:31:19 -0700637 vnet_link_t linkt;
638 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100639
Neale Ranns580bba72018-04-23 05:31:19 -0700640 FOR_EACH_VNET_LINK(linkt)
641 {
642 ai = adj_nbr_find (FIB_PROTOCOL_IP6, linkt, &nh, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100643
Neale Ranns580bba72018-04-23 05:31:19 -0700644 if (INDEX_INVALID != ai)
645 cb(ai, ctx);
646 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100647}
648
649/**
650 * @brief Walk adjacencies on a link with a given next-hop.
651 * that is visit the adjacencies with different link types.
652 */
653void
654adj_nbr_walk_nh (u32 sw_if_index,
655 fib_protocol_t adj_nh_proto,
656 const ip46_address_t *nh,
657 adj_walk_cb_t cb,
658 void *ctx)
659{
660 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
661 return;
662
Neale Ranns580bba72018-04-23 05:31:19 -0700663 vnet_link_t linkt;
664 adj_index_t ai;
Neale Rannsb80c5362016-10-08 13:03:40 +0100665
Neale Ranns580bba72018-04-23 05:31:19 -0700666 FOR_EACH_VNET_LINK(linkt)
667 {
668 ai = adj_nbr_find (FIB_PROTOCOL_IP4, linkt, nh, sw_if_index);
669
670 if (INDEX_INVALID != ai)
671 cb(ai, ctx);
672 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100673}
674
675/**
Neale Ranns8b37b872016-11-21 12:25:22 +0000676 * Flags associated with the interface state walks
677 */
678typedef enum adj_nbr_interface_flags_t_
679{
680 ADJ_NBR_INTERFACE_UP = (1 << 0),
681} adj_nbr_interface_flags_t;
682
683/**
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100684 * Context for the state change walk of the DB
685 */
686typedef struct adj_nbr_interface_state_change_ctx_t_
687{
688 /**
Neale Ranns8b37b872016-11-21 12:25:22 +0000689 * Flags on the interface
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100690 */
Neale Ranns8b37b872016-11-21 12:25:22 +0000691 adj_nbr_interface_flags_t flags;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100692} adj_nbr_interface_state_change_ctx_t;
693
Neale Rannsb80c5362016-10-08 13:03:40 +0100694static adj_walk_rc_t
695adj_nbr_interface_state_change_one (adj_index_t ai,
Neale Ranns8b37b872016-11-21 12:25:22 +0000696 void *arg)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100697{
698 /*
699 * Back walk the graph to inform the forwarding entries
Neale Ranns8b37b872016-11-21 12:25:22 +0000700 * that this interface state has changed. Do this synchronously
701 * since this is the walk that provides convergence
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100702 */
703 adj_nbr_interface_state_change_ctx_t *ctx = arg;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100704 fib_node_back_walk_ctx_t bw_ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000705 .fnbw_reason = ((ctx->flags & ADJ_NBR_INTERFACE_UP) ?
706 FIB_NODE_BW_REASON_FLAG_INTERFACE_UP :
707 FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN),
708 /*
709 * the force sync applies only as far as the first fib_entry.
710 * And it's the fib_entry's we need to converge away from
711 * the adjacencies on the now down link
712 */
713 .fnbw_flags = (!(ctx->flags & ADJ_NBR_INTERFACE_UP) ?
714 FIB_NODE_BW_FLAG_FORCE_SYNC :
Neale Ranns30d53642018-08-27 07:29:15 -0700715 FIB_NODE_BW_FLAG_NONE),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100716 };
Neale Ranns30d53642018-08-27 07:29:15 -0700717 ip_adjacency_t *adj;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100718
Neale Ranns30d53642018-08-27 07:29:15 -0700719 adj = adj_get(ai);
720
721 adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100722 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
Neale Ranns30d53642018-08-27 07:29:15 -0700723 adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100724
725 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100726}
727
Neale Ranns8b37b872016-11-21 12:25:22 +0000728/**
729 * @brief Registered function for SW interface state changes
730 */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100731static clib_error_t *
Neale Ranns8b37b872016-11-21 12:25:22 +0000732adj_nbr_sw_interface_state_change (vnet_main_t * vnm,
733 u32 sw_if_index,
734 u32 flags)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100735{
736 fib_protocol_t proto;
737
738 /*
739 * walk each adj on the interface and trigger a walk from that adj
740 */
741 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
742 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100743 adj_nbr_interface_state_change_ctx_t ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000744 .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
745 ADJ_NBR_INTERFACE_UP :
746 0),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100747 };
748
Neale Rannsb80c5362016-10-08 13:03:40 +0100749 adj_nbr_walk(sw_if_index, proto,
750 adj_nbr_interface_state_change_one,
751 &ctx);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100752 }
753
754 return (NULL);
755}
756
Neale Ranns8b37b872016-11-21 12:25:22 +0000757VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(
758 adj_nbr_sw_interface_state_change,
759 VNET_ITF_FUNC_PRIORITY_HIGH);
760
761/**
762 * @brief Invoked on each SW interface of a HW interface when the
763 * HW interface state changes
764 */
Neale Ranns0053de62018-05-22 08:40:52 -0700765static walk_rc_t
Neale Ranns8b37b872016-11-21 12:25:22 +0000766adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
767 u32 sw_if_index,
768 void *arg)
769{
770 adj_nbr_interface_state_change_ctx_t *ctx = arg;
771 fib_protocol_t proto;
772
773 /*
774 * walk each adj on the interface and trigger a walk from that adj
775 */
776 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
777 {
778 adj_nbr_walk(sw_if_index, proto,
779 adj_nbr_interface_state_change_one,
780 ctx);
781 }
Neale Ranns0053de62018-05-22 08:40:52 -0700782 return (WALK_CONTINUE);
Neale Ranns8b37b872016-11-21 12:25:22 +0000783}
784
785/**
786 * @brief Registered callback for HW interface state changes
787 */
788static clib_error_t *
789adj_nbr_hw_interface_state_change (vnet_main_t * vnm,
790 u32 hw_if_index,
791 u32 flags)
792{
793 /*
794 * walk SW interface on the HW
795 */
796 adj_nbr_interface_state_change_ctx_t ctx = {
797 .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
798 ADJ_NBR_INTERFACE_UP :
799 0),
800 };
801
802 vnet_hw_interface_walk_sw(vnm, hw_if_index,
803 adj_nbr_hw_sw_interface_state_change,
804 &ctx);
805
806 return (NULL);
807}
808
809VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(
810 adj_nbr_hw_interface_state_change,
811 VNET_ITF_FUNC_PRIORITY_HIGH);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100812
Neale Rannsb80c5362016-10-08 13:03:40 +0100813static adj_walk_rc_t
814adj_nbr_interface_delete_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100815 void *arg)
816{
817 /*
818 * Back walk the graph to inform the forwarding entries
819 * that this interface has been deleted.
820 */
821 fib_node_back_walk_ctx_t bw_ctx = {
822 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
823 };
Neale Ranns30d53642018-08-27 07:29:15 -0700824 ip_adjacency_t *adj;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100825
Neale Ranns30d53642018-08-27 07:29:15 -0700826 adj = adj_get(ai);
827
828 adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100829 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
Neale Ranns30d53642018-08-27 07:29:15 -0700830 adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Rannsb80c5362016-10-08 13:03:40 +0100831
832 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100833}
834
835/**
836 * adj_nbr_interface_add_del
837 *
838 * Registered to receive interface Add and delete notifications
839 */
840static clib_error_t *
841adj_nbr_interface_add_del (vnet_main_t * vnm,
842 u32 sw_if_index,
843 u32 is_add)
844{
845 fib_protocol_t proto;
846
847 if (is_add)
848 {
849 /*
850 * not interested in interface additions. we will not back walk
851 * to resolve paths through newly added interfaces. Why? The control
852 * plane should have the brains to add interfaces first, then routes.
853 * So the case where there are paths with a interface that matches
854 * one just created is the case where the path resolved through an
855 * interface that was deleted, and still has not been removed. The
856 * new interface added, is NO GUARANTEE that the interface being
857 * added now, even though it may have the same sw_if_index, is the
858 * same interface that the path needs. So tough!
859 * If the control plane wants these routes to resolve it needs to
860 * remove and add them again.
861 */
862 return (NULL);
863 }
864
865 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
866 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100867 adj_nbr_walk(sw_if_index, proto,
868 adj_nbr_interface_delete_one,
869 NULL);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100870 }
871
872 return (NULL);
873
874}
875
876VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del);
877
878
Neale Rannsb80c5362016-10-08 13:03:40 +0100879static adj_walk_rc_t
880adj_nbr_show_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100881 void *arg)
882{
883 vlib_cli_output (arg, "[@%d] %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100884 ai,
885 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100886 FORMAT_IP_ADJACENCY_NONE);
Neale Rannsb80c5362016-10-08 13:03:40 +0100887
888 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100889}
890
891static clib_error_t *
892adj_nbr_show (vlib_main_t * vm,
893 unformat_input_t * input,
894 vlib_cli_command_t * cmd)
895{
896 adj_index_t ai = ADJ_INDEX_INVALID;
Neale Rannsb80c5362016-10-08 13:03:40 +0100897 u32 sw_if_index = ~0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100898
899 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
900 {
901 if (unformat (input, "%d", &ai))
902 ;
Neale Rannsb80c5362016-10-08 13:03:40 +0100903 else if (unformat (input, "%U",
904 unformat_vnet_sw_interface, vnet_get_main(),
905 &sw_if_index))
906 ;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100907 else
908 break;
909 }
910
911 if (ADJ_INDEX_INVALID != ai)
912 {
913 vlib_cli_output (vm, "[@%d] %U",
914 ai,
Neale Rannsb80c5362016-10-08 13:03:40 +0100915 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100916 FORMAT_IP_ADJACENCY_DETAIL);
917 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100918 else if (~0 != sw_if_index)
919 {
920 fib_protocol_t proto;
921
922 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
923 {
924 adj_nbr_walk(sw_if_index, proto,
925 adj_nbr_show_one,
926 vm);
927 }
928 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100929 else
930 {
931 fib_protocol_t proto;
932
933 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
934 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100935 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
936 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100937 adj_nbr_walk(sw_if_index, proto,
938 adj_nbr_show_one,
939 vm);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100940 }
941 }
942 }
943
944 return 0;
945}
946
Neale Rannsb80c5362016-10-08 13:03:40 +0100947/*?
948 * Show all neighbour adjacencies.
949 * @cliexpar
950 * @cliexstart{sh adj nbr}
951 * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
952 * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
953 * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
954 * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
955 * @cliexend
956 ?*/
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100957VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
958 .path = "show adj nbr",
Neale Rannsb80c5362016-10-08 13:03:40 +0100959 .short_help = "show adj nbr [<adj_index>] [interface]",
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100960 .function = adj_nbr_show,
961};
962
963u8*
964format_adj_nbr_incomplete (u8* s, va_list *ap)
965{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400966 index_t index = va_arg(*ap, index_t);
967 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100968 vnet_main_t * vnm = vnet_get_main();
969 ip_adjacency_t * adj = adj_get(index);
970
Neale Ranns924d03a2016-10-19 08:25:46 +0100971 s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100972 s = format (s, ": via %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100973 format_ip46_address, &adj->sub_type.nbr.next_hop,
974 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100975 s = format (s, " %U",
Steven70488ab2018-03-28 17:59:00 -0700976 format_vnet_sw_if_index_name,
977 vnm, adj->rewrite_header.sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100978
979 return (s);
980}
981
982u8*
983format_adj_nbr (u8* s, va_list *ap)
984{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400985 index_t index = va_arg(*ap, index_t);
986 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100987 ip_adjacency_t * adj = adj_get(index);
988
Neale Ranns924d03a2016-10-19 08:25:46 +0100989 s = format (s, "%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100990 s = format (s, " via %U ",
Neale Rannsb80c5362016-10-08 13:03:40 +0100991 format_ip46_address, &adj->sub_type.nbr.next_hop,
992 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100993 s = format (s, "%U",
994 format_vnet_rewrite,
Neale Rannsb069a692017-03-15 12:34:25 -0400995 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100996
997 return (s);
998}
999
1000static void
1001adj_dpo_lock (dpo_id_t *dpo)
1002{
1003 adj_lock(dpo->dpoi_index);
1004}
1005static void
1006adj_dpo_unlock (dpo_id_t *dpo)
1007{
1008 adj_unlock(dpo->dpoi_index);
1009}
1010
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001011static void
1012adj_mem_show (void)
1013{
1014 fib_show_memory_usage("Adjacency",
1015 pool_elts(adj_pool),
1016 pool_len(adj_pool),
1017 sizeof(ip_adjacency_t));
1018}
1019
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001020const static dpo_vft_t adj_nbr_dpo_vft = {
1021 .dv_lock = adj_dpo_lock,
1022 .dv_unlock = adj_dpo_unlock,
1023 .dv_format = format_adj_nbr,
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001024 .dv_mem_show = adj_mem_show,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001025 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001026};
1027const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1028 .dv_lock = adj_dpo_lock,
1029 .dv_unlock = adj_dpo_unlock,
1030 .dv_format = format_adj_nbr_incomplete,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001031 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001032};
1033
1034/**
1035 * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1036 * object.
1037 *
1038 * this means that these graph nodes are ones from which a nbr is the
1039 * parent object in the DPO-graph.
1040 */
1041const static char* const nbr_ip4_nodes[] =
1042{
Neale Rannsf06aea52016-11-29 06:51:37 -08001043 "ip4-rewrite",
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001044 NULL,
1045};
1046const static char* const nbr_ip6_nodes[] =
1047{
1048 "ip6-rewrite",
1049 NULL,
1050};
1051const static char* const nbr_mpls_nodes[] =
1052{
1053 "mpls-output",
1054 NULL,
1055};
Neale Ranns5e575b12016-10-03 09:40:25 +01001056const static char* const nbr_ethernet_nodes[] =
1057{
1058 "adj-l2-rewrite",
1059 NULL,
1060};
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001061const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1062{
1063 [DPO_PROTO_IP4] = nbr_ip4_nodes,
1064 [DPO_PROTO_IP6] = nbr_ip6_nodes,
1065 [DPO_PROTO_MPLS] = nbr_mpls_nodes,
Neale Ranns5e575b12016-10-03 09:40:25 +01001066 [DPO_PROTO_ETHERNET] = nbr_ethernet_nodes,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001067};
1068
1069const static char* const nbr_incomplete_ip4_nodes[] =
1070{
1071 "ip4-arp",
1072 NULL,
1073};
1074const static char* const nbr_incomplete_ip6_nodes[] =
1075{
1076 "ip6-discover-neighbor",
1077 NULL,
1078};
1079const static char* const nbr_incomplete_mpls_nodes[] =
1080{
1081 "mpls-adj-incomplete",
1082 NULL,
1083};
1084
1085const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1086{
1087 [DPO_PROTO_IP4] = nbr_incomplete_ip4_nodes,
1088 [DPO_PROTO_IP6] = nbr_incomplete_ip6_nodes,
1089 [DPO_PROTO_MPLS] = nbr_incomplete_mpls_nodes,
1090};
1091
1092void
1093adj_nbr_module_init (void)
1094{
1095 dpo_register(DPO_ADJACENCY,
1096 &adj_nbr_dpo_vft,
1097 nbr_nodes);
1098 dpo_register(DPO_ADJACENCY_INCOMPLETE,
1099 &adj_nbr_incompl_dpo_vft,
1100 nbr_incomplete_nodes);
1101}