src/vnet/lisp-gpe/lisp_gpe_adjacency.c

   1 /*
   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  * @file
  17  * @brief Common utility functions for IPv4, IPv6 and L2 LISP-GPE adjacencys.
  18  *
  19  */
  20
  21 #include <vnet/dpo/load_balance.h>
  22 #include <vnet/lisp-cp/control.h>
  23 #include <vnet/lisp-cp/lisp_types.h>
  24 #include <vnet/lisp-gpe/lisp_gpe_sub_interface.h>
  25 #include <vnet/lisp-gpe/lisp_gpe_adjacency.h>
  26 #include <vnet/lisp-gpe/lisp_gpe_tunnel.h>
  27 #include <vnet/fib/fib_entry.h>
  28 #include <vnet/adj/adj_midchain.h>
  29 #include <vppinfra/bihash_24_8.h>
  30 #include <vppinfra/bihash_template.h>
  31
  32 /**
  33  * Memory pool of all adjacencies
  34  */
  35 static lisp_gpe_adjacency_t *lisp_adj_pool;
  36
  37 /**
  38  * Hash table of all adjacencies. key:{nh, itf}
  39  * We never have an all zeros address since the interfaces are multi-access,
  40  * therefore there is no ambiguity between a v4 and v6 next-hop, so we don't
  41  * need to add the protocol to the key.
  42  */
  43 static
  44 BVT (clib_bihash)
  45   lisp_adj_db;
  46
  47 #define LISP_ADJ_SET_KEY(_key, _itf, _nh)       \
  48 {                                               \
  49   _key.key[0] = (_nh)->ip.v6.as_u64[0];         \
  50   _key.key[1] = (_nh)->ip.v6.as_u64[1];         \
  51   _key.key[2] = (_itf);                         \
  52 }
  53
  54      static index_t lisp_adj_find (const ip_address_t * addr, u32 sw_if_index)
  55 {
  56   BVT (clib_bihash_kv) kv;
  57
  58   LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
  59
  60   if (BV (clib_bihash_search) (&lisp_adj_db, &kv, &kv) < 0)
  61     {
  62       return (INDEX_INVALID);
  63     }
  64   else
  65     {
  66       return (kv.value);
  67     }
  68 }
  69
  70 static void
  71 lisp_adj_insert (const ip_address_t * addr, u32 sw_if_index, index_t ai)
  72 {
  73   BVT (clib_bihash_kv) kv;
  74
  75   LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
  76   kv.value = ai;
  77
  78   BV (clib_bihash_add_del) (&lisp_adj_db, &kv, 1);
  79 }
  80
  81 static void
  82 lisp_adj_remove (const ip_address_t * addr, u32 sw_if_index)
  83 {
  84   BVT (clib_bihash_kv) kv;
  85
  86   LISP_ADJ_SET_KEY (kv, sw_if_index, addr);
  87
  88   BV (clib_bihash_add_del) (&lisp_adj_db, &kv, 0);
  89 }
  90
  91 static lisp_gpe_adjacency_t *
  92 lisp_gpe_adjacency_get_i (index_t lai)
  93 {
  94   return (pool_elt_at_index (lisp_adj_pool, lai));
  95 }
  96
  97 fib_forward_chain_type_t
  98 lisp_gpe_adj_get_fib_chain_type (const lisp_gpe_adjacency_t * ladj)
  99 {
 100   switch (ip_addr_version (&ladj->remote_rloc))
 101     {
 102     case IP4:
 103       return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
 104     case IP6:
 105       return (FIB_FORW_CHAIN_TYPE_UNICAST_IP6);
 106     default:
 107       ASSERT (0);
 108       break;
 109     }
 110   return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
 111 }
 112
 113 static void
 114 ip46_address_to_ip_address (const ip46_address_t * a, ip_address_t * b)
 115 {
 116   if (ip46_address_is_ip4 (a))
 117     {
 118       memset (b, 0, sizeof (*b));
 119       ip_address_set (b, &a->ip4, IP4);
 120     }
 121   else
 122     {
 123       ip_address_set (b, &a->ip6, IP6);
 124     }
 125 }
 126
 127 /**
 128  * @brief Stack the tunnel's midchain on the IP forwarding chain of the via
 129  */
 130 static void
 131 lisp_gpe_adj_stack_one (lisp_gpe_adjacency_t * ladj, adj_index_t ai)
 132 {
 133   const lisp_gpe_tunnel_t *lgt;
 134   dpo_id_t tmp = DPO_INVALID;
 135
 136   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 137   fib_entry_contribute_forwarding (lgt->fib_entry_index,
 138                                    lisp_gpe_adj_get_fib_chain_type (ladj),
 139                                    &tmp);
 140
 141   if (DPO_LOAD_BALANCE == tmp.dpoi_type)
 142     {
 143       /*
 144        * post LISP rewrite we will load-balance. However, the LISP encap
 145        * is always the same for this adjacency/tunnel and hence the IP/UDP src,dst
 146        * hash is always the same result too. So we do that hash now and
 147        * stack on the choice.
 148        * If the choice is an incomplete adj then we will need a poke when
 149        * it becomes complete. This happens since the adj update walk propagates
 150        * as far a recursive paths.
 151        */
 152       const dpo_id_t *choice;
 153       load_balance_t *lb;
 154       int hash;
 155
 156       lb = load_balance_get (tmp.dpoi_index);
 157
 158       if (IP4 == ip_addr_version (&ladj->remote_rloc))
 159         {
 160           hash = ip4_compute_flow_hash ((ip4_header_t *) adj_get_rewrite (ai),
 161                                         lb->lb_hash_config);
 162         }
 163       else
 164         {
 165           hash = ip6_compute_flow_hash ((ip6_header_t *) adj_get_rewrite (ai),
 166                                         lb->lb_hash_config);
 167         }
 168
 169       choice =
 170         load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1);
 171       dpo_copy (&tmp, choice);
 172     }
 173
 174   adj_nbr_midchain_stack (ai, &tmp);
 175   dpo_reset (&tmp);
 176 }
 177
 178 /**
 179  * @brief Call back when restacking all adjacencies on a GRE interface
 180  */
 181 static adj_walk_rc_t
 182 lisp_gpe_adj_walk_cb (adj_index_t ai, void *ctx)
 183 {
 184   lisp_gpe_adjacency_t *ladj = ctx;
 185
 186   lisp_gpe_adj_stack_one (ladj, ai);
 187
 188   return (ADJ_WALK_RC_CONTINUE);
 189 }
 190
 191 static void
 192 lisp_gpe_adj_stack (lisp_gpe_adjacency_t * ladj)
 193 {
 194   fib_protocol_t nh_proto;
 195   ip46_address_t nh;
 196
 197   ip_address_to_46 (&ladj->remote_rloc, &nh, &nh_proto);
 198
 199   /*
 200    * walk all the adjacencies on th lisp interface and restack them
 201    */
 202   adj_nbr_walk_nh (ladj->sw_if_index,
 203                    nh_proto, &nh, lisp_gpe_adj_walk_cb, ladj);
 204 }
 205
 206 static lisp_gpe_next_protocol_e
 207 lisp_gpe_adj_proto_from_vnet_link_type (vnet_link_t linkt)
 208 {
 209   switch (linkt)
 210     {
 211     case VNET_LINK_IP4:
 212       return (LISP_GPE_NEXT_PROTO_IP4);
 213     case VNET_LINK_IP6:
 214       return (LISP_GPE_NEXT_PROTO_IP6);
 215     case VNET_LINK_ETHERNET:
 216       return (LISP_GPE_NEXT_PROTO_ETHERNET);
 217     case VNET_LINK_NSH:
 218       return (LISP_GPE_NEXT_PROTO_NSH);
 219     default:
 220       ASSERT (0);
 221     }
 222   return (LISP_GPE_NEXT_PROTO_IP4);
 223 }
 224
 225 #define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
 226
 227 static lisp_afi_e
 228 lisp_afi_from_vnet_link_type (vnet_link_t link)
 229 {
 230   switch (link)
 231     {
 232     case VNET_LINK_IP4:
 233       return LISP_AFI_IP;
 234     case VNET_LINK_IP6:
 235       return LISP_AFI_IP6;
 236     case VNET_LINK_ETHERNET:
 237       return LISP_AFI_MAC;
 238     default:
 239       return LISP_AFI_NO_ADDR;
 240     }
 241 }
 242
 243 static void
 244 lisp_gpe_increment_stats_counters (lisp_cp_main_t * lcm, ip_adjacency_t * adj,
 245                                    vlib_buffer_t * b)
 246 {
 247   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
 248   lisp_gpe_adjacency_t *ladj;
 249   ip_address_t rloc;
 250   index_t lai;
 251   u32 si, di;
 252   gid_address_t src, dst;
 253   lisp_stats_t *stats;
 254   uword *feip;
 255
 256   ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
 257   si = vnet_buffer (b)->sw_if_index[VLIB_TX];
 258   lai = lisp_adj_find (&rloc, si);
 259   ASSERT (INDEX_INVALID != lai);
 260
 261   ladj = pool_elt_at_index (lisp_adj_pool, lai);
 262
 263   u8 *lisp_data = (u8 *) vlib_buffer_get_current (b);
 264
 265   /* skip IP header */
 266   if (is_v4_packet (lisp_data))
 267     lisp_data += sizeof (ip4_header_t);
 268   else
 269     lisp_data += sizeof (ip6_header_t);
 270
 271   /* skip UDP header */
 272   lisp_data += sizeof (udp_header_t);
 273   // TODO: skip TCP?
 274
 275   /* skip LISP GPE header */
 276   lisp_data += sizeof (lisp_gpe_header_t);
 277
 278   i16 saved_current_data = b->current_data;
 279   b->current_data = lisp_data - b->data;
 280
 281   lisp_afi_e afi = lisp_afi_from_vnet_link_type (adj->ia_link);
 282   get_src_and_dst_eids_from_buffer (lcm, b, &src, &dst, afi);
 283   b->current_data = saved_current_data;
 284   di = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, &dst, &src);
 285   if (PREDICT_FALSE (~0 == di))
 286     {
 287       clib_warning ("dst mapping not found (%U, %U)", format_gid_address,
 288                     &src, format_gid_address, &dst);
 289       return;
 290     }
 291
 292   feip = hash_get (lcm->fwd_entry_by_mapping_index, di);
 293   if (PREDICT_FALSE (!feip))
 294     return;
 295
 296   lisp_stats_key_t key;
 297   memset (&key, 0, sizeof (key));
 298   key.fwd_entry_index = feip[0];
 299   key.tunnel_index = ladj->tunnel_index;
 300
 301   uword *p = hash_get_mem (lgm->lisp_stats_index_by_key, &key);
 302   if (p)
 303     {
 304       stats = pool_elt_at_index (lgm->lisp_stats_pool, p[0]);
 305     }
 306   else
 307     {
 308       pool_get (lgm->lisp_stats_pool, stats);
 309       memset (stats, 0, sizeof (*stats));
 310
 311       lisp_stats_key_t *key_copy = clib_mem_alloc (sizeof (*key_copy));
 312       memcpy (key_copy, &key, sizeof (*key_copy));
 313       hash_set_mem (lgm->lisp_stats_index_by_key, key_copy,
 314                     stats - lgm->lisp_stats_pool);
 315     }
 316   stats->pkt_count++;
 317   /* compute payload length starting after GPE */
 318   stats->bytes += b->current_length - (lisp_data - b->data - b->current_data);
 319 }
 320
 321 static void
 322 lisp_gpe_fixup (vlib_main_t * vm, ip_adjacency_t * adj, vlib_buffer_t * b)
 323 {
 324   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 325
 326   if (lcm->flags & LISP_FLAG_STATS_ENABLED)
 327     lisp_gpe_increment_stats_counters (lcm, adj, b);
 328
 329   /* Fixup the checksum and len fields in the LISP tunnel encap
 330    * that was applied at the midchain node */
 331   ip_udp_fixup_one (vm, b, is_v4_packet (vlib_buffer_get_current (b)));
 332 }
 333
 334 /**
 335  * @brief The LISP-GPE interface registered function to update, i.e.
 336  * provide an rewrite string for, an adjacency.
 337  */
 338 void
 339 lisp_gpe_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, adj_index_t ai)
 340 {
 341   const lisp_gpe_tunnel_t *lgt;
 342   lisp_gpe_adjacency_t *ladj;
 343   ip_adjacency_t *adj;
 344   ip_address_t rloc;
 345   vnet_link_t linkt;
 346   index_t lai;
 347
 348   adj = adj_get (ai);
 349   ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
 350
 351   /*
 352    * find an existing or create a new adj
 353    */
 354   lai = lisp_adj_find (&rloc, sw_if_index);
 355
 356   ASSERT (INDEX_INVALID != lai);
 357
 358   ladj = pool_elt_at_index (lisp_adj_pool, lai);
 359   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 360   linkt = adj_get_link_type (ai);
 361   adj_nbr_midchain_update_rewrite
 362     (ai, lisp_gpe_fixup,
 363      (VNET_LINK_ETHERNET == linkt ?
 364       ADJ_MIDCHAIN_FLAG_NO_COUNT :
 365       ADJ_MIDCHAIN_FLAG_NONE),
 366      lisp_gpe_tunnel_build_rewrite (lgt, ladj,
 367                                     lisp_gpe_adj_proto_from_vnet_link_type
 368                                     (linkt)));
 369
 370   lisp_gpe_adj_stack_one (ladj, ai);
 371 }
 372
 373 u8 *
 374 lisp_gpe_build_rewrite (vnet_main_t * vnm,
 375                         u32 sw_if_index,
 376                         vnet_link_t link_type, const void *dst_address)
 377 {
 378   ASSERT (0);
 379   return (NULL);
 380 }
 381
 382 index_t
 383 lisp_gpe_adjacency_find_or_create_and_lock (const locator_pair_t * pair,
 384                                             u32 overlay_table_id, u32 vni)
 385 {
 386   const lisp_gpe_sub_interface_t *l3s;
 387   const lisp_gpe_tunnel_t *lgt;
 388   lisp_gpe_adjacency_t *ladj;
 389   index_t lai, l3si;
 390
 391   /*
 392    * first find the L3 sub-interface that corresponds to the loacl-rloc and vni
 393    */
 394   l3si = lisp_gpe_sub_interface_find_or_create_and_lock (&pair->lcl_loc,
 395                                                          overlay_table_id,
 396                                                          vni);
 397   l3s = lisp_gpe_sub_interface_get (l3si);
 398
 399   /*
 400    * find an existing or create a new adj
 401    */
 402   lai = lisp_adj_find (&pair->rmt_loc, l3s->sw_if_index);
 403
 404   if (INDEX_INVALID == lai)
 405     {
 406
 407       pool_get (lisp_adj_pool, ladj);
 408       memset (ladj, 0, sizeof (*ladj));
 409       lai = (ladj - lisp_adj_pool);
 410
 411       ip_address_copy (&ladj->remote_rloc, &pair->rmt_loc);
 412       ladj->vni = vni;
 413       /* transfer the lock to the adj */
 414       ladj->lisp_l3_sub_index = l3si;
 415       ladj->sw_if_index = l3s->sw_if_index;
 416
 417       /* if vni is non-default */
 418       if (ladj->vni)
 419         ladj->flags = LISP_GPE_FLAGS_I;
 420
 421       /* work in lisp-gpe not legacy mode */
 422       ladj->flags |= LISP_GPE_FLAGS_P;
 423
 424       /*
 425        * find the tunnel that will provide the underlying transport
 426        * and hence the rewrite.
 427        * The RLOC FIB index is default table - always.
 428        */
 429       ladj->tunnel_index = lisp_gpe_tunnel_find_or_create_and_lock (pair, 0);
 430
 431       lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 432
 433       /*
 434        * become of child of the RLOC FIB entry so we are updated when
 435        * its reachability changes, allowing us to re-stack the midcahins
 436        */
 437       ladj->fib_entry_child_index = fib_entry_child_add (lgt->fib_entry_index,
 438                                                          FIB_NODE_TYPE_LISP_ADJ,
 439                                                          lai);
 440
 441       lisp_adj_insert (&ladj->remote_rloc, ladj->sw_if_index, lai);
 442     }
 443   else
 444     {
 445       /* unlock the interface from the find. */
 446       lisp_gpe_sub_interface_unlock (l3si);
 447       ladj = lisp_gpe_adjacency_get_i (lai);
 448     }
 449
 450   ladj->locks++;
 451
 452   return (lai);
 453 }
 454
 455 /**
 456  * @brief Get a pointer to a tunnel from a pointer to a FIB node
 457  */
 458 static lisp_gpe_adjacency_t *
 459 lisp_gpe_adjacency_from_fib_node (const fib_node_t * node)
 460 {
 461   return ((lisp_gpe_adjacency_t *)
 462           ((char *) node -
 463            STRUCT_OFFSET_OF (lisp_gpe_adjacency_t, fib_node)));
 464 }
 465
 466 static void
 467 lisp_gpe_adjacency_last_lock_gone (lisp_gpe_adjacency_t * ladj)
 468 {
 469   const lisp_gpe_tunnel_t *lgt;
 470
 471   /*
 472    * no children so we are not counting locks. no-op.
 473    * at least not counting
 474    */
 475   lisp_adj_remove (&ladj->remote_rloc, ladj->sw_if_index);
 476
 477   /*
 478    * unlock the resources this adj holds
 479    */
 480   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 481
 482   fib_entry_child_remove (lgt->fib_entry_index, ladj->fib_entry_child_index);
 483
 484   lisp_gpe_tunnel_unlock (ladj->tunnel_index);
 485   lisp_gpe_sub_interface_unlock (ladj->lisp_l3_sub_index);
 486
 487   pool_put (lisp_adj_pool, ladj);
 488 }
 489
 490 void
 491 lisp_gpe_adjacency_unlock (index_t lai)
 492 {
 493   lisp_gpe_adjacency_t *ladj;
 494
 495   ladj = lisp_gpe_adjacency_get_i (lai);
 496
 497   ladj->locks--;
 498
 499   if (0 == ladj->locks)
 500     {
 501       lisp_gpe_adjacency_last_lock_gone (ladj);
 502     }
 503 }
 504
 505 const lisp_gpe_adjacency_t *
 506 lisp_gpe_adjacency_get (index_t lai)
 507 {
 508   return (lisp_gpe_adjacency_get_i (lai));
 509 }
 510
 511
 512 /**
 513  * @brief LISP GPE tunnel back walk
 514  *
 515  * The FIB entry through which this tunnel resolves has been updated.
 516  * re-stack the midchain on the new forwarding.
 517  */
 518 static fib_node_back_walk_rc_t
 519 lisp_gpe_adjacency_back_walk (fib_node_t * node,
 520                               fib_node_back_walk_ctx_t * ctx)
 521 {
 522   lisp_gpe_adj_stack (lisp_gpe_adjacency_from_fib_node (node));
 523
 524   return (FIB_NODE_BACK_WALK_CONTINUE);
 525 }
 526
 527 static fib_node_t *
 528 lisp_gpe_adjacency_get_fib_node (fib_node_index_t index)
 529 {
 530   lisp_gpe_adjacency_t *ladj;
 531
 532   ladj = pool_elt_at_index (lisp_adj_pool, index);
 533   return (&ladj->fib_node);
 534 }
 535
 536 static void
 537 lisp_gpe_adjacency_last_fib_lock_gone (fib_node_t * node)
 538 {
 539   lisp_gpe_adjacency_last_lock_gone (lisp_gpe_adjacency_from_fib_node (node));
 540 }
 541
 542 const static fib_node_vft_t lisp_gpe_tuennel_vft = {
 543   .fnv_get = lisp_gpe_adjacency_get_fib_node,
 544   .fnv_back_walk = lisp_gpe_adjacency_back_walk,
 545   .fnv_last_lock = lisp_gpe_adjacency_last_fib_lock_gone,
 546 };
 547
 548 u8 *
 549 format_lisp_gpe_adjacency (u8 * s, va_list * args)
 550 {
 551   lisp_gpe_adjacency_t *ladj = va_arg (*args, lisp_gpe_adjacency_t *);
 552   lisp_gpe_adjacency_format_flags_t flags =
 553     va_arg (*args, lisp_gpe_adjacency_format_flags_t);
 554
 555   if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
 556     {
 557       s =
 558         format (s, "index %d locks:%d\n", ladj - lisp_adj_pool, ladj->locks);
 559     }
 560
 561   s = format (s, " vni: %d,", ladj->vni);
 562   s = format (s, " remote-RLOC: %U,", format_ip_address, &ladj->remote_rloc);
 563
 564   if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
 565     {
 566       s = format (s, " %U\n",
 567                   format_lisp_gpe_sub_interface,
 568                   lisp_gpe_sub_interface_get (ladj->lisp_l3_sub_index));
 569       s = format (s, " %U\n",
 570                   format_lisp_gpe_tunnel,
 571                   lisp_gpe_tunnel_get (ladj->tunnel_index));
 572     }
 573   else
 574     {
 575       s = format (s, " LISP L3 sub-interface index: %d,",
 576                   ladj->lisp_l3_sub_index);
 577       s = format (s, " LISP tunnel index: %d", ladj->tunnel_index);
 578     }
 579
 580
 581   return (s);
 582 }
 583
 584 static clib_error_t *
 585 lisp_gpe_adjacency_show (vlib_main_t * vm,
 586                          unformat_input_t * input, vlib_cli_command_t * cmd)
 587 {
 588   lisp_gpe_adjacency_t *ladj;
 589   index_t index;
 590
 591   if (pool_elts (lisp_adj_pool) == 0)
 592     vlib_cli_output (vm, "No lisp-gpe Adjacencies");
 593
 594   if (unformat (input, "%d", &index))
 595     {
 596       ladj = lisp_gpe_adjacency_get_i (index);
 597       vlib_cli_output (vm, "%U", format_lisp_gpe_adjacency, ladj,
 598                        LISP_GPE_ADJ_FORMAT_FLAG_DETAIL);
 599     }
 600   else
 601     {
 602       /* *INDENT-OFF* */
 603       pool_foreach (ladj, lisp_adj_pool,
 604       ({
 605         vlib_cli_output (vm, "[%d] %U\n",
 606                          ladj - lisp_adj_pool,
 607                          format_lisp_gpe_adjacency, ladj,
 608                          LISP_GPE_ADJ_FORMAT_FLAG_NONE);
 609       }));
 610       /* *INDENT-ON* */
 611     }
 612
 613   return 0;
 614 }
 615
 616 /* *INDENT-OFF* */
 617 VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) =
 618 {
 619   .path = "show gpe adjacency",
 620   .function = lisp_gpe_adjacency_show,
 621 };
 622 /* *INDENT-ON* */
 623
 624 #define LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (256)
 625 #define LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (1<<20)
 626
 627 static clib_error_t *
 628 lisp_gpe_adj_module_init (vlib_main_t * vm)
 629 {
 630   BV (clib_bihash_init) (&lisp_adj_db,
 631                          "Adjacency Neighbour table",
 632                          LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS,
 633                          LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE);
 634
 635   fib_node_register_type (FIB_NODE_TYPE_LISP_ADJ, &lisp_gpe_tuennel_vft);
 636   return (NULL);
 637 }
 638
 639 VLIB_INIT_FUNCTION (lisp_gpe_adj_module_init)
 640 /*
 641  * fd.io coding-style-patch-verification: ON
 642  *
 643  * Local Variables:
 644  * eval: (c-set-style "gnu")
 645  * End:
 646  */