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_feature_node_names >= 1);
 178
 179   vec_resize (cm->start_node_indices, n_start_node_names);
 180   for (i = 0; i < n_start_node_names; i++)
 181     {
 182       n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]);
 183       /* Given node name must exist. */
 184       ASSERT (n != 0);
 185       cm->start_node_indices[i] = n->index;
 186     }
 187
 188   vec_resize (cm->node_index_by_feature_index, n_feature_node_names);
 189   for (i = 0; i < n_feature_node_names; i++)
 190     {
 191       if (!feature_node_names[i])
 192         cm->node_index_by_feature_index[i] = ~0;
 193       else
 194         {
 195           n = vlib_get_node_by_name (vm, (u8 *) feature_node_names[i]);
 196           /* Given node may exist in plug-in library which is not present */
 197           if (n)
 198             {
 199               if (i + 1 == n_feature_node_names)
 200                 cm->end_node_index = n->index;
 201               cm->node_index_by_feature_index[i] = n->index;
 202             }
 203           else
 204             cm->node_index_by_feature_index[i] = ~0;
 205         }
 206     }
 207 }
 208
 209 static void
 210 remove_reference (vnet_config_main_t * cm, vnet_config_t * c)
 211 {
 212   ASSERT (c->reference_count > 0);
 213   c->reference_count -= 1;
 214   if (c->reference_count == 0)
 215     {
 216       hash_unset (cm->config_string_hash, c->config_string_vector);
 217       vnet_config_free (cm, c);
 218       pool_put (cm->config_pool, c);
 219     }
 220 }
 221
 222 static int
 223 feature_cmp (void *a1, void *a2)
 224 {
 225   vnet_config_feature_t *f1 = a1;
 226   vnet_config_feature_t *f2 = a2;
 227
 228   return (int) f1->feature_index - f2->feature_index;
 229 }
 230
 231 always_inline u32 *
 232 vnet_get_config_heap (vnet_config_main_t * cm, u32 ci)
 233 {
 234   return heap_elt_at_index (cm->config_string_heap, ci);
 235 }
 236
 237 u32
 238 vnet_config_add_feature (vlib_main_t * vm,
 239                          vnet_config_main_t * cm,
 240                          u32 config_string_heap_index,
 241                          u32 feature_index,
 242                          void *feature_config, u32 n_feature_config_bytes)
 243 {
 244   vnet_config_t *old, *new;
 245   vnet_config_feature_t *new_features, *f;
 246   u32 n_feature_config_u32s;
 247   u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index);
 248
 249   if (node_index == ~0)         // feature node does not exist
 250     return config_string_heap_index;    // return original config index
 251
 252   if (config_string_heap_index == ~0)
 253     {
 254       old = 0;
 255       new_features = 0;
 256     }
 257   else
 258     {
 259       u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
 260       old = pool_elt_at_index (cm->config_pool, p[-1]);
 261       new_features = old->features;
 262       if (new_features)
 263         new_features = duplicate_feature_vector (new_features);
 264     }
 265
 266   vec_add2 (new_features, f, 1);
 267   f->feature_index = feature_index;
 268   f->node_index = node_index;
 269
 270   n_feature_config_u32s =
 271     round_pow2 (n_feature_config_bytes,
 272                 sizeof (f->feature_config[0])) /
 273     sizeof (f->feature_config[0]);
 274   vec_add (f->feature_config, feature_config, n_feature_config_u32s);
 275
 276   /* Sort (prioritize) features. */
 277   if (vec_len (new_features) > 1)
 278     vec_sort_with_function (new_features, feature_cmp);
 279
 280   if (old)
 281     remove_reference (cm, old);
 282
 283   new = find_config_with_features (vm, cm, new_features);
 284   new->reference_count += 1;
 285
 286   /*
 287    * User gets pointer to config string first element
 288    * (which defines the pool index
 289    * this config string comes from).
 290    */
 291   vec_validate (cm->config_pool_index_by_user_index,
 292                 new->config_string_heap_index + 1);
 293   cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
 294     = new - cm->config_pool;
 295   return new->config_string_heap_index + 1;
 296 }
 297
 298 u32
 299 vnet_config_del_feature (vlib_main_t * vm,
 300                          vnet_config_main_t * cm,
 301                          u32 config_string_heap_index,
 302                          u32 feature_index,
 303                          void *feature_config, u32 n_feature_config_bytes)
 304 {
 305   vnet_config_t *old, *new;
 306   vnet_config_feature_t *new_features, *f;
 307   u32 n_feature_config_u32s;
 308
 309   {
 310     u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
 311
 312     old = pool_elt_at_index (cm->config_pool, p[-1]);
 313   }
 314
 315   n_feature_config_u32s =
 316     round_pow2 (n_feature_config_bytes,
 317                 sizeof (f->feature_config[0])) /
 318     sizeof (f->feature_config[0]);
 319
 320   /* Find feature with same index and opaque data. */
 321   vec_foreach (f, old->features)
 322   {
 323     if (f->feature_index == feature_index
 324         && vec_len (f->feature_config) == n_feature_config_u32s
 325         && (n_feature_config_u32s == 0
 326             || !memcmp (f->feature_config, feature_config,
 327                         n_feature_config_bytes)))
 328       break;
 329   }
 330
 331   /* Feature not found. */
 332   if (f >= vec_end (old->features))
 333     return config_string_heap_index;    // return original config index
 334
 335   new_features = duplicate_feature_vector (old->features);
 336   f = new_features + (f - old->features);
 337   vnet_config_feature_free (f);
 338   vec_delete (new_features, 1, f - new_features);
 339
 340   /* must remove old from config_pool now as it may be expanded and change
 341      memory location if the following function find_config_with_features()
 342      adds a new config because none of existing config's has matching features
 343      and so can be reused */
 344   remove_reference (cm, old);
 345   new = find_config_with_features (vm, cm, new_features);
 346   new->reference_count += 1;
 347
 348   vec_validate (cm->config_pool_index_by_user_index,
 349                 new->config_string_heap_index + 1);
 350   cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
 351     = new - cm->config_pool;
 352   return new->config_string_heap_index + 1;
 353 }
 354
 355 /*
 356  * fd.io coding-style-patch-verification: ON
 357  *
 358  * Local Variables:
 359  * eval: (c-set-style "gnu")
 360  * End:
 361  */