vnet/vnet/lisp-gpe/lisp_gpe_tenant.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 #include <vnet/lisp-gpe/lisp_gpe_tenant.h>
  17
  18 /**
  19  * The pool of all tenants
  20  */
  21 static lisp_gpe_tenant_t *lisp_gpe_tenant_pool;
  22
  23 /**
  24  * The hash table of all tenants: key:{VNI}.
  25  */
  26 uword *lisp_gpe_tenant_db;
  27
  28 static lisp_gpe_tenant_t *
  29 lisp_gpe_tenant_find (u32 vni)
  30 {
  31   uword *p;
  32
  33   p = hash_get (lisp_gpe_tenant_db, vni);
  34
  35   if (NULL == p)
  36     return (NULL);
  37
  38   return (pool_elt_at_index (lisp_gpe_tenant_pool, p[0]));
  39 }
  40
  41 static lisp_gpe_tenant_t *
  42 lisp_gpe_tenant_find_or_create_i (u32 vni)
  43 {
  44   lisp_gpe_tenant_t *lt;
  45
  46   lt = lisp_gpe_tenant_find (vni);
  47
  48   if (NULL == lt)
  49     {
  50       pool_get (lisp_gpe_tenant_pool, lt);
  51       memset (lt, 0, sizeof (*lt));
  52
  53       lt->lt_vni = vni;
  54       lt->lt_table_id = ~0;
  55       lt->lt_bd_id = ~0;
  56
  57       hash_set (lisp_gpe_tenant_db, vni, lt - lisp_gpe_tenant_pool);
  58     }
  59
  60   return (lt);
  61 }
  62
  63 /**
  64  * @brief Find or create a tenant for the given VNI
  65  */
  66 u32
  67 lisp_gpe_tenant_find_or_create (u32 vni)
  68 {
  69   lisp_gpe_tenant_t *lt;
  70
  71   lt = lisp_gpe_tenant_find (vni);
  72
  73   if (NULL == lt)
  74     {
  75       lt = lisp_gpe_tenant_find_or_create_i (vni);
  76     }
  77
  78   return (lt - lisp_gpe_tenant_pool);
  79 }
  80
  81 /**
  82  * @brief If there are no more locks/users of te tenant, then delete it
  83  */
  84 static void
  85 lisp_gpe_tenant_delete_if_empty (lisp_gpe_tenant_t * lt)
  86 {
  87   int i;
  88
  89   for (i = 0; i < LISP_GPE_TENANT_LOCK_NUM; i++)
  90     {
  91       if (lt->lt_locks[i])
  92         return;
  93     }
  94
  95   hash_unset (lisp_gpe_tenant_db, lt->lt_vni);
  96   pool_put (lisp_gpe_tenant_pool, lt);
  97 }
  98
  99 /**
 100  * @brief Add/create and lock a new or find and lock the existing L3
 101  * interface for the tenant
 102  *
 103  * @paran vni The tenant's VNI
 104  * @param table_id the Tenant's L3 table ID.
 105  *
 106  * @return the SW IF index of the L3 interface
 107  */
 108 u32
 109 lisp_gpe_tenant_l3_iface_add_or_lock (u32 vni, u32 table_id)
 110 {
 111   lisp_gpe_tenant_t *lt;
 112
 113   lt = lisp_gpe_tenant_find_or_create_i (vni);
 114
 115   if (~0 == lt->lt_table_id)
 116     lt->lt_table_id = table_id;
 117
 118   ASSERT (lt->lt_table_id == table_id);
 119
 120   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L3_IFACE])
 121     {
 122       /* create the l3 interface since there are currently no users of it */
 123       lt->lt_l3_sw_if_index =
 124         lisp_gpe_add_l3_iface (&lisp_gpe_main, vni, table_id);
 125     }
 126
 127   lt->lt_locks[LISP_GPE_TENANT_LOCK_L3_IFACE]++;
 128
 129   return (lt->lt_l3_sw_if_index);
 130 }
 131
 132 /**
 133  * @brief Release the lock held on the tenant's L3 interface
 134  */
 135 void
 136 lisp_gpe_tenant_l3_iface_unlock (u32 vni)
 137 {
 138   lisp_gpe_tenant_t *lt;
 139
 140   lt = lisp_gpe_tenant_find (vni);
 141
 142   if (NULL == lt)
 143     {
 144       clib_warning ("No tenant for VNI %d", vni);
 145     }
 146
 147   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L3_IFACE])
 148     {
 149       clib_warning ("No L3 interface for tenant VNI %d", vni);
 150       return;
 151     }
 152
 153   lt->lt_locks[LISP_GPE_TENANT_LOCK_L3_IFACE]--;
 154
 155   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L3_IFACE])
 156     {
 157       /* the last user has gone, so delete the l3 interface */
 158       lisp_gpe_del_l3_iface (&lisp_gpe_main, vni, lt->lt_table_id);
 159     }
 160
 161   /*
 162    * If there are no more locks on any tenant managed resource, then
 163    * this tenant is toast.
 164    */
 165   lisp_gpe_tenant_delete_if_empty (lt);
 166 }
 167
 168 /**
 169  * @brief Add/create and lock a new or find and lock the existing L2
 170  * interface for the tenant
 171  *
 172  * @paran vni The tenant's VNI
 173  * @param table_id the Tenant's L2 Bridge Domain ID.
 174  *
 175  * @return the SW IF index of the L2 interface
 176  */
 177 u32
 178 lisp_gpe_tenant_l2_iface_add_or_lock (u32 vni, u32 bd_id)
 179 {
 180   lisp_gpe_tenant_t *lt;
 181
 182   lt = lisp_gpe_tenant_find_or_create_i (vni);
 183
 184   if (NULL == lt)
 185     {
 186       clib_warning ("No tenant for VNI %d", vni);
 187       return ~0;
 188     }
 189
 190   if (~0 == lt->lt_bd_id)
 191     lt->lt_bd_id = bd_id;
 192
 193   ASSERT (lt->lt_bd_id == bd_id);
 194
 195   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L2_IFACE])
 196     {
 197       /* create the l2 interface since there are currently no users of it */
 198       lt->lt_l2_sw_if_index =
 199         lisp_gpe_add_l2_iface (&lisp_gpe_main, vni, bd_id);
 200     }
 201
 202   lt->lt_locks[LISP_GPE_TENANT_LOCK_L2_IFACE]++;
 203
 204   return (lt->lt_l2_sw_if_index);
 205 }
 206
 207 /**
 208  * @brief Release the lock held on the tenant's L3 interface
 209  */
 210 void
 211 lisp_gpe_tenant_l2_iface_unlock (u32 vni)
 212 {
 213   lisp_gpe_tenant_t *lt;
 214
 215   lt = lisp_gpe_tenant_find (vni);
 216
 217   if (NULL == lt)
 218     {
 219       clib_warning ("No tenant for VNI %d", vni);
 220       return;
 221     }
 222
 223   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L2_IFACE])
 224     {
 225       clib_warning ("No L2 interface for tenant VNI %d", vni);
 226       return;
 227     }
 228
 229   lt->lt_locks[LISP_GPE_TENANT_LOCK_L2_IFACE]--;
 230
 231   if (0 == lt->lt_locks[LISP_GPE_TENANT_LOCK_L2_IFACE])
 232     {
 233       /* the last user has gone, so delete the l2 interface */
 234       lisp_gpe_del_l2_iface (&lisp_gpe_main, vni, lt->lt_bd_id);
 235     }
 236
 237   /*
 238    * If there are no more locks on any tenant managed resource, then
 239    * this tenant is toast.
 240    */
 241   lisp_gpe_tenant_delete_if_empty (lt);
 242 }
 243
 244 /**
 245  * @brief get a const pointer to the tenant object
 246  */
 247 const lisp_gpe_tenant_t *
 248 lisp_gpe_tenant_get (u32 index)
 249 {
 250   return (pool_elt_at_index (lisp_gpe_tenant_pool, index));
 251 }
 252
 253 /**
 254  * @brief Flush/delete ALL the tenants
 255  */
 256 void
 257 lisp_gpe_tenant_flush (void)
 258 {
 259   lisp_gpe_tenant_t *lt;
 260
 261   /* *INDENT-OFF* */
 262   pool_foreach(lt, lisp_gpe_tenant_pool,
 263   ({
 264     lisp_gpe_tenant_l2_iface_unlock(lt->lt_vni);
 265     lisp_gpe_tenant_l3_iface_unlock(lt->lt_vni);
 266   }));
 267   /* *INDENT-ON* */
 268 }
 269
 270 /**
 271  * @brif Show/display one tenant
 272  */
 273 static u8 *
 274 format_lisp_gpe_tenant (u8 * s, va_list ap)
 275 {
 276   const lisp_gpe_tenant_t *lt = va_arg (ap, lisp_gpe_tenant_t *);
 277
 278   s = format (s, "VNI:%d ", lt->lt_vni);
 279
 280   if (lt->lt_table_id != ~0)
 281     {
 282       s = format (s, "VRF:%d ", lt->lt_table_id);
 283       s = format (s, "L3-SW-IF:%d ", lt->lt_l3_sw_if_index);
 284     }
 285
 286   if (lt->lt_bd_id != ~0)
 287     {
 288       s = format (s, "BD-ID:%d ", lt->lt_bd_id);
 289       s = format (s, "L2-SW-IF:%d ", lt->lt_l2_sw_if_index);
 290     }
 291
 292   return (s);
 293 }
 294
 295 /**
 296  * @brief CLI command to show LISP-GPE tenant.
 297  */
 298 static clib_error_t *
 299 lisp_gpe_tenant_show (vlib_main_t * vm,
 300                       unformat_input_t * input, vlib_cli_command_t * cmd)
 301 {
 302   lisp_gpe_tenant_t *lt;
 303
 304   /* *INDENT-OFF* */
 305   pool_foreach (lt, lisp_gpe_tenant_pool,
 306   ({
 307     vlib_cli_output (vm, "%U", format_lisp_gpe_tenant, lt);
 308   }));
 309   /* *INDENT-ON* */
 310
 311   return 0;
 312 }
 313
 314 /* *INDENT-OFF* */
 315 VLIB_CLI_COMMAND (lisp_gpe_tenant_command) = {
 316   .path = "show lisp gpe tenant",
 317   .short_help = "show lisp gpe tenant",
 318   .function = lisp_gpe_tenant_show,
 319 };
 320 /* *INDENT-ON* */
 321
 322
 323 /*
 324  * fd.io coding-style-patch-verification: ON
 325  *
 326  * Local Variables:
 327  * eval: (c-set-style "gnu")
 328  * End:
 329  */