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_endpoint.h>
  18 #include <plugins/gbp/gbp_sclass.h>
  19
  20 #include <vnet/dpo/dvr_dpo.h>
  21 #include <vnet/fib/fib_table.h>
  22 #include <vnet/l2/l2_input.h>
  23 #include <vnet/l2/feat_bitmap.h>
  24 #include <vnet/l2/l2_bvi.h>
  25 #include <vnet/l2/l2_fib.h>
  26
  27 /**
  28  * Pool of GBP bridge_domains
  29  */
  30 gbp_bridge_domain_t *gbp_bridge_domain_pool;
  31
  32 /**
  33  * DB of bridge_domains
  34  */
  35 gbp_bridge_domain_db_t gbp_bridge_domain_db;
  36
  37 /**
  38  * logger
  39  */
  40 vlib_log_class_t gb_logger;
  41
  42 #define GBP_BD_DBG(...)                           \
  43     vlib_log_debug (gb_logger, __VA_ARGS__);
  44
  45 index_t
  46 gbp_bridge_domain_index (const gbp_bridge_domain_t * gbd)
  47 {
  48   return (gbd - gbp_bridge_domain_pool);
  49 }
  50
  51 static void
  52 gbp_bridge_domain_lock (index_t i)
  53 {
  54   gbp_bridge_domain_t *gb;
  55
  56   gb = gbp_bridge_domain_get (i);
  57   gb->gb_locks++;
  58 }
  59
  60 u32
  61 gbp_bridge_domain_get_bd_id (index_t gbdi)
  62 {
  63   gbp_bridge_domain_t *gb;
  64
  65   gb = gbp_bridge_domain_get (gbdi);
  66
  67   return (gb->gb_bd_id);
  68 }
  69
  70 static index_t
  71 gbp_bridge_domain_find (u32 bd_id)
  72 {
  73   uword *p;
  74
  75   p = hash_get (gbp_bridge_domain_db.gbd_by_bd_id, bd_id);
  76
  77   if (NULL != p)
  78     return p[0];
  79
  80   return (INDEX_INVALID);
  81 }
  82
  83 index_t
  84 gbp_bridge_domain_find_and_lock (u32 bd_id)
  85 {
  86   uword *p;
  87
  88   p = hash_get (gbp_bridge_domain_db.gbd_by_bd_id, bd_id);
  89
  90   if (NULL != p)
  91     {
  92       gbp_bridge_domain_lock (p[0]);
  93       return p[0];
  94     }
  95   return (INDEX_INVALID);
  96 }
  97
  98 static void
  99 gbp_bridge_domain_db_add (gbp_bridge_domain_t * gb)
 100 {
 101   index_t gbi = gb - gbp_bridge_domain_pool;
 102
 103   hash_set (gbp_bridge_domain_db.gbd_by_bd_id, gb->gb_bd_id, gbi);
 104   vec_validate_init_empty (gbp_bridge_domain_db.gbd_by_bd_index,
 105                            gb->gb_bd_index, INDEX_INVALID);
 106   gbp_bridge_domain_db.gbd_by_bd_index[gb->gb_bd_index] = gbi;
 107 }
 108
 109 static void
 110 gbp_bridge_domain_db_remove (gbp_bridge_domain_t * gb)
 111 {
 112   hash_unset (gbp_bridge_domain_db.gbd_by_bd_id, gb->gb_bd_id);
 113   gbp_bridge_domain_db.gbd_by_bd_index[gb->gb_bd_index] = INDEX_INVALID;
 114 }
 115
 116 static u8 *
 117 format_gbp_bridge_domain_ptr (u8 * s, va_list * args)
 118 {
 119   gbp_bridge_domain_t *gb = va_arg (*args, gbp_bridge_domain_t *);
 120   vnet_main_t *vnm = vnet_get_main ();
 121
 122   if (NULL != gb)
 123     s = format (s, "[%d] bd:[%d,%d], bvi:%U uu-flood:%U locks:%d",
 124                 gb - gbp_bridge_domain_pool,
 125                 gb->gb_bd_id,
 126                 gb->gb_bd_index,
 127                 format_vnet_sw_if_index_name, vnm, gb->gb_bvi_sw_if_index,
 128                 format_vnet_sw_if_index_name, vnm, gb->gb_uu_fwd_sw_if_index,
 129                 gb->gb_locks);
 130   else
 131     s = format (s, "NULL");
 132
 133   return (s);
 134 }
 135
 136 u8 *
 137 format_gbp_bridge_domain (u8 * s, va_list * args)
 138 {
 139   index_t gbi = va_arg (*args, index_t);
 140
 141   s =
 142     format (s, "%U", format_gbp_bridge_domain_ptr,
 143             gbp_bridge_domain_get (gbi));
 144
 145   return (s);
 146 }
 147
 148 int
 149 gbp_bridge_domain_add_and_lock (u32 bd_id,
 150                                 gbp_bridge_domain_flags_t flags,
 151                                 u32 bvi_sw_if_index,
 152                                 u32 uu_fwd_sw_if_index,
 153                                 u32 bm_flood_sw_if_index)
 154 {
 155   gbp_bridge_domain_t *gb;
 156   index_t gbi;
 157
 158   gbi = gbp_bridge_domain_find (bd_id);
 159
 160   if (INDEX_INVALID == gbi)
 161     {
 162       u32 bd_index;
 163
 164       bd_index = bd_find_index (&bd_main, bd_id);
 165
 166       if (~0 == bd_index)
 167         return (VNET_API_ERROR_BD_NOT_MODIFIABLE);
 168
 169       /*
 170        * unset learning in the bridge
 171        */
 172       bd_set_flags (vlib_get_main (), bd_index, L2_LEARN, 0);
 173
 174       pool_get (gbp_bridge_domain_pool, gb);
 175       memset (gb, 0, sizeof (*gb));
 176
 177       gb->gb_bd_id = bd_id;
 178       gb->gb_bd_index = bd_index;
 179       gb->gb_uu_fwd_sw_if_index = uu_fwd_sw_if_index;
 180       gb->gb_bvi_sw_if_index = bvi_sw_if_index;
 181       gb->gb_bm_flood_sw_if_index = bm_flood_sw_if_index;
 182       gb->gb_locks = 1;
 183       gb->gb_flags = flags;
 184
 185       /*
 186        * Set the BVI and uu-flood interfaces into the BD
 187        */
 188       set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 189                        MODE_L2_BRIDGE, gb->gb_bvi_sw_if_index,
 190                        bd_index, L2_BD_PORT_TYPE_BVI, 0, 0);
 191       if (~0 != gb->gb_uu_fwd_sw_if_index)
 192         {
 193           set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 194                            MODE_L2_BRIDGE, gb->gb_uu_fwd_sw_if_index,
 195                            bd_index, L2_BD_PORT_TYPE_UU_FWD, 0, 0);
 196           gbp_sclass_enable_l2 (gb->gb_uu_fwd_sw_if_index);
 197         }
 198       if (~0 != gb->gb_bm_flood_sw_if_index)
 199         {
 200           set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 201                            MODE_L2_BRIDGE, gb->gb_bm_flood_sw_if_index,
 202                            bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
 203           gbp_sclass_enable_l2 (gb->gb_bm_flood_sw_if_index);
 204         }
 205
 206       /*
 207        * Add the BVI's MAC to the L2FIB
 208        */
 209       l2fib_add_entry (vnet_sw_interface_get_hw_address
 210                        (vnet_get_main (), gb->gb_bvi_sw_if_index),
 211                        gb->gb_bd_index, gb->gb_bvi_sw_if_index,
 212                        (L2FIB_ENTRY_RESULT_FLAG_STATIC |
 213                         L2FIB_ENTRY_RESULT_FLAG_BVI));
 214
 215       gbp_bridge_domain_db_add (gb);
 216     }
 217   else
 218     {
 219       gb = gbp_bridge_domain_get (gbi);
 220       gb->gb_locks++;
 221     }
 222
 223   GBP_BD_DBG ("add: %U", format_gbp_bridge_domain_ptr, gb);
 224
 225   return (0);
 226 }
 227
 228 void
 229 gbp_bridge_domain_unlock (index_t index)
 230 {
 231   gbp_bridge_domain_t *gb;
 232
 233   gb = gbp_bridge_domain_get (index);
 234
 235   gb->gb_locks--;
 236
 237   if (0 == gb->gb_locks)
 238     {
 239       GBP_BD_DBG ("destroy: %U", format_gbp_bridge_domain_ptr, gb);
 240
 241       l2fib_del_entry (vnet_sw_interface_get_hw_address
 242                        (vnet_get_main (), gb->gb_bvi_sw_if_index),
 243                        gb->gb_bd_index, gb->gb_bvi_sw_if_index);
 244
 245       set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 246                        MODE_L3, gb->gb_bvi_sw_if_index,
 247                        gb->gb_bd_index, L2_BD_PORT_TYPE_BVI, 0, 0);
 248       if (~0 != gb->gb_uu_fwd_sw_if_index)
 249         {
 250           set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 251                            MODE_L3, gb->gb_uu_fwd_sw_if_index,
 252                            gb->gb_bd_index, L2_BD_PORT_TYPE_UU_FWD, 0, 0);
 253           gbp_sclass_disable_l2 (gb->gb_uu_fwd_sw_if_index);
 254         }
 255       if (~0 != gb->gb_bm_flood_sw_if_index)
 256         {
 257           set_int_l2_mode (vlib_get_main (), vnet_get_main (),
 258                            MODE_L3, gb->gb_bm_flood_sw_if_index,
 259                            gb->gb_bd_index, L2_BD_PORT_TYPE_NORMAL, 0, 0);
 260           gbp_sclass_disable_l2 (gb->gb_bm_flood_sw_if_index);
 261         }
 262
 263       gbp_bridge_domain_db_remove (gb);
 264
 265       pool_put (gbp_bridge_domain_pool, gb);
 266     }
 267 }
 268
 269 int
 270 gbp_bridge_domain_delete (u32 bd_id)
 271 {
 272   index_t gbi;
 273
 274   GBP_BD_DBG ("del: %d", bd_id);
 275   gbi = gbp_bridge_domain_find (bd_id);
 276
 277   if (INDEX_INVALID != gbi)
 278     {
 279       GBP_BD_DBG ("del: %U", format_gbp_bridge_domain, gbi);
 280       gbp_bridge_domain_unlock (gbi);
 281
 282       return (0);
 283     }
 284
 285   return (VNET_API_ERROR_NO_SUCH_ENTRY);
 286 }
 287
 288 void
 289 gbp_bridge_domain_walk (gbp_bridge_domain_cb_t cb, void *ctx)
 290 {
 291   gbp_bridge_domain_t *gbpe;
 292
 293   /* *INDENT-OFF* */
 294   pool_foreach(gbpe, gbp_bridge_domain_pool,
 295   {
 296     if (!cb(gbpe, ctx))
 297       break;
 298   });
 299   /* *INDENT-ON* */
 300 }
 301
 302 static clib_error_t *
 303 gbp_bridge_domain_cli (vlib_main_t * vm,
 304                        unformat_input_t * input, vlib_cli_command_t * cmd)
 305 {
 306   vnet_main_t *vnm = vnet_get_main ();
 307   u32 bm_flood_sw_if_index = ~0;
 308   u32 uu_fwd_sw_if_index = ~0;
 309   u32 bvi_sw_if_index = ~0;
 310   u32 bd_id = ~0;
 311   u8 add = 1;
 312
 313   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 314     {
 315       if (unformat (input, "bvi %U", unformat_vnet_sw_interface,
 316                     vnm, &bvi_sw_if_index))
 317         ;
 318       else if (unformat (input, "uu-fwd %U", unformat_vnet_sw_interface,
 319                          vnm, &uu_fwd_sw_if_index))
 320         ;
 321       else if (unformat (input, "bm-flood %U", unformat_vnet_sw_interface,
 322                          vnm, &bm_flood_sw_if_index))
 323         ;
 324       else if (unformat (input, "add"))
 325         add = 1;
 326       else if (unformat (input, "del"))
 327         add = 0;
 328       else if (unformat (input, "bd %d", &bd_id))
 329         ;
 330       else
 331         break;
 332     }
 333
 334   if (~0 == bd_id)
 335     return clib_error_return (0, "EPG-ID must be specified");
 336
 337   if (add)
 338     {
 339       if (~0 == bvi_sw_if_index)
 340         return clib_error_return (0, "interface must be specified");
 341
 342       gbp_bridge_domain_add_and_lock (bd_id, GBP_BD_FLAG_NONE,
 343                                       bvi_sw_if_index,
 344                                       uu_fwd_sw_if_index,
 345                                       bm_flood_sw_if_index);
 346     }
 347   else
 348     gbp_bridge_domain_delete (bd_id);
 349
 350   return (NULL);
 351 }
 352
 353 /*?
 354  * Configure a GBP bridge-domain
 355  *
 356  * @cliexpar
 357  * @cliexstart{set gbp bridge-domain [del] bd <ID> bvi <interface> uu-flood <interface>}
 358  * @cliexend
 359  ?*/
 360 /* *INDENT-OFF* */
 361 VLIB_CLI_COMMAND (gbp_bridge_domain_cli_node, static) = {
 362   .path = "gbp bridge-domain",
 363   .short_help = "gbp bridge-domain [del] epg bd <ID> bvi <interface> uu-flood <interface>",
 364   .function = gbp_bridge_domain_cli,
 365 };
 366
 367 static int
 368 gbp_bridge_domain_show_one (gbp_bridge_domain_t *gb, void *ctx)
 369 {
 370   vlib_main_t *vm;
 371
 372   vm = ctx;
 373   vlib_cli_output (vm, "  %U", format_gbp_bridge_domain_ptr, gb);
 374
 375   return (1);
 376 }
 377
 378 static clib_error_t *
 379 gbp_bridge_domain_show (vlib_main_t * vm,
 380                    unformat_input_t * input, vlib_cli_command_t * cmd)
 381 {
 382   vlib_cli_output (vm, "Bridge-Domains:");
 383   gbp_bridge_domain_walk (gbp_bridge_domain_show_one, vm);
 384
 385   return (NULL);
 386 }
 387
 388
 389 /*?
 390  * Show Group Based Policy Bridge_Domains and derived information
 391  *
 392  * @cliexpar
 393  * @cliexstart{show gbp bridge_domain}
 394  * @cliexend
 395  ?*/
 396 /* *INDENT-OFF* */
 397 VLIB_CLI_COMMAND (gbp_bridge_domain_show_node, static) = {
 398   .path = "show gbp bridge-domain",
 399   .short_help = "show gbp bridge-domain\n",
 400   .function = gbp_bridge_domain_show,
 401 };
 402 /* *INDENT-ON* */
 403
 404 static clib_error_t *
 405 gbp_bridge_domain_init (vlib_main_t * vm)
 406 {
 407   gb_logger = vlib_log_register_class ("gbp", "bd");
 408
 409   return (NULL);
 410 }
 411
 412 VLIB_INIT_FUNCTION (gbp_bridge_domain_init);
 413
 414 /*
 415  * fd.io coding-style-patch-verification: ON
 416  *
 417  * Local Variables:
 418  * eval: (c-set-style "gnu")
 419  * End:
 420  */