src/plugins/lisp/lisp-gpe/interface.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 /**
  17  * @file
  18  * @brief Common utility functions for LISP-GPE interfaces.
  19  *
  20  */
  21
  22 #include <vppinfra/error.h>
  23 #include <vppinfra/hash.h>
  24 #include <vnet/vnet.h>
  25 #include <vnet/ip/ip.h>
  26 #include <vnet/udp/udp_inlines.h>
  27 #include <vnet/ethernet/ethernet.h>
  28 #include <lisp/lisp-gpe/lisp_gpe.h>
  29 #include <lisp/lisp-gpe/lisp_gpe_fwd_entry.h>
  30 #include <lisp/lisp-gpe/lisp_gpe_tenant.h>
  31 #include <lisp/lisp-gpe/lisp_gpe_adjacency.h>
  32 #include <vnet/adj/adj.h>
  33 #include <vnet/fib/fib_table.h>
  34 #include <vnet/fib/ip4_fib.h>
  35 #include <vnet/fib/ip6_fib.h>
  36 #include <lisp/lisp-cp/lisp_cp_dpo.h>
  37
  38 /**
  39  * @brief The VLIB node arc/edge from the interface's TX node, to the L2
  40  * load-balanceing node. Which is where all packets go
  41  */
  42 static uword l2_arc_to_lb;
  43
  44 #define foreach_lisp_gpe_tx_next        \
  45   _(DROP, "error-drop")                 \
  46   _(IP4_LOOKUP, "ip4-lookup")           \
  47   _(IP6_LOOKUP, "ip6-lookup")
  48
  49 typedef enum
  50 {
  51 #define _(sym,str) LISP_GPE_TX_NEXT_##sym,
  52   foreach_lisp_gpe_tx_next
  53 #undef _
  54     LISP_GPE_TX_N_NEXT,
  55 } lisp_gpe_tx_next_t;
  56
  57 typedef struct
  58 {
  59   u32 tunnel_index;
  60 } lisp_gpe_tx_trace_t;
  61
  62 u8 *
  63 format_lisp_gpe_tx_trace (u8 * s, va_list * args)
  64 {
  65   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  66   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  67   lisp_gpe_tx_trace_t *t = va_arg (*args, lisp_gpe_tx_trace_t *);
  68
  69   s = format (s, "LISP-GPE-TX: tunnel %d", t->tunnel_index);
  70   return s;
  71 }
  72
  73 #define is_v4_packet(_h) ((*(u8*) _h) & 0xF0) == 0x40
  74
  75 /**
  76  * @brief LISP-GPE interface TX (encap) function.
  77  * @node lisp_gpe_interface_tx
  78  *
  79  * The LISP-GPE interface TX (encap) function.
  80  *
  81  * Looks up the associated tunnel based on the adjacency hit in the SD FIB
  82  * and if the tunnel is multihomed it uses the flow hash to determine
  83  * sub-tunnel, and rewrite string, to be used to encapsulate the packet.
  84  *
  85  * @param[in]   vm      vlib_main_t corresponding to the current thread.
  86  * @param[in]   node    vlib_node_runtime_t data for this node.
  87  * @param[in]   frame   vlib_frame_t whose contents should be dispatched.
  88  *
  89  * @return number of vectors in frame.
  90  */
  91 VLIB_NODE_FN (lisp_tunnel_output)
  92 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
  93 {
  94   u32 n_left_from, next_index, *from, *to_next;
  95
  96   from = vlib_frame_vector_args (from_frame);
  97   n_left_from = from_frame->n_vectors;
  98
  99   next_index = node->cached_next_index;
 100
 101   while (n_left_from > 0)
 102     {
 103       u32 n_left_to_next;
 104
 105       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 106
 107       while (n_left_from > 0 && n_left_to_next > 0)
 108         {
 109           u32 bi0, adj_index0, next0;
 110           const ip_adjacency_t *adj0;
 111           const dpo_id_t *dpo0;
 112           vlib_buffer_t *b0;
 113
 114           bi0 = from[0];
 115           to_next[0] = bi0;
 116           from += 1;
 117           to_next += 1;
 118           n_left_from -= 1;
 119           n_left_to_next -= 1;
 120
 121           b0 = vlib_get_buffer (vm, bi0);
 122           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 123
 124           /* Follow the DPO on which the midchain is stacked */
 125           adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
 126           adj0 = adj_get (adj_index0);
 127           dpo0 = &adj0->sub_type.midchain.next_dpo;
 128           next0 = dpo0->dpoi_next_node;
 129           vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 130
 131           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 132             {
 133               lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
 134                                                         sizeof (*tr));
 135               tr->tunnel_index = adj_index0;
 136             }
 137           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 138                                            n_left_to_next, bi0, next0);
 139         }
 140
 141       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 142     }
 143
 144   return from_frame->n_vectors;
 145 }
 146
 147 VLIB_REGISTER_NODE (lisp_tunnel_output) = {
 148   .name = "lisp-tunnel-output",
 149   .vector_size = sizeof (u32),
 150   .format_trace = format_lisp_gpe_tx_trace,
 151   .sibling_of = "tunnel-output",
 152 };
 153
 154 static u8 *
 155 format_lisp_gpe_name (u8 * s, va_list * args)
 156 {
 157   u32 dev_instance = va_arg (*args, u32);
 158   return format (s, "lisp_gpe%d", dev_instance);
 159 }
 160
 161 VNET_DEVICE_CLASS (lisp_gpe_device_class) = {
 162   .name = "LISP_GPE",
 163   .format_device_name = format_lisp_gpe_name,
 164 };
 165
 166 u8 *
 167 format_lisp_gpe_header_with_length (u8 * s, va_list * args)
 168 {
 169   lisp_gpe_header_t *h = va_arg (*args, lisp_gpe_header_t *);
 170   u32 max_header_bytes = va_arg (*args, u32);
 171   u32 header_bytes;
 172
 173   header_bytes = sizeof (h[0]);
 174   if (max_header_bytes != 0 && header_bytes > max_header_bytes)
 175     return format (s, "lisp-gpe header truncated");
 176
 177   s = format (s, "flags: ");
 178 #define _(n,v) if (h->flags & v) s = format (s, "%s ", #n);
 179   foreach_lisp_gpe_flag_bit;
 180 #undef _
 181
 182   s = format (s, "\n  ver_res %d res %d next_protocol %d iid %d(%x)",
 183               h->ver_res, h->res, h->next_protocol,
 184               clib_net_to_host_u32 (h->iid << 8),
 185               clib_net_to_host_u32 (h->iid << 8));
 186   return s;
 187 }
 188
 189 VNET_HW_INTERFACE_CLASS (lisp_gpe_hw_class) = {
 190   .name = "LISP_GPE",
 191   .format_header = format_lisp_gpe_header_with_length,
 192   .build_rewrite = lisp_gpe_build_rewrite,
 193   .update_adjacency = lisp_gpe_update_adjacency,
 194 };
 195
 196
 197 typedef struct
 198 {
 199   u32 dpo_index;
 200 } l2_lisp_gpe_tx_trace_t;
 201
 202 static u8 *
 203 format_l2_lisp_gpe_tx_trace (u8 * s, va_list * args)
 204 {
 205   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 206   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 207   l2_lisp_gpe_tx_trace_t *t = va_arg (*args, l2_lisp_gpe_tx_trace_t *);
 208
 209   s = format (s, "L2-LISP-GPE-TX: load-balance %d", t->dpo_index);
 210   return s;
 211 }
 212
 213 /**
 214  * @brief LISP-GPE interface TX (encap) function for L2 overlays.
 215  * @node l2_lisp_gpe_interface_tx
 216  *
 217  * The L2 LISP-GPE interface TX (encap) function.
 218  *
 219  * Uses bridge domain index, source and destination ethernet addresses to
 220  * lookup tunnel. If the tunnel is multihomed a flow has is used to determine
 221  * the sub-tunnel and therefore the rewrite string to be used to encapsulate
 222  * the packets.
 223  *
 224  * @param[in]   vm        vlib_main_t corresponding to the current thread.
 225  * @param[in]   node      vlib_node_runtime_t data for this node.
 226  * @param[in]   frame     vlib_frame_t whose contents should be dispatched.
 227  *
 228  * @return number of vectors in frame.
 229  */
 230 static uword
 231 l2_lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
 232                           vlib_frame_t * from_frame)
 233 {
 234   u32 n_left_from, next_index, *from, *to_next;
 235   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 236   u32 thread_index = vm->thread_index;
 237   vlib_combined_counter_main_t *cm = &load_balance_main.lbm_to_counters;
 238
 239   from = vlib_frame_vector_args (from_frame);
 240   n_left_from = from_frame->n_vectors;
 241
 242   next_index = node->cached_next_index;
 243
 244   while (n_left_from > 0)
 245     {
 246       u32 n_left_to_next;
 247
 248       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 249
 250       while (n_left_from > 0 && n_left_to_next > 0)
 251         {
 252           vlib_buffer_t *b0;
 253           u32 bi0, lbi0;
 254           ethernet_header_t *e0;
 255
 256           bi0 = from[0];
 257           to_next[0] = bi0;
 258           from += 1;
 259           to_next += 1;
 260           n_left_from -= 1;
 261           n_left_to_next -= 1;
 262
 263           b0 = vlib_get_buffer (vm, bi0);
 264           e0 = vlib_buffer_get_current (b0);
 265
 266           vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_MAC;
 267
 268           /* lookup dst + src mac */
 269           lbi0 = lisp_l2_fib_lookup (lgm, vnet_buffer (b0)->l2.bd_index,
 270                                      e0->src_address, e0->dst_address);
 271           vnet_buffer (b0)->ip.adj_index[VLIB_TX] = lbi0;
 272
 273           vlib_increment_combined_counter (cm, thread_index, lbi0, 1,
 274                                            vlib_buffer_length_in_chain (vm,
 275                                                                         b0));
 276           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 277             {
 278               l2_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
 279                                                            sizeof (*tr));
 280               tr->dpo_index = lbi0;
 281             }
 282           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 283                                            n_left_to_next, bi0, l2_arc_to_lb);
 284         }
 285
 286       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 287     }
 288
 289   return from_frame->n_vectors;
 290 }
 291
 292 static u8 *
 293 format_l2_lisp_gpe_name (u8 * s, va_list * args)
 294 {
 295   u32 dev_instance = va_arg (*args, u32);
 296   return format (s, "l2_lisp_gpe%d", dev_instance);
 297 }
 298
 299 VNET_DEVICE_CLASS (l2_lisp_gpe_device_class,static) = {
 300   .name = "L2_LISP_GPE",
 301   .format_device_name = format_l2_lisp_gpe_name,
 302   .format_tx_trace = format_l2_lisp_gpe_tx_trace,
 303   .tx_function = l2_lisp_gpe_interface_tx,
 304 };
 305
 306 typedef struct
 307 {
 308   u32 dpo_index;
 309 } nsh_lisp_gpe_tx_trace_t;
 310
 311 u8 *
 312 format_nsh_lisp_gpe_tx_trace (u8 * s, va_list * args)
 313 {
 314   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 315   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 316   nsh_lisp_gpe_tx_trace_t *t = va_arg (*args, nsh_lisp_gpe_tx_trace_t *);
 317
 318   s = format (s, "NSH-GPE-TX: tunnel %d", t->dpo_index);
 319   return s;
 320 }
 321
 322 /**
 323  * @brief LISP-GPE interface TX for NSH overlays.
 324  * @node nsh_lisp_gpe_interface_tx
 325  *
 326  * The NSH LISP-GPE interface TX function.
 327  *
 328  * @param[in]   vm        vlib_main_t corresponding to the current thread.
 329  * @param[in]   node      vlib_node_runtime_t data for this node.
 330  * @param[in]   frame     vlib_frame_t whose contents should be dispatched.
 331  *
 332  * @return number of vectors in frame.
 333  */
 334 static uword
 335 nsh_lisp_gpe_interface_tx (vlib_main_t * vm, vlib_node_runtime_t * node,
 336                            vlib_frame_t * from_frame)
 337 {
 338   u32 n_left_from, next_index, *from, *to_next;
 339   lisp_gpe_main_t *lgm = &lisp_gpe_main;
 340
 341   from = vlib_frame_vector_args (from_frame);
 342   n_left_from = from_frame->n_vectors;
 343
 344   next_index = node->cached_next_index;
 345
 346   while (n_left_from > 0)
 347     {
 348       u32 n_left_to_next;
 349
 350       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 351
 352       while (n_left_from > 0 && n_left_to_next > 0)
 353         {
 354           vlib_buffer_t *b0;
 355           u32 bi0;
 356           u32 *nsh0, next0;
 357           const dpo_id_t *dpo0;
 358
 359           bi0 = from[0];
 360           to_next[0] = bi0;
 361           from += 1;
 362           to_next += 1;
 363           n_left_from -= 1;
 364           n_left_to_next -= 1;
 365
 366           b0 = vlib_get_buffer (vm, bi0);
 367           nsh0 = vlib_buffer_get_current (b0);
 368
 369           vnet_buffer (b0)->lisp.overlay_afi = LISP_AFI_LCAF;
 370
 371           /* lookup SPI + SI (second word of the NSH header).
 372            * NB: Load balancing was done by the control plane */
 373           dpo0 = lisp_nsh_fib_lookup (lgm, nsh0[1]);
 374
 375           next0 = dpo0->dpoi_next_node;
 376           vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
 377
 378           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 379             {
 380               nsh_lisp_gpe_tx_trace_t *tr = vlib_add_trace (vm, node, b0,
 381                                                             sizeof (*tr));
 382               tr->dpo_index = dpo0->dpoi_index;
 383             }
 384           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
 385                                            n_left_to_next, bi0, next0);
 386         }
 387
 388       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 389     }
 390
 391   return from_frame->n_vectors;
 392 }
 393
 394 static u8 *
 395 format_nsh_lisp_gpe_name (u8 * s, va_list * args)
 396 {
 397   u32 dev_instance = va_arg (*args, u32);
 398   return format (s, "nsh_lisp_gpe%d", dev_instance);
 399 }
 400
 401 VNET_DEVICE_CLASS (nsh_lisp_gpe_device_class,static) = {
 402   .name = "NSH_LISP_GPE",
 403   .format_device_name = format_nsh_lisp_gpe_name,
 404   .format_tx_trace = format_nsh_lisp_gpe_tx_trace,
 405   .tx_function = nsh_lisp_gpe_interface_tx,
 406 };
 407
 408 static vnet_hw_interface_t *
 409 lisp_gpe_create_iface (lisp_gpe_main_t * lgm, u32 vni, u32 dp_table,
 410                        vnet_device_class_t * dev_class,
 411                        tunnel_lookup_t * tuns)
 412 {
 413   u32 flen;
 414   u32 hw_if_index = ~0;
 415   u8 *new_name;
 416   vnet_hw_interface_t *hi;
 417   vnet_main_t *vnm = lgm->vnet_main;
 418
 419   /* create hw lisp_gpeX iface if needed, otherwise reuse existing */
 420   flen = vec_len (lgm->free_tunnel_hw_if_indices);
 421   if (flen > 0)
 422     {
 423       hw_if_index = lgm->free_tunnel_hw_if_indices[flen - 1];
 424       vec_dec_len (lgm->free_tunnel_hw_if_indices, 1);
 425
 426       hi = vnet_get_hw_interface (vnm, hw_if_index);
 427
 428       /* rename interface */
 429       new_name = format (0, "%U", dev_class->format_device_name, vni);
 430
 431       vec_add1 (new_name, 0);
 432       vnet_rename_interface (vnm, hw_if_index, (char *) new_name);
 433       vec_free (new_name);
 434
 435       /* clear old stats of freed interface before reuse */
 436       vnet_interface_main_t *im = &vnm->interface_main;
 437       vnet_interface_counter_lock (im);
 438       vlib_zero_combined_counter (&im->combined_sw_if_counters
 439                                   [VNET_INTERFACE_COUNTER_TX],
 440                                   hi->sw_if_index);
 441       vlib_zero_combined_counter (&im->combined_sw_if_counters
 442                                   [VNET_INTERFACE_COUNTER_RX],
 443                                   hi->sw_if_index);
 444       vlib_zero_simple_counter (&im->sw_if_counters
 445                                 [VNET_INTERFACE_COUNTER_DROP],
 446                                 hi->sw_if_index);
 447       vnet_interface_counter_unlock (im);
 448     }
 449   else
 450     {
 451       hw_if_index = vnet_register_interface (vnm, dev_class->index, vni,
 452                                              lisp_gpe_hw_class.index, 0);
 453       hi = vnet_get_hw_interface (vnm, hw_if_index);
 454     }
 455
 456   hash_set (tuns->hw_if_index_by_dp_table, dp_table, hw_if_index);
 457
 458   /* set tunnel termination: post decap, packets are tagged as having been
 459    * originated by lisp-gpe interface */
 460   hash_set (tuns->sw_if_index_by_vni, vni, hi->sw_if_index);
 461   hash_set (tuns->vni_by_sw_if_index, hi->sw_if_index, vni);
 462
 463   return hi;
 464 }
 465
 466 static void
 467 lisp_gpe_remove_iface (lisp_gpe_main_t * lgm, u32 hi_index, u32 dp_table,
 468                        tunnel_lookup_t * tuns)
 469 {
 470   vnet_main_t *vnm = lgm->vnet_main;
 471   vnet_hw_interface_t *hi;
 472   uword *vnip;
 473
 474   hi = vnet_get_hw_interface (vnm, hi_index);
 475
 476   /* disable interface */
 477   vnet_sw_interface_set_flags (vnm, hi->sw_if_index, 0 /* down */ );
 478   vnet_hw_interface_set_flags (vnm, hi->hw_if_index, 0 /* down */ );
 479   hash_unset (tuns->hw_if_index_by_dp_table, dp_table);
 480   vec_add1 (lgm->free_tunnel_hw_if_indices, hi->hw_if_index);
 481
 482   /* clean tunnel termination and vni to sw_if_index binding */
 483   vnip = hash_get (tuns->vni_by_sw_if_index, hi->sw_if_index);
 484   if (0 == vnip)
 485     {
 486       clib_warning ("No vni associated to interface %d", hi->sw_if_index);
 487       return;
 488     }
 489   hash_unset (tuns->sw_if_index_by_vni, vnip[0]);
 490   hash_unset (tuns->vni_by_sw_if_index, hi->sw_if_index);
 491 }
 492
 493 static void
 494 lisp_gpe_iface_set_table (u32 sw_if_index, u32 table_id)
 495 {
 496   fib_node_index_t fib_index;
 497
 498   fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id,
 499                                                  FIB_SOURCE_LISP);
 500   ip4_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
 501   ip4_sw_interface_enable_disable (sw_if_index, 1);
 502
 503   fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, table_id,
 504                                                  FIB_SOURCE_LISP);
 505   ip6_main.fib_index_by_sw_if_index[sw_if_index] = fib_index;
 506   ip6_sw_interface_enable_disable (sw_if_index, 1);
 507 }
 508
 509 static void
 510 lisp_gpe_tenant_del_default_routes (u32 table_id)
 511 {
 512   fib_protocol_t proto;
 513
 514   FOR_EACH_FIB_IP_PROTOCOL (proto)
 515   {
 516     fib_prefix_t prefix = {
 517       .fp_proto = proto,
 518     };
 519     u32 fib_index;
 520
 521     fib_index = fib_table_find (prefix.fp_proto, table_id);
 522     fib_table_entry_special_remove (fib_index, &prefix, FIB_SOURCE_LISP);
 523     fib_table_unlock (fib_index, prefix.fp_proto, FIB_SOURCE_LISP);
 524   }
 525 }
 526
 527 static void
 528 lisp_gpe_tenant_add_default_routes (u32 table_id)
 529 {
 530   fib_protocol_t proto;
 531
 532   FOR_EACH_FIB_IP_PROTOCOL (proto)
 533   {
 534     fib_prefix_t prefix = {
 535       .fp_proto = proto,
 536     };
 537     u32 fib_index;
 538
 539     /*
 540      * Add a deafult route that results in a control plane punt DPO
 541      */
 542     fib_index = fib_table_find_or_create_and_lock (prefix.fp_proto, table_id,
 543                                                    FIB_SOURCE_LISP);
 544     fib_table_entry_special_dpo_add (fib_index, &prefix, FIB_SOURCE_LISP,
 545                                      FIB_ENTRY_FLAG_EXCLUSIVE,
 546                                      lisp_cp_dpo_get (fib_proto_to_dpo
 547                                                       (proto)));
 548   }
 549 }
 550
 551
 552 /**
 553  * @brief Add/del LISP-GPE L3 interface.
 554  *
 555  * Creates LISP-GPE interface, sets ingress arcs from lisp_gpeX_lookup,
 556  * installs default routes that attract all traffic with no more specific
 557  * routes to lgpe-ipx-lookup, set egress arcs to ipx-lookup, sets
 558  * the interface in the right vrf and enables it.
 559  *
 560  * @param[in]   lgm     Reference to @ref lisp_gpe_main_t.
 561  * @param[in]   a       Parameters to create interface.
 562  *
 563  * @return number of vectors in frame.
 564  */
 565 u32
 566 lisp_gpe_add_l3_iface (lisp_gpe_main_t * lgm, u32 vni, u32 table_id,
 567                        u8 with_default_routes)
 568 {
 569   vnet_main_t *vnm = lgm->vnet_main;
 570   tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
 571   vnet_hw_interface_t *hi;
 572   uword *hip, *si;
 573
 574   hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
 575
 576   if (hip)
 577     {
 578       clib_warning ("vrf %d already mapped to a vni", table_id);
 579       return ~0;
 580     }
 581
 582   si = hash_get (l3_ifaces->sw_if_index_by_vni, vni);
 583
 584   if (si)
 585     {
 586       clib_warning ("Interface for vni %d already exists", vni);
 587     }
 588
 589   /* create lisp iface and populate tunnel tables */
 590   hi = lisp_gpe_create_iface (lgm, vni, table_id,
 591                               &lisp_gpe_device_class, l3_ifaces);
 592
 593   /* insert default routes that point to lisp-cp lookup */
 594   lisp_gpe_iface_set_table (hi->sw_if_index, table_id);
 595   if (with_default_routes)
 596     lisp_gpe_tenant_add_default_routes (table_id);
 597
 598   /* enable interface */
 599   vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
 600                                VNET_SW_INTERFACE_FLAG_ADMIN_UP);
 601   vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
 602                                VNET_HW_INTERFACE_FLAG_LINK_UP);
 603
 604   return (hi->sw_if_index);
 605 }
 606
 607 void
 608 lisp_gpe_del_l3_iface (lisp_gpe_main_t * lgm, u32 vni, u32 table_id)
 609 {
 610   vnet_main_t *vnm = lgm->vnet_main;
 611   tunnel_lookup_t *l3_ifaces = &lgm->l3_ifaces;
 612   vnet_hw_interface_t *hi;
 613   uword *hip;
 614
 615   hip = hash_get (l3_ifaces->hw_if_index_by_dp_table, table_id);
 616
 617   if (hip == 0)
 618     {
 619       clib_warning ("The interface for vrf %d doesn't exist", table_id);
 620       return;
 621     }
 622
 623   hi = vnet_get_hw_interface (vnm, hip[0]);
 624
 625   lisp_gpe_remove_iface (lgm, hip[0], table_id, &lgm->l3_ifaces);
 626
 627   /* unset default routes */
 628   ip4_sw_interface_enable_disable (hi->sw_if_index, 0);
 629   ip6_sw_interface_enable_disable (hi->sw_if_index, 0);
 630   lisp_gpe_tenant_del_default_routes (table_id);
 631 }
 632
 633 /**
 634  * @brief Add/del LISP-GPE L2 interface.
 635  *
 636  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
 637  * bridge domain, sets egress arcs and enables it.
 638  *
 639  * @param[in]   lgm     Reference to @ref lisp_gpe_main_t.
 640  * @param[in]   a       Parameters to create interface.
 641  *
 642  * @return number of vectors in frame.
 643  */
 644 u32
 645 lisp_gpe_add_l2_iface (lisp_gpe_main_t * lgm, u32 vni, u32 bd_id)
 646 {
 647   vnet_main_t *vnm = lgm->vnet_main;
 648   tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
 649   vnet_hw_interface_t *hi;
 650   uword *hip, *si;
 651   u16 bd_index;
 652
 653   if (bd_id > L2_BD_ID_MAX)
 654     {
 655       clib_warning ("bridge domain ID %d exceed 16M limit", bd_id);
 656       return ~0;
 657     }
 658
 659   bd_index = bd_find_or_add_bd_index (&bd_main, bd_id);
 660   hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
 661
 662   if (hip)
 663     {
 664       clib_warning ("bridge domain %d already mapped to a vni", bd_id);
 665       return ~0;
 666     }
 667
 668   si = hash_get (l2_ifaces->sw_if_index_by_vni, vni);
 669   if (si)
 670     {
 671       clib_warning ("Interface for vni %d already exists", vni);
 672       return ~0;
 673     }
 674
 675   /* create lisp iface and populate tunnel tables */
 676   hi = lisp_gpe_create_iface (lgm, vni, bd_index,
 677                               &l2_lisp_gpe_device_class, &lgm->l2_ifaces);
 678
 679   /* enable interface */
 680   vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
 681                                VNET_SW_INTERFACE_FLAG_ADMIN_UP);
 682   vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
 683                                VNET_HW_INTERFACE_FLAG_LINK_UP);
 684
 685   l2_arc_to_lb = vlib_node_add_named_next (vlib_get_main (),
 686                                            hi->tx_node_index,
 687                                            "l2-load-balance");
 688
 689   /* we're ready. add iface to l2 bridge domain */
 690   set_int_l2_mode (lgm->vlib_main, vnm, MODE_L2_BRIDGE, hi->sw_if_index,
 691                    bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
 692
 693   return (hi->sw_if_index);
 694 }
 695
 696 /**
 697  * @brief Add/del LISP-GPE L2 interface.
 698  *
 699  * Creates LISP-GPE interface, sets it in L2 mode in the appropriate
 700  * bridge domain, sets egress arcs and enables it.
 701  *
 702  * @param[in]   lgm     Reference to @ref lisp_gpe_main_t.
 703  * @param[in]   a       Parameters to create interface.
 704  *
 705  * @return number of vectors in frame.
 706  */
 707 void
 708 lisp_gpe_del_l2_iface (lisp_gpe_main_t * lgm, u32 vni, u32 bd_id)
 709 {
 710   tunnel_lookup_t *l2_ifaces = &lgm->l2_ifaces;
 711   vnet_hw_interface_t *hi;
 712
 713   u32 bd_index = bd_find_index (&bd_main, bd_id);
 714   ASSERT (bd_index != ~0);
 715   uword *hip = hash_get (l2_ifaces->hw_if_index_by_dp_table, bd_index);
 716
 717   if (hip == 0)
 718     {
 719       clib_warning ("The interface for bridge domain %d doesn't exist",
 720                     bd_id);
 721       return;
 722     }
 723
 724   /* Remove interface from bridge .. by enabling L3 mode */
 725   hi = vnet_get_hw_interface (lgm->vnet_main, hip[0]);
 726   set_int_l2_mode (lgm->vlib_main, lgm->vnet_main, MODE_L3, hi->sw_if_index,
 727                    0, L2_BD_PORT_TYPE_NORMAL, 0, 0);
 728   lisp_gpe_remove_iface (lgm, hip[0], bd_index, &lgm->l2_ifaces);
 729 }
 730
 731 /**
 732  * @brief Add LISP-GPE NSH interface.
 733  *
 734  * Creates LISP-GPE interface, sets it in L3 mode.
 735  *
 736  * @param[in]   lgm     Reference to @ref lisp_gpe_main_t.
 737  * @param[in]   a       Parameters to create interface.
 738  *
 739  * @return sw_if_index.
 740  */
 741 u32
 742 vnet_lisp_gpe_add_nsh_iface (lisp_gpe_main_t * lgm)
 743 {
 744   vnet_main_t *vnm = lgm->vnet_main;
 745   tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
 746   vnet_hw_interface_t *hi;
 747   uword *hip, *si;
 748
 749   hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
 750
 751   if (hip)
 752     {
 753       clib_warning ("NSH interface 0 already exists");
 754       return ~0;
 755     }
 756
 757   si = hash_get (nsh_ifaces->sw_if_index_by_vni, 0);
 758   if (si)
 759     {
 760       clib_warning ("NSH interface already exists");
 761       return ~0;
 762     }
 763
 764   /* create lisp iface and populate tunnel tables */
 765   hi = lisp_gpe_create_iface (lgm, 0, 0,
 766                               &nsh_lisp_gpe_device_class, &lgm->nsh_ifaces);
 767
 768   /* enable interface */
 769   vnet_sw_interface_set_flags (vnm, hi->sw_if_index,
 770                                VNET_SW_INTERFACE_FLAG_ADMIN_UP);
 771   vnet_hw_interface_set_flags (vnm, hi->hw_if_index,
 772                                VNET_HW_INTERFACE_FLAG_LINK_UP);
 773
 774   return (hi->sw_if_index);
 775 }
 776
 777 /**
 778  * @brief Del LISP-GPE NSH interface.
 779  *
 780  */
 781 void
 782 vnet_lisp_gpe_del_nsh_iface (lisp_gpe_main_t * lgm)
 783 {
 784   tunnel_lookup_t *nsh_ifaces = &lgm->nsh_ifaces;
 785   uword *hip;
 786
 787   hip = hash_get (nsh_ifaces->hw_if_index_by_dp_table, 0);
 788
 789   if (hip == 0)
 790     {
 791       clib_warning ("The NSH 0 interface doesn't exist");
 792       return;
 793     }
 794   lisp_gpe_remove_iface (lgm, hip[0], 0, &lgm->nsh_ifaces);
 795 }
 796
 797 static clib_error_t *
 798 lisp_gpe_add_del_iface_command_fn (vlib_main_t * vm, unformat_input_t * input,
 799                                    vlib_cli_command_t * cmd)
 800 {
 801   unformat_input_t _line_input, *line_input = &_line_input;
 802   u8 is_add = 1;
 803   u32 table_id, vni, bd_id;
 804   u8 vni_is_set = 0, vrf_is_set = 0, bd_index_is_set = 0;
 805   u8 nsh_iface = 0;
 806   clib_error_t *error = NULL;
 807
 808   if (vnet_lisp_gpe_enable_disable_status () == 0)
 809     {
 810       return clib_error_return (0, "LISP is disabled");
 811     }
 812
 813   /* Get a line of input. */
 814   if (!unformat_user (input, unformat_line_input, line_input))
 815     return 0;
 816
 817   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 818     {
 819       if (unformat (line_input, "add"))
 820         is_add = 1;
 821       else if (unformat (line_input, "del"))
 822         is_add = 0;
 823       else if (unformat (line_input, "vrf %d", &table_id))
 824         {
 825           vrf_is_set = 1;
 826         }
 827       else if (unformat (line_input, "vni %d", &vni))
 828         {
 829           vni_is_set = 1;
 830         }
 831       else if (unformat (line_input, "bd %d", &bd_id))
 832         {
 833           bd_index_is_set = 1;
 834         }
 835       else if (unformat (line_input, "nsh"))
 836         {
 837           nsh_iface = 1;
 838         }
 839       else
 840         {
 841           error = clib_error_return (0, "parse error: '%U'",
 842                                      format_unformat_error, line_input);
 843           goto done;
 844         }
 845     }
 846
 847   if (nsh_iface)
 848     {
 849       if (is_add)
 850         {
 851           if (~0 == vnet_lisp_gpe_add_nsh_iface (&lisp_gpe_main))
 852             {
 853               error = clib_error_return (0, "NSH interface not created");
 854               goto done;
 855             }
 856         }
 857       else
 858         {
 859           vnet_lisp_gpe_del_nsh_iface (&lisp_gpe_main);
 860         }
 861       goto done;
 862     }
 863
 864   if (vrf_is_set && bd_index_is_set)
 865     {
 866       error = clib_error_return
 867         (0, "Cannot set both vrf and brdige domain index!");
 868       goto done;
 869     }
 870
 871   if (!vni_is_set)
 872     {
 873       error = clib_error_return (0, "vni must be set!");
 874       goto done;
 875     }
 876
 877   if (!vrf_is_set && !bd_index_is_set)
 878     {
 879       error =
 880         clib_error_return (0, "vrf or bridge domain index must be set!");
 881       goto done;
 882     }
 883
 884   if (bd_index_is_set)
 885     {
 886       if (is_add)
 887         {
 888           if (~0 == lisp_gpe_tenant_l2_iface_add_or_lock (vni, bd_id))
 889             {
 890               error = clib_error_return (0, "L2 interface not created");
 891               goto done;
 892             }
 893         }
 894       else
 895         lisp_gpe_tenant_l2_iface_unlock (vni);
 896     }
 897   else
 898     {
 899       if (is_add)
 900         {
 901           if (~0 == lisp_gpe_tenant_l3_iface_add_or_lock (vni, table_id, 1
 902                                                           /* with_default_route */
 903               ))
 904             {
 905               error = clib_error_return (0, "L3 interface not created");
 906               goto done;
 907             }
 908         }
 909       else
 910         lisp_gpe_tenant_l3_iface_unlock (vni);
 911     }
 912
 913 done:
 914   unformat_free (line_input);
 915
 916   return error;
 917 }
 918
 919 VLIB_CLI_COMMAND (add_del_lisp_gpe_iface_command, static) = {
 920   .path = "gpe iface",
 921   .short_help = "gpe iface add/del vni <vni> vrf <vrf>",
 922   .function = lisp_gpe_add_del_iface_command_fn,
 923 };
 924
 925 /*
 926  * fd.io coding-style-patch-verification: ON
 927  *
 928  * Local Variables:
 929  * eval: (c-set-style "gnu")
 930  * End:
 931  */