X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vnet%2Fvnet%2Fvxlan%2Fvxlan.c;h=86d49248e622bc56da0521857553d18def55719c;hb=5b7a563ff0a39b74a0f037572b7709e3c9aa5cf2;hp=28ed173c020f1d2d4c112754ce36ffb351dda31a;hpb=2d34374f7d2f624a4a66cf46d4d11e5b49808ada;p=vpp.git

diff --git a/vnet/vnet/vxlan/vxlan.c b/vnet/vnet/vxlan/vxlan.c
index 28ed173c020..86d49248e62 100644
--- a/vnet/vnet/vxlan/vxlan.c
+++ b/vnet/vnet/vxlan/vxlan.c
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include <vnet/vxlan/vxlan.h>
+#include <vnet/ip/format.h>
 
 vxlan_main_t vxlan_main;
 
@@ -44,8 +45,8 @@ u8 * format_vxlan_tunnel (u8 * s, va_list * args)
   s = format (s, 
               "[%d] %U (src) %U (dst) vni %d encap_fib_index %d",
               t - ngm->tunnels,
-              format_ip4_address, &t->src,
-              format_ip4_address, &t->dst,
+              format_ip46_address, &t->src, IP46_TYPE_ANY,
+              format_ip46_address, &t->dst, IP46_TYPE_ANY,
               t->vni,
               t->encap_fib_index);
   s = format (s, " decap_next %U\n", format_decap_next, t->decap_next_index);
@@ -66,11 +67,23 @@ static uword dummy_interface_tx (vlib_main_t * vm,
   return frame->n_vectors;
 }
 
+static clib_error_t *
+vxlan_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
+{
+  if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
+    vnet_hw_interface_set_flags (vnm, hw_if_index, VNET_HW_INTERFACE_FLAG_LINK_UP);
+  else
+    vnet_hw_interface_set_flags (vnm, hw_if_index, 0);
+
+  return /* no error */ 0;
+}
+
 VNET_DEVICE_CLASS (vxlan_device_class,static) = {
   .name = "VXLAN",
   .format_device_name = format_vxlan_name,
   .format_tx_trace = format_vxlan_encap_trace,
   .tx_function = dummy_interface_tx,
+  .admin_up_down_function = vxlan_interface_admin_up_down,
 };
 
 static uword dummy_set_rewrite (vnet_main_t * vnm,
@@ -97,13 +110,23 @@ VNET_HW_INTERFACE_CLASS (vxlan_hw_class) = {
 };
 
 #define foreach_copy_field                      \
-_(src.as_u32)                                   \
-_(dst.as_u32)                                   \
 _(vni)                                          \
 _(encap_fib_index)                              \
 _(decap_next_index)
 
-static int vxlan_rewrite (vxlan_tunnel_t * t)
+#define foreach_copy_ipv4 {                     \
+  _(src.ip4.as_u32)                             \
+  _(dst.ip4.as_u32)                             \
+}
+
+#define foreach_copy_ipv6 {                     \
+  _(src.ip6.as_u64[0])                          \
+  _(src.ip6.as_u64[1])                          \
+  _(dst.ip6.as_u64[0])                          \
+  _(dst.ip6.as_u64[1])                          \
+}
+
+static int vxlan4_rewrite (vxlan_tunnel_t * t)
 {
   u8 *rw = 0;
   ip4_header_t * ip0;
@@ -121,8 +144,8 @@ static int vxlan_rewrite (vxlan_tunnel_t * t)
   ip0->protocol = IP_PROTOCOL_UDP;
 
   /* we fix up the ip4 header length and checksum after-the-fact */
-  ip0->src_address.as_u32 = t->src.as_u32;
-  ip0->dst_address.as_u32 = t->dst.as_u32;
+  ip0->src_address.as_u32 = t->src.ip4.as_u32;
+  ip0->dst_address.as_u32 = t->dst.ip4.as_u32;
   ip0->checksum = ip4_header_checksum (ip0);
 
   /* UDP header, randomize src port on something, maybe? */
@@ -136,6 +159,39 @@ static int vxlan_rewrite (vxlan_tunnel_t * t)
   return (0);
 }
 
