blob: dcf3cb149a6bb65eac6f8988ba4c5b18769a8208 [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);
62 memset(adj_nbr_tables[nh_proto][sw_if_index],
63 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
96static adj_index_t
97adj_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 Ranns0bfe5d82016-08-25 15:29:12 +0100198
AkshayaNadahalli17f5f602017-03-27 14:47:41 +0530199 adj_nbr_evaluate_feature (adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100200 return (adj);
201}
202
203/*
Neale Ranns32e1c012016-11-22 17:07:28 +0000204 * adj_nbr_add_or_lock
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100205 *
206 * Add an adjacency for the neighbour requested.
207 *
208 * The key for an adj is:
209 * - the Next-hops protocol (i.e. v4 or v6)
210 * - the address of the next-hop
211 * - the interface the next-hop is reachable through
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100212 */
213adj_index_t
214adj_nbr_add_or_lock (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100215 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100216 const ip46_address_t *nh_addr,
217 u32 sw_if_index)
218{
219 adj_index_t adj_index;
220 ip_adjacency_t *adj;
221
222 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
223
224 if (ADJ_INDEX_INVALID == adj_index)
225 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100226 vnet_main_t *vnm;
227
228 vnm = vnet_get_main();
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100229 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100230 adj_index = adj_get_index(adj);
231 adj_lock(adj_index);
232
233 vnet_rewrite_init(vnm, sw_if_index,
234 adj_get_nd_node(nh_proto),
235 vnet_tx_node_index_for_sw_interface(vnm, sw_if_index),
236 &adj->rewrite_header);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100237
238 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100239 * we need a rewrite where the destination IP address is converted
240 * to the appropriate link-layer address. This is interface specific.
241 * So ask the interface to do it.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100242 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100243 vnet_update_adjacency_for_sw_interface(vnm, sw_if_index, adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100244 }
245 else
246 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100247 adj_lock(adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100248 }
249
Neale Rannsb80c5362016-10-08 13:03:40 +0100250 return (adj_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100251}
252
253adj_index_t
254adj_nbr_add_or_lock_w_rewrite (fib_protocol_t nh_proto,
Neale Ranns924d03a2016-10-19 08:25:46 +0100255 vnet_link_t link_type,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100256 const ip46_address_t *nh_addr,
257 u32 sw_if_index,
258 u8 *rewrite)
259{
260 adj_index_t adj_index;
261 ip_adjacency_t *adj;
262
263 adj_index = adj_nbr_find(nh_proto, link_type, nh_addr, sw_if_index);
264
265 if (ADJ_INDEX_INVALID == adj_index)
266 {
267 adj = adj_nbr_alloc(nh_proto, link_type, nh_addr, sw_if_index);
268 adj->rewrite_header.sw_if_index = sw_if_index;
269 }
270 else
271 {
272 adj = adj_get(adj_index);
273 }
274
Neale Ranns6c3ebcc2016-10-02 21:20:15 +0100275 adj_lock(adj_get_index(adj));
Neale Rannsb80c5362016-10-08 13:03:40 +0100276 adj_nbr_update_rewrite(adj_get_index(adj),
277 ADJ_NBR_REWRITE_FLAG_COMPLETE,
278 rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100279
Neale Ranns6c3ebcc2016-10-02 21:20:15 +0100280 return (adj_get_index(adj));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100281}
282
283/**
284 * adj_nbr_update_rewrite
285 *
286 * Update the adjacency's rewrite string. A NULL string implies the
287 * rewirte is reset (i.e. when ARP/ND etnry is gone).
288 * NB: the adj being updated may be handling traffic in the DP.
289 */
290void
291adj_nbr_update_rewrite (adj_index_t adj_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100292 adj_nbr_rewrite_flag_t flags,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100293 u8 *rewrite)
294{
295 ip_adjacency_t *adj;
296
297 ASSERT(ADJ_INDEX_INVALID != adj_index);
298
299 adj = adj_get(adj_index);
Neale Rannsb80c5362016-10-08 13:03:40 +0100300
301 if (flags & ADJ_NBR_REWRITE_FLAG_COMPLETE)
302 {
303 /*
304 * update the adj's rewrite string and build the arc
305 * from the rewrite node to the interface's TX node
306 */
307 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_REWRITE,
308 adj_get_rewrite_node(adj->ia_link),
309 vnet_tx_node_index_for_sw_interface(
310 vnet_get_main(),
311 adj->rewrite_header.sw_if_index),
312 rewrite);
313 }
314 else
315 {
316 adj_nbr_update_rewrite_internal(adj, IP_LOOKUP_NEXT_ARP,
317 adj_get_nd_node(adj->ia_nh_proto),
318 vnet_tx_node_index_for_sw_interface(
319 vnet_get_main(),
320 adj->rewrite_header.sw_if_index),
321 rewrite);
322 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100323}
324
325/**
326 * adj_nbr_update_rewrite_internal
327 *
328 * Update the adjacency's rewrite string. A NULL string implies the
329 * rewirte is reset (i.e. when ARP/ND etnry is gone).
330 * NB: the adj being updated may be handling traffic in the DP.
331 */
332void
333adj_nbr_update_rewrite_internal (ip_adjacency_t *adj,
Neale Rannsfa5d1982017-02-20 14:19:51 -0800334 ip_lookup_next_t adj_next_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100335 u32 this_node,
336 u32 next_node,
337 u8 *rewrite)
338{
Neale Ranns19c68d22016-12-07 15:38:14 +0000339 ip_adjacency_t *walk_adj;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000340 adj_index_t walk_ai;
341 vlib_main_t * vm;
342 u32 old_next;
Neale Ranns19c68d22016-12-07 15:38:14 +0000343 int do_walk;
Neale Rannsad95b5d2016-11-10 20:35:14 +0000344
345 vm = vlib_get_main();
346 old_next = adj->lookup_next_index;
347
348 walk_ai = adj_get_index(adj);
349 if (VNET_LINK_MPLS == adj->ia_link)
350 {
351 /*
352 * The link type MPLS has no children in the control plane graph, it only
353 * has children in the data-palne graph. The backwalk is up the former.
354 * So we need to walk from its IP cousin.
355 */
356 walk_ai = adj_nbr_find(adj->ia_nh_proto,
357 fib_proto_to_link(adj->ia_nh_proto),
358 &adj->sub_type.nbr.next_hop,
359 adj->rewrite_header.sw_if_index);
360 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100361
362 /*
Neale Ranns19c68d22016-12-07 15:38:14 +0000363 * Don't call the walk re-entrantly
364 */
365 if (ADJ_INDEX_INVALID != walk_ai)
366 {
367 walk_adj = adj_get(walk_ai);
Neale Rannsfa5d1982017-02-20 14:19:51 -0800368 if (ADJ_FLAG_SYNC_WALK_ACTIVE & walk_adj->ia_flags)
Neale Ranns19c68d22016-12-07 15:38:14 +0000369 {
370 do_walk = 0;
371 }
372 else
373 {
374 /*
375 * Prevent re-entrant walk of the same adj
376 */
Neale Rannsfa5d1982017-02-20 14:19:51 -0800377 walk_adj->ia_flags |= ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000378 do_walk = 1;
379 }
380 }
381 else
382 {
383 do_walk = 0;
384 }
385
386 /*
387 * lock the adjacencies that are affected by updates this walk will provoke.
388 * Since the aim of the walk is to update children to link to a different
389 * DPO, this adj will no longer be in use and its lock count will drop to 0.
390 * We don't want it to be deleted as part of this endevour.
391 */
392 adj_lock(adj_get_index(adj));
393 adj_lock(walk_ai);
394
395 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100396 * Updating a rewrite string is not atomic;
397 * - the rewrite string is too long to write in one instruction
398 * - when swapping from incomplete to complete, we also need to update
Neale Rannsad95b5d2016-11-10 20:35:14 +0000399 * the VLIB graph next-index of the adj.
Neale Rannsb80c5362016-10-08 13:03:40 +0100400 * ideally we would only want to suspend forwarding via this adj whilst we
401 * do this, but we do not have that level of granularity - it's suspend all
402 * worker threads or nothing.
403 * The other chioces are:
404 * - to mark the adj down and back walk so child load-balances drop this adj
405 * from the set.
406 * - update the next_node index of this adj to point to error-drop
407 * both of which will mean for MAC change we will drop for this adj
Neale Rannsad95b5d2016-11-10 20:35:14 +0000408 * which is not acceptable. However, when the adj changes type (from
409 * complete to incomplete and vice-versa) the child DPOs, which have the
410 * VLIB graph next node index, will be sending packets to the wrong graph
411 * node. So from the options above, updating the next_node of the adj to
412 * be drop will work, but it relies on each graph node v4/v6/mpls, rewrite/
413 * arp/midchain always be valid w.r.t. a mis-match of adj type and node type
414 * (i.e. a rewrite adj in the arp node). This is not enforcable. Getting it
415 * wrong will lead to hard to find bugs since its a race condition. So we
416 * choose the more reliable method of updating the children to use the drop,
417 * then switching adj's type, then updating the children again. Did I mention
418 * that this doesn't happen often...
419 * So we need to distinguish between the two cases:
420 * 1 - mac change
421 * 2 - adj type change
422 */
Neale Ranns19c68d22016-12-07 15:38:14 +0000423 if (do_walk &&
424 old_next != adj_next_index &&
Neale Rannsad95b5d2016-11-10 20:35:14 +0000425 ADJ_INDEX_INVALID != walk_ai)
426 {
427 /*
428 * the adj is changing type. we need to fix all children so that they
429 * stack momentarily on a drop, while the adj changes. If we don't do
430 * this the children will send packets to a VLIB graph node that does
431 * not correspond to the adj's type - and it goes downhill from there.
432 */
433 fib_node_back_walk_ctx_t bw_ctx = {
434 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_DOWN,
435 /*
436 * force this walk to be synchrous. if we don't and a node in the graph
437 * (a heavily shared path-list) chooses to back-ground the walk (make it
438 * async) then it will pause and we will do the adj update below, before
439 * all the children are updated. not good.
440 */
441 .fnbw_flags = FIB_NODE_BW_FLAG_FORCE_SYNC,
442 };
443
444 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
445 }
446
447 /*
448 * If we are just updating the MAC string of the adj (which we also can't
449 * do atomically), then we need to stop packets switching through the adj.
450 * We can't do that on a per-adj basis, so it's all the packets.
451 * If we are updating the type, and we walked back to the children above,
452 * then this barrier serves to flush the queues/frames.
Neale Rannsb80c5362016-10-08 13:03:40 +0100453 */
454 vlib_worker_thread_barrier_sync(vm);
455
456 adj->lookup_next_index = adj_next_index;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100457
458 if (NULL != rewrite)
459 {
460 /*
461 * new rewrite provided.
Neale Rannsb80c5362016-10-08 13:03:40 +0100462 * fill in the adj's rewrite string, and build the VLIB graph arc.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100463 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100464 vnet_rewrite_set_data_internal(&adj->rewrite_header,
465 sizeof(adj->rewrite_data),
466 rewrite,
467 vec_len(rewrite));
Neale Rannsb80c5362016-10-08 13:03:40 +0100468 vec_free(rewrite);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100469 }
470 else
471 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100472 vnet_rewrite_clear_data_internal(&adj->rewrite_header,
473 sizeof(adj->rewrite_data));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100474 }
Neale Rannsad95b5d2016-11-10 20:35:14 +0000475 adj->rewrite_header.next_index = vlib_node_add_next(vlib_get_main(),
476 this_node,
477 next_node);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100478
479 /*
Neale Rannsb80c5362016-10-08 13:03:40 +0100480 * done with the rewirte update - let the workers loose.
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100481 */
Neale Rannsb80c5362016-10-08 13:03:40 +0100482 vlib_worker_thread_barrier_release(vm);
Neale Rannsad95b5d2016-11-10 20:35:14 +0000483
Neale Ranns19c68d22016-12-07 15:38:14 +0000484 if (do_walk &&
485 (old_next != adj->lookup_next_index) &&
486 (ADJ_INDEX_INVALID != walk_ai))
Neale Rannsad95b5d2016-11-10 20:35:14 +0000487 {
488 /*
489 * backwalk to the children so they can stack on the now updated
490 * adjacency
491 */
492 fib_node_back_walk_ctx_t bw_ctx = {
493 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_ADJ_UPDATE,
494 };
495
496 fib_walk_sync(FIB_NODE_TYPE_ADJ, walk_ai, &bw_ctx);
497 }
Neale Ranns19c68d22016-12-07 15:38:14 +0000498 /*
499 * Prevent re-entrant walk of the same adj
500 */
501 if (do_walk)
502 {
Neale Rannsfa5d1982017-02-20 14:19:51 -0800503 walk_adj->ia_flags &= ~ADJ_FLAG_SYNC_WALK_ACTIVE;
Neale Ranns19c68d22016-12-07 15:38:14 +0000504 }
505
506 adj_unlock(adj_get_index(adj));
507 adj_unlock(walk_ai);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100508}
509
510typedef struct adj_db_count_ctx_t_ {
511 u64 count;
512} adj_db_count_ctx_t;
513
514static void
515adj_db_count (BVT(clib_bihash_kv) * kvp,
516 void *arg)
517{
518 adj_db_count_ctx_t * ctx = arg;
519 ctx->count++;
520}
521
522u32
523adj_nbr_db_size (void)
524{
525 adj_db_count_ctx_t ctx = {
526 .count = 0,
527 };
528 fib_protocol_t proto;
529 u32 sw_if_index = 0;
530
531 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
532 {
533 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
534 {
535 if (NULL != adj_nbr_tables[proto][sw_if_index])
536 {
537 BV(clib_bihash_foreach_key_value_pair) (
538 adj_nbr_tables[proto][sw_if_index],
539 adj_db_count,
540 &ctx);
541 }
542 }
543 }
544 return (ctx.count);
545}
546
547/**
Neale Rannsb80c5362016-10-08 13:03:40 +0100548 * @brief Context for a walk of the adjacency neighbour DB
549 */
550typedef struct adj_walk_ctx_t_
551{
552 adj_walk_cb_t awc_cb;
553 void *awc_ctx;
554} adj_walk_ctx_t;
555
556static void
557adj_nbr_walk_cb (BVT(clib_bihash_kv) * kvp,
558 void *arg)
559{
560 adj_walk_ctx_t *ctx = arg;
561
562 // FIXME: can't stop early...
563 ctx->awc_cb(kvp->value, ctx->awc_ctx);
564}
565
566void
567adj_nbr_walk (u32 sw_if_index,
568 fib_protocol_t adj_nh_proto,
569 adj_walk_cb_t cb,
570 void *ctx)
571{
572 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
573 return;
574
575 adj_walk_ctx_t awc = {
576 .awc_ctx = ctx,
577 .awc_cb = cb,
578 };
579
580 BV(clib_bihash_foreach_key_value_pair) (
581 adj_nbr_tables[adj_nh_proto][sw_if_index],
582 adj_nbr_walk_cb,
583 &awc);
584}
585
586/**
587 * @brief Context for a walk of the adjacency neighbour DB
588 */
589typedef struct adj_walk_nh_ctx_t_
590{
591 adj_walk_cb_t awc_cb;
592 void *awc_ctx;
593 const ip46_address_t *awc_nh;
594} adj_walk_nh_ctx_t;
595
596static void
597adj_nbr_walk_nh_cb (BVT(clib_bihash_kv) * kvp,
598 void *arg)
599{
600 ip_adjacency_t *adj;
601 adj_walk_nh_ctx_t *ctx = arg;
602
603 adj = adj_get(kvp->value);
604
605 if (!ip46_address_cmp(&adj->sub_type.nbr.next_hop, ctx->awc_nh))
606 ctx->awc_cb(kvp->value, ctx->awc_ctx);
607}
608
609/**
610 * @brief Walk adjacencies on a link with a given v4 next-hop.
611 * that is visit the adjacencies with different link types.
612 */
613void
614adj_nbr_walk_nh4 (u32 sw_if_index,
615 const ip4_address_t *addr,
616 adj_walk_cb_t cb,
617 void *ctx)
618{
619 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP4, sw_if_index))
620 return;
621
622 ip46_address_t nh = {
623 .ip4 = *addr,
624 };
625
626 adj_walk_nh_ctx_t awc = {
627 .awc_ctx = ctx,
628 .awc_cb = cb,
629 .awc_nh = &nh,
630 };
631
632 BV(clib_bihash_foreach_key_value_pair) (
633 adj_nbr_tables[FIB_PROTOCOL_IP4][sw_if_index],
634 adj_nbr_walk_nh_cb,
635 &awc);
636}
637
638/**
639 * @brief Walk adjacencies on a link with a given v6 next-hop.
640 * that is visit the adjacencies with different link types.
641 */
642void
643adj_nbr_walk_nh6 (u32 sw_if_index,
644 const ip6_address_t *addr,
645 adj_walk_cb_t cb,
646 void *ctx)
647{
648 if (!ADJ_NBR_ITF_OK(FIB_PROTOCOL_IP6, sw_if_index))
649 return;
650
651 ip46_address_t nh = {
652 .ip6 = *addr,
653 };
654
655 adj_walk_nh_ctx_t awc = {
656 .awc_ctx = ctx,
657 .awc_cb = cb,
658 .awc_nh = &nh,
659 };
660
661 BV(clib_bihash_foreach_key_value_pair) (
662 adj_nbr_tables[FIB_PROTOCOL_IP6][sw_if_index],
663 adj_nbr_walk_nh_cb,
664 &awc);
665}
666
667/**
668 * @brief Walk adjacencies on a link with a given next-hop.
669 * that is visit the adjacencies with different link types.
670 */
671void
672adj_nbr_walk_nh (u32 sw_if_index,
673 fib_protocol_t adj_nh_proto,
674 const ip46_address_t *nh,
675 adj_walk_cb_t cb,
676 void *ctx)
677{
678 if (!ADJ_NBR_ITF_OK(adj_nh_proto, sw_if_index))
679 return;
680
681 adj_walk_nh_ctx_t awc = {
682 .awc_ctx = ctx,
683 .awc_cb = cb,
684 .awc_nh = nh,
685 };
686
687 BV(clib_bihash_foreach_key_value_pair) (
688 adj_nbr_tables[adj_nh_proto][sw_if_index],
689 adj_nbr_walk_nh_cb,
690 &awc);
691}
692
693/**
Neale Ranns8b37b872016-11-21 12:25:22 +0000694 * Flags associated with the interface state walks
695 */
696typedef enum adj_nbr_interface_flags_t_
697{
698 ADJ_NBR_INTERFACE_UP = (1 << 0),
699} adj_nbr_interface_flags_t;
700
701/**
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100702 * Context for the state change walk of the DB
703 */
704typedef struct adj_nbr_interface_state_change_ctx_t_
705{
706 /**
Neale Ranns8b37b872016-11-21 12:25:22 +0000707 * Flags on the interface
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100708 */
Neale Ranns8b37b872016-11-21 12:25:22 +0000709 adj_nbr_interface_flags_t flags;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100710} adj_nbr_interface_state_change_ctx_t;
711
Neale Rannsb80c5362016-10-08 13:03:40 +0100712static adj_walk_rc_t
713adj_nbr_interface_state_change_one (adj_index_t ai,
Neale Ranns8b37b872016-11-21 12:25:22 +0000714 void *arg)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100715{
716 /*
717 * Back walk the graph to inform the forwarding entries
Neale Ranns8b37b872016-11-21 12:25:22 +0000718 * that this interface state has changed. Do this synchronously
719 * since this is the walk that provides convergence
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100720 */
721 adj_nbr_interface_state_change_ctx_t *ctx = arg;
722
723 fib_node_back_walk_ctx_t bw_ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000724 .fnbw_reason = ((ctx->flags & ADJ_NBR_INTERFACE_UP) ?
725 FIB_NODE_BW_REASON_FLAG_INTERFACE_UP :
726 FIB_NODE_BW_REASON_FLAG_INTERFACE_DOWN),
727 /*
728 * the force sync applies only as far as the first fib_entry.
729 * And it's the fib_entry's we need to converge away from
730 * the adjacencies on the now down link
731 */
732 .fnbw_flags = (!(ctx->flags & ADJ_NBR_INTERFACE_UP) ?
733 FIB_NODE_BW_FLAG_FORCE_SYNC :
734 0),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100735 };
736
Neale Rannsb80c5362016-10-08 13:03:40 +0100737 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
738
739 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100740}
741
Neale Ranns8b37b872016-11-21 12:25:22 +0000742/**
743 * @brief Registered function for SW interface state changes
744 */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100745static clib_error_t *
Neale Ranns8b37b872016-11-21 12:25:22 +0000746adj_nbr_sw_interface_state_change (vnet_main_t * vnm,
747 u32 sw_if_index,
748 u32 flags)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100749{
750 fib_protocol_t proto;
751
752 /*
753 * walk each adj on the interface and trigger a walk from that adj
754 */
755 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
756 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100757 adj_nbr_interface_state_change_ctx_t ctx = {
Neale Ranns8b37b872016-11-21 12:25:22 +0000758 .flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
759 ADJ_NBR_INTERFACE_UP :
760 0),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100761 };
762
Neale Rannsb80c5362016-10-08 13:03:40 +0100763 adj_nbr_walk(sw_if_index, proto,
764 adj_nbr_interface_state_change_one,
765 &ctx);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100766 }
767
768 return (NULL);
769}
770
Neale Ranns8b37b872016-11-21 12:25:22 +0000771VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION_PRIO(
772 adj_nbr_sw_interface_state_change,
773 VNET_ITF_FUNC_PRIORITY_HIGH);
774
775/**
776 * @brief Invoked on each SW interface of a HW interface when the
777 * HW interface state changes
778 */
779static void
780adj_nbr_hw_sw_interface_state_change (vnet_main_t * vnm,
781 u32 sw_if_index,
782 void *arg)
783{
784 adj_nbr_interface_state_change_ctx_t *ctx = arg;
785 fib_protocol_t proto;
786
787 /*
788 * walk each adj on the interface and trigger a walk from that adj
789 */
790 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
791 {
792 adj_nbr_walk(sw_if_index, proto,
793 adj_nbr_interface_state_change_one,
794 ctx);
795 }
796}
797
798/**
799 * @brief Registered callback for HW interface state changes
800 */
801static clib_error_t *
802adj_nbr_hw_interface_state_change (vnet_main_t * vnm,
803 u32 hw_if_index,
804 u32 flags)
805{
806 /*
807 * walk SW interface on the HW
808 */
809 adj_nbr_interface_state_change_ctx_t ctx = {
810 .flags = ((flags & VNET_HW_INTERFACE_FLAG_LINK_UP) ?
811 ADJ_NBR_INTERFACE_UP :
812 0),
813 };
814
815 vnet_hw_interface_walk_sw(vnm, hw_if_index,
816 adj_nbr_hw_sw_interface_state_change,
817 &ctx);
818
819 return (NULL);
820}
821
822VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION_PRIO(
823 adj_nbr_hw_interface_state_change,
824 VNET_ITF_FUNC_PRIORITY_HIGH);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100825
Neale Rannsb80c5362016-10-08 13:03:40 +0100826static adj_walk_rc_t
827adj_nbr_interface_delete_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100828 void *arg)
829{
830 /*
831 * Back walk the graph to inform the forwarding entries
832 * that this interface has been deleted.
833 */
834 fib_node_back_walk_ctx_t bw_ctx = {
835 .fnbw_reason = FIB_NODE_BW_REASON_FLAG_INTERFACE_DELETE,
836 };
837
Neale Rannsb80c5362016-10-08 13:03:40 +0100838 fib_walk_sync(FIB_NODE_TYPE_ADJ, ai, &bw_ctx);
839
840 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100841}
842
843/**
844 * adj_nbr_interface_add_del
845 *
846 * Registered to receive interface Add and delete notifications
847 */
848static clib_error_t *
849adj_nbr_interface_add_del (vnet_main_t * vnm,
850 u32 sw_if_index,
851 u32 is_add)
852{
853 fib_protocol_t proto;
854
855 if (is_add)
856 {
857 /*
858 * not interested in interface additions. we will not back walk
859 * to resolve paths through newly added interfaces. Why? The control
860 * plane should have the brains to add interfaces first, then routes.
861 * So the case where there are paths with a interface that matches
862 * one just created is the case where the path resolved through an
863 * interface that was deleted, and still has not been removed. The
864 * new interface added, is NO GUARANTEE that the interface being
865 * added now, even though it may have the same sw_if_index, is the
866 * same interface that the path needs. So tough!
867 * If the control plane wants these routes to resolve it needs to
868 * remove and add them again.
869 */
870 return (NULL);
871 }
872
873 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
874 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100875 adj_nbr_walk(sw_if_index, proto,
876 adj_nbr_interface_delete_one,
877 NULL);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100878 }
879
880 return (NULL);
881
882}
883
884VNET_SW_INTERFACE_ADD_DEL_FUNCTION(adj_nbr_interface_add_del);
885
886
Neale Rannsb80c5362016-10-08 13:03:40 +0100887static adj_walk_rc_t
888adj_nbr_show_one (adj_index_t ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100889 void *arg)
890{
891 vlib_cli_output (arg, "[@%d] %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100892 ai,
893 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100894 FORMAT_IP_ADJACENCY_NONE);
Neale Rannsb80c5362016-10-08 13:03:40 +0100895
896 return (ADJ_WALK_RC_CONTINUE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100897}
898
899static clib_error_t *
900adj_nbr_show (vlib_main_t * vm,
901 unformat_input_t * input,
902 vlib_cli_command_t * cmd)
903{
904 adj_index_t ai = ADJ_INDEX_INVALID;
Neale Rannsb80c5362016-10-08 13:03:40 +0100905 u32 sw_if_index = ~0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100906
907 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
908 {
909 if (unformat (input, "%d", &ai))
910 ;
Neale Rannsb80c5362016-10-08 13:03:40 +0100911 else if (unformat (input, "%U",
912 unformat_vnet_sw_interface, vnet_get_main(),
913 &sw_if_index))
914 ;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100915 else
916 break;
917 }
918
919 if (ADJ_INDEX_INVALID != ai)
920 {
921 vlib_cli_output (vm, "[@%d] %U",
922 ai,
Neale Rannsb80c5362016-10-08 13:03:40 +0100923 format_ip_adjacency, ai,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100924 FORMAT_IP_ADJACENCY_DETAIL);
925 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100926 else if (~0 != sw_if_index)
927 {
928 fib_protocol_t proto;
929
930 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
931 {
932 adj_nbr_walk(sw_if_index, proto,
933 adj_nbr_show_one,
934 vm);
935 }
936 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100937 else
938 {
939 fib_protocol_t proto;
940
941 for (proto = FIB_PROTOCOL_IP4; proto <= FIB_PROTOCOL_IP6; proto++)
942 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100943 vec_foreach_index(sw_if_index, adj_nbr_tables[proto])
944 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100945 adj_nbr_walk(sw_if_index, proto,
946 adj_nbr_show_one,
947 vm);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100948 }
949 }
950 }
951
952 return 0;
953}
954
Neale Rannsb80c5362016-10-08 13:03:40 +0100955/*?
956 * Show all neighbour adjacencies.
957 * @cliexpar
958 * @cliexstart{sh adj nbr}
959 * [@2] ipv4 via 1.0.0.2 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
960 * [@3] mpls via 1.0.0.2 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
961 * [@4] ipv4 via 1.0.0.3 loop0: IP4: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
962 * [@5] mpls via 1.0.0.3 loop0: MPLS_UNICAST: 00:00:22:aa:bb:cc -> 00:00:11:aa:bb:cc
963 * @cliexend
964 ?*/
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100965VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
966 .path = "show adj nbr",
Neale Rannsb80c5362016-10-08 13:03:40 +0100967 .short_help = "show adj nbr [<adj_index>] [interface]",
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100968 .function = adj_nbr_show,
969};
970
971u8*
972format_adj_nbr_incomplete (u8* s, va_list *ap)
973{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400974 index_t index = va_arg(*ap, index_t);
975 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100976 vnet_main_t * vnm = vnet_get_main();
977 ip_adjacency_t * adj = adj_get(index);
978
Neale Ranns924d03a2016-10-19 08:25:46 +0100979 s = format (s, "arp-%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100980 s = format (s, ": via %U",
Neale Rannsb80c5362016-10-08 13:03:40 +0100981 format_ip46_address, &adj->sub_type.nbr.next_hop,
982 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100983 s = format (s, " %U",
Steven70488ab2018-03-28 17:59:00 -0700984 format_vnet_sw_if_index_name,
985 vnm, adj->rewrite_header.sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100986
987 return (s);
988}
989
990u8*
991format_adj_nbr (u8* s, va_list *ap)
992{
Billy McFallcfcf1e22016-10-14 09:51:49 -0400993 index_t index = va_arg(*ap, index_t);
994 CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100995 ip_adjacency_t * adj = adj_get(index);
996
Neale Ranns924d03a2016-10-19 08:25:46 +0100997 s = format (s, "%U", format_vnet_link, adj->ia_link);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100998 s = format (s, " via %U ",
Neale Rannsb80c5362016-10-08 13:03:40 +0100999 format_ip46_address, &adj->sub_type.nbr.next_hop,
1000 adj_proto_to_46(adj->ia_nh_proto));
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001001 s = format (s, "%U",
1002 format_vnet_rewrite,
Neale Rannsb069a692017-03-15 12:34:25 -04001003 &adj->rewrite_header, sizeof (adj->rewrite_data), 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001004
1005 return (s);
1006}
1007
1008static void
1009adj_dpo_lock (dpo_id_t *dpo)
1010{
1011 adj_lock(dpo->dpoi_index);
1012}
1013static void
1014adj_dpo_unlock (dpo_id_t *dpo)
1015{
1016 adj_unlock(dpo->dpoi_index);
1017}
1018
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001019static void
1020adj_mem_show (void)
1021{
1022 fib_show_memory_usage("Adjacency",
1023 pool_elts(adj_pool),
1024 pool_len(adj_pool),
1025 sizeof(ip_adjacency_t));
1026}
1027
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001028const static dpo_vft_t adj_nbr_dpo_vft = {
1029 .dv_lock = adj_dpo_lock,
1030 .dv_unlock = adj_dpo_unlock,
1031 .dv_format = format_adj_nbr,
Neale Ranns6c3ebcc2016-10-02 21:20:15 +01001032 .dv_mem_show = adj_mem_show,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001033 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001034};
1035const static dpo_vft_t adj_nbr_incompl_dpo_vft = {
1036 .dv_lock = adj_dpo_lock,
1037 .dv_unlock = adj_dpo_unlock,
1038 .dv_format = format_adj_nbr_incomplete,
Andrew Yourtchenko5f3fcb92017-10-25 05:50:37 -07001039 .dv_get_urpf = adj_dpo_get_urpf,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001040};
1041
1042/**
1043 * @brief The per-protocol VLIB graph nodes that are assigned to an adjacency
1044 * object.
1045 *
1046 * this means that these graph nodes are ones from which a nbr is the
1047 * parent object in the DPO-graph.
1048 */
1049const static char* const nbr_ip4_nodes[] =
1050{
Neale Rannsf06aea52016-11-29 06:51:37 -08001051 "ip4-rewrite",
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001052 NULL,
1053};
1054const static char* const nbr_ip6_nodes[] =
1055{
1056 "ip6-rewrite",
1057 NULL,
1058};
1059const static char* const nbr_mpls_nodes[] =
1060{
1061 "mpls-output",
1062 NULL,
1063};
Neale Ranns5e575b12016-10-03 09:40:25 +01001064const static char* const nbr_ethernet_nodes[] =
1065{
1066 "adj-l2-rewrite",
1067 NULL,
1068};
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001069const static char* const * const nbr_nodes[DPO_PROTO_NUM] =
1070{
1071 [DPO_PROTO_IP4] = nbr_ip4_nodes,
1072 [DPO_PROTO_IP6] = nbr_ip6_nodes,
1073 [DPO_PROTO_MPLS] = nbr_mpls_nodes,
Neale Ranns5e575b12016-10-03 09:40:25 +01001074 [DPO_PROTO_ETHERNET] = nbr_ethernet_nodes,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001075};
1076
1077const static char* const nbr_incomplete_ip4_nodes[] =
1078{
1079 "ip4-arp",
1080 NULL,
1081};
1082const static char* const nbr_incomplete_ip6_nodes[] =
1083{
1084 "ip6-discover-neighbor",
1085 NULL,
1086};
1087const static char* const nbr_incomplete_mpls_nodes[] =
1088{
1089 "mpls-adj-incomplete",
1090 NULL,
1091};
1092
1093const static char* const * const nbr_incomplete_nodes[DPO_PROTO_NUM] =
1094{
1095 [DPO_PROTO_IP4] = nbr_incomplete_ip4_nodes,
1096 [DPO_PROTO_IP6] = nbr_incomplete_ip6_nodes,
1097 [DPO_PROTO_MPLS] = nbr_incomplete_mpls_nodes,
1098};
1099
1100void
1101adj_nbr_module_init (void)
1102{
1103 dpo_register(DPO_ADJACENCY,
1104 &adj_nbr_dpo_vft,
1105 nbr_nodes);
1106 dpo_register(DPO_ADJACENCY_INCOMPLETE,
1107 &adj_nbr_incompl_dpo_vft,
1108 nbr_incomplete_nodes);
1109}