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)
  49     f->feature_config = vec_dup (f->feature_config);
  50
  51   return result;
  52 }
  53
  54 static void
  55 free_feature_vector (vnet_config_feature_t * feature_vector)
  56 {
  57   vnet_config_feature_t * f;
  58
  59   vec_foreach (f, feature_vector)
  60     vnet_config_feature_free (f);
  61   vec_free (feature_vector);
  62 }
  63
  64 static u32
  65 add_next (vlib_main_t * vm,
  66           vnet_config_main_t * cm,
  67           u32 last_node_index,
  68           u32 this_node_index)
  69 {
  70   u32 i, ni = ~0;
  71
  72   if (last_node_index != ~0)
  73     return vlib_node_add_next (vm, last_node_index, this_node_index);
  74
  75   for (i = 0; i < vec_len (cm->start_node_indices); i++)
  76     {
  77       u32 tmp;
  78       tmp = vlib_node_add_next (vm, cm->start_node_indices[i], this_node_index);
  79       if (ni == ~0)
  80         ni = tmp;
  81       /* Start nodes to first must agree on next indices. */
  82       ASSERT (ni == tmp);
  83     }
  84
  85   return ni;
  86 }
  87
  88 static vnet_config_t *
  89 find_config_with_features (vlib_main_t * vm,
  90                            vnet_config_main_t * cm,
  91                            vnet_config_feature_t * feature_vector)
  92 {
  93   u32 last_node_index = ~0;
  94   vnet_config_feature_t * f;
  95   u32 * config_string;
  96   uword * p;
  97   vnet_config_t * c;
  98
  99   config_string = cm->config_string_temp;
 100   cm->config_string_temp = 0;
 101   if (config_string)
 102     _vec_len (config_string) = 0;
 103
 104   vec_foreach (f, feature_vector)
 105     {
 106       /* Connect node graph. */
 107       f->next_index = add_next (vm, cm, last_node_index, f->node_index);
 108       last_node_index = f->node_index;
 109
 110       /* Store next index in config string. */
 111       vec_add1 (config_string, f->next_index);
 112
 113       /* Store feature config. */
 114       vec_add (config_string, f->feature_config, vec_len (f->feature_config));
 115     }
 116
 117   /* Terminate config string with next for end node. */
 118   if (last_node_index == ~0 || last_node_index != cm->end_node_index)
 119     {
 120       u32 next_index = add_next (vm, cm, last_node_index, cm->end_node_index);
 121       vec_add1 (config_string, next_index);
 122     }
 123
 124   /* See if config string is unique. */
 125   p = hash_get_mem (cm->config_string_hash, config_string);
 126   if (p)
 127     {
 128       /* Not unique.  Share existing config. */
 129       cm->config_string_temp = config_string; /* we'll use it again later. */
 130       free_feature_vector (feature_vector);
 131       c = pool_elt_at_index (cm->config_pool, p[0]);
 132     }
 133   else
 134     {
 135       u32 * d;
 136
 137       pool_get (cm->config_pool, c);
 138       c->index = c - cm->config_pool;
 139       c->features = feature_vector;
 140       c->config_string_vector = config_string;
 141
 142       /* Allocate copy of config string in heap.
 143          VLIB buffers will maintain pointers to heap as they read out
 144          configuration data. */
 145       c->config_string_heap_index
 146         = heap_alloc (cm->config_string_heap, vec_len (config_string) + 1,
 147                       c->config_string_heap_handle);
 148
 149       /* First element in heap points back to pool index. */
 150       d = vec_elt_at_index (cm->config_string_heap, c->config_string_heap_index);
 151       d[0] = c->index;
 152       memcpy (d + 1, config_string, vec_bytes (config_string));
 153       hash_set_mem (cm->config_string_hash, config_string, c->index);
 154
 155       c->reference_count = 0; /* will be incremented by caller. */
 156     }
 157
 158   return c;
 159 }
 160
 161 void 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[],
 166                        int n_feature_node_names)
 167 {
 168   vlib_node_t * n;
 169   u32 i;
 170
 171   memset (cm, 0, sizeof (cm[0]));
 172
 173   cm->config_string_hash = hash_create_vec (0, STRUCT_SIZE_OF (vnet_config_t, config_string_vector[0]), sizeof (uword));
 174
 175   ASSERT (n_start_node_names >= 1);
 176   ASSERT (n_feature_node_names >= 1);
 177
 178   vec_resize (cm->start_node_indices, n_start_node_names);
 179   for (i = 0; i < n_start_node_names; i++)
 180     {
 181       n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]);
 182       /* Given node name must exist. */
 183       ASSERT (n != 0);
 184       cm->start_node_indices[i] = n->index;
 185     }
 186
 187   vec_resize (cm->node_index_by_feature_index, n_feature_node_names);
 188   for (i = 0; i < n_feature_node_names; i++)
 189     {
 190       if (! feature_node_names[i])
 191         cm->node_index_by_feature_index[i] = ~0;
 192       else
 193         {
 194           n = vlib_get_node_by_name (vm, (u8 *) feature_node_names[i]);
 195           /* Given node may exist in plug-in library which is not present */
 196           if (n)
 197             {
 198               if (i + 1 == n_feature_node_names)
 199                 cm->end_node_index = n->index;
 200               cm->node_index_by_feature_index[i] = n->index;
 201              }
 202           else cm->node_index_by_feature_index[i] = ~0;
 203         }
 204     }
 205 }
 206
 207 static void
 208 remove_reference (vnet_config_main_t * cm, vnet_config_t * c)
 209 {
 210   ASSERT (c->reference_count > 0);
 211   c->reference_count -= 1;
 212   if (c->reference_count == 0)
 213     {
 214       hash_unset (cm->config_string_hash, c->config_string_vector);
 215       vnet_config_free (cm, c);
 216       pool_put (cm->config_pool, c);
 217     }
 218 }
 219
 220 always_inline u32 *
 221 vnet_get_config_heap (vnet_config_main_t * cm, u32 ci)
 222 { return heap_elt_at_index (cm->config_string_heap, ci); }
 223
 224 u32 vnet_config_add_feature (vlib_main_t * vm,
 225                              vnet_config_main_t * cm,
 226                              u32 config_string_heap_index,
 227                              u32 feature_index,
 228                              void * feature_config,
 229                              u32 n_feature_config_bytes)
 230 {
 231   vnet_config_t * old, * new;
 232   vnet_config_feature_t * new_features, * f;
 233   u32 n_feature_config_u32s;
 234   u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index);
 235
 236   if (node_index == ~0)                 // feature node does not exist
 237     return config_string_heap_index;    // return original config index
 238
 239   if (config_string_heap_index == ~0)
 240     {
 241       old = 0;
 242       new_features = 0;
 243     }
 244   else
 245     {
 246       u32 * p = vnet_get_config_heap (cm, config_string_heap_index);
 247       old = pool_elt_at_index (cm->config_pool, p[-1]);
 248       new_features = old->features;
 249       if (new_features)
 250         new_features = duplicate_feature_vector (new_features);
 251     }
 252
 253   vec_add2 (new_features, f, 1);
 254   f->feature_index = feature_index;
 255   f->node_index = node_index;
 256
 257   n_feature_config_u32s = round_pow2 (n_feature_config_bytes, sizeof (f->feature_config[0])) / sizeof (f->feature_config[0]);
 258   vec_add (f->feature_config, feature_config, n_feature_config_u32s);
 259
 260   /* Sort (prioritize) features. */
 261   if (vec_len (new_features) > 1)
 262     vec_sort (new_features, f1, f2, (int) f1->feature_index - f2->feature_index);
 263
 264   if (old)
 265     remove_reference (cm, old);
 266
 267   new = find_config_with_features (vm, cm, new_features);
 268   new->reference_count += 1;
 269
 270   /* User gets pointer to config string first element (which defines the pool index
 271      this config string comes from). */
 272   return new->config_string_heap_index + 1;
 273 }
 274
 275 u32 vnet_config_del_feature (vlib_main_t * vm,
 276                              vnet_config_main_t * cm,
 277                              u32 config_string_heap_index,
 278                              u32 feature_index,
 279                              void * feature_config,
 280                              u32 n_feature_config_bytes)
 281 {
 282   vnet_config_t * old, * new;
 283   vnet_config_feature_t * new_features, * f;
 284   u32 n_feature_config_u32s;
 285
 286   {
 287     u32 * p = vnet_get_config_heap (cm, config_string_heap_index);
 288
 289     old = pool_elt_at_index (cm->config_pool, p[-1]);
 290   }
 291
 292   n_feature_config_u32s = round_pow2 (n_feature_config_bytes, sizeof (f->feature_config[0])) / sizeof (f->feature_config[0]);
 293
 294   /* Find feature with same index and opaque data. */
 295   vec_foreach (f, old->features)
 296     {
 297       if (f->feature_index == feature_index
 298           && vec_len (f->feature_config) == n_feature_config_u32s
 299           && (n_feature_config_u32s == 0
 300               || ! memcmp (f->feature_config, feature_config, n_feature_config_bytes)))
 301         break;
 302     }
 303
 304   /* Feature not found. */
 305   if (f >= vec_end (old->features))
 306     return config_string_heap_index;    // return original config index
 307
 308   new_features = duplicate_feature_vector (old->features);
 309   f = new_features + (f - old->features);
 310   vnet_config_feature_free (f);
 311   vec_delete (new_features, 1, f - new_features);
 312
 313   /* must remove old from config_pool now as it may be expanded and change
 314      memory location if the following function find_config_with_features()
 315      adds a new config because none of existing config's has matching features
 316      and so can be reused */
 317   remove_reference (cm, old);
 318   new = find_config_with_features (vm, cm, new_features);
 319   new->reference_count += 1;
 320
 321   return new->config_string_heap_index + 1;
 322 }