+static int vxlan6_rewrite (vxlan_tunnel_t * t)
+{
+  u8 *rw = 0;
+  ip6_header_t * ip0;
+  ip6_vxlan_header_t * h0;
+  int len = sizeof (*h0);
+
+  vec_validate_aligned (rw, len-1, CLIB_CACHE_LINE_BYTES);
+
+  h0 = (ip6_vxlan_header_t *) rw;
+
+  /* Fixed portion of the (outer) ip6 header */
+  ip0 = &h0->ip6;
+  ip0->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32(6 << 28);
+  ip0->hop_limit = 255;
+  ip0->protocol = IP_PROTOCOL_UDP;
+
+  ip0->src_address.as_u64[0] = t->src.ip6.as_u64[0];
+  ip0->src_address.as_u64[1] = t->src.ip6.as_u64[1];
+  ip0->dst_address.as_u64[0] = t->dst.ip6.as_u64[0];
+  ip0->dst_address.as_u64[1] = t->dst.ip6.as_u64[1];
+
+  /* UDP header, randomize src port on something, maybe? */
+  h0->udp.src_port = clib_host_to_net_u16 (4789);
+  h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_vxlan);
+
+  /* VXLAN header */
+  vnet_set_vni_and_flags(&h0->vxlan, t->vni);
+
+  t->rewrite = rw;
+  return (0);
+}
+
 int vnet_vxlan_add_del_tunnel 
 (vnet_vxlan_add_del_tunnel_args_t *a, u32 * sw_if_indexp)
 {
@@ -143,17 +199,28 @@ int vnet_vxlan_add_del_tunnel
   vxlan_tunnel_t *t = 0;
   vnet_main_t * vnm = vxm->vnet_main;
   ip4_main_t * im4 = &ip4_main;
+  ip6_main_t * im6 = &ip6_main;
   vnet_hw_interface_t * hi;
   uword * p;
   u32 hw_if_index = ~0;
   u32 sw_if_index = ~0;
   int rv;
-  vxlan_tunnel_key_t key;
+  vxlan4_tunnel_key_t key4;
+  vxlan6_tunnel_key_t key6;
+  l2output_main_t * l2om = &l2output_main;
+
+  if (!a->is_ip6) {
+    key4.src = a->dst.ip4.as_u32; /* decap src in key is encap dst in config */
+    key4.vni = clib_host_to_net_u32 (a->vni << 8);
   
-  key.src = a->dst.as_u32; /* decap src in key is encap dst in config */
-  key.vni = clib_host_to_net_u32 (a->vni << 8);
+    p = hash_get (vxm->vxlan4_tunnel_by_key, key4.as_u64);
+  } else {
+    key6.src.as_u64[0] = a->dst.ip6.as_u64[0];
+    key6.src.as_u64[1] = a->dst.ip6.as_u64[1];
+    key6.vni = clib_host_to_net_u32 (a->vni << 8);
 
-  p = hash_get (vxm->vxlan_tunnel_by_key, key.as_u64);
+    p = hash_get_mem (vxm->vxlan6_tunnel_by_key, &key6);
+  }
   
   if (a->is_add)
     {
@@ -173,9 +240,28 @@ int vnet_vxlan_add_del_tunnel
       /* copy from arg structure */
 #define _(x) t->x = a->x;
       foreach_copy_field;
+      if (!a->is_ip6) foreach_copy_ipv4
+      else            foreach_copy_ipv6
 #undef _
       
-      rv = vxlan_rewrite (t);
+      /* copy the key */
+      if (a->is_ip6)
+        {
+          t->key6 = clib_mem_alloc (sizeof(vxlan6_tunnel_key_t));
+          clib_memcpy (t->key6, &key6, sizeof(key6));
+        }
+      else
+        {
+          t->key4 = 0; /* not yet used */
+        }
+
+      if (!a->is_ip6) t->flags |= VXLAN_TUNNEL_IS_IPV4;
+
+      if (!a->is_ip6) {
+        rv = vxlan4_rewrite (t);
+      } else {
+        rv = vxlan6_rewrite (t);
+      }
 
       if (rv)
         {
@@ -183,7 +269,10 @@ int vnet_vxlan_add_del_tunnel
           return rv;
         }
 
-      hash_set (vxm->vxlan_tunnel_by_key, key.as_u64, t - vxm->tunnels);
+      if (!a->is_ip6)
+        hash_set (vxm->vxlan4_tunnel_by_key, key4.as_u64, t - vxm->tunnels);
+      else
+        hash_set_mem (vxm->vxlan6_tunnel_by_key, t->key6, t - vxm->tunnels);
       
       if (vec_len (vxm->free_vxlan_tunnel_hw_if_indices) > 0)
         {
@@ -230,10 +319,24 @@ int vnet_vxlan_add_del_tunnel
 	  l2im->configs[sw_if_index].feature_bitmap = L2INPUT_FEAT_DROP;
 	  l2im->configs[sw_if_index].bd_index = 0;
 	}
+      
+      /* 
+       * Directs the l2 output path to work out the interface
+       * output next-arc itself. Needed when recycling a tunnel.
+       */
+      vec_validate_init_empty(l2om->next_nodes.output_node_index_vec, 
+                              sw_if_index, ~0);
+      l2om->next_nodes.output_node_index_vec[t->sw_if_index] 
+        = ~0;
       vnet_sw_interface_set_flags (vnm, sw_if_index, 
                                    VNET_SW_INTERFACE_FLAG_ADMIN_UP);
+      if (!a->is_ip6) {
       vec_validate (im4->fib_index_by_sw_if_index, sw_if_index);
       im4->fib_index_by_sw_if_index[sw_if_index] = t->encap_fib_index;
+      } else {
+        vec_validate (im6->fib_index_by_sw_if_index, sw_if_index);
+        im6->fib_index_by_sw_if_index[sw_if_index] = t->encap_fib_index;
+      }
     }
   else
     {
@@ -250,10 +353,16 @@ int vnet_vxlan_add_del_tunnel
 
       vxm->tunnel_index_by_sw_if_index[t->sw_if_index] = ~0;
 
-      hash_unset (vxm->vxlan_tunnel_by_key, key.as_u64);
+      /* Directs the l2 path to turf packets sent to this sw_if_index */
+      l2om->next_nodes.output_node_index_vec[t->sw_if_index] 
+        = L2OUTPUT_NEXT_DEL_TUNNEL;
+
+      if (!a->is_ip6)
+        hash_unset (vxm->vxlan4_tunnel_by_key, key4.as_u64);
+      else
+        hash_unset_mem (vxm->vxlan6_tunnel_by_key, t->key6);
 
       vec_free (t->rewrite);
-      t->rewrite = vxlan_dummy_rewrite;
       pool_put (vxm->tunnels, t);
     }
 
@@ -263,7 +372,7 @@ int vnet_vxlan_add_del_tunnel
   return 0;
 }
 
