src/plugins/gbp/gbp_bridge_domain.c

   1 /*
   2  * Copyright (c) 2018 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 #include <plugins/gbp/gbp_bridge_domain.h>
  17 #include <plugins/gbp/gbp_route_domain.h>
  18 #include <plugins/gbp/gbp_endpoint.h>
  19 #include <plugins/gbp/gbp_learn.h>
  20 #include <plugins/gbp/gbp_itf.h>
  21
  22 #include <vnet/dpo/dvr_dpo.h>
  23 #include <vnet/fib/fib_table.h>
  24 #include <vnet/l2/l2_input.h>
  25 #include <vnet/l2/feat_bitmap.h>
  26 #include <vnet/l2/l2_bvi.h>
  27 #include <vnet/l2/l2_fib.h>
  28
  29 /**
  30  * Pool of GBP bridge_domains
  31  */
  32 gbp_bridge_domain_t *gbp_bridge_domain_pool;
  33
  34 /**
  35  * DB of bridge_domains
  36  */
  37 gbp_bridge_domain_db_t gbp_bridge_domain_db;
  38
  39 /**
  40  * Map of BD index to contract scope
  41  */
  42 gbp_scope_t *gbp_scope_by_bd_index;
  43
  44 /**
  45  * logger
  46  */
  47 vlib_log_class_t gb_logger;
  48
  49 #define GBP_BD_DBG(...)                           \
  50     vlib_log_debug (gb_logger, __VA_ARGS__);
  51
  52 index_t
  53 gbp_bridge_domain_index (const gbp_bridge_domain_t * gbd)
  54 {
  55   return (gbd - gbp_bridge_domain_pool);
  56 }
  57
  58 static void
  59 gbp_bridge_domain_lock (index_t i)
  60 {
  61   gbp_bridge_domain_t *gb;
  62
  63   gb = gbp_bridge_domain_get (i);
  64   gb->gb_locks++;
  65 }
  66
  67 u32
  68 gbp_bridge_domain_get_bd_id (index_t gbdi)
  69 {
  70   gbp_bridge_domain_t *gb;
  71
  72   gb = gbp_bridge_domain_get (gbdi);
  73
  74   return (gb->gb_bd_id);
  75 }
  76
  77 static index_t
  78 gbp_bridge_domain_find (u32 bd_id)
  79 {
  80   uword *p;
  81
  82   p = hash_get (gbp_bridge_domain_db.gbd_by_bd_id, bd_id);
  83
  84   if (NULL != p)
  85     return p[0];
  86
  87   return (INDEX_INVALID);
  88 }
  89
  90 index_t
  91 gbp_bridge_domain_find_and_lock (u32 bd_id)
  92 {
  93   uword *p;
  94
  95   p = hash_get (gbp_bridge_domain_db.gbd_by_bd_id, bd_id);
  96
  97   if (NULL != p)
  98     {
  99       gbp_bridge_domain_lock (p[0]);
 100       return p[0];
 101     }
 102   return (INDEX_INVALID);
 103 }
 104
 105 static void
 106 gbp_bridge_domain_db_add (gbp_bridge_domain_t * gb)
 107 {
 108   index_t gbi = gb - gbp_bridge_domain_pool;
 109
 110   hash_set (gbp_bridge_domain_db.gbd_by_bd_id, gb->gb_bd_id, gbi);
 111   vec_validate_init_empty (gbp_bridge_domain_db.gbd_by_bd_index,
 112                            gb->gb_bd_index, INDEX_INVALID);
 113   gbp_bridge_domain_db.gbd_by_bd_index[gb->gb_bd_index] = gbi;
 114 }
 115
 116 static void
 117 gbp_bridge_domain_db_remove (gbp_bridge_domain_t * gb)
 118 {
 119   hash_unset (gbp_bridge_domain_db.gbd_by_bd_id, gb->gb_bd_id);
 120   gbp_bridge_domain_db.gbd_by_bd_index[gb->gb_bd_index] = INDEX_INVALID;
 121 }
 122
 123 u8 *
 124 format_gbp_bridge_domain_flags (u8 * s, va_list * args)
 125 {
 126   gbp_bridge_domain_flags_t gf = va_arg (*args, gbp_bridge_domain_flags_t);
 127
 128   if (gf)
 129     {
 130       if (gf & GBP_BD_FLAG_DO_NOT_LEARN)
 131         s = format (s, "do-not-learn ");
 132       if (gf & GBP_BD_FLAG_UU_FWD_DROP)
 133         s = format (s, "uu-fwd-drop ");
 134       if (gf & GBP_BD_FLAG_MCAST_DROP)
 135         s = format (s, "mcast-drop ");
 136       if (gf & GBP_BD_FLAG_UCAST_ARP)
 137         s = format (s, "ucast-arp ");
 138     }
 139   else
 140     {
 141       s = format (s, "none");
 142     }
 143   return (s);
 144 }
 145
 146 static u8 *
 147 format_gbp_bridge_domain_ptr (u8 * s, va_list * args)
 148 {
 149   gbp_bridge_domain_t *gb = va_arg (*args, gbp_bridge_domain_t *);
 150   vnet_main_t *vnm = vnet_get_main ();
 151
 152   if (NULL != gb)
 153     s =
 154       format (s,
 155               "[%d] bd:[%d,%d], bvi:%U uu-flood:%U bm-flood:%U flags:%U locks:%d",
 156               gb - gbp_bridge_domain_pool, gb->gb_bd_id, gb->gb_bd_index,
 157               format_vnet_sw_if_index_name, vnm, gb->gb_bvi_sw_if_index,
 158               format_vnet_sw_if_index_name, vnm, gb->gb_uu_fwd_sw_if_index,
 159               format_gbp_itf_hdl, gb->gb_bm_flood_itf,
 160               format_gbp_bridge_domain_flags, gb->gb_flags, gb->gb_locks);
 161   else
 162     s = format (s, "NULL");
 163
 164   return (s);
 165 }
 166
 167 u8 *
 168 format_gbp_bridge_domain (u8 * s, va_list * args)
 169 {
 170   index_t gbi = va_arg (*args, index_t);
 171
 172   s =
 173     format (s, "%U", format_gbp_bridge_domain_ptr,
 174             gbp_bridge_domain_get (gbi));
 175
 176   return (s);
 177 }
 178
 179 int
 180 gbp_bridge_domain_add_and_lock (u32 bd_id,
 181                                 u32 rd_id,
 182                                 gbp_bridge_domain_flags_t flags,
 183                                 u32 bvi_sw_if_index,
 184                                 u32 uu_fwd_sw_if_index,
 185                                 u32 bm_flood_sw_if_index)
 186 {
 187   gbp_bridge_domain_t *gb;
 188   index_t gbi;
 189
 190   gbi = gbp_bridge_domain_find (bd_id);
 191
 192   if (INDEX_INVALID == gbi)
 193     {
 194       gbp_route_domain_t *gr;
 195       u32 bd_index;
 196
 197       bd_index = bd_find_index (&bd_main, bd_id);
 198
 199       if (~0 == bd_index)
 200         return (VNET_API_ERROR_BD_NOT_MODIFIABLE);
 201
 202       bd_flags_t bd_flags = L2_NONE;
 203       if (flags & GBP_BD_FLAG_UU_FWD_DROP)
 204         bd_flags |= L2_UU_FLOOD;
 205       if (flags & GBP_BD_FLAG_MCAST_DROP)
 206         bd_flags |= L2_FLOOD;
 207
 208       pool_get (gbp_bridge_domain_pool, gb);
 209       memset (gb, 0, sizeof (*gb));
 210
 211       gbi = gb - gbp_bridge_domain_pool;
 212       gb->gb_bd_id = bd_id;
 213       gb->gb_bd_index = bd_index;
 214       gb->gb_uu_fwd_sw_if_index = uu_fwd_sw_if_index;
 215       gb->gb_bvi_sw_if_index = bvi_sw_if_index;
 216       gbp_itf_hdl_reset (&gb->gb_bm_flood_itf);
 217       gb->gb_locks = 1;
 218       gb->gb_flags = flags;
 219       gb->gb_rdi = gbp_route_domain_find_and_lock (rd_id);
 220
 221       /*
 222        * set the scope from the BD's RD's scope
 223        */
 224       gr = gbp_route_domain_get (gb->gb_rdi);
 225       vec_validate (gbp_scope_by_bd_index, gb->gb_bd_index);
 226       gbp_scope_by_bd_index[gb->gb_bd_index] = gr->grd_scope;
 227
 228       /*
 229        * Set the BVI and uu-flood interfaces into the BD
 230        */
 231       gbp_bridge_domain_itf_add (gbi, gb->gb_bvi_sw_if_index,
 232                                  L2_BD_PORT_TYPE_BVI);
 233
 234       if ((!(flags & GBP_BD_FLAG_UU_FWD_DROP) ||
 235            (flags & GBP_BD_FLAG_UCAST_ARP)) &&
 236           ~0 != gb->gb_uu_fwd_sw_if_index)
 237         gbp_bridge_domain_itf_add (gbi, gb->gb_uu_fwd_sw_if_index,
 238                                    L2_BD_PORT_TYPE_UU_FWD);
 239
 240       if (!(flags & GBP_BD_FLAG_MCAST_DROP) && ~0 != bm_flood_sw_if_index)
 241         {
 242           gb->gb_bm_flood_itf =
 243             gbp_itf_l2_add_and_lock (bm_flood_sw_if_index, gbi);
 244           gbp_itf_l2_set_input_feature (gb->gb_bm_flood_itf,
 245                                         L2INPUT_FEAT_GBP_LEARN);
 246         }
 247
 248       /*
 249        * unset any flag(s) set above
 250        */
 251       bd_set_flags (vlib_get_main (), bd_index, bd_flags, 0);
 252
 253       if (flags & GBP_BD_FLAG_UCAST_ARP)
 254         {
 255           bd_flags = L2_ARP_UFWD;
 256           bd_set_flags (vlib_get_main (), bd_index, bd_flags, 1);
 257         }
 258
 259       /*
 260        * Add the BVI's MAC to the L2FIB
 261        */
 262       l2fib_add_entry (vnet_sw_interface_get_hw_address
 263                        (vnet_get_main (), gb->gb_bvi_sw_if_index),
 264                        gb->gb_bd_index, gb->gb_bvi_sw_if_index,
 265                        (L2FIB_ENTRY_RESULT_FLAG_STATIC |
 266                         L2FIB_ENTRY_RESULT_FLAG_BVI));
 267
 268       gbp_bridge_domain_db_add (gb);
 269     }
 270   else
 271     {
 272       gb = gbp_bridge_domain_get (gbi);
 273       gb->gb_locks++;
 274     }
 275
 276   GBP_BD_DBG ("add: %U", format_gbp_bridge_domain_ptr, gb);
 277
 278   return (0);
 279 }
 280
 281 void
 282 gbp_bridge_domain_itf_add (index_t gbdi,
 283                            u32 sw_if_index, l2_bd_port_type_t type)
 284 {
 285   gbp_bridge_domain_t *gb;
 286
 287   gb = gbp_bridge_domain_get (gbdi);
 288
 289   set_int_l2_mode (vlib_get_main (), vnet_get_main (), MODE_L2_BRIDGE,
 290                    sw_if_index, gb->gb_bd_index, type, 0, 0);
 291   /*
 292    * adding an interface to the bridge enables learning on the
 293    * interface. Disable learning on the interface by default for gbp
 294    * interfaces
 295    */
 296   l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_LEARN, 0);
 297 }
 298
 299 void
 300 gbp_bridge_domain_itf_del (index_t gbdi,
 301                            u32 sw_if_index, l2_bd_port_type_t type)
 302 {
 303   gbp_bridge_domain_t *gb;
 304
 305   gb = gbp_bridge_domain_get (gbdi);
 306
 307   set_int_l2_mode (vlib_get_main (), vnet_get_main (), MODE_L3, sw_if_index,
 308                    gb->gb_bd_index, type, 0, 0);
 309 }
 310
 311 void
 312 gbp_bridge_domain_unlock (index_t gbdi)
 313 {
 314   gbp_bridge_domain_t *gb;
 315
 316   gb = gbp_bridge_domain_get (gbdi);
 317
 318   gb->gb_locks--;
 319
 320   if (0 == gb->gb_locks)
 321     {
 322       GBP_BD_DBG ("destroy: %U", format_gbp_bridge_domain_ptr, gb);
 323
 324       l2fib_del_entry (vnet_sw_interface_get_hw_address
 325                        (vnet_get_main (), gb->gb_bvi_sw_if_index),
 326                        gb->gb_bd_index, gb->gb_bvi_sw_if_index);
 327
 328       gbp_bridge_domain_itf_del (gbdi, gb->gb_bvi_sw_if_index,
 329                                  L2_BD_PORT_TYPE_BVI);
 330       if (~0 != gb->gb_uu_fwd_sw_if_index)
 331         gbp_bridge_domain_itf_del (gbdi, gb->gb_uu_fwd_sw_if_index,
 332                                    L2_BD_PORT_TYPE_UU_FWD);
 333       gbp_itf_unlock (&gb->gb_bm_flood_itf);
 334
 335       gbp_bridge_domain_db_remove (gb);
 336       gbp_route_domain_unlock (gb->gb_rdi);
 337
 338       pool_put (gbp_bridge_domain_pool, gb);
 339     }
 340 }
 341
 342 int
 343 gbp_bridge_domain_delete (u32 bd_id)
 344 {
 345   index_t gbi;
 346
 347   GBP_BD_DBG ("del: %d", bd_id);
 348   gbi = gbp_bridge_domain_find (bd_id);
 349
 350   if (INDEX_INVALID != gbi)
 351     {
 352       GBP_BD_DBG ("del: %U", format_gbp_bridge_domain, gbi);
 353       gbp_bridge_domain_unlock (gbi);
 354
 355       return (0);
 356     }
 357
 358   return (VNET_API_ERROR_NO_SUCH_ENTRY);
 359 }
 360
 361 void
 362 gbp_bridge_domain_walk (gbp_bridge_domain_cb_t cb, void *ctx)
 363 {
 364   gbp_bridge_domain_t *gbpe;
 365
 366   /* *INDENT-OFF* */
 367   pool_foreach (gbpe, gbp_bridge_domain_pool)
 368   {
 369     if (!cb(gbpe, ctx))
 370       break;
 371   }
 372   /* *INDENT-ON* */
 373 }
 374
 375 static clib_error_t *
 376 gbp_bridge_domain_cli (vlib_main_t * vm,
 377                        unformat_input_t * input, vlib_cli_command_t * cmd)
 378 {
 379   vnet_main_t *vnm = vnet_get_main ();
 380   gbp_bridge_domain_flags_t flags;
 381   u32 bm_flood_sw_if_index = ~0;
 382   u32 uu_fwd_sw_if_index = ~0;
 383   u32 bd_id = ~0, rd_id = ~0;
 384   u32 bvi_sw_if_index = ~0;
 385   u8 add = 1;
 386
 387   flags = GBP_BD_FLAG_NONE;
 388
 389   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 390     {
 391       if (unformat (input, "bvi %U", unformat_vnet_sw_interface,
 392                     vnm, &bvi_sw_if_index))
 393         ;
 394       else if (unformat (input, "uu-fwd %U", unformat_vnet_sw_interface,
 395                          vnm, &uu_fwd_sw_if_index))
 396         ;
 397       else if (unformat (input, "bm-flood %U", unformat_vnet_sw_interface,
 398                          vnm, &bm_flood_sw_if_index))
 399         ;
 400       else if (unformat (input, "add"))
 401         add = 1;
 402       else if (unformat (input, "del"))
 403         add = 0;
 404       else if (unformat (input, "flags %d", &flags))
 405         ;
 406       else if (unformat (input, "bd %d", &bd_id))
 407         ;
 408       else if (unformat (input, "rd %d", &rd_id))
 409         ;
 410       else
 411         break;
 412     }
 413
 414   if (~0 == bd_id)
 415     return clib_error_return (0, "BD-ID must be specified");
 416   if (~0 == rd_id)
 417     return clib_error_return (0, "RD-ID must be specified");
 418
 419   if (add)
 420     {
 421       if (~0 == bvi_sw_if_index)
 422         return clib_error_return (0, "interface must be specified");
 423
 424       gbp_bridge_domain_add_and_lock (bd_id, rd_id,
 425                                       flags,
 426                                       bvi_sw_if_index,
 427                                       uu_fwd_sw_if_index,
 428                                       bm_flood_sw_if_index);
 429     }
 430   else
 431     gbp_bridge_domain_delete (bd_id);
 432
 433   return (NULL);
 434 }
 435
 436 /*?
 437  * Configure a GBP bridge-domain
 438  *
 439  * @cliexpar
 440  * @cliexstart{gbp bridge-domain [del] bd <ID> bvi <interface> [uu-fwd <interface>] [bm-flood <interface>] [flags <flags>]}
 441  * @cliexend
 442  ?*/
 443 /* *INDENT-OFF* */
 444 VLIB_CLI_COMMAND (gbp_bridge_domain_cli_node, static) = {
 445   .path = "gbp bridge-domain",
 446   .short_help = "gbp bridge-domain [del] bd <ID> bvi <interface> [uu-fwd <interface>] [bm-flood <interface>] [flags <flags>]",
 447   .function = gbp_bridge_domain_cli,
 448 };
 449
 450 static int
 451 gbp_bridge_domain_show_one (gbp_bridge_domain_t *gb, void *ctx)
 452 {
 453   vlib_main_t *vm;
 454
 455   vm = ctx;
 456   vlib_cli_output (vm, "  %U", format_gbp_bridge_domain_ptr, gb);
 457
 458   return (1);
 459 }
 460
 461 static clib_error_t *
 462 gbp_bridge_domain_show (vlib_main_t * vm,
 463                    unformat_input_t * input, vlib_cli_command_t * cmd)
 464 {
 465   vlib_cli_output (vm, "Bridge-Domains:");
 466   gbp_bridge_domain_walk (gbp_bridge_domain_show_one, vm);
 467
 468   return (NULL);
 469 }
 470
 471
 472 /*?
 473  * Show Group Based Policy Bridge_Domains and derived information
 474  *
 475  * @cliexpar
 476  * @cliexstart{show gbp bridge_domain}
 477  * @cliexend
 478  ?*/
 479 /* *INDENT-OFF* */
 480 VLIB_CLI_COMMAND (gbp_bridge_domain_show_node, static) = {
 481   .path = "show gbp bridge-domain",
 482   .short_help = "show gbp bridge-domain\n",
 483   .function = gbp_bridge_domain_show,
 484 };
 485 /* *INDENT-ON* */
 486
 487 static clib_error_t *
 488 gbp_bridge_domain_init (vlib_main_t * vm)
 489 {
 490   gb_logger = vlib_log_register_class ("gbp", "bd");
 491
 492   return (NULL);
 493 }
 494
 495 VLIB_INIT_FUNCTION (gbp_bridge_domain_init);
 496
 497 /*
 498  * fd.io coding-style-patch-verification: ON
 499  *
 500  * Local Variables:
 501  * eval: (c-set-style "gnu")
 502  * End:
 503  */