src/vnet/lisp-gpe/lisp_gpe_tunnel.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 tunnels.
  18  *
  19  */
  20 #include <vnet/lisp-gpe/lisp_gpe.h>
  21 #include <vnet/lisp-gpe/lisp_gpe_tunnel.h>
  22 #include <vnet/lisp-gpe/lisp_gpe_adjacency.h>
  23
  24 #include <vnet/fib/fib_table.h>
  25
  26 /**
  27  * @brief Pool of all LISP tunnels
  28  */
  29 static lisp_gpe_tunnel_t *lisp_gpe_tunnel_pool;
  30
  31 /**
  32  * @brief a DB of all tunnels
  33  */
  34 static uword *lisp_gpe_tunnel_db;
  35
  36 /**
  37  * @brief Compute IP-UDP-GPE sub-tunnel encap/rewrite header.
  38  *
  39  * @param[in]   t       Parent of the sub-tunnel.
  40  * @param[in]   st      Sub-tunnel.
  41  * @param[in]   lp      Local and remote locators used in the encap header.
  42  *
  43  * @return 0 on success.
  44  */
  45 u8 *
  46 lisp_gpe_tunnel_build_rewrite (const lisp_gpe_tunnel_t * lgt,
  47                                const lisp_gpe_adjacency_t * ladj,
  48                                lisp_gpe_next_protocol_e payload_proto)
  49 {
  50   lisp_gpe_header_t *lisp0;
  51   u8 *rw = 0;
  52   int len;
  53   gpe_encap_mode_t encap_mode = vnet_gpe_get_encap_mode ();
  54
  55   if (IP4 == ip_addr_version (&lgt->key->lcl))
  56     {
  57       ip4_udp_lisp_gpe_header_t *h0;
  58       ip4_header_t *ip0;
  59
  60       len = sizeof (*h0);
  61
  62       vec_validate_aligned (rw, len - 1, CLIB_CACHE_LINE_BYTES);
  63
  64       h0 = (ip4_udp_lisp_gpe_header_t *) rw;
  65
  66       /* Fixed portion of the (outer) ip4 header */
  67       ip0 = &h0->ip4;
  68       ip0->ip_version_and_header_length = 0x45;
  69       ip0->ttl = 254;
  70       ip0->protocol = IP_PROTOCOL_UDP;
  71
  72       /* we fix up the ip4 header length and checksum after-the-fact */
  73       ip_address_copy_addr (&ip0->src_address, &lgt->key->lcl);
  74       ip_address_copy_addr (&ip0->dst_address, &lgt->key->rmt);
  75       ip0->checksum = ip4_header_checksum (ip0);
  76
  77       /* UDP header, randomize src port on something, maybe? */
  78       h0->udp.src_port = clib_host_to_net_u16 (4341);
  79       h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe);
  80
  81       /* LISP-gpe header */
  82       lisp0 = &h0->lisp;
  83     }
  84   else
  85     {
  86       ip6_udp_lisp_gpe_header_t *h0;
  87       ip6_header_t *ip0;
  88
  89       len = sizeof (*h0);
  90
  91       vec_validate_aligned (rw, len - 1, CLIB_CACHE_LINE_BYTES);
  92
  93       h0 = (ip6_udp_lisp_gpe_header_t *) rw;
  94
  95       /* Fixed portion of the (outer) ip6 header */
  96       ip0 = &h0->ip6;
  97       ip0->ip_version_traffic_class_and_flow_label =
  98         clib_host_to_net_u32 (0x6 << 28);
  99       ip0->hop_limit = 254;
 100       ip0->protocol = IP_PROTOCOL_UDP;
 101
 102       /* we fix up the ip6 header length after-the-fact */
 103       ip_address_copy_addr (&ip0->src_address, &lgt->key->lcl);
 104       ip_address_copy_addr (&ip0->dst_address, &lgt->key->rmt);
 105
 106       /* UDP header, randomize src port on something, maybe? */
 107       h0->udp.src_port = clib_host_to_net_u16 (4341);
 108       h0->udp.dst_port = clib_host_to_net_u16 (UDP_DST_PORT_lisp_gpe);
 109
 110       /* LISP-gpe header */
 111       lisp0 = &h0->lisp;
 112     }
 113
 114   lisp0->flags = ladj->flags;
 115   if (GPE_ENCAP_VXLAN == encap_mode)
 116     /* unset P flag */
 117     lisp0->flags &= ~LISP_GPE_FLAGS_P;
 118
 119   lisp0->ver_res = 0;
 120   lisp0->res = 0;
 121   lisp0->next_protocol = payload_proto;
 122   lisp0->iid = clib_host_to_net_u32 (ladj->vni) >> 8;   /* first 24 bits only */
 123
 124   return (rw);
 125 }
 126
 127 static lisp_gpe_tunnel_t *
 128 lisp_gpe_tunnel_db_find (const lisp_gpe_tunnel_key_t * key)
 129 {
 130   uword *p;
 131
 132   p = hash_get_mem (lisp_gpe_tunnel_db, (void *) key);
 133
 134   if (NULL != p)
 135     {
 136       return (pool_elt_at_index (lisp_gpe_tunnel_pool, p[0]));
 137     }
 138   return (NULL);
 139 }
 140
 141 lisp_gpe_tunnel_t *
 142 lisp_gpe_tunnel_get_i (index_t lgti)
 143 {
 144   return (pool_elt_at_index (lisp_gpe_tunnel_pool, lgti));
 145 }
 146
 147 index_t
 148 lisp_gpe_tunnel_find_or_create_and_lock (const locator_pair_t * pair,
 149                                          u32 rloc_fib_index)
 150 {
 151   lisp_gpe_tunnel_key_t key = {
 152     .lcl = pair->lcl_loc,
 153     .rmt = pair->rmt_loc,
 154     .fib_index = rloc_fib_index,
 155   };
 156   lisp_gpe_tunnel_t *lgt;
 157   fib_prefix_t pfx;
 158
 159   lgt = lisp_gpe_tunnel_db_find (&key);
 160
 161   if (NULL == lgt)
 162     {
 163       pool_get (lisp_gpe_tunnel_pool, lgt);
 164       memset (lgt, 0, sizeof (*lgt));
 165
 166       lgt->key = clib_mem_alloc (sizeof (*lgt->key));
 167       memset (lgt->key, 0, sizeof (*lgt->key));
 168
 169       lgt->key->rmt = pair->rmt_loc;
 170       lgt->key->lcl = pair->lcl_loc;
 171       lgt->key->fib_index = rloc_fib_index;
 172
 173       /*
 174        * source the FIB entry for the RLOC so we can track its forwarding
 175        * chain
 176        */
 177       ip_address_to_fib_prefix (&lgt->key->rmt, &pfx);
 178
 179       lgt->fib_entry_index = fib_table_entry_special_add (rloc_fib_index,
 180                                                           &pfx,
 181                                                           FIB_SOURCE_RR,
 182                                                           FIB_ENTRY_FLAG_NONE,
 183                                                           ADJ_INDEX_INVALID);
 184
 185       hash_set_mem (lisp_gpe_tunnel_db, &lgt->key,
 186                     (lgt - lisp_gpe_tunnel_pool));
 187     }
 188
 189   lgt->locks++;
 190
 191   return (lgt - lisp_gpe_tunnel_pool);
 192 }
 193
 194 void
 195 lisp_gpe_tunnel_unlock (index_t lgti)
 196 {
 197   lisp_gpe_tunnel_t *lgt;
 198
 199   lgt = lisp_gpe_tunnel_get_i (lgti);
 200   lgt->locks--;
 201
 202   if (0 == lgt->locks)
 203     {
 204       hash_unset_mem (lisp_gpe_tunnel_db, &lgt->key);
 205       clib_mem_free (lgt->key);
 206       pool_put (lisp_gpe_tunnel_pool, lgt);
 207     }
 208 }
 209
 210 const lisp_gpe_tunnel_t *
 211 lisp_gpe_tunnel_get (index_t lgti)
 212 {
 213   return (lisp_gpe_tunnel_get_i (lgti));
 214 }
 215
 216 /** Format LISP-GPE tunnel. */
 217 u8 *
 218 format_lisp_gpe_tunnel (u8 * s, va_list * args)
 219 {
 220   lisp_gpe_tunnel_t *lgt = va_arg (*args, lisp_gpe_tunnel_t *);
 221
 222   s = format (s, "tunnel %d\n", lgt - lisp_gpe_tunnel_pool);
 223   s = format (s, " fib-index: %d, locks:%d \n",
 224               lgt->key->fib_index, lgt->locks);
 225   s = format (s, " lisp ver 0\n");
 226
 227   s = format (s, " locator-pair:\n");
 228   s = format (s, "  local: %U remote: %U\n",
 229               format_ip_address, &lgt->key->lcl,
 230               format_ip_address, &lgt->key->rmt);
 231   s = format (s, " RLOC FIB entry: %d\n", lgt->fib_entry_index);
 232
 233   return s;
 234 }
 235
 236 /**
 237  * CLI command to show LISP-GPE tunnels.
 238  */
 239 static clib_error_t *
 240 show_lisp_gpe_tunnel_command_fn (vlib_main_t * vm,
 241                                  unformat_input_t * input,
 242                                  vlib_cli_command_t * cmd)
 243 {
 244   lisp_gpe_tunnel_t *lgt;
 245   index_t index;
 246
 247   if (pool_elts (lisp_gpe_tunnel_pool) == 0)
 248     vlib_cli_output (vm, "No lisp-gpe tunnels configured...");
 249
 250   if (unformat (input, "%d", &index))
 251     {
 252       lgt = lisp_gpe_tunnel_get_i (index);
 253       vlib_cli_output (vm, "%U", format_lisp_gpe_tunnel, lgt);
 254     }
 255   else
 256     {
 257       /* *INDENT-OFF* */
 258       pool_foreach (lgt, lisp_gpe_tunnel_pool,
 259       ({
 260         vlib_cli_output (vm, "%U", format_lisp_gpe_tunnel, lgt);
 261       }));
 262       /* *INDENT-ON* */
 263     }
 264
 265   return 0;
 266 }
 267
 268 /* *INDENT-OFF* */
 269 VLIB_CLI_COMMAND (show_lisp_gpe_tunnel_command, static) =
 270 {
 271   .path = "show gpe tunnel",
 272   .function = show_lisp_gpe_tunnel_command_fn,
 273 };
 274 /* *INDENT-ON* */
 275
 276 static clib_error_t *
 277 lisp_gpe_tunnel_module_init (vlib_main_t * vm)
 278 {
 279   lisp_gpe_tunnel_db = hash_create_mem (0,
 280                                         sizeof (lisp_gpe_tunnel_key_t),
 281                                         sizeof (uword));
 282
 283   return (NULL);
 284 }
 285
 286 VLIB_INIT_FUNCTION (lisp_gpe_tunnel_module_init);
 287
 288 /*
 289  * fd.io coding-style-patch-verification: ON
 290  *
 291  * Local Variables:
 292  * eval: (c-set-style "gnu")
 293  * End:
 294  */