-static u32 fib_index_from_fib_id (u32 fib_id)
+static u32 fib4_index_from_fib_id (u32 fib_id)
 {
   ip4_main_t * im = &ip4_main;
   uword * p;
@@ -275,6 +384,18 @@ static u32 fib_index_from_fib_id (u32 fib_id)
   return p[0];
 }
 
+static u32 fib6_index_from_fib_id (u32 fib_id)
+{
+  ip6_main_t * im = &ip6_main;
+  uword * p;
+
+  p = hash_get (im->fib_index_by_table_id, fib_id);
+  if (!p)
+    return ~0;
+
+  return p[0];
+}
+
 static uword unformat_decap_next (unformat_input_t * input, va_list * args)
 {
   u32 * result = va_arg (*args, u32 *);
@@ -301,16 +422,19 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
                                    vlib_cli_command_t * cmd)
 {
   unformat_input_t _line_input, * line_input = &_line_input;
-  ip4_address_t src, dst;
+  ip46_address_t src, dst;
   u8 is_add = 1;
   u8 src_set = 0;
   u8 dst_set = 0;
+  u8 ipv4_set = 0;
+  u8 ipv6_set = 0;
   u32 encap_fib_index = 0;
   u32 decap_next_index = ~0;
   u32 vni = 0;
   u32 tmp;
   int rv;
   vnet_vxlan_add_del_tunnel_args_t _a, * a = &_a;
+  u32 sw_if_index;
   
   /* Get a line of input. */
   if (! unformat_user (input, unformat_line_input, line_input))
@@ -318,16 +442,39 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
 
   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
     if (unformat (line_input, "del"))
-      is_add = 0;
+      {
+        is_add = 0;
+      }
+    else if (unformat (line_input, "src %U",
+                       unformat_ip4_address, &src.ip4))
+      {
+        src_set = 1;
+        ipv4_set = 1;
+      }
+    else if (unformat (line_input, "dst %U",
+                       unformat_ip4_address, &dst.ip4))
+      {
+        dst_set = 1;
+        ipv4_set = 1;
+      }
     else if (unformat (line_input, "src %U", 
-                       unformat_ip4_address, &src))
-      src_set = 1;
+                       unformat_ip6_address, &src.ip6))
+      {
+        src_set = 1;
+        ipv6_set = 1;
+      }
     else if (unformat (line_input, "dst %U",
-                       unformat_ip4_address, &dst))
-      dst_set = 1;
+                       unformat_ip6_address, &dst.ip6))
+      {
+        dst_set = 1;
+        ipv6_set = 1;
+      }
     else if (unformat (line_input, "encap-vrf-id %d", &tmp))
       {
-        encap_fib_index = fib_index_from_fib_id (tmp);
+        if (ipv6_set)
+          encap_fib_index = fib6_index_from_fib_id (tmp);
+        else
+          encap_fib_index = fib4_index_from_fib_id (tmp);
         if (encap_fib_index == ~0)
           return clib_error_return (0, "nonexistent encap-vrf-id %d", tmp);
       }
