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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <lisp/lisp-gpe/lisp_gpe_fwd_entry.h>
17 #include <lisp/lisp-gpe/lisp_gpe_adjacency.h>
18 #include <lisp/lisp-gpe/lisp_gpe_tenant.h>
19 #include <lisp/lisp-cp/lisp_cp_dpo.h>
20 #include <vnet/fib/fib_table.h>
21 #include <vnet/fib/fib_entry.h>
22 #include <vnet/fib/fib_path_list.h>
23 #include <vnet/fib/ip6_fib.h>
24 #include <vnet/fib/ip4_fib.h>
25 #include <vnet/dpo/drop_dpo.h>
26 #include <vnet/dpo/lookup_dpo.h>
27 #include <vnet/dpo/load_balance.h>
28 #include <vnet/adj/adj_midchain.h>
31 * @brief Add route to IP4 or IP6 Destination FIB.
33 * Add a route to the destination FIB that results in the lookup
34 * in the SRC FIB. The SRC FIB is created is it does not yet exist.
36 * @param[in] dst_table_id Destination FIB Table-ID
37 * @param[in] dst_prefix Destination IP prefix.
39 * @return src_fib_index The index/ID of the SRC FIB created.
42 ip_dst_fib_add_route (u32 dst_fib_index, const ip_prefix_t * dst_prefix)
44 fib_node_index_t src_fib_index;
45 fib_prefix_t dst_fib_prefix;
46 fib_node_index_t dst_fei;
48 ASSERT (NULL != dst_prefix);
50 ip_prefix_to_fib_prefix (dst_prefix, &dst_fib_prefix);
53 * lookup the destination prefix in the VRF table and retrieve the
54 * LISP associated data
56 dst_fei = fib_table_lookup_exact_match (dst_fib_index, &dst_fib_prefix);
59 * If the FIB entry is not present, or not LISP sourced, add it
61 if (dst_fei == FIB_NODE_INDEX_INVALID ||
62 NULL == fib_entry_get_source_data (dst_fei, FIB_SOURCE_LISP))
64 dpo_id_t src_lkup_dpo = DPO_INVALID;
66 /* create a new src FIB. */
68 fib_table_create_and_lock (dst_fib_prefix.fp_proto,
70 "LISP-src for [%d,%U]",
72 format_fib_prefix, &dst_fib_prefix);
74 * add src fib default route
76 fib_prefix_t prefix = {
77 .fp_proto = dst_fib_prefix.fp_proto,
79 fib_table_entry_special_dpo_add (src_fib_index, &prefix,
81 FIB_ENTRY_FLAG_EXCLUSIVE,
82 lisp_cp_dpo_get (fib_proto_to_dpo
83 (dst_fib_prefix.fp_proto)));
85 * create a data-path object to perform the source address lookup
88 lookup_dpo_add_or_lock_w_fib_index (src_fib_index,
89 (ip_prefix_version (dst_prefix) ==
90 AF_IP6 ? DPO_PROTO_IP6 :
93 LOOKUP_INPUT_SRC_ADDR,
94 LOOKUP_TABLE_FROM_CONFIG,
98 * add the entry to the destination FIB that uses the lookup DPO
100 dst_fei = fib_table_entry_special_dpo_add (dst_fib_index,
103 FIB_ENTRY_FLAG_EXCLUSIVE,
107 * the DPO is locked by the FIB entry, and we have no further
110 dpo_unlock (&src_lkup_dpo);
113 * save the SRC FIB index on the entry so we can retrieve it for
116 fib_entry_set_source_data (dst_fei, FIB_SOURCE_LISP, &src_fib_index);
121 * destination FIB entry already present
123 src_fib_index = *(u32 *) fib_entry_get_source_data (dst_fei,
127 return (src_fib_index);
131 * @brief Del route to IP4 or IP6 SD FIB.
133 * Remove routes from both destination and source FIBs.
135 * @param[in] src_fib_index The index/ID of the SRC FIB
136 * @param[in] src_prefix Source IP prefix.
137 * @param[in] dst_fib_index The index/ID of the DST FIB
138 * @param[in] dst_prefix Destination IP prefix.
141 ip_src_dst_fib_del_route (u32 src_fib_index,
142 const ip_prefix_t * src_prefix,
143 u32 dst_fib_index, const ip_prefix_t * dst_prefix)
145 fib_prefix_t dst_fib_prefix, src_fib_prefix;
149 ASSERT (NULL != dst_prefix);
150 ASSERT (NULL != src_prefix);
152 ip_prefix_to_fib_prefix (dst_prefix, &dst_fib_prefix);
153 ip_prefix_to_fib_prefix (src_prefix, &src_fib_prefix);
155 fib_table_entry_delete (src_fib_index, &src_fib_prefix, FIB_SOURCE_LISP);
157 /* check if only default left or empty */
158 fib_prefix_t default_pref = {
159 .fp_proto = dst_fib_prefix.fp_proto
162 if (fib_table_lookup_exact_match (src_fib_index,
163 &default_pref) != FIB_NODE_INDEX_INVALID)
166 n_entries = fib_table_get_num_entries (src_fib_index,
167 src_fib_prefix.fp_proto,
169 if (n_entries == 0 || (have_default && n_entries == 1))
172 * remove src FIB default route
175 fib_table_entry_special_remove (src_fib_index, &default_pref,
179 * there's nothing left now, unlock the source FIB and the
182 fib_table_entry_special_remove (dst_fib_index,
183 &dst_fib_prefix, FIB_SOURCE_LISP);
184 fib_table_unlock (src_fib_index, src_fib_prefix.fp_proto,
190 * @brief Add route to IP4 or IP6 SRC FIB.
192 * Adds a route to in the LISP SRC FIB with the result of the route
193 * being the DPO passed.
195 * @param[in] src_fib_index The index/ID of the SRC FIB
196 * @param[in] src_prefix Source IP prefix.
197 * @param[in] src_dpo The DPO the route will link to.
199 * @return fib index of the inserted prefix
201 static fib_node_index_t
202 ip_src_fib_add_route_w_dpo (u32 src_fib_index,
203 const ip_prefix_t * src_prefix,
204 const dpo_id_t * src_dpo)
206 fib_node_index_t fei = ~0;
207 fib_prefix_t src_fib_prefix;
209 ip_prefix_to_fib_prefix (src_prefix, &src_fib_prefix);
212 * add the entry into the source fib.
214 fib_node_index_t src_fei;
216 src_fei = fib_table_lookup_exact_match (src_fib_index, &src_fib_prefix);
218 if (FIB_NODE_INDEX_INVALID == src_fei ||
219 !fib_entry_is_sourced (src_fei, FIB_SOURCE_LISP))
221 fei = fib_table_entry_special_dpo_add (src_fib_index,
224 FIB_ENTRY_FLAG_EXCLUSIVE,
230 static fib_route_path_t *
231 lisp_gpe_mk_fib_paths (const lisp_fwd_path_t * paths)
233 const lisp_gpe_adjacency_t *ladj;
234 fib_route_path_t *rpaths = NULL;
239 vec_validate (rpaths, vec_len (paths) - 1);
241 best_priority = paths[0].priority;
243 vec_foreach_index (ii, paths)
245 if (paths[0].priority != best_priority)
248 ladj = lisp_gpe_adjacency_get (paths[ii].lisp_adj);
250 fp = ip_address_to_46 (&ladj->remote_rloc, &rpaths[ii].frp_addr);
252 rpaths[ii].frp_proto = fib_proto_to_dpo (fp);
253 rpaths[ii].frp_sw_if_index = ladj->sw_if_index;
254 rpaths[ii].frp_weight = (paths[ii].weight ? paths[ii].weight : 1);
257 ASSERT (0 != vec_len (rpaths));
263 * @brief Add route to IP4 or IP6 SRC FIB.
265 * Adds a route to in the LISP SRC FIB for the tunnel.
267 * @param[in] src_fib_index The index/ID of the SRC FIB
268 * @param[in] src_prefix Source IP prefix.
269 * @param[in] paths The paths from which to construct the
272 static fib_node_index_t
273 ip_src_fib_add_route (u32 src_fib_index,
274 const ip_prefix_t * src_prefix,
275 const lisp_fwd_path_t * paths)
277 fib_prefix_t src_fib_prefix;
278 fib_route_path_t *rpaths;
280 ip_prefix_to_fib_prefix (src_prefix, &src_fib_prefix);
282 rpaths = lisp_gpe_mk_fib_paths (paths);
284 fib_node_index_t fib_entry_index =
285 fib_table_entry_update (src_fib_index, &src_fib_prefix, FIB_SOURCE_LISP,
286 FIB_ENTRY_FLAG_NONE, rpaths);
288 return fib_entry_index;
292 gpe_native_fwd_add_del_lfe (lisp_gpe_fwd_entry_t * lfe, u8 is_add)
294 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
295 u8 found = 0, ip_version;
297 ip_version = ip_prefix_version (&lfe->key->rmt.ippref);
299 new_lfei = lfe - lgm->lisp_fwd_entry_pool;
300 vec_foreach (lfei, lgm->native_fwd_lfes[ip_version])
302 lfe = pool_elt_at_index (lgm->lisp_fwd_entry_pool, lfei[0]);
303 if (lfei[0] == new_lfei)
313 vec_add1 (lgm->native_fwd_lfes[ip_version], new_lfei);
318 vec_del1 (lgm->native_fwd_lfes[ip_version], lfei[0]);
323 create_fib_entries (lisp_gpe_fwd_entry_t * lfe)
327 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
330 fib_prefix_t fib_prefix;
331 u8 ip_version = ip_prefix_version (&lfe->key->rmt.ippref);
332 dproto = (ip_version == AF_IP4 ? DPO_PROTO_IP4 : DPO_PROTO_IP6);
336 lfe->src_fib_index = ip_dst_fib_add_route (lfe->eid_fib_index,
337 &lfe->key->rmt.ippref);
338 memcpy (&ippref, &lfe->key->lcl.ippref, sizeof (ippref));
342 lfe->src_fib_index = lfe->eid_fib_index;
343 memcpy (&ippref, &lfe->key->rmt.ippref, sizeof (ippref));
346 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE == lfe->type)
348 dpo_id_t dpo = DPO_INVALID;
352 case LISP_FORWARD_NATIVE:
353 /* TODO handle route overlaps with fib and default route */
354 if (vec_len (lgm->native_fwd_rpath[ip_version]))
356 ip_prefix_to_fib_prefix (&lfe->key->rmt.ippref, &fib_prefix);
357 fi = fib_table_entry_update (lfe->eid_fib_index, &fib_prefix,
360 lgm->native_fwd_rpath[ip_version]);
361 gpe_native_fwd_add_del_lfe (lfe, 1);
365 /* TODO update timers? */
366 case LISP_SEND_MAP_REQUEST:
367 /* insert tunnel that always sends map-request */
368 dpo_copy (&dpo, lisp_cp_dpo_get (dproto));
371 /* for drop fwd entries, just add route, no need to add encap tunnel */
372 dpo_copy (&dpo, drop_dpo_get (dproto));
375 fi = ip_src_fib_add_route_w_dpo (lfe->src_fib_index, &ippref, &dpo);
380 fi = ip_src_fib_add_route (lfe->src_fib_index, &ippref, lfe->paths);
383 fe = fib_entry_get (fi);
384 return fe->fe_lb.dpoi_index;
388 delete_fib_entries (lisp_gpe_fwd_entry_t * lfe)
390 fib_prefix_t dst_fib_prefix;
393 ip_src_dst_fib_del_route (lfe->src_fib_index,
394 &lfe->key->lcl.ippref,
395 lfe->eid_fib_index, &lfe->key->rmt.ippref);
398 ip_prefix_to_fib_prefix (&lfe->key->rmt.ippref, &dst_fib_prefix);
399 fib_table_entry_delete (lfe->src_fib_index, &dst_fib_prefix,
401 gpe_native_fwd_add_del_lfe (lfe, 0);
405 static lisp_gpe_fwd_entry_t *
406 find_fwd_entry (lisp_gpe_main_t * lgm,
407 vnet_lisp_gpe_add_del_fwd_entry_args_t * a,
408 lisp_gpe_fwd_entry_key_t * key)
412 clib_memset (key, 0, sizeof (*key));
414 if (GID_ADDR_IP_PREFIX == gid_address_type (&a->rmt_eid))
417 * the ip version of the source is not set to ip6 when the
418 * source is all zeros. force it.
420 ip_prefix_version (&gid_address_ippref (&a->lcl_eid)) =
421 ip_prefix_version (&gid_address_ippref (&a->rmt_eid));
424 gid_to_dp_address (&a->rmt_eid, &key->rmt);
425 gid_to_dp_address (&a->lcl_eid, &key->lcl);
428 p = hash_get_mem (lgm->lisp_gpe_fwd_entries, key);
432 return (pool_elt_at_index (lgm->lisp_fwd_entry_pool, p[0]));
438 lisp_gpe_fwd_entry_path_sort (void *a1, void *a2)
440 lisp_fwd_path_t *p1 = a1, *p2 = a2;
442 return (p1->priority - p2->priority);
446 lisp_gpe_fwd_entry_mk_paths (lisp_gpe_fwd_entry_t * lfe,
447 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
449 lisp_fwd_path_t *path;
452 vec_validate (lfe->paths, vec_len (a->locator_pairs) - 1);
454 vec_foreach_index (index, a->locator_pairs)
456 path = &lfe->paths[index];
458 path->priority = a->locator_pairs[index].priority;
459 path->weight = a->locator_pairs[index].weight;
462 lisp_gpe_adjacency_find_or_create_and_lock (&a->locator_pairs
464 a->dp_table, lfe->key->vni);
466 vec_sort_with_function (lfe->paths, lisp_gpe_fwd_entry_path_sort);
470 vnet_lisp_gpe_add_fwd_counters (vnet_lisp_gpe_add_del_fwd_entry_args_t * a,
473 const lisp_gpe_adjacency_t *ladj;
474 lisp_fwd_path_t *path;
475 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
477 lisp_gpe_fwd_entry_t *lfe;
478 lisp_gpe_fwd_entry_key_t fe_key;
479 lisp_stats_key_t key;
481 lfe = find_fwd_entry (lgm, a, &fe_key);
486 if (LISP_GPE_FWD_ENTRY_TYPE_NORMAL != lfe->type)
489 clib_memset (&key, 0, sizeof (key));
490 key.fwd_entry_index = fwd_entry_index;
492 vec_foreach (path, lfe->paths)
494 ladj = lisp_gpe_adjacency_get (path->lisp_adj);
495 key.tunnel_index = ladj->tunnel_index;
496 lisp_stats_key_t *key_copy = clib_mem_alloc (sizeof (*key_copy));
497 memcpy (key_copy, &key, sizeof (*key_copy));
498 pool_get (lgm->placeholder_stats_pool, placeholder_elt);
499 hash_set_mem (lgm->lisp_stats_index_by_key, key_copy,
500 placeholder_elt - lgm->placeholder_stats_pool);
502 vlib_validate_combined_counter (&lgm->counters,
504 lgm->placeholder_stats_pool);
505 vlib_zero_combined_counter (&lgm->counters,
507 lgm->placeholder_stats_pool);
512 * @brief Add/Delete LISP IP forwarding entry.
514 * creation of forwarding entries for IP LISP overlay:
516 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
517 * @param[in] a Parameters for building the forwarding entry.
519 * @return 0 on success.
522 add_ip_fwd_entry (lisp_gpe_main_t * lgm,
523 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
525 lisp_gpe_fwd_entry_key_t key;
526 lisp_gpe_fwd_entry_t *lfe;
527 fib_protocol_t fproto;
529 lfe = find_fwd_entry (lgm, a, &key);
532 /* don't support updates */
533 return VNET_API_ERROR_INVALID_VALUE;
535 pool_get (lgm->lisp_fwd_entry_pool, lfe);
536 clib_memset (lfe, 0, sizeof (*lfe));
537 lfe->key = clib_mem_alloc (sizeof (key));
538 memcpy (lfe->key, &key, sizeof (key));
540 hash_set_mem (lgm->lisp_gpe_fwd_entries, lfe->key,
541 lfe - lgm->lisp_fwd_entry_pool);
542 a->fwd_entry_index = lfe - lgm->lisp_fwd_entry_pool;
544 fproto = (AF_IP4 == ip_prefix_version (&fid_addr_ippref (&lfe->key->rmt)) ?
545 FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6);
547 lfe->type = (a->is_negative ?
548 LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE :
549 LISP_GPE_FWD_ENTRY_TYPE_NORMAL);
550 lfe->tenant = lisp_gpe_tenant_find_or_create (lfe->key->vni);
551 lfe->eid_table_id = a->table_id;
552 lfe->eid_fib_index = fib_table_find_or_create_and_lock (fproto,
555 lfe->is_src_dst = a->is_src_dst;
557 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
559 lisp_gpe_fwd_entry_mk_paths (lfe, a);
563 lfe->action = a->action;
566 lfe->dpoi_index = create_fib_entries (lfe);
571 del_ip_fwd_entry_i (lisp_gpe_main_t * lgm, lisp_gpe_fwd_entry_t * lfe)
573 lisp_fwd_path_t *path;
574 fib_protocol_t fproto;
576 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
578 vec_foreach (path, lfe->paths)
580 lisp_gpe_adjacency_unlock (path->lisp_adj);
584 delete_fib_entries (lfe);
586 fproto = (AF_IP4 == ip_prefix_version (&fid_addr_ippref (&lfe->key->rmt)) ?
587 FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6);
588 fib_table_unlock (lfe->eid_fib_index, fproto, FIB_SOURCE_LISP);
590 hash_unset_mem (lgm->lisp_gpe_fwd_entries, lfe->key);
591 clib_mem_free (lfe->key);
592 pool_put (lgm->lisp_fwd_entry_pool, lfe);
596 * @brief Add/Delete LISP IP forwarding entry.
598 * removal of forwarding entries for IP LISP overlay:
600 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
601 * @param[in] a Parameters for building the forwarding entry.
603 * @return 0 on success.
606 del_ip_fwd_entry (lisp_gpe_main_t * lgm,
607 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
609 lisp_gpe_fwd_entry_key_t key;
610 lisp_gpe_fwd_entry_t *lfe;
612 lfe = find_fwd_entry (lgm, a, &key);
616 return VNET_API_ERROR_INVALID_VALUE;
618 del_ip_fwd_entry_i (lgm, lfe);
624 make_mac_fib_key (BVT (clib_bihash_kv) * kv, u16 bd_index, u8 src_mac[6],
627 kv->key[0] = (((u64) bd_index) << 48) | mac_to_u64 (dst_mac);
628 kv->key[1] = mac_to_u64 (src_mac);
633 * @brief Lookup L2 SD FIB entry
635 * Does a vni + dest + source lookup in the L2 LISP FIB. If the lookup fails
636 * it tries a second time with source set to 0 (i.e., a simple dest lookup).
638 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
639 * @param[in] bd_index Bridge domain index.
640 * @param[in] src_mac Source mac address.
641 * @param[in] dst_mac Destination mac address.
643 * @return index of mapping matching the lookup key.
646 lisp_l2_fib_lookup (lisp_gpe_main_t * lgm, u16 bd_index, u8 src_mac[6],
650 BVT (clib_bihash_kv) kv, value;
652 make_mac_fib_key (&kv, bd_index, src_mac, dst_mac);
653 rv = BV (clib_bihash_search_inline_2) (&lgm->l2_fib, &kv, &value);
655 /* no match, try with src 0, catch all for dst */
659 rv = BV (clib_bihash_search_inline_2) (&lgm->l2_fib, &kv, &value);
666 return lisp_gpe_main.l2_lb_cp_lkup.dpoi_index;
670 * @brief Add/del L2 SD FIB entry
672 * Inserts value in L2 FIB keyed by vni + dest + source. If entry is
673 * overwritten the associated value is returned.
675 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
676 * @param[in] bd_index Bridge domain index.
677 * @param[in] src_mac Source mac address.
678 * @param[in] dst_mac Destination mac address.
679 * @param[in] val Value to add.
680 * @param[in] is_add Add/del flag.
682 * @return ~0 or value of overwritten entry.
685 lisp_l2_fib_add_del_entry (u16 bd_index, u8 src_mac[6],
686 u8 dst_mac[6], const dpo_id_t * dpo, u8 is_add)
688 lisp_gpe_main_t *lgm = &lisp_gpe_main;
689 BVT (clib_bihash_kv) kv, value;
692 make_mac_fib_key (&kv, bd_index, src_mac, dst_mac);
694 if (BV (clib_bihash_search) (&lgm->l2_fib, &kv, &value) == 0)
695 old_val = value.value;
698 BV (clib_bihash_add_del) (&lgm->l2_fib, &kv, 0 /* is_add */ );
701 kv.value = dpo->dpoi_index;
702 BV (clib_bihash_add_del) (&lgm->l2_fib, &kv, 1 /* is_add */ );
707 #define L2_FIB_DEFAULT_HASH_NUM_BUCKETS (64 * 1024)
708 #define L2_FIB_DEFAULT_HASH_MEMORY_SIZE (32<<20)
711 l2_fib_init (lisp_gpe_main_t * lgm)
715 BV (clib_bihash_init) (&lgm->l2_fib, "l2 fib",
716 1 << max_log2 (L2_FIB_DEFAULT_HASH_NUM_BUCKETS),
717 L2_FIB_DEFAULT_HASH_MEMORY_SIZE);
720 * the result from a 'miss' in a L2 Table
722 lbi = load_balance_create (1, DPO_PROTO_ETHERNET, 0);
723 load_balance_set_bucket (lbi, 0, lisp_cp_dpo_get (DPO_PROTO_ETHERNET));
725 dpo_set (&lgm->l2_lb_cp_lkup, DPO_LOAD_BALANCE, DPO_PROTO_ETHERNET, lbi);
729 del_l2_fwd_entry_i (lisp_gpe_main_t * lgm, lisp_gpe_fwd_entry_t * lfe)
731 lisp_fwd_path_t *path;
733 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
735 vec_foreach (path, lfe->paths)
737 lisp_gpe_adjacency_unlock (path->lisp_adj);
739 fib_path_list_child_remove (lfe->l2.path_list_index,
740 lfe->l2.child_index);
743 lisp_l2_fib_add_del_entry (lfe->l2.eid_bd_index,
744 fid_addr_mac (&lfe->key->lcl),
745 fid_addr_mac (&lfe->key->rmt), NULL, 0);
747 hash_unset_mem (lgm->lisp_gpe_fwd_entries, lfe->key);
748 clib_mem_free (lfe->key);
749 pool_put (lgm->lisp_fwd_entry_pool, lfe);
753 * @brief Delete LISP L2 forwarding entry.
755 * Coordinates the removal of forwarding entries for L2 LISP overlay:
757 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
758 * @param[in] a Parameters for building the forwarding entry.
760 * @return 0 on success.
763 del_l2_fwd_entry (lisp_gpe_main_t * lgm,
764 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
766 lisp_gpe_fwd_entry_key_t key;
767 lisp_gpe_fwd_entry_t *lfe;
769 lfe = find_fwd_entry (lgm, a, &key);
772 return VNET_API_ERROR_INVALID_VALUE;
774 del_l2_fwd_entry_i (lgm, lfe);
780 * @brief Construct and insert the forwarding information used by an L2 entry
783 lisp_gpe_l2_update_fwding (lisp_gpe_fwd_entry_t * lfe)
785 lisp_gpe_main_t *lgm = &lisp_gpe_main;
786 dpo_id_t dpo = DPO_INVALID;
788 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
790 fib_path_list_contribute_forwarding (lfe->l2.path_list_index,
791 FIB_FORW_CHAIN_TYPE_ETHERNET,
792 FIB_PATH_LIST_FWD_FLAG_NONE,
794 dpo_copy (&dpo, &lfe->l2.dpo);
800 case SEND_MAP_REQUEST:
801 dpo_copy (&dpo, &lgm->l2_lb_cp_lkup);
806 dpo_copy (&dpo, drop_dpo_get (DPO_PROTO_ETHERNET));
810 /* add entry to l2 lisp fib */
811 lisp_l2_fib_add_del_entry (lfe->l2.eid_bd_index,
812 fid_addr_mac (&lfe->key->lcl),
813 fid_addr_mac (&lfe->key->rmt), &dpo, 1);
814 lfe->dpoi_index = dpo.dpoi_index;
820 * @brief Add LISP L2 forwarding entry.
822 * Coordinates the creation of forwarding entries for L2 LISP overlay:
823 * creates lisp-gpe tunnel and injects new entry in Source/Dest L2 FIB.
825 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
826 * @param[in] a Parameters for building the forwarding entry.
828 * @return 0 on success.
831 add_l2_fwd_entry (lisp_gpe_main_t * lgm,
832 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
834 lisp_gpe_fwd_entry_key_t key;
835 bd_main_t *bdm = &bd_main;
836 lisp_gpe_fwd_entry_t *lfe;
839 bd_indexp = hash_get (bdm->bd_index_by_bd_id, a->bd_id);
842 clib_warning ("bridge domain %d doesn't exist", a->bd_id);
846 lfe = find_fwd_entry (lgm, a, &key);
849 /* don't support updates */
850 return VNET_API_ERROR_INVALID_VALUE;
852 pool_get (lgm->lisp_fwd_entry_pool, lfe);
853 clib_memset (lfe, 0, sizeof (*lfe));
854 lfe->key = clib_mem_alloc (sizeof (key));
855 memcpy (lfe->key, &key, sizeof (key));
857 hash_set_mem (lgm->lisp_gpe_fwd_entries, lfe->key,
858 lfe - lgm->lisp_fwd_entry_pool);
859 a->fwd_entry_index = lfe - lgm->lisp_fwd_entry_pool;
861 lfe->type = (a->is_negative ?
862 LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE :
863 LISP_GPE_FWD_ENTRY_TYPE_NORMAL);
864 lfe->l2.eid_bd_id = a->bd_id;
865 lfe->l2.eid_bd_index = bd_indexp[0];
866 lfe->tenant = lisp_gpe_tenant_find_or_create (lfe->key->vni);
868 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
870 fib_route_path_t *rpaths;
873 * Make the sorted array of LISP paths with their resp. adjacency
875 lisp_gpe_fwd_entry_mk_paths (lfe, a);
878 * From the LISP paths, construct a FIB path list that will
879 * contribute a load-balance.
881 rpaths = lisp_gpe_mk_fib_paths (lfe->paths);
883 lfe->l2.path_list_index =
884 fib_path_list_create (FIB_PATH_LIST_FLAG_NONE, rpaths);
887 * become a child of the path-list so we receive updates when
888 * its forwarding state changes. this includes an implicit lock.
890 lfe->l2.child_index =
891 fib_path_list_child_add (lfe->l2.path_list_index,
892 FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY,
893 lfe - lgm->lisp_fwd_entry_pool);
897 lfe->action = a->action;
900 lisp_gpe_l2_update_fwding (lfe);
906 * @brief Lookup NSH SD FIB entry
908 * Does an SPI+SI lookup in the NSH LISP FIB.
910 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
911 * @param[in] spi_si SPI + SI.
913 * @return next node index.
916 lisp_nsh_fib_lookup (lisp_gpe_main_t * lgm, u32 spi_si_net_order)
919 BVT (clib_bihash_kv) kv, value;
921 clib_memset (&kv, 0, sizeof (kv));
922 kv.key[0] = spi_si_net_order;
923 rv = BV (clib_bihash_search_inline_2) (&lgm->nsh_fib, &kv, &value);
927 return lgm->nsh_cp_lkup;
931 lisp_gpe_fwd_entry_t *lfe;
932 lfe = pool_elt_at_index (lgm->lisp_fwd_entry_pool, value.value);
933 return &lfe->nsh.choice;
938 * @brief Add/del NSH FIB entry
940 * Inserts value in NSH FIB keyed by SPI+SI. If entry is
941 * overwritten the associated value is returned.
943 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
944 * @param[in] spi_si SPI + SI.
945 * @param[in] dpo Load balanced mapped to SPI + SI
947 * @return ~0 or value of overwritten entry.
950 lisp_nsh_fib_add_del_entry (u32 spi_si_host_order, u32 lfei, u8 is_add)
952 lisp_gpe_main_t *lgm = &lisp_gpe_main;
953 BVT (clib_bihash_kv) kv, value;
956 clib_memset (&kv, 0, sizeof (kv));
957 kv.key[0] = clib_host_to_net_u32 (spi_si_host_order);
960 if (BV (clib_bihash_search) (&lgm->nsh_fib, &kv, &value) == 0)
961 old_val = value.value;
964 BV (clib_bihash_add_del) (&lgm->nsh_fib, &kv, 0 /* is_add */ );
968 BV (clib_bihash_add_del) (&lgm->nsh_fib, &kv, 1 /* is_add */ );
973 #define NSH_FIB_DEFAULT_HASH_NUM_BUCKETS (64 * 1024)
974 #define NSH_FIB_DEFAULT_HASH_MEMORY_SIZE (32<<20)
977 nsh_fib_init (lisp_gpe_main_t * lgm)
979 BV (clib_bihash_init) (&lgm->nsh_fib, "nsh fib",
980 1 << max_log2 (NSH_FIB_DEFAULT_HASH_NUM_BUCKETS),
981 NSH_FIB_DEFAULT_HASH_MEMORY_SIZE);
984 * the result from a 'miss' in a NSH Table
986 lgm->nsh_cp_lkup = lisp_cp_dpo_get (DPO_PROTO_NSH);
990 del_nsh_fwd_entry_i (lisp_gpe_main_t * lgm, lisp_gpe_fwd_entry_t * lfe)
992 lisp_fwd_path_t *path;
994 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
996 vec_foreach (path, lfe->paths)
998 lisp_gpe_adjacency_unlock (path->lisp_adj);
1000 fib_path_list_child_remove (lfe->nsh.path_list_index,
1001 lfe->nsh.child_index);
1002 dpo_reset (&lfe->nsh.choice);
1005 lisp_nsh_fib_add_del_entry (fid_addr_nsh (&lfe->key->rmt), (u32) ~ 0, 0);
1007 hash_unset_mem (lgm->lisp_gpe_fwd_entries, lfe->key);
1008 clib_mem_free (lfe->key);
1009 pool_put (lgm->lisp_fwd_entry_pool, lfe);
1013 * @brief Delete LISP NSH forwarding entry.
1015 * Coordinates the removal of forwarding entries for NSH LISP overlay:
1017 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
1018 * @param[in] a Parameters for building the forwarding entry.
1020 * @return 0 on success.
1023 del_nsh_fwd_entry (lisp_gpe_main_t * lgm,
1024 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
1026 lisp_gpe_fwd_entry_key_t key;
1027 lisp_gpe_fwd_entry_t *lfe;
1029 lfe = find_fwd_entry (lgm, a, &key);
1032 return VNET_API_ERROR_INVALID_VALUE;
1034 del_nsh_fwd_entry_i (lgm, lfe);
1040 * @brief Construct and insert the forwarding information used by an NSH entry
1043 lisp_gpe_nsh_update_fwding (lisp_gpe_fwd_entry_t * lfe)
1045 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
1046 dpo_id_t dpo = DPO_INVALID;
1047 vnet_hw_interface_t *hi;
1050 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
1052 fib_path_list_contribute_forwarding (lfe->nsh.path_list_index,
1053 FIB_FORW_CHAIN_TYPE_NSH,
1054 FIB_PATH_LIST_FWD_FLAG_NONE,
1058 * LISP encap is always the same for this SPI+SI so we do that hash now
1059 * and stack on the choice.
1061 if (DPO_LOAD_BALANCE == lfe->nsh.dpo.dpoi_type)
1063 const dpo_id_t *tmp;
1064 const load_balance_t *lb;
1067 lb = load_balance_get (lfe->nsh.dpo.dpoi_index);
1068 hash = fid_addr_nsh (&lfe->key->rmt) % lb->lb_n_buckets;
1070 load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1);
1072 dpo_copy (&dpo, tmp);
1077 switch (lfe->action)
1079 case SEND_MAP_REQUEST:
1080 dpo_copy (&dpo, lgm->nsh_cp_lkup);
1083 case FORWARD_NATIVE:
1085 dpo_copy (&dpo, drop_dpo_get (DPO_PROTO_NSH));
1089 /* We have only one nsh-lisp interface (no NSH virtualization) */
1090 hip = hash_get (lgm->nsh_ifaces.hw_if_index_by_dp_table, 0);
1093 hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
1094 dpo_stack_from_node (hi->tx_node_index, &lfe->nsh.choice, &dpo);
1096 /* add entry to nsh lisp fib */
1097 lisp_nsh_fib_add_del_entry (fid_addr_nsh (&lfe->key->rmt),
1098 lfe - lgm->lisp_fwd_entry_pool, 1);
1104 * @brief Add LISP NSH forwarding entry.
1106 * Coordinates the creation of forwarding entries for L2 LISP overlay:
1107 * creates lisp-gpe tunnel and injects new entry in Source/Dest L2 FIB.
1109 * @param[in] lgm Reference to @ref lisp_gpe_main_t.
1110 * @param[in] a Parameters for building the forwarding entry.
1112 * @return 0 on success.
1115 add_nsh_fwd_entry (lisp_gpe_main_t * lgm,
1116 vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
1118 lisp_gpe_fwd_entry_key_t key;
1119 lisp_gpe_fwd_entry_t *lfe;
1121 lfe = find_fwd_entry (lgm, a, &key);
1124 /* don't support updates */
1125 return VNET_API_ERROR_INVALID_VALUE;
1127 pool_get (lgm->lisp_fwd_entry_pool, lfe);
1128 clib_memset (lfe, 0, sizeof (*lfe));
1129 lfe->key = clib_mem_alloc (sizeof (key));
1130 memcpy (lfe->key, &key, sizeof (key));
1132 hash_set_mem (lgm->lisp_gpe_fwd_entries, lfe->key,
1133 lfe - lgm->lisp_fwd_entry_pool);
1134 a->fwd_entry_index = lfe - lgm->lisp_fwd_entry_pool;
1136 lfe->type = (a->is_negative ?
1137 LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE :
1138 LISP_GPE_FWD_ENTRY_TYPE_NORMAL);
1141 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE != lfe->type)
1143 fib_route_path_t *rpaths;
1146 * Make the sorted array of LISP paths with their resp. adjacency
1148 lisp_gpe_fwd_entry_mk_paths (lfe, a);
1151 * From the LISP paths, construct a FIB path list that will
1152 * contribute a load-balance.
1154 rpaths = lisp_gpe_mk_fib_paths (lfe->paths);
1156 lfe->nsh.path_list_index =
1157 fib_path_list_create (FIB_PATH_LIST_FLAG_NONE, rpaths);
1160 * become a child of the path-list so we receive updates when
1161 * its forwarding state changes. this includes an implicit lock.
1163 lfe->nsh.child_index =
1164 fib_path_list_child_add (lfe->nsh.path_list_index,
1165 FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY,
1166 lfe - lgm->lisp_fwd_entry_pool);
1170 lfe->action = a->action;
1173 lisp_gpe_nsh_update_fwding (lfe);
1179 * @brief conver from the embedded fib_node_t struct to the LSIP entry
1181 static lisp_gpe_fwd_entry_t *
1182 lisp_gpe_fwd_entry_from_fib_node (fib_node_t * node)
1184 return ((lisp_gpe_fwd_entry_t *) (((char *) node) -
1185 STRUCT_OFFSET_OF (lisp_gpe_fwd_entry_t,
1190 * @brief Function invoked during a backwalk of the FIB graph
1192 static fib_node_back_walk_rc_t
1193 lisp_gpe_fib_node_back_walk (fib_node_t * node,
1194 fib_node_back_walk_ctx_t * ctx)
1196 lisp_gpe_fwd_entry_t *lfe = lisp_gpe_fwd_entry_from_fib_node (node);
1198 if (fid_addr_type (&lfe->key->rmt) == FID_ADDR_MAC)
1199 lisp_gpe_l2_update_fwding (lfe);
1200 else if (fid_addr_type (&lfe->key->rmt) == FID_ADDR_NSH)
1201 lisp_gpe_nsh_update_fwding (lfe);
1203 return (FIB_NODE_BACK_WALK_CONTINUE);
1207 * @brief Get a fib_node_t struct from the index of a LISP fwd entry
1210 lisp_gpe_fwd_entry_get_fib_node (fib_node_index_t index)
1212 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1213 lisp_gpe_fwd_entry_t *lfe;
1215 lfe = pool_elt_at_index (lgm->lisp_fwd_entry_pool, index);
1217 return (&(lfe->node));
1221 * @brief An indication from the graph that the last lock has gone
1224 lisp_gpe_fwd_entry_fib_node_last_lock_gone (fib_node_t * node)
1226 /* We don't manage the locks of the LISP objects via the graph, since
1227 * this object has no children. so this is a no-op. */
1231 * @brief Virtual function table to register with FIB for the LISP type
1233 const static fib_node_vft_t lisp_fwd_vft = {
1234 .fnv_get = lisp_gpe_fwd_entry_get_fib_node,
1235 .fnv_last_lock = lisp_gpe_fwd_entry_fib_node_last_lock_gone,
1236 .fnv_back_walk = lisp_gpe_fib_node_back_walk,
1240 * @brief Forwarding entry create/remove dispatcher.
1242 * Calls l2 or l3 forwarding entry add/del function based on input data.
1244 * @param[in] a Forwarding entry parameters.
1245 * @param[out] hw_if_indexp NOT USED
1247 * @return 0 on success.
1250 vnet_lisp_gpe_add_del_fwd_entry (vnet_lisp_gpe_add_del_fwd_entry_args_t * a,
1253 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1256 if (vnet_lisp_gpe_enable_disable_status () == 0)
1258 clib_warning ("LISP is disabled!");
1259 return VNET_API_ERROR_LISP_DISABLED;
1262 type = gid_address_type (&a->rmt_eid);
1265 case GID_ADDR_IP_PREFIX:
1267 return add_ip_fwd_entry (lgm, a);
1269 return del_ip_fwd_entry (lgm, a);
1273 return add_l2_fwd_entry (lgm, a);
1275 return del_l2_fwd_entry (lgm, a);
1278 return add_nsh_fwd_entry (lgm, a);
1280 return del_nsh_fwd_entry (lgm, a);
1282 clib_warning ("Forwarding entries for type %d not supported!", type);
1288 vnet_lisp_flush_stats (void)
1290 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
1291 vlib_combined_counter_main_t *cm = &lgm->counters;
1294 if (cm->counters == NULL)
1297 for (i = 0; i < vlib_combined_counter_n_counters (cm); i++)
1298 vlib_zero_combined_counter (cm, i);
1304 lisp_del_adj_stats (lisp_gpe_main_t * lgm, u32 fwd_entry_index, u32 ti)
1307 lisp_stats_key_t key;
1312 clib_memset (&key, 0, sizeof (key));
1313 key.fwd_entry_index = fwd_entry_index;
1314 key.tunnel_index = ti;
1316 p = hash_get_mem (lgm->lisp_stats_index_by_key, &key);
1319 s = pool_elt_at_index (lgm->placeholder_stats_pool, p[0]);
1320 hp = hash_get_pair (lgm->lisp_stats_index_by_key, &key);
1321 key_copy = (void *) (hp->key);
1322 hash_unset_mem (lgm->lisp_stats_index_by_key, &key);
1323 clib_mem_free (key_copy);
1324 pool_put (lgm->placeholder_stats_pool, s);
1329 vnet_lisp_gpe_del_fwd_counters (vnet_lisp_gpe_add_del_fwd_entry_args_t * a,
1330 u32 fwd_entry_index)
1332 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1333 lisp_gpe_fwd_entry_key_t fe_key;
1334 lisp_gpe_fwd_entry_t *lfe;
1335 lisp_fwd_path_t *path;
1336 const lisp_gpe_adjacency_t *ladj;
1338 lfe = find_fwd_entry (lgm, a, &fe_key);
1342 if (LISP_GPE_FWD_ENTRY_TYPE_NORMAL != lfe->type)
1345 vec_foreach (path, lfe->paths)
1347 ladj = lisp_gpe_adjacency_get (path->lisp_adj);
1348 lisp_del_adj_stats (lgm, fwd_entry_index, ladj->tunnel_index);
1353 * @brief Flush all the forwrding entries
1356 vnet_lisp_gpe_fwd_entry_flush (void)
1358 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1359 lisp_gpe_fwd_entry_t *lfe;
1362 pool_foreach (lfe, lgm->lisp_fwd_entry_pool,
1364 switch (fid_addr_type(&lfe->key->rmt))
1367 del_l2_fwd_entry_i (lgm, lfe);
1369 case FID_ADDR_IP_PREF:
1370 del_ip_fwd_entry_i (lgm, lfe);
1373 del_nsh_fwd_entry_i (lgm, lfe);
1381 format_lisp_fwd_path (u8 * s, va_list * ap)
1383 lisp_fwd_path_t *lfp = va_arg (*ap, lisp_fwd_path_t *);
1385 s = format (s, "weight:%d ", lfp->weight);
1386 s = format (s, "adj:[%U]\n",
1387 format_lisp_gpe_adjacency,
1388 lisp_gpe_adjacency_get (lfp->lisp_adj),
1389 LISP_GPE_ADJ_FORMAT_FLAG_NONE);
1394 typedef enum lisp_gpe_fwd_entry_format_flag_t_
1396 LISP_GPE_FWD_ENTRY_FORMAT_NONE = (0 << 0),
1397 LISP_GPE_FWD_ENTRY_FORMAT_DETAIL = (1 << 1),
1398 } lisp_gpe_fwd_entry_format_flag_t;
1402 format_lisp_gpe_fwd_entry (u8 * s, va_list * ap)
1404 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1405 lisp_gpe_fwd_entry_t *lfe = va_arg (*ap, lisp_gpe_fwd_entry_t *);
1406 lisp_gpe_fwd_entry_format_flag_t flags =
1407 va_arg (*ap, lisp_gpe_fwd_entry_format_flag_t);
1409 s = format (s, "VNI:%d VRF:%d EID: %U -> %U [index:%d]",
1410 lfe->key->vni, lfe->eid_table_id,
1411 format_fid_address, &lfe->key->lcl,
1412 format_fid_address, &lfe->key->rmt,
1413 lfe - lgm->lisp_fwd_entry_pool);
1415 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE == lfe->type)
1417 s = format (s, "\n Negative - action:%U",
1418 format_negative_mapping_action, lfe->action);
1422 lisp_fwd_path_t *path;
1424 s = format (s, "\n via:");
1425 vec_foreach (path, lfe->paths)
1427 s = format (s, "\n %U", format_lisp_fwd_path, path);
1431 if (flags & LISP_GPE_FWD_ENTRY_FORMAT_DETAIL)
1433 switch (fid_addr_type (&lfe->key->rmt))
1436 s = format (s, " fib-path-list:%d\n", lfe->l2.path_list_index);
1437 s = format (s, " dpo:%U\n", format_dpo_id, &lfe->l2.dpo, 0);
1440 s = format (s, " fib-path-list:%d\n", lfe->nsh.path_list_index);
1441 s = format (s, " dpo:%U\n", format_dpo_id, &lfe->nsh.dpo, 0);
1443 case FID_ADDR_IP_PREF:
1451 static clib_error_t *
1452 lisp_gpe_fwd_entry_show (vlib_main_t * vm,
1453 unformat_input_t * input, vlib_cli_command_t * cmd)
1455 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1456 lisp_gpe_fwd_entry_t *lfe;
1460 if (unformat (input, "vni %d", &vni))
1462 else if (unformat (input, "%d", &index))
1464 if (!pool_is_free_index (lgm->lisp_fwd_entry_pool, index))
1466 lfe = pool_elt_at_index (lgm->lisp_fwd_entry_pool, index);
1468 vlib_cli_output (vm, "[%d@] %U",
1470 format_lisp_gpe_fwd_entry, lfe,
1471 LISP_GPE_FWD_ENTRY_FORMAT_DETAIL);
1475 vlib_cli_output (vm, "entry %d invalid", index);
1482 pool_foreach (lfe, lgm->lisp_fwd_entry_pool,
1485 (lfe->key->vni == vni))
1486 vlib_cli_output (vm, "%U", format_lisp_gpe_fwd_entry, lfe,
1487 LISP_GPE_FWD_ENTRY_FORMAT_NONE);
1495 VLIB_CLI_COMMAND (lisp_gpe_fwd_entry_show_command, static) = {
1496 .path = "show gpe entry",
1497 .short_help = "show gpe entry vni <vni> vrf <vrf> [leid <leid>] reid <reid>",
1498 .function = lisp_gpe_fwd_entry_show,
1503 lisp_gpe_fwd_entry_init (vlib_main_t * vm)
1505 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1506 clib_error_t *error = NULL;
1508 if ((error = vlib_call_init_function (vm, lisp_cp_dpo_module_init)))
1514 fib_node_register_type (FIB_NODE_TYPE_LISP_GPE_FWD_ENTRY, &lisp_fwd_vft);
1520 vnet_lisp_gpe_get_fwd_entry_vnis (void)
1522 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
1523 lisp_gpe_fwd_entry_t *lfe;
1527 pool_foreach (lfe, lgm->lisp_fwd_entry_pool,
1529 hash_set (vnis, lfe->key->vni, 0);
1536 lisp_api_gpe_fwd_entry_t *
1537 vnet_lisp_gpe_fwd_entries_get_by_vni (u32 vni)
1539 lisp_gpe_main_t *lgm = &lisp_gpe_main;
1540 lisp_gpe_fwd_entry_t *lfe;
1541 lisp_api_gpe_fwd_entry_t *entries = 0, e;
1544 pool_foreach (lfe, lgm->lisp_fwd_entry_pool,
1546 if (lfe->key->vni == vni)
1548 clib_memset (&e, 0, sizeof (e));
1549 e.dp_table = lfe->eid_table_id;
1550 e.vni = lfe->key->vni;
1551 if (lfe->type == LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE)
1552 e.action = lfe->action;
1553 e.fwd_entry_index = lfe - lgm->lisp_fwd_entry_pool;
1554 memcpy (&e.reid, &lfe->key->rmt, sizeof (e.reid));
1555 memcpy (&e.leid, &lfe->key->lcl, sizeof (e.leid));
1556 vec_add1 (entries, e);
1565 vnet_lisp_gpe_get_fwd_stats (vnet_lisp_gpe_add_del_fwd_entry_args_t * a,
1568 lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
1569 lisp_gpe_fwd_entry_t *lfe;
1570 lisp_gpe_fwd_entry_key_t unused;
1572 lfe = find_fwd_entry (lgm, a, &unused);
1576 if (LISP_GPE_FWD_ENTRY_TYPE_NEGATIVE == lfe->type)
1579 if (~0 == lfe->dpoi_index)
1582 vlib_get_combined_counter (&load_balance_main.lbm_to_counters,
1583 lfe->dpoi_index, c);
1587 VLIB_INIT_FUNCTION (lisp_gpe_fwd_entry_init);
1590 * fd.io coding-style-patch-verification: ON
1593 * eval: (c-set-style "gnu")