src/vnet/srv6/sr_steering.c

   1 /*
   2  * sr_steering.c: ipv6 segment routing steering into SR policy
   3  *
   4  * Copyright (c) 2016 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /**
  19  * @file
  20  * @brief Packet steering into SR Policies
  21  *
  22  * This file is in charge of handling the FIB appropiatly to steer packets
  23  * through SR Policies as defined in 'sr_policy_rewrite.c'. Notice that here
  24  * we are only doing steering. SR policy application is done in
  25  * sr_policy_rewrite.c
  26  *
  27  * Supports:
  28  *  - Steering of IPv6 traffic Destination Address based
  29  *  - Steering of IPv4 traffic Destination Address based
  30  *  - Steering of L2 frames, interface based (sw interface)
  31  */
  32
  33 #include <vlib/vlib.h>
  34 #include <vnet/vnet.h>
  35 #include <vnet/srv6/sr.h>
  36 #include <vnet/ip/ip.h>
  37 #include <vnet/srv6/sr_packet.h>
  38 #include <vnet/ip/ip6_packet.h>
  39 #include <vnet/fib/ip6_fib.h>
  40 #include <vnet/dpo/dpo.h>
  41
  42 #include <vppinfra/error.h>
  43 #include <vppinfra/elog.h>
  44
  45 /**
  46  * @brief Steer traffic L2 and L3 traffic through a given SR policy
  47  *
  48  * @param is_del
  49  * @param bsid is the bindingSID of the SR Policy (alt to sr_policy_index)
  50  * @param sr_policy is the index of the SR Policy (alt to bsid)
  51  * @param table_id is the VRF where to install the FIB entry for the BSID
  52  * @param prefix is the IPv4/v6 address for L3 traffic type
  53  * @param mask_width is the mask for L3 traffic type
  54  * @param sw_if_index is the incoming interface for L2 traffic
  55  * @param traffic_type describes the type of traffic
  56  *
  57  * @return 0 if correct, else error
  58  */
  59 int
  60 sr_steering_policy (int is_del, ip6_address_t * bsid, u32 sr_policy_index,
  61                     u32 table_id, ip46_address_t * prefix, u32 mask_width,
  62                     u32 sw_if_index, u8 traffic_type)
  63 {
  64   ip6_sr_main_t *sm = &sr_main;
  65   sr_steering_key_t key;
  66   ip6_sr_steering_policy_t *steer_pl;
  67   fib_prefix_t pfx = { 0 };
  68
  69   ip6_sr_policy_t *sr_policy = 0;
  70   uword *p = 0;
  71
  72   clib_memset (&key, 0, sizeof (sr_steering_key_t));
  73
  74   /* Compute the steer policy key */
  75   if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
  76     {
  77       key.l3.prefix.as_u64[0] = prefix->as_u64[0];
  78       key.l3.prefix.as_u64[1] = prefix->as_u64[1];
  79       key.l3.mask_width = mask_width;
  80       key.l3.fib_table = (table_id != (u32) ~ 0 ? table_id : 0);
  81     }
  82   else if (traffic_type == SR_STEER_L2)
  83     {
  84       key.l2.sw_if_index = sw_if_index;
  85
  86       /* Sanitise the SW_IF_INDEX */
  87       if (pool_is_free_index (sm->vnet_main->interface_main.sw_interfaces,
  88                               sw_if_index))
  89         return -3;
  90
  91       vnet_sw_interface_t *sw =
  92         vnet_get_sw_interface (sm->vnet_main, sw_if_index);
  93       if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
  94         return -3;
  95     }
  96   else
  97     return -1;
  98
  99   key.traffic_type = traffic_type;
 100
 101   /* Search for the item */
 102   p = mhash_get (&sm->sr_steer_policies_hash, &key);
 103
 104   if (p)
 105     {
 106       /* Retrieve Steer Policy function */
 107       steer_pl = pool_elt_at_index (sm->steer_policies, p[0]);
 108
 109       if (is_del)
 110         {
 111           if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
 112             {
 113               /* Remove FIB entry */
 114               pfx.fp_proto = FIB_PROTOCOL_IP6;
 115               pfx.fp_len = steer_pl->classify.l3.mask_width;
 116               pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
 117
 118               fib_table_entry_delete (fib_table_find
 119                                       (FIB_PROTOCOL_IP6,
 120                                        steer_pl->classify.l3.fib_table),
 121                                       &pfx, FIB_SOURCE_SR);
 122             }
 123           else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
 124             {
 125               /* Remove FIB entry */
 126               pfx.fp_proto = FIB_PROTOCOL_IP4;
 127               pfx.fp_len = steer_pl->classify.l3.mask_width;
 128               pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
 129
 130               fib_table_entry_delete (fib_table_find
 131                                       (FIB_PROTOCOL_IP4,
 132                                        steer_pl->classify.l3.fib_table), &pfx,
 133                                       FIB_SOURCE_SR);
 134             }
 135           else if (steer_pl->classify.traffic_type == SR_STEER_L2)
 136             {
 137               /* Remove HW redirection */
 138               int ret = vnet_feature_enable_disable ("device-input",
 139                                                      "sr-pl-rewrite-encaps-l2",
 140                                                      sw_if_index, 0, 0, 0);
 141
 142               if (ret != 0)
 143                 return -1;
 144
 145               sm->sw_iface_sr_policies[sw_if_index] = ~(u32) 0;
 146
 147               /* Remove promiscous mode from interface */
 148               vnet_main_t *vnm = vnet_get_main ();
 149               vnet_hw_interface_t *hi =
 150                 vnet_get_sup_hw_interface (vnm, sw_if_index);
 151               /* Make sure it is main interface */
 152               if (hi->sw_if_index == sw_if_index)
 153                 ethernet_set_flags (vnm, hi->hw_if_index, 0);
 154             }
 155
 156           /* Delete SR steering policy entry */
 157           pool_put (sm->steer_policies, steer_pl);
 158           mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
 159
 160           /* If no more SR policies or steering policies */
 161           if (!pool_elts (sm->sr_policies) && !pool_elts (sm->steer_policies))
 162             {
 163               fib_table_unlock (sm->fib_table_ip6,
 164                                 FIB_PROTOCOL_IP6, FIB_SOURCE_SR);
 165               fib_table_unlock (sm->fib_table_ip4,
 166                                 FIB_PROTOCOL_IP6, FIB_SOURCE_SR);
 167               sm->fib_table_ip6 = (u32) ~ 0;
 168               sm->fib_table_ip4 = (u32) ~ 0;
 169             }
 170
 171           return 0;
 172         }
 173       else                      /* It means user requested to update an existing SR steering policy */
 174         {
 175           /* Retrieve SR steering policy */
 176           if (bsid)
 177             {
 178               p = mhash_get (&sm->sr_policies_index_hash, bsid);
 179               if (p)
 180                 sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
 181               else
 182                 return -2;
 183             }
 184           else
 185             sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
 186
 187           if (!sr_policy)
 188             return -2;
 189
 190           steer_pl->sr_policy = sr_policy - sm->sr_policies;
 191
 192           /* Remove old FIB/hw redirection and create a new one */
 193           if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
 194             {
 195               /* Remove FIB entry */
 196               pfx.fp_proto = FIB_PROTOCOL_IP6;
 197               pfx.fp_len = steer_pl->classify.l3.mask_width;
 198               pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
 199
 200               fib_table_entry_delete (fib_table_find
 201                                       (FIB_PROTOCOL_IP6,
 202                                        steer_pl->classify.l3.fib_table),
 203                                       &pfx, FIB_SOURCE_SR);
 204
 205               /* Create a new one */
 206               goto update_fib;
 207             }
 208           else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
 209             {
 210               /* Remove FIB entry */
 211               pfx.fp_proto = FIB_PROTOCOL_IP4;
 212               pfx.fp_len = steer_pl->classify.l3.mask_width;
 213               pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
 214
 215               fib_table_entry_delete (fib_table_find
 216                                       (FIB_PROTOCOL_IP4,
 217                                        steer_pl->classify.l3.fib_table),
 218                                       &pfx, FIB_SOURCE_SR);
 219
 220               /* Create a new one */
 221               goto update_fib;
 222             }
 223           else if (steer_pl->classify.traffic_type == SR_STEER_L2)
 224             {
 225               /* Update L2-HW redirection */
 226               goto update_fib;
 227             }
 228         }
 229     }
 230   else
 231     /* delete; steering policy does not exist; complain */
 232   if (is_del)
 233     return -4;
 234
 235   /* Retrieve SR policy */
 236   if (bsid)
 237     {
 238       p = mhash_get (&sm->sr_policies_index_hash, bsid);
 239       if (p)
 240         sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
 241       else
 242         return -2;
 243     }
 244   else
 245     sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
 246
 247   /* Create a new steering policy */
 248   pool_get (sm->steer_policies, steer_pl);
 249   clib_memset (steer_pl, 0, sizeof (*steer_pl));
 250
 251   if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
 252     {
 253       clib_memcpy_fast (&steer_pl->classify.l3.prefix, prefix,
 254                         sizeof (ip46_address_t));
 255       steer_pl->classify.l3.mask_width = mask_width;
 256       steer_pl->classify.l3.fib_table =
 257         (table_id != (u32) ~ 0 ? table_id : 0);
 258       steer_pl->classify.traffic_type = traffic_type;
 259     }
 260   else if (traffic_type == SR_STEER_L2)
 261     {
 262       steer_pl->classify.l2.sw_if_index = sw_if_index;
 263       steer_pl->classify.traffic_type = traffic_type;
 264     }
 265   else
 266     {
 267       /* Incorrect API usage. Should never get here */
 268       pool_put (sm->steer_policies, steer_pl);
 269       mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
 270       return -1;
 271     }
 272   steer_pl->sr_policy = sr_policy - sm->sr_policies;
 273
 274   /* Create and store key */
 275   mhash_set (&sm->sr_steer_policies_hash, &key, steer_pl - sm->steer_policies,
 276              NULL);
 277
 278   if (traffic_type == SR_STEER_L2)
 279     {
 280       if (!sr_policy->is_encap)
 281         goto cleanup_error_encap;
 282
 283       if (vnet_feature_enable_disable
 284           ("device-input", "sr-pl-rewrite-encaps-l2", sw_if_index, 1, 0, 0))
 285         goto cleanup_error_redirection;
 286
 287       /* Set promiscous mode on interface */
 288       vnet_main_t *vnm = vnet_get_main ();
 289       vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
 290       /* Make sure it is main interface */
 291       if (hi->sw_if_index == sw_if_index)
 292         ethernet_set_flags (vnm, hi->hw_if_index,
 293                             ETHERNET_INTERFACE_FLAG_ACCEPT_ALL);
 294     }
 295   else if (traffic_type == SR_STEER_IPV4)
 296     if (!sr_policy->is_encap)
 297       goto cleanup_error_encap;
 298
 299 update_fib:
 300   /* FIB API calls - Recursive route through the BindingSID */
 301   if (traffic_type == SR_STEER_IPV6)
 302     {
 303       pfx.fp_proto = FIB_PROTOCOL_IP6;
 304       pfx.fp_len = steer_pl->classify.l3.mask_width;
 305       pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
 306
 307       fib_table_entry_path_add (fib_table_find (FIB_PROTOCOL_IP6,
 308                                                 (table_id !=
 309                                                  (u32) ~ 0 ?
 310                                                  table_id : 0)),
 311                                 &pfx, FIB_SOURCE_SR,
 312                                 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT,
 313                                 DPO_PROTO_IP6,
 314                                 (ip46_address_t *) & sr_policy->bsid, ~0,
 315                                 sm->fib_table_ip6, 1, NULL,
 316                                 FIB_ROUTE_PATH_FLAG_NONE);
 317     }
 318   else if (traffic_type == SR_STEER_IPV4)
 319     {
 320       pfx.fp_proto = FIB_PROTOCOL_IP4;
 321       pfx.fp_len = steer_pl->classify.l3.mask_width;
 322       pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
 323
 324       fib_table_entry_path_add (fib_table_find (FIB_PROTOCOL_IP4,
 325                                                 (table_id !=
 326                                                  (u32) ~ 0 ?
 327                                                  table_id : 0)),
 328                                 &pfx, FIB_SOURCE_SR,
 329                                 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT,
 330                                 DPO_PROTO_IP6,
 331                                 (ip46_address_t *) & sr_policy->bsid, ~0,
 332                                 sm->fib_table_ip4, 1, NULL,
 333                                 FIB_ROUTE_PATH_FLAG_NONE);
 334     }
 335   else if (traffic_type == SR_STEER_L2)
 336     {
 337       if (sw_if_index < vec_len (sm->sw_iface_sr_policies))
 338         sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
 339       else
 340         {
 341           vec_resize (sm->sw_iface_sr_policies,
 342                       (pool_len (sm->vnet_main->interface_main.sw_interfaces)
 343                        - vec_len (sm->sw_iface_sr_policies)));
 344           sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
 345         }
 346     }
 347
 348   return 0;
 349
 350 cleanup_error_encap:
 351   pool_put (sm->steer_policies, steer_pl);
 352   mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
 353   return -5;
 354
 355 cleanup_error_redirection:
 356   pool_put (sm->steer_policies, steer_pl);
 357   mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
 358   return -3;
 359 }
 360
 361 static clib_error_t *
 362 sr_steer_policy_command_fn (vlib_main_t * vm, unformat_input_t * input,
 363                             vlib_cli_command_t * cmd)
 364 {
 365   vnet_main_t *vnm = vnet_get_main ();
 366
 367   int is_del = 0;
 368
 369   ip46_address_t prefix;
 370   u32 dst_mask_width = 0;
 371   u32 sw_if_index = (u32) ~ 0;
 372   u8 traffic_type = 0;
 373   u32 fib_table = (u32) ~ 0;
 374
 375   ip6_address_t bsid;
 376   u32 sr_policy_index = (u32) ~ 0;
 377
 378   u8 sr_policy_set = 0;
 379
 380   clib_memset (&prefix, 0, sizeof (ip46_address_t));
 381
 382   int rv;
 383   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 384     {
 385       if (unformat (input, "del"))
 386         is_del = 1;
 387       else if (!traffic_type
 388                && unformat (input, "l3 %U/%d", unformat_ip6_address,
 389                             &prefix.ip6, &dst_mask_width))
 390         traffic_type = SR_STEER_IPV6;
 391       else if (!traffic_type
 392                && unformat (input, "l3 %U/%d", unformat_ip4_address,
 393                             &prefix.ip4, &dst_mask_width))
 394         traffic_type = SR_STEER_IPV4;
 395       else if (!traffic_type
 396                && unformat (input, "l2 %U", unformat_vnet_sw_interface, vnm,
 397                             &sw_if_index))
 398         traffic_type = SR_STEER_L2;
 399       else if (!sr_policy_set
 400                && unformat (input, "via index %d", &sr_policy_index))
 401         sr_policy_set = 1;
 402       else if (!sr_policy_set
 403                && unformat (input, "via bsid %U",
 404                             unformat_ip6_address, &bsid))
 405         sr_policy_set = 1;
 406       else if (fib_table == (u32) ~ 0
 407                && unformat (input, "fib-table %d", &fib_table));
 408       else
 409         break;
 410     }
 411
 412   if (!traffic_type)
 413     return clib_error_return (0, "No L2/L3 traffic specified");
 414   if (!is_del && !sr_policy_set)
 415     return clib_error_return (0, "No SR policy specified");
 416
 417   /* Make sure that the prefixes are clean */
 418   if (traffic_type == SR_STEER_IPV4)
 419     {
 420       u32 mask =
 421         (dst_mask_width ? (0xFFFFFFFFu >> (32 - dst_mask_width)) : 0);
 422       prefix.ip4.as_u32 &= mask;
 423     }
 424   else if (traffic_type == SR_STEER_IPV6)
 425     {
 426       ip6_address_t mask;
 427       ip6_address_mask_from_width (&mask, dst_mask_width);
 428       ip6_address_mask (&prefix.ip6, &mask);
 429     }
 430
 431   rv =
 432     sr_steering_policy (is_del, (sr_policy_index == ~(u32) 0 ? &bsid : NULL),
 433                         sr_policy_index, fib_table, &prefix, dst_mask_width,
 434                         sw_if_index, traffic_type);
 435
 436   switch (rv)
 437     {
 438     case 0:
 439       break;
 440     case 1:
 441       return 0;
 442     case -1:
 443       return clib_error_return (0, "Incorrect API usage.");
 444     case -2:
 445       return clib_error_return (0,
 446                                 "The requested SR policy could not be located. Review the BSID/index.");
 447     case -3:
 448       return clib_error_return (0,
 449                                 "Unable to do SW redirect. Incorrect interface.");
 450     case -4:
 451       return clib_error_return (0,
 452                                 "The requested SR steering policy could not be deleted.");
 453     case -5:
 454       return clib_error_return (0,
 455                                 "The SR policy is not an encapsulation one.");
 456     default:
 457       return clib_error_return (0, "BUG: sr steer policy returns %d", rv);
 458     }
 459   return 0;
 460 }
 461
 462 /* *INDENT-OFF* */
 463 VLIB_CLI_COMMAND (sr_steer_policy_command, static) = {
 464   .path = "sr steer",
 465   .short_help = "sr steer (del) [l3 <ip_addr/mask>|l2 <sf_if>] "
 466     "via [index <sr_policy_index>|bsid <bsid_ip6_addr>] "
 467     "(fib-table <fib_table_index>)",
 468   .long_help =
 469     "\tSteer a L2 or L3 traffic through an existing SR policy.\n"
 470     "\tExamples:\n"
 471     "\t\tsr steer l3 2001::/64 via sr_policy index 5\n"
 472     "\t\tsr steer l3 2001::/64 via sr_policy bsid 2010::9999:1\n"
 473     "\t\tsr steer l2 GigabitEthernet0/5/0 via sr_policy index 5\n"
 474     "\t\tsr steer del l3 2001::/64 via sr_policy index 5\n",
 475   .function = sr_steer_policy_command_fn,
 476 };
 477 /* *INDENT-ON* */
 478
 479 static clib_error_t *
 480 show_sr_steering_policies_command_fn (vlib_main_t * vm,
 481                                       unformat_input_t * input,
 482                                       vlib_cli_command_t * cmd)
 483 {
 484   ip6_sr_main_t *sm = &sr_main;
 485   ip6_sr_steering_policy_t **steer_policies = 0;
 486   ip6_sr_steering_policy_t *steer_pl;
 487
 488   vnet_main_t *vnm = vnet_get_main ();
 489
 490   ip6_sr_policy_t *pl = 0;
 491   int i;
 492
 493   vlib_cli_output (vm, "SR steering policies:");
 494   /* *INDENT-OFF* */
 495   pool_foreach (steer_pl, sm->steer_policies) {vec_add1(steer_policies, steer_pl);}
 496   /* *INDENT-ON* */
 497   vlib_cli_output (vm, "Traffic\t\tSR policy BSID");
 498   for (i = 0; i < vec_len (steer_policies); i++)
 499     {
 500       steer_pl = steer_policies[i];
 501       pl = pool_elt_at_index (sm->sr_policies, steer_pl->sr_policy);
 502       if (steer_pl->classify.traffic_type == SR_STEER_L2)
 503         {
 504           vlib_cli_output (vm, "L2 %U\t%U",
 505                            format_vnet_sw_if_index_name, vnm,
 506                            steer_pl->classify.l2.sw_if_index,
 507                            format_ip6_address, &pl->bsid);
 508         }
 509       else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
 510         {
 511           vlib_cli_output (vm, "L3 %U/%d\t%U",
 512                            format_ip4_address,
 513                            &steer_pl->classify.l3.prefix.ip4,
 514                            steer_pl->classify.l3.mask_width,
 515                            format_ip6_address, &pl->bsid);
 516         }
 517       else if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
 518         {
 519           vlib_cli_output (vm, "L3 %U/%d\t%U",
 520                            format_ip6_address,
 521                            &steer_pl->classify.l3.prefix.ip6,
 522                            steer_pl->classify.l3.mask_width,
 523                            format_ip6_address, &pl->bsid);
 524         }
 525     }
 526   return 0;
 527 }
 528
 529 /* *INDENT-OFF* */
 530 VLIB_CLI_COMMAND (show_sr_steering_policies_command, static) = {
 531   .path = "show sr steering-policies",
 532   .short_help = "show sr steering-policies",
 533   .function = show_sr_steering_policies_command_fn,
 534 };
 535 /* *INDENT-ON* */
 536
 537 clib_error_t *
 538 sr_steering_init (vlib_main_t * vm)
 539 {
 540   ip6_sr_main_t *sm = &sr_main;
 541
 542   /* Init memory for function keys */
 543   mhash_init (&sm->sr_steer_policies_hash, sizeof (uword),
 544               sizeof (sr_steering_key_t));
 545
 546   sm->sw_iface_sr_policies = 0;
 547
 548   sm->vnet_main = vnet_get_main ();
 549
 550   return 0;
 551 }
 552
 553 /* *INDENT-OFF* */
 554 VLIB_INIT_FUNCTION (sr_steering_init);
 555 /* *INDENT-ON* */
 556
 557 /* *INDENT-OFF* */
 558 VNET_FEATURE_INIT (sr_pl_rewrite_encaps_l2, static) =
 559 {
 560   .arc_name = "device-input",
 561   .node_name = "sr-pl-rewrite-encaps-l2",
 562   .runs_before = VNET_FEATURES ("ethernet-input"),
 563 };
 564 /* *INDENT-ON* */
 565
 566 /*
 567 * fd.io coding-style-patch-verification: ON
 568 *
 569 * Local Variables:
 570 * eval: (c-set-style "gnu")
 571 * End:
 572 */