@@ -352,22 +499,34 @@ vxlan_add_del_tunnel_command_fn (vlib_main_t * vm,
   if (dst_set == 0)
     return clib_error_return (0, "tunnel dst address not specified");
 
+  if (ipv4_set && ipv6_set)
+    return clib_error_return (0, "both IPv4 and IPv6 addresses specified");
+
+  if ((ipv4_set && memcmp(&src.ip4, &dst.ip4, sizeof(src.ip4)) == 0) ||
+      (ipv6_set && memcmp(&src.ip6, &dst.ip6, sizeof(src.ip6)) == 0))
+    return clib_error_return (0, "src and dst addresses are identical");
+
   if (vni == 0)
     return clib_error_return (0, "vni not specified");
 
   memset (a, 0, sizeof (*a));
 
   a->is_add = is_add;
+  a->is_ip6 = ipv6_set;
 
 #define _(x) a->x = x;
   foreach_copy_field;
+  if (ipv4_set) foreach_copy_ipv4
+  else          foreach_copy_ipv6
 #undef _
   
-  rv = vnet_vxlan_add_del_tunnel (a, 0 /* hw_if_indexp */);
+  rv = vnet_vxlan_add_del_tunnel (a, &sw_if_index);
 
   switch(rv)
     {
     case 0:
+      if (is_add)
+        vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index);
       break;
     case VNET_API_ERROR_INVALID_DECAP_NEXT:
       return clib_error_return (0, "invalid decap-next...");
@@ -418,27 +577,24 @@ VLIB_CLI_COMMAND (show_vxlan_tunnel_command, static) = {
     .function = show_vxlan_tunnel_command_fn,
 };
 
+
 clib_error_t *vxlan_init (vlib_main_t *vm)
 {
   vxlan_main_t * vxm = &vxlan_main;
-  ip4_vxlan_header_t * hdr;
-  ip4_header_t * ip;
   
   vxm->vnet_main = vnet_get_main();
   vxm->vlib_main = vm;
 
-  /* init dummy rewrite string for deleted vxlan tunnels */
-  _vec_len(vxlan_dummy_rewrite) = sizeof(ip4_vxlan_header_t);
-  hdr = (ip4_vxlan_header_t *) vxlan_dummy_rewrite;
-  ip = &hdr->ip4;
-  /* minimal rewrite setup, see vxlan_rewite() above as reference */
-  ip->ip_version_and_header_length = 0x45;
-  ip->checksum = ip4_header_checksum (ip);
- 
+  /* initialize the ip6 hash */
+  vxm->vxlan6_tunnel_by_key = hash_create_mem(0,
+        sizeof(vxlan6_tunnel_key_t),
+        sizeof(uword));
+
   udp_register_dst_port (vm, UDP_DST_PORT_vxlan, 
-                         vxlan_input_node.index, 1 /* is_ip4 */);
+                         vxlan4_input_node.index, /* is_ip4 */ 1);
+  udp_register_dst_port (vm, UDP_DST_PORT_vxlan6,
+                         vxlan6_input_node.index, /* is_ip4 */ 0);
   return 0;
 }
 
 VLIB_INIT_FUNCTION(vxlan_init);
-