src/plugins/srv6-ad-flow/ad-flow.c

   1 /*
   2  * Copyright (c) 2015 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  *------------------------------------------------------------------
  18  * ad-flow.c - SRv6 Flow-based Dynamic Proxy (AD.Flow) behavior
  19  *------------------------------------------------------------------
  20  */
  21
  22 #include <vnet/vnet.h>
  23 #include <vnet/adj/adj.h>
  24 #include <vnet/plugin/plugin.h>
  25 #include <vpp/app/version.h>
  26 #include <srv6-ad-flow/ad-flow.h>
  27
  28 #include <vppinfra/bihash_template.c>
  29
  30 #define SID_CREATE_IFACE_FEATURE_ERROR -1
  31 #define SID_CREATE_INVALID_IFACE_TYPE  -3
  32 #define SID_CREATE_INVALID_IFACE_INDEX -4
  33 #define SID_CREATE_INVALID_ADJ_INDEX   -5
  34
  35 unsigned char function_name[] = "SRv6-AD-Flow-plugin";
  36 unsigned char keyword_str[] = "End.AD.Flow";
  37 unsigned char def_str[] =
  38   "Endpoint with flow-based dynamic proxy to SR-unaware appliance";
  39 unsigned char params_str[] = "nh <next-hop> oif <iface-out> iif <iface-in>";
  40
  41 srv6_ad_flow_main_t srv6_ad_flow_main;
  42
  43 static u32
  44 ad_flow_calc_bihash_buckets (u32 n_elts)
  45 {
  46   return 1 << (max_log2 (n_elts >> 1) + 1);
  47 }
  48
  49 static u32
  50 ad_flow_calc_bihash_memory (u32 n_buckets, uword kv_size)
  51 {
  52   return n_buckets * (8 + kv_size * 4);
  53 }
  54
  55 /*****************************************/
  56 /* SRv6 LocalSID instantiation and removal functions */
  57 static int
  58 srv6_ad_flow_localsid_creation_fn (ip6_sr_localsid_t *localsid)
  59 {
  60   ip6_sr_main_t *srm = &sr_main;
  61   srv6_ad_flow_main_t *sm = &srv6_ad_flow_main;
  62   srv6_ad_flow_localsid_t *ls_mem = localsid->plugin_mem;
  63   u32 localsid_index = localsid - srm->localsids;
  64
  65   /* Step 1: Prepare xconnect adjacency for sending packets to the VNF */
  66
  67   /* Retrieve the adjacency corresponding to the (OIF, next_hop) */
  68   adj_index_t nh_adj_index = ADJ_INDEX_INVALID;
  69   if (ls_mem->inner_type == AD_TYPE_IP4)
  70     nh_adj_index =
  71       adj_nbr_add_or_lock (FIB_PROTOCOL_IP4, VNET_LINK_IP4, &ls_mem->nh_addr,
  72                            ls_mem->sw_if_index_out);
  73   else if (ls_mem->inner_type == AD_TYPE_IP6)
  74     nh_adj_index =
  75       adj_nbr_add_or_lock (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &ls_mem->nh_addr,
  76                            ls_mem->sw_if_index_out);
  77
  78   if (nh_adj_index == ADJ_INDEX_INVALID)
  79     {
  80       clib_mem_free (ls_mem);
  81       return SID_CREATE_INVALID_ADJ_INDEX;
  82     }
  83
  84   ls_mem->nh_adj = nh_adj_index;
  85
  86   /* Step 2: Prepare inbound policy for packets returning from the VNF */
  87
  88   /* Sanitise the SW_IF_INDEX */
  89   if (pool_is_free_index (sm->vnet_main->interface_main.sw_interfaces,
  90                           ls_mem->sw_if_index_in))
  91     {
  92       adj_unlock (ls_mem->nh_adj);
  93       clib_mem_free (ls_mem);
  94       return SID_CREATE_INVALID_IFACE_INDEX;
  95     }
  96
  97   vnet_sw_interface_t *sw =
  98     vnet_get_sw_interface (sm->vnet_main, ls_mem->sw_if_index_in);
  99   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
 100     {
 101       adj_unlock (ls_mem->nh_adj);
 102       clib_mem_free (ls_mem);
 103       return SID_CREATE_INVALID_IFACE_TYPE;
 104     }
 105
 106   if (ls_mem->inner_type == AD_TYPE_IP4)
 107     {
 108       /* Enable End.AD4 rewrite node for this interface */
 109       int ret =
 110         vnet_feature_enable_disable ("ip4-unicast", "srv6-ad4-flow-rewrite",
 111                                      ls_mem->sw_if_index_in, 1, 0, 0);
 112       if (ret != 0)
 113         {
 114           adj_unlock (ls_mem->nh_adj);
 115           clib_mem_free (ls_mem);
 116           return SID_CREATE_IFACE_FEATURE_ERROR;
 117         }
 118
 119       /* Associate local SID index to this interface (resize vector if needed)
 120        */
 121       if (ls_mem->sw_if_index_in >= vec_len (sm->sw_iface_localsid4))
 122         {
 123           vec_resize (sm->sw_iface_localsid4,
 124                       (pool_len (sm->vnet_main->interface_main.sw_interfaces) -
 125                        vec_len (sm->sw_iface_localsid4)));
 126         }
 127       sm->sw_iface_localsid4[ls_mem->sw_if_index_in] = localsid_index;
 128     }
 129   else if (ls_mem->inner_type == AD_TYPE_IP6)
 130     {
 131       /* Enable End.AD6 rewrite node for this interface */
 132       int ret =
 133         vnet_feature_enable_disable ("ip6-unicast", "srv6-ad6-flow-rewrite",
 134                                      ls_mem->sw_if_index_in, 1, 0, 0);
 135       if (ret != 0)
 136         {
 137           adj_unlock (ls_mem->nh_adj);
 138           clib_mem_free (ls_mem);
 139           return SID_CREATE_IFACE_FEATURE_ERROR;
 140         }
 141
 142       /* Associate local SID index to this interface (resize vector if needed)
 143        */
 144       if (ls_mem->sw_if_index_in >= vec_len (sm->sw_iface_localsid6))
 145         {
 146           vec_resize (sm->sw_iface_localsid6,
 147                       (pool_len (sm->vnet_main->interface_main.sw_interfaces) -
 148                        vec_len (sm->sw_iface_localsid6)));
 149         }
 150       sm->sw_iface_localsid6[ls_mem->sw_if_index_in] = localsid_index;
 151     }
 152
 153   /* Initialize flow and cache tables */
 154   ls_mem->cache_size = SRV6_AD_FLOW_DEFAULT_CACHE_SIZE;
 155   ls_mem->cache_buckets = ad_flow_calc_bihash_buckets (ls_mem->cache_size);
 156   ls_mem->cache_memory_size = ad_flow_calc_bihash_memory (
 157     ls_mem->cache_buckets, sizeof (clib_bihash_40_8_t));
 158
 159   pool_alloc (ls_mem->cache, ls_mem->cache_size);
 160   pool_alloc (ls_mem->lru_pool, ls_mem->cache_size);
 161
 162   dlist_elt_t *head;
 163   pool_get (ls_mem->lru_pool, head);
 164   ls_mem->lru_head_index = head - ls_mem->lru_pool;
 165   clib_dlist_init (ls_mem->lru_pool, ls_mem->lru_head_index);
 166
 167   clib_bihash_init_40_8 (&ls_mem->ftable, "ad-flow", ls_mem->cache_buckets,
 168                          ls_mem->cache_memory_size);
 169
 170   /* Step 3: Initialize rewrite counters */
 171   srv6_ad_flow_localsid_t **ls_p;
 172   pool_get (sm->sids, ls_p);
 173   *ls_p = ls_mem;
 174   ls_mem->index = ls_p - sm->sids;
 175
 176   vlib_validate_combined_counter (&(sm->sid_bypass_counters), ls_mem->index);
 177   vlib_validate_combined_counter (&(sm->sid_punt_counters), ls_mem->index);
 178   vlib_validate_combined_counter (&(sm->sid_cache_full_counters),
 179                                   ls_mem->index);
 180   vlib_validate_combined_counter (&(sm->rw_valid_counters), ls_mem->index);
 181   vlib_validate_combined_counter (&(sm->rw_invalid_counters), ls_mem->index);
 182
 183   vlib_zero_combined_counter (&(sm->sid_bypass_counters), ls_mem->index);
 184   vlib_zero_combined_counter (&(sm->sid_punt_counters), ls_mem->index);
 185   vlib_zero_combined_counter (&(sm->sid_cache_full_counters), ls_mem->index);
 186   vlib_zero_combined_counter (&(sm->rw_valid_counters), ls_mem->index);
 187   vlib_zero_combined_counter (&(sm->rw_invalid_counters), ls_mem->index);
 188
 189   return 0;
 190 }
 191
 192 static int
 193 srv6_ad_flow_localsid_removal_fn (ip6_sr_localsid_t *localsid)
 194 {
 195   srv6_ad_flow_main_t *sm = &srv6_ad_flow_main;
 196   srv6_ad_flow_localsid_t *ls_mem = localsid->plugin_mem;
 197
 198   if (ls_mem->inner_type == AD_TYPE_IP4)
 199     {
 200       /* Disable End.AD4 rewrite node for this interface */
 201       int ret =
 202         vnet_feature_enable_disable ("ip4-unicast", "srv6-ad4-flow-rewrite",
 203                                      ls_mem->sw_if_index_in, 0, 0, 0);
 204       if (ret != 0)
 205         return -1;
 206
 207       /* Remove local SID pointer from interface table */
 208       sm->sw_iface_localsid4[ls_mem->sw_if_index_in] = ~(u32) 0;
 209     }
 210   else if (ls_mem->inner_type == AD_TYPE_IP6)
 211     {
 212       /* Disable End.AD6 rewrite node for this interface */
 213       int ret =
 214         vnet_feature_enable_disable ("ip6-unicast", "srv6-ad6-flow-rewrite",
 215                                      ls_mem->sw_if_index_in, 0, 0, 0);
 216       if (ret != 0)
 217         return -1;
 218
 219       /* Remove local SID pointer from interface table */
 220       sm->sw_iface_localsid6[ls_mem->sw_if_index_in] = ~(u32) 0;
 221     }
 222
 223   /* Unlock (OIF, NHOP) adjacency */
 224   adj_unlock (ls_mem->nh_adj);
 225
 226   /* Delete SID entry */
 227   pool_put (sm->sids, pool_elt_at_index (sm->sids, ls_mem->index));
 228
 229   /* Clean up local SID memory */
 230   srv6_ad_flow_entry_t *e;
 231   pool_foreach (e, ls_mem->cache)
 232     {
 233       vec_free (e->rw_data);
 234     }
 235   pool_free (ls_mem->cache);
 236   pool_free (ls_mem->lru_pool);
 237   clib_bihash_free_40_8 (&ls_mem->ftable);
 238   clib_mem_free (localsid->plugin_mem);
 239
 240   return 0;
 241 }
 242
 243 /**********************************/
 244 /* SRv6 LocalSID format functions */
 245 /*
 246  * Prints nicely the parameters of a localsid
 247  * Example: print "Table 5"
 248  */
 249 u8 *
 250 format_srv6_ad_flow_localsid (u8 *s, va_list *args)
 251 {
 252   srv6_ad_flow_localsid_t *ls_mem = va_arg (*args, void *);
 253
 254   vnet_main_t *vnm = vnet_get_main ();
 255   srv6_ad_flow_main_t *sm = &srv6_ad_flow_main;
 256
 257   if (ls_mem->inner_type == AD_TYPE_IP4)
 258     {
 259       s = format (s, "Next-hop:\t%U\n\t", format_ip4_address,
 260                   &ls_mem->nh_addr.ip4);
 261     }
 262   else if (ls_mem->inner_type == AD_TYPE_IP6)
 263     {
 264       s = format (s, "Next-hop:\t%U\n\t", format_ip6_address,
 265                   &ls_mem->nh_addr.ip6);
 266     }
 267
 268   s = format (s, "Outgoing iface:\t%U\n", format_vnet_sw_if_index_name, vnm,
 269               ls_mem->sw_if_index_out);
 270   s = format (s, "\tIncoming iface:\t%U\n", format_vnet_sw_if_index_name, vnm,
 271               ls_mem->sw_if_index_in);
 272
 273   vlib_counter_t sid_bypass, sid_punt, sid_full, rw_valid, rw_invalid;
 274   vlib_get_combined_counter (&(sm->sid_bypass_counters), ls_mem->index,
 275                              &sid_bypass);
 276   vlib_get_combined_counter (&(sm->sid_punt_counters), ls_mem->index,
 277                              &sid_punt);
 278   vlib_get_combined_counter (&(sm->sid_cache_full_counters), ls_mem->index,
 279                              &sid_full);
 280   vlib_get_combined_counter (&(sm->rw_valid_counters), ls_mem->index,
 281                              &rw_valid);
 282   vlib_get_combined_counter (&(sm->rw_invalid_counters), ls_mem->index,
 283                              &rw_invalid);
 284
 285   s =
 286     format (s, "\tTraffic that bypassed the NF: \t[%Ld packets : %Ld bytes]\n",
 287             sid_bypass.packets, sid_bypass.bytes);
 288   s = format (s, "\tPunted traffic: \t[%Ld packets : %Ld bytes]\n",
 289               sid_punt.packets, sid_punt.bytes);
 290   s =
 291     format (s, "\tDropped traffic (cache full): \t[%Ld packets : %Ld bytes]\n",
 292             sid_full.packets, sid_full.bytes);
 293   s = format (s, "\tGood rewrite traffic: \t[%Ld packets : %Ld bytes]\n",
 294               rw_valid.packets, rw_valid.bytes);
 295   s = format (s, "\tBad rewrite traffic:  \t[%Ld packets : %Ld bytes]\n",
 296               rw_invalid.packets, rw_invalid.bytes);
 297
 298   return s;
 299 }
 300
 301 /*
 302  * Process the parameters of a localsid
 303  * Example: process from:
 304  * sr localsid address cafe::1 behavior new_srv6_localsid 5
 305  * everything from behavior on... so in this case 'new_srv6_localsid 5'
 306  * Notice that it MUST match the keyword_str and params_str defined above.
 307  */
 308 uword
 309 unformat_srv6_ad_flow_localsid (unformat_input_t *input, va_list *args)
 310 {
 311   void **plugin_mem_p = va_arg (*args, void **);
 312   srv6_ad_flow_localsid_t *ls_mem;
 313
 314   vnet_main_t *vnm = vnet_get_main ();
 315
 316   u8 inner_type = AD_TYPE_IP4;
 317   ip46_address_t nh_addr;
 318   u32 sw_if_index_out;
 319   u32 sw_if_index_in;
 320
 321   u8 params = 0;
 322 #define PARAM_AD_NH  (1 << 0)
 323 #define PARAM_AD_OIF (1 << 1)
 324 #define PARAM_AD_IIF (1 << 2)
 325
 326   if (!unformat (input, "end.ad.flow"))
 327     return 0;
 328
 329   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 330     {
 331       if (!(params & PARAM_AD_NH) &&
 332           unformat (input, "nh %U", unformat_ip4_address, &nh_addr.ip4))
 333         {
 334           inner_type = AD_TYPE_IP4;
 335           params |= PARAM_AD_NH;
 336         }
 337       if (!(params & PARAM_AD_NH) &&
 338           unformat (input, "nh %U", unformat_ip6_address, &nh_addr.ip6))
 339         {
 340           inner_type = AD_TYPE_IP6;
 341           params |= PARAM_AD_NH;
 342         }
 343       else if (!(params & PARAM_AD_OIF) &&
 344                unformat (input, "oif %U", unformat_vnet_sw_interface, vnm,
 345                          &sw_if_index_out))
 346         {
 347           params |= PARAM_AD_OIF;
 348         }
 349       else if (!(params & PARAM_AD_IIF) &&
 350                unformat (input, "iif %U", unformat_vnet_sw_interface, vnm,
 351                          &sw_if_index_in))
 352         {
 353           params |= PARAM_AD_IIF;
 354         }
 355       else
 356         {
 357           break;
 358         }
 359     }
 360
 361   /* Make sure that all parameters are supplied */
 362   u8 params_chk = (PARAM_AD_NH | PARAM_AD_OIF | PARAM_AD_IIF);
 363   if ((params & params_chk) != params_chk)
 364     {
 365       return 0;
 366     }
 367
 368   /* Allocate and initialize memory block for local SID parameters */
 369   ls_mem = clib_mem_alloc_aligned_at_offset (sizeof *ls_mem, 0, 0, 1);
 370   clib_memset (ls_mem, 0, sizeof *ls_mem);
 371   *plugin_mem_p = ls_mem;
 372
 373   /* Set local SID parameters */
 374   ls_mem->inner_type = inner_type;
 375   if (inner_type == AD_TYPE_IP4)
 376     ls_mem->nh_addr.ip4 = nh_addr.ip4;
 377   else if (inner_type == AD_TYPE_IP6)
 378     ls_mem->nh_addr.ip6 = nh_addr.ip6;
 379   ls_mem->sw_if_index_out = sw_if_index_out;
 380   ls_mem->sw_if_index_in = sw_if_index_in;
 381
 382   return 1;
 383 }
 384
 385 /*************************/
 386 /* SRv6 LocalSID FIB DPO */
 387 static u8 *
 388 format_srv6_ad_flow_dpo (u8 *s, va_list *args)
 389 {
 390   index_t index = va_arg (*args, index_t);
 391   CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
 392
 393   return (format (s, "SR: dynamic_proxy_index:[%u]", index));
 394 }
 395
 396 void
 397 srv6_ad_flow_dpo_lock (dpo_id_t *dpo)
 398 {
 399 }
 400
 401 void
 402 srv6_ad_flow_dpo_unlock (dpo_id_t *dpo)
 403 {
 404 }
 405
 406 const static dpo_vft_t srv6_ad_flow_vft = {
 407   .dv_lock = srv6_ad_flow_dpo_lock,
 408   .dv_unlock = srv6_ad_flow_dpo_unlock,
 409   .dv_format = format_srv6_ad_flow_dpo,
 410 };
 411
 412 const static char *const srv6_ad_flow_ip6_nodes[] = {
 413   "srv6-ad-flow-localsid",
 414   NULL,
 415 };
 416
 417 const static char *const *const srv6_ad_flow_nodes[DPO_PROTO_NUM] = {
 418   [DPO_PROTO_IP6] = srv6_ad_flow_ip6_nodes,
 419 };
 420
 421 /**********************/
 422 static clib_error_t *
 423 srv6_ad_flow_init (vlib_main_t *vm)
 424 {
 425   srv6_ad_flow_main_t *sm = &srv6_ad_flow_main;
 426   int rv = 0;
 427
 428   sm->vlib_main = vm;
 429   sm->vnet_main = vnet_get_main ();
 430
 431   /* Create DPO */
 432   sm->srv6_ad_flow_dpo_type =
 433     dpo_register_new_type (&srv6_ad_flow_vft, srv6_ad_flow_nodes);
 434
 435   /* Register SRv6 LocalSID */
 436   rv = sr_localsid_register_function (
 437     vm, function_name, keyword_str, def_str, params_str, 128,
 438     &sm->srv6_ad_flow_dpo_type, format_srv6_ad_flow_localsid,
 439     unformat_srv6_ad_flow_localsid, srv6_ad_flow_localsid_creation_fn,
 440     srv6_ad_flow_localsid_removal_fn);
 441   if (rv < 0)
 442     clib_error_return (0, "SRv6 LocalSID function could not be registered.");
 443   else
 444     sm->srv6_localsid_behavior_id = rv;
 445
 446   return 0;
 447 }
 448
 449 VNET_FEATURE_INIT (srv6_ad4_flow_rewrite, static) = {
 450   .arc_name = "ip4-unicast",
 451   .node_name = "srv6-ad4-flow-rewrite",
 452   .runs_before = 0,
 453 };
 454
 455 VNET_FEATURE_INIT (srv6_ad6_flow_rewrite, static) = {
 456   .arc_name = "ip6-unicast",
 457   .node_name = "srv6-ad6-flow-rewrite",
 458   .runs_before = 0,
 459 };
 460
 461 VLIB_INIT_FUNCTION (srv6_ad_flow_init);
 462
 463 VLIB_PLUGIN_REGISTER () = {
 464   .version = VPP_BUILD_VER,
 465   .description = "Dynamic Segment Routing for IPv6 (SRv6) Proxy",
 466 };
 467
 468 /*
 469  * fd.io coding-style-patch-verification: ON
 470  *
 471  * Local Variables:
 472  * eval: (c-set-style "gnu")
 473  * End:
 474  */