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 AF_IP4:
 103       return (FIB_FORW_CHAIN_TYPE_UNICAST_IP4);
 104     case AF_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       clib_memset (b, 0, sizeof (*b));
 119       ip_address_set (b, &a->ip4, AF_IP4);
 120     }
 121   else
 122     {
 123       ip_address_set (b, &a->ip6, AF_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
 135   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 136
 137   adj_nbr_midchain_stack_on_fib_entry (ai,
 138                                        lgt->fib_entry_index,
 139                                        lisp_gpe_adj_get_fib_chain_type
 140                                        (ladj));
 141 }
 142
 143 /**
 144  * @brief Call back when restacking all adjacencies on a GRE interface
 145  */
 146 static adj_walk_rc_t
 147 lisp_gpe_adj_walk_cb (adj_index_t ai, void *ctx)
 148 {
 149   lisp_gpe_adjacency_t *ladj = ctx;
 150
 151   lisp_gpe_adj_stack_one (ladj, ai);
 152
 153   return (ADJ_WALK_RC_CONTINUE);
 154 }
 155
 156 static void
 157 lisp_gpe_adj_stack (lisp_gpe_adjacency_t * ladj)
 158 {
 159   fib_protocol_t nh_proto;
 160   ip46_address_t nh;
 161
 162   nh_proto = ip_address_to_46 (&ladj->remote_rloc, &nh);
 163
 164   /*
 165    * walk all the adjacencies on th lisp interface and restack them
 166    */
 167   adj_nbr_walk_nh (ladj->sw_if_index,
 168                    nh_proto, &nh, lisp_gpe_adj_walk_cb, ladj);
 169 }
 170
 171 static lisp_gpe_next_protocol_e
 172 lisp_gpe_adj_proto_from_vnet_link_type (vnet_link_t linkt)
 173 {
 174   switch (linkt)
 175     {
 176     case VNET_LINK_IP4:
 177       return (LISP_GPE_NEXT_PROTO_IP4);
 178     case VNET_LINK_IP6:
 179       return (LISP_GPE_NEXT_PROTO_IP6);
 180     case VNET_LINK_ETHERNET:
 181       return (LISP_GPE_NEXT_PROTO_ETHERNET);
 182     case VNET_LINK_NSH:
 183       return (LISP_GPE_NEXT_PROTO_NSH);
 184     default:
 185       ASSERT (0);
 186     }
 187   return (LISP_GPE_NEXT_PROTO_IP4);
 188 }
 189
 190 #define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
 191
 192 static lisp_afi_e
 193 lisp_afi_from_vnet_link_type (vnet_link_t link)
 194 {
 195   switch (link)
 196     {
 197     case VNET_LINK_IP4:
 198       return LISP_AFI_IP;
 199     case VNET_LINK_IP6:
 200       return LISP_AFI_IP6;
 201     case VNET_LINK_ETHERNET:
 202       return LISP_AFI_MAC;
 203     default:
 204       return LISP_AFI_NO_ADDR;
 205     }
 206 }
 207
 208 static void
 209 lisp_gpe_increment_stats_counters (lisp_cp_main_t * lcm,
 210                                    const ip_adjacency_t * adj,
 211                                    vlib_buffer_t * b)
 212 {
 213   lisp_gpe_main_t *lgm = vnet_lisp_gpe_get_main ();
 214   lisp_gpe_adjacency_t *ladj;
 215   ip_address_t rloc;
 216   index_t lai;
 217   u32 si, di;
 218   gid_address_t src, dst;
 219   uword *feip;
 220
 221   ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
 222   si = vnet_buffer (b)->sw_if_index[VLIB_TX];
 223   lai = lisp_adj_find (&rloc, si);
 224   ASSERT (INDEX_INVALID != lai);
 225
 226   ladj = pool_elt_at_index (lisp_adj_pool, lai);
 227
 228   u8 *lisp_data = (u8 *) vlib_buffer_get_current (b);
 229
 230   /* skip IP header */
 231   if (is_v4_packet (lisp_data))
 232     lisp_data += sizeof (ip4_header_t);
 233   else
 234     lisp_data += sizeof (ip6_header_t);
 235
 236   /* skip UDP header */
 237   lisp_data += sizeof (udp_header_t);
 238   // TODO: skip TCP?
 239
 240   /* skip LISP GPE header */
 241   lisp_data += sizeof (lisp_gpe_header_t);
 242
 243   i16 saved_current_data = b->current_data;
 244   b->current_data = lisp_data - b->data;
 245
 246   lisp_afi_e afi = lisp_afi_from_vnet_link_type (adj->ia_link);
 247   get_src_and_dst_eids_from_buffer (lcm, b, &src, &dst, afi);
 248   b->current_data = saved_current_data;
 249   di = gid_dictionary_sd_lookup (&lcm->mapping_index_by_gid, &dst, &src);
 250   if (PREDICT_FALSE (~0 == di))
 251     {
 252       clib_warning ("dst mapping not found (%U, %U)", format_gid_address,
 253                     &src, format_gid_address, &dst);
 254       return;
 255     }
 256
 257   feip = hash_get (lcm->fwd_entry_by_mapping_index, di);
 258   if (PREDICT_FALSE (!feip))
 259     return;
 260
 261   lisp_stats_key_t key;
 262   clib_memset (&key, 0, sizeof (key));
 263   key.fwd_entry_index = feip[0];
 264   key.tunnel_index = ladj->tunnel_index;
 265
 266   uword *p = hash_get_mem (lgm->lisp_stats_index_by_key, &key);
 267   ALWAYS_ASSERT (p);
 268
 269   /* compute payload length starting after GPE */
 270   u32 bytes = b->current_length - (lisp_data - b->data - b->current_data);
 271   vlib_increment_combined_counter (&lgm->counters, vlib_get_thread_index (),
 272                                    p[0], 1, bytes);
 273 }
 274
 275 static void
 276 lisp_gpe_fixup (vlib_main_t * vm,
 277                 const ip_adjacency_t * adj,
 278                 vlib_buffer_t * b, const void *data)
 279 {
 280   lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
 281
 282   if (lcm->flags & LISP_FLAG_STATS_ENABLED)
 283     lisp_gpe_increment_stats_counters (lcm, adj, b);
 284
 285   /* Fixup the checksum and len fields in the LISP tunnel encap
 286    * that was applied at the midchain node */
 287   ip_udp_fixup_one (vm, b, is_v4_packet (vlib_buffer_get_current (b)));
 288 }
 289
 290 /**
 291  * @brief The LISP-GPE interface registered function to update, i.e.
 292  * provide an rewrite string for, an adjacency.
 293  */
 294 void
 295 lisp_gpe_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, adj_index_t ai)
 296 {
 297   const lisp_gpe_tunnel_t *lgt;
 298   lisp_gpe_adjacency_t *ladj;
 299   ip_adjacency_t *adj;
 300   ip_address_t rloc;
 301   vnet_link_t linkt;
 302   adj_flags_t af;
 303   index_t lai;
 304
 305   adj = adj_get (ai);
 306   ip46_address_to_ip_address (&adj->sub_type.nbr.next_hop, &rloc);
 307
 308   /*
 309    * find an existing or create a new adj
 310    */
 311   lai = lisp_adj_find (&rloc, sw_if_index);
 312
 313   ASSERT (INDEX_INVALID != lai);
 314
 315   ladj = pool_elt_at_index (lisp_adj_pool, lai);
 316   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 317   linkt = adj_get_link_type (ai);
 318   af = ADJ_FLAG_MIDCHAIN_IP_STACK;
 319   if (VNET_LINK_ETHERNET == linkt)
 320     af |= ADJ_FLAG_MIDCHAIN_NO_COUNT;
 321
 322   adj_nbr_midchain_update_rewrite
 323     (ai, lisp_gpe_fixup, NULL, af,
 324      lisp_gpe_tunnel_build_rewrite (lgt, ladj,
 325                                     lisp_gpe_adj_proto_from_vnet_link_type
 326                                     (linkt)));
 327
 328   lisp_gpe_adj_stack_one (ladj, ai);
 329 }
 330
 331 u8 *
 332 lisp_gpe_build_rewrite (vnet_main_t * vnm,
 333                         u32 sw_if_index,
 334                         vnet_link_t link_type, const void *dst_address)
 335 {
 336   ASSERT (0);
 337   return (NULL);
 338 }
 339
 340 index_t
 341 lisp_gpe_adjacency_find_or_create_and_lock (const locator_pair_t * pair,
 342                                             u32 overlay_table_id, u32 vni)
 343 {
 344   const lisp_gpe_sub_interface_t *l3s;
 345   const lisp_gpe_tunnel_t *lgt;
 346   lisp_gpe_adjacency_t *ladj;
 347   index_t lai, l3si;
 348
 349   /*
 350    * first find the L3 sub-interface that corresponds to the loacl-rloc and vni
 351    */
 352   l3si = lisp_gpe_sub_interface_find_or_create_and_lock (&pair->lcl_loc,
 353                                                          overlay_table_id,
 354                                                          vni);
 355   l3s = lisp_gpe_sub_interface_get (l3si);
 356
 357   /*
 358    * find an existing or create a new adj
 359    */
 360   lai = lisp_adj_find (&pair->rmt_loc, l3s->sw_if_index);
 361
 362   if (INDEX_INVALID == lai)
 363     {
 364
 365       pool_get (lisp_adj_pool, ladj);
 366       clib_memset (ladj, 0, sizeof (*ladj));
 367       lai = (ladj - lisp_adj_pool);
 368
 369       ip_address_copy (&ladj->remote_rloc, &pair->rmt_loc);
 370       ladj->vni = vni;
 371       /* transfer the lock to the adj */
 372       ladj->lisp_l3_sub_index = l3si;
 373       ladj->sw_if_index = l3s->sw_if_index;
 374
 375       /* if vni is non-default */
 376       if (ladj->vni)
 377         ladj->flags = LISP_GPE_FLAGS_I;
 378
 379       /* work in lisp-gpe not legacy mode */
 380       ladj->flags |= LISP_GPE_FLAGS_P;
 381
 382       /*
 383        * find the tunnel that will provide the underlying transport
 384        * and hence the rewrite.
 385        * The RLOC FIB index is default table - always.
 386        */
 387       ladj->tunnel_index = lisp_gpe_tunnel_find_or_create_and_lock (pair, 0);
 388
 389       lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 390
 391       /*
 392        * become of child of the RLOC FIB entry so we are updated when
 393        * its reachability changes, allowing us to re-stack the midcahins
 394        */
 395       ladj->fib_entry_child_index = fib_entry_child_add (lgt->fib_entry_index,
 396                                                          FIB_NODE_TYPE_LISP_ADJ,
 397                                                          lai);
 398
 399       lisp_adj_insert (&ladj->remote_rloc, ladj->sw_if_index, lai);
 400     }
 401   else
 402     {
 403       /* unlock the interface from the find. */
 404       lisp_gpe_sub_interface_unlock (l3si);
 405       ladj = lisp_gpe_adjacency_get_i (lai);
 406     }
 407
 408   ladj->locks++;
 409
 410   return (lai);
 411 }
 412
 413 /**
 414  * @brief Get a pointer to a tunnel from a pointer to a FIB node
 415  */
 416 static lisp_gpe_adjacency_t *
 417 lisp_gpe_adjacency_from_fib_node (const fib_node_t * node)
 418 {
 419   return ((lisp_gpe_adjacency_t *)
 420           ((char *) node -
 421            STRUCT_OFFSET_OF (lisp_gpe_adjacency_t, fib_node)));
 422 }
 423
 424 static void
 425 lisp_gpe_adjacency_last_lock_gone (lisp_gpe_adjacency_t * ladj)
 426 {
 427   const lisp_gpe_tunnel_t *lgt;
 428
 429   /*
 430    * no children so we are not counting locks. no-op.
 431    * at least not counting
 432    */
 433   lisp_adj_remove (&ladj->remote_rloc, ladj->sw_if_index);
 434
 435   /*
 436    * unlock the resources this adj holds
 437    */
 438   lgt = lisp_gpe_tunnel_get (ladj->tunnel_index);
 439
 440   fib_entry_child_remove (lgt->fib_entry_index, ladj->fib_entry_child_index);
 441
 442   lisp_gpe_tunnel_unlock (ladj->tunnel_index);
 443   lisp_gpe_sub_interface_unlock (ladj->lisp_l3_sub_index);
 444
 445   pool_put (lisp_adj_pool, ladj);
 446 }
 447
 448 void
 449 lisp_gpe_adjacency_unlock (index_t lai)
 450 {
 451   lisp_gpe_adjacency_t *ladj;
 452
 453   ladj = lisp_gpe_adjacency_get_i (lai);
 454
 455   ladj->locks--;
 456
 457   if (0 == ladj->locks)
 458     {
 459       lisp_gpe_adjacency_last_lock_gone (ladj);
 460     }
 461 }
 462
 463 const lisp_gpe_adjacency_t *
 464 lisp_gpe_adjacency_get (index_t lai)
 465 {
 466   return (lisp_gpe_adjacency_get_i (lai));
 467 }
 468
 469
 470 /**
 471  * @brief LISP GPE tunnel back walk
 472  *
 473  * The FIB entry through which this tunnel resolves has been updated.
 474  * re-stack the midchain on the new forwarding.
 475  */
 476 static fib_node_back_walk_rc_t
 477 lisp_gpe_adjacency_back_walk (fib_node_t * node,
 478                               fib_node_back_walk_ctx_t * ctx)
 479 {
 480   lisp_gpe_adj_stack (lisp_gpe_adjacency_from_fib_node (node));
 481
 482   return (FIB_NODE_BACK_WALK_CONTINUE);
 483 }
 484
 485 static fib_node_t *
 486 lisp_gpe_adjacency_get_fib_node (fib_node_index_t index)
 487 {
 488   lisp_gpe_adjacency_t *ladj;
 489
 490   ladj = pool_elt_at_index (lisp_adj_pool, index);
 491   return (&ladj->fib_node);
 492 }
 493
 494 static void
 495 lisp_gpe_adjacency_last_fib_lock_gone (fib_node_t * node)
 496 {
 497   lisp_gpe_adjacency_last_lock_gone (lisp_gpe_adjacency_from_fib_node (node));
 498 }
 499
 500 const static fib_node_vft_t lisp_gpe_tuennel_vft = {
 501   .fnv_get = lisp_gpe_adjacency_get_fib_node,
 502   .fnv_back_walk = lisp_gpe_adjacency_back_walk,
 503   .fnv_last_lock = lisp_gpe_adjacency_last_fib_lock_gone,
 504 };
 505
 506 u8 *
 507 format_lisp_gpe_adjacency (u8 * s, va_list * args)
 508 {
 509   lisp_gpe_adjacency_t *ladj = va_arg (*args, lisp_gpe_adjacency_t *);
 510   lisp_gpe_adjacency_format_flags_t flags =
 511     va_arg (*args, lisp_gpe_adjacency_format_flags_t);
 512
 513   if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
 514     {
 515       s =
 516         format (s, "index %d locks:%d\n", ladj - lisp_adj_pool, ladj->locks);
 517     }
 518
 519   s = format (s, " vni: %d,", ladj->vni);
 520   s = format (s, " remote-RLOC: %U,", format_ip_address, &ladj->remote_rloc);
 521
 522   if (flags & LISP_GPE_ADJ_FORMAT_FLAG_DETAIL)
 523     {
 524       s = format (s, " %U\n",
 525                   format_lisp_gpe_sub_interface,
 526                   lisp_gpe_sub_interface_get (ladj->lisp_l3_sub_index));
 527       s = format (s, " %U\n",
 528                   format_lisp_gpe_tunnel,
 529                   lisp_gpe_tunnel_get (ladj->tunnel_index));
 530     }
 531   else
 532     {
 533       s = format (s, " LISP L3 sub-interface index: %d,",
 534                   ladj->lisp_l3_sub_index);
 535       s = format (s, " LISP tunnel index: %d", ladj->tunnel_index);
 536     }
 537
 538
 539   return (s);
 540 }
 541
 542 static clib_error_t *
 543 lisp_gpe_adjacency_show (vlib_main_t * vm,
 544                          unformat_input_t * input, vlib_cli_command_t * cmd)
 545 {
 546   lisp_gpe_adjacency_t *ladj;
 547   index_t index;
 548
 549   if (pool_elts (lisp_adj_pool) == 0)
 550     vlib_cli_output (vm, "No lisp-gpe Adjacencies");
 551
 552   if (unformat (input, "%d", &index))
 553     {
 554       ladj = lisp_gpe_adjacency_get_i (index);
 555       vlib_cli_output (vm, "%U", format_lisp_gpe_adjacency, ladj,
 556                        LISP_GPE_ADJ_FORMAT_FLAG_DETAIL);
 557     }
 558   else
 559     {
 560       /* *INDENT-OFF* */
 561       pool_foreach (ladj, lisp_adj_pool,
 562       ({
 563         vlib_cli_output (vm, "[%d] %U\n",
 564                          ladj - lisp_adj_pool,
 565                          format_lisp_gpe_adjacency, ladj,
 566                          LISP_GPE_ADJ_FORMAT_FLAG_NONE);
 567       }));
 568       /* *INDENT-ON* */
 569     }
 570
 571   return 0;
 572 }
 573
 574 /* *INDENT-OFF* */
 575 VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) =
 576 {
 577   .path = "show gpe adjacency",
 578   .function = lisp_gpe_adjacency_show,
 579 };
 580 /* *INDENT-ON* */
 581
 582 #define LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS (256)
 583 #define LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE (1<<20)
 584
 585 static clib_error_t *
 586 lisp_gpe_adj_module_init (vlib_main_t * vm)
 587 {
 588   BV (clib_bihash_init) (&lisp_adj_db,
 589                          "Adjacency Neighbour table",
 590                          LISP_ADJ_NBR_DEFAULT_HASH_NUM_BUCKETS,
 591                          LISP_ADJ_NBR_DEFAULT_HASH_MEMORY_SIZE);
 592
 593   fib_node_register_type (FIB_NODE_TYPE_LISP_ADJ, &lisp_gpe_tuennel_vft);
 594   return (NULL);
 595 }
 596
 597 VLIB_INIT_FUNCTION (lisp_gpe_adj_module_init);
 598 /*
 599  * fd.io coding-style-patch-verification: ON
 600  *
 601  * Local Variables:
 602  * eval: (c-set-style "gnu")
 603  * End:
 604  */