vnet/vnet/config.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  * config.c: feature configuration
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vnet/vnet.h>
  41
  42 static vnet_config_feature_t *
  43 duplicate_feature_vector (vnet_config_feature_t * feature_vector)
  44 {
  45   vnet_config_feature_t *result, *f;
  46
  47   result = vec_dup (feature_vector);
  48   vec_foreach (f, result) f->feature_config = vec_dup (f->feature_config);
  49
  50   return result;
  51 }
  52
  53 static void
  54 free_feature_vector (vnet_config_feature_t * feature_vector)
  55 {
  56   vnet_config_feature_t *f;
  57
  58   vec_foreach (f, feature_vector) vnet_config_feature_free (f);
  59   vec_free (feature_vector);
  60 }
  61
  62 static u32
  63 add_next (vlib_main_t * vm,
  64           vnet_config_main_t * cm, u32 last_node_index, u32 this_node_index)
  65 {
  66   u32 i, ni = ~0;
  67
  68   if (last_node_index != ~0)
  69     return vlib_node_add_next (vm, last_node_index, this_node_index);
  70
  71   for (i = 0; i < vec_len (cm->start_node_indices); i++)
  72     {
  73       u32 tmp;
  74       tmp =
  75         vlib_node_add_next (vm, cm->start_node_indices[i], this_node_index);
  76       if (ni == ~0)
  77         ni = tmp;
  78       /* Start nodes to first must agree on next indices. */
  79       ASSERT (ni == tmp);
  80     }
  81
  82   return ni;
  83 }
  84
  85 static vnet_config_t *
  86 find_config_with_features (vlib_main_t * vm,
  87                            vnet_config_main_t * cm,
  88                            vnet_config_feature_t * feature_vector)
  89 {
  90   u32 last_node_index = ~0;
  91   vnet_config_feature_t *f;
  92   u32 *config_string;
  93   uword *p;
  94   vnet_config_t *c;
  95
  96   config_string = cm->config_string_temp;
  97   cm->config_string_temp = 0;
  98   if (config_string)
  99     _vec_len (config_string) = 0;
 100
 101   vec_foreach (f, feature_vector)
 102   {
 103     /* Connect node graph. */
 104     f->next_index = add_next (vm, cm, last_node_index, f->node_index);
 105     last_node_index = f->node_index;
 106
 107     /* Store next index in config string. */
 108     vec_add1 (config_string, f->next_index);
 109
 110     /* Store feature config. */
 111     vec_add (config_string, f->feature_config, vec_len (f->feature_config));
 112   }
 113
 114   /* Terminate config string with next for end node. */
 115   if (last_node_index == ~0 || last_node_index != cm->end_node_index)
 116     {
 117       u32 next_index = add_next (vm, cm, last_node_index, cm->end_node_index);
 118       vec_add1 (config_string, next_index);
 119     }
 120
 121   /* See if config string is unique. */
 122   p = hash_get_mem (cm->config_string_hash, config_string);
 123   if (p)
 124     {
 125       /* Not unique.  Share existing config. */
 126       cm->config_string_temp = config_string;   /* we'll use it again later. */
 127       free_feature_vector (feature_vector);
 128       c = pool_elt_at_index (cm->config_pool, p[0]);
 129     }
 130   else
 131     {
 132       u32 *d;
 133
 134       pool_get (cm->config_pool, c);
 135       c->index = c - cm->config_pool;
 136       c->features = feature_vector;
 137       c->config_string_vector = config_string;
 138
 139       /* Allocate copy of config string in heap.
 140          VLIB buffers will maintain pointers to heap as they read out
 141          configuration data. */
 142       c->config_string_heap_index
 143         = heap_alloc (cm->config_string_heap, vec_len (config_string) + 1,
 144                       c->config_string_heap_handle);
 145
 146       /* First element in heap points back to pool index. */
 147       d =
 148         vec_elt_at_index (cm->config_string_heap,
 149                           c->config_string_heap_index);
 150       d[0] = c->index;
 151       clib_memcpy (d + 1, config_string, vec_bytes (config_string));
 152       hash_set_mem (cm->config_string_hash, config_string, c->index);
 153
 154       c->reference_count = 0;   /* will be incremented by caller. */
 155     }
 156
 157   return c;
 158 }
 159
 160 void
 161 vnet_config_init (vlib_main_t * vm,
 162                   vnet_config_main_t * cm,
 163                   char *start_node_names[],
 164                   int n_start_node_names,
 165                   char *feature_node_names[], int n_feature_node_names)
 166 {
 167   vlib_node_t *n;
 168   u32 i;
 169
 170   memset (cm, 0, sizeof (cm[0]));
 171
 172   cm->config_string_hash =
 173     hash_create_vec (0,
 174                      STRUCT_SIZE_OF (vnet_config_t, config_string_vector[0]),
 175                      sizeof (uword));
 176
 177   ASSERT (n_start_node_names >= 1);
 178   ASSERT (n_feature_node_names >= 1);
 179
 180   vec_resize (cm->start_node_indices, n_start_node_names);
 181   for (i = 0; i < n_start_node_names; i++)
 182     {
 183       n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]);
 184       /* Given node name must exist. */
 185       ASSERT (n != 0);
 186       cm->start_node_indices[i] = n->index;
 187     }
 188
 189   vec_resize (cm->node_index_by_feature_index, n_feature_node_names);
 190   for (i = 0; i < n_feature_node_names; i++)
 191     {
 192       if (!feature_node_names[i])
 193         cm->node_index_by_feature_index[i] = ~0;
 194       else
 195         {
 196           n = vlib_get_node_by_name (vm, (u8 *) feature_node_names[i]);
 197           /* Given node may exist in plug-in library which is not present */
 198           if (n)
 199             {
 200               if (i + 1 == n_feature_node_names)
 201                 cm->end_node_index = n->index;
 202               cm->node_index_by_feature_index[i] = n->index;
 203             }
 204           else
 205             cm->node_index_by_feature_index[i] = ~0;
 206         }
 207     }
 208 }
 209
 210 static void
 211 remove_reference (vnet_config_main_t * cm, vnet_config_t * c)
 212 {
 213   ASSERT (c->reference_count > 0);
 214   c->reference_count -= 1;
 215   if (c->reference_count == 0)
 216     {
 217       hash_unset (cm->config_string_hash, c->config_string_vector);
 218       vnet_config_free (cm, c);
 219       pool_put (cm->config_pool, c);
 220     }
 221 }
 222
 223 static int
 224 feature_cmp (void *a1, void *a2)
 225 {
 226   vnet_config_feature_t *f1 = a1;
 227   vnet_config_feature_t *f2 = a2;
 228
 229   return (int) f1->feature_index - f2->feature_index;
 230 }
 231
 232 always_inline u32 *
 233 vnet_get_config_heap (vnet_config_main_t * cm, u32 ci)
 234 {
 235   return heap_elt_at_index (cm->config_string_heap, ci);
 236 }
 237
 238 u32
 239 vnet_config_add_feature (vlib_main_t * vm,
 240                          vnet_config_main_t * cm,
 241                          u32 config_string_heap_index,
 242                          u32 feature_index,
 243                          void *feature_config, u32 n_feature_config_bytes)
 244 {
 245   vnet_config_t *old, *new;
 246   vnet_config_feature_t *new_features, *f;
 247   u32 n_feature_config_u32s;
 248   u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index);
 249
 250   if (node_index == ~0)         // feature node does not exist
 251     return config_string_heap_index;    // return original config index
 252
 253   if (config_string_heap_index == ~0)
 254     {
 255       old = 0;
 256       new_features = 0;
 257     }
 258   else
 259     {
 260       u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
 261       old = pool_elt_at_index (cm->config_pool, p[-1]);
 262       new_features = old->features;
 263       if (new_features)
 264         new_features = duplicate_feature_vector (new_features);
 265     }
 266
 267   vec_add2 (new_features, f, 1);
 268   f->feature_index = feature_index;
 269   f->node_index = node_index;
 270
 271   n_feature_config_u32s =
 272     round_pow2 (n_feature_config_bytes,
 273                 sizeof (f->feature_config[0])) /
 274     sizeof (f->feature_config[0]);
 275   vec_add (f->feature_config, feature_config, n_feature_config_u32s);
 276
 277   /* Sort (prioritize) features. */
 278   if (vec_len (new_features) > 1)
 279     vec_sort_with_function (new_features, feature_cmp);
 280
 281   if (old)
 282     remove_reference (cm, old);
 283
 284   new = find_config_with_features (vm, cm, new_features);
 285   new->reference_count += 1;
 286
 287   /*
 288    * User gets pointer to config string first element
 289    * (which defines the pool index
 290    * this config string comes from).
 291    */
 292   vec_validate (cm->config_pool_index_by_user_index,
 293                 new->config_string_heap_index + 1);
 294   cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
 295     = new - cm->config_pool;
 296   return new->config_string_heap_index + 1;
 297 }
 298
 299 u32
 300 vnet_config_del_feature (vlib_main_t * vm,
 301                          vnet_config_main_t * cm,
 302                          u32 config_string_heap_index,
 303                          u32 feature_index,
 304                          void *feature_config, u32 n_feature_config_bytes)
 305 {
 306   vnet_config_t *old, *new;
 307   vnet_config_feature_t *new_features, *f;
 308   u32 n_feature_config_u32s;
 309
 310   {
 311     u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
 312
 313     old = pool_elt_at_index (cm->config_pool, p[-1]);
 314   }
 315
 316   n_feature_config_u32s =
 317     round_pow2 (n_feature_config_bytes,
 318                 sizeof (f->feature_config[0])) /
 319     sizeof (f->feature_config[0]);
 320
 321   /* Find feature with same index and opaque data. */
 322   vec_foreach (f, old->features)
 323   {
 324     if (f->feature_index == feature_index
 325         && vec_len (f->feature_config) == n_feature_config_u32s
 326         && (n_feature_config_u32s == 0
 327             || !memcmp (f->feature_config, feature_config,
 328                         n_feature_config_bytes)))
 329       break;
 330   }
 331
 332   /* Feature not found. */
 333   if (f >= vec_end (old->features))
 334     return config_string_heap_index;    // return original config index
 335
 336   new_features = duplicate_feature_vector (old->features);
 337   f = new_features + (f - old->features);
 338   vnet_config_feature_free (f);
 339   vec_delete (new_features, 1, f - new_features);
 340
 341   /* must remove old from config_pool now as it may be expanded and change
 342      memory location if the following function find_config_with_features()
 343      adds a new config because none of existing config's has matching features
 344      and so can be reused */
 345   remove_reference (cm, old);
 346   new = find_config_with_features (vm, cm, new_features);
 347   new->reference_count += 1;
 348
 349   vec_validate (cm->config_pool_index_by_user_index,
 350                 new->config_string_heap_index + 1);
 351   cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
 352     = new - cm->config_pool;
 353   return new->config_string_heap_index + 1;
 354 }
 355
 356 /*
 357  * fd.io coding-style-patch-verification: ON
 358  *
 359  * Local Variables:
 360  * eval: (c-set-style "gnu")
 361  * End:
 362  */