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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * config.c: feature configuration
18 * Copyright (c) 2008 Eliot Dresselhaus
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:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
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.
40 #include <vnet/vnet.h>
42 static vnet_config_feature_t *
43 duplicate_feature_vector (vnet_config_feature_t * feature_vector)
45 vnet_config_feature_t *result, *f;
47 result = vec_dup (feature_vector);
48 vec_foreach (f, result) f->feature_config = vec_dup (f->feature_config);
54 free_feature_vector (vnet_config_feature_t * feature_vector)
56 vnet_config_feature_t *f;
58 vec_foreach (f, feature_vector) vnet_config_feature_free (f);
59 vec_free (feature_vector);
63 add_next (vlib_main_t * vm,
64 vnet_config_main_t * cm, u32 last_node_index, u32 this_node_index)
68 if (last_node_index != ~0)
69 return vlib_node_add_next (vm, last_node_index, this_node_index);
71 for (i = 0; i < vec_len (cm->start_node_indices); i++)
75 vlib_node_add_next (vm, cm->start_node_indices[i], this_node_index);
78 /* Start nodes to first must agree on next indices. */
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,
91 u32 last_node_index = ~0;
92 vnet_config_feature_t *f;
97 config_string = cm->config_string_temp;
98 cm->config_string_temp = 0;
100 vec_set_len (config_string, 0);
102 vec_foreach (f, feature_vector)
104 /* Connect node graph. */
105 f->next_index = add_next (vm, cm, last_node_index, f->node_index);
106 last_node_index = f->node_index;
108 /* Store next index in config string. */
109 vec_add1 (config_string, f->next_index);
111 /* Store feature config. */
112 vec_add (config_string, f->feature_config, vec_len (f->feature_config));
115 /* Terminate config string with next for end node. */
116 if (last_node_index == ~0 || last_node_index != end_node_index)
118 u32 next_index = add_next (vm, cm, last_node_index, end_node_index);
119 vec_add1 (config_string, next_index);
122 /* Add the end node index to the config string so that it is part of
123 * the key used to detect string sharing. If this is not included then
124 * a modification of the end node would affect all the user of a shared
126 vec_add1 (config_string, end_node_index);
128 /* See if config string is unique. */
129 p = hash_get_mem (cm->config_string_hash, config_string);
132 /* Not unique. Share existing config. */
133 cm->config_string_temp = config_string; /* we'll use it again later. */
134 free_feature_vector (feature_vector);
135 c = pool_elt_at_index (cm->config_pool, p[0]);
141 pool_get (cm->config_pool, c);
142 c->index = c - cm->config_pool;
143 c->features = feature_vector;
144 c->config_string_vector = config_string;
146 /* Allocate copy of config string in heap.
147 VLIB buffers will maintain pointers to heap as they read out
148 configuration data. */
149 c->config_string_heap_index
150 = heap_alloc (cm->config_string_heap, vec_len (config_string) + 1,
151 c->config_string_heap_handle);
153 /* First element in heap points back to pool index. */
155 vec_elt_at_index (cm->config_string_heap,
156 c->config_string_heap_index);
158 clib_memcpy (d + 1, config_string, vec_bytes (config_string));
159 hash_set_mem (cm->config_string_hash, config_string, c->index);
161 c->reference_count = 0; /* will be incremented by caller. */
163 vec_validate_init_empty (cm->end_node_indices_by_user_index,
164 c->config_string_heap_index + 1,
165 cm->default_end_node_index);
166 cm->end_node_indices_by_user_index[c->config_string_heap_index + 1]
174 vnet_config_init (vlib_main_t * vm,
175 vnet_config_main_t * cm,
176 char *start_node_names[],
177 int n_start_node_names,
178 char *feature_node_names[], int n_feature_node_names)
183 clib_memset (cm, 0, sizeof (cm[0]));
185 cm->config_string_hash =
187 STRUCT_SIZE_OF (vnet_config_t, config_string_vector[0]),
190 ASSERT (n_feature_node_names >= 1);
192 vec_resize (cm->start_node_indices, n_start_node_names);
193 for (i = 0; i < n_start_node_names; i++)
195 n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]);
196 /* Given node name must exist. */
198 cm->start_node_indices[i] = n->index;
201 vec_resize (cm->node_index_by_feature_index, n_feature_node_names);
202 for (i = 0; i < n_feature_node_names; i++)
204 if (!feature_node_names[i])
205 cm->node_index_by_feature_index[i] = ~0;
208 n = vlib_get_node_by_name (vm, (u8 *) feature_node_names[i]);
209 /* Given node may exist in plug-in library which is not present */
212 if (i + 1 == n_feature_node_names)
213 cm->default_end_node_index = n->index;
214 cm->node_index_by_feature_index[i] = n->index;
217 cm->node_index_by_feature_index[i] = ~0;
223 remove_reference (vnet_config_main_t * cm, vnet_config_t * c)
225 ASSERT (c->reference_count > 0);
226 c->reference_count -= 1;
227 if (c->reference_count == 0)
229 hash_unset (cm->config_string_hash, c->config_string_vector);
230 vnet_config_free (cm, c);
231 pool_put (cm->config_pool, c);
236 feature_cmp (void *a1, void *a2)
238 vnet_config_feature_t *f1 = a1;
239 vnet_config_feature_t *f2 = a2;
241 return (int) f1->feature_index - f2->feature_index;
245 vnet_get_config_heap (vnet_config_main_t * cm, u32 ci)
247 return heap_elt_at_index (cm->config_string_heap, ci);
251 vnet_config_del (vnet_config_main_t * cm, u32 config_id)
253 u32 *p = vnet_get_config_heap (cm, config_id);
254 vnet_config_t *old = pool_elt_at_index (cm->config_pool, p[-1]);
255 remove_reference (cm, old);
259 vnet_config_reset_end_node (vlib_main_t *vm, vnet_config_main_t *cm, u32 ci)
261 cm->end_node_indices_by_user_index[ci] = cm->default_end_node_index;
264 vnet_config_modify_end_node (vm, cm, ci, cm->default_end_node_index));
268 vnet_config_modify_end_node (vlib_main_t * vm,
269 vnet_config_main_t * cm,
270 u32 config_string_heap_index, u32 end_node_index)
272 vnet_config_feature_t *new_features;
273 vnet_config_t *old, *new;
275 if (end_node_index == ~0) // feature node does not exist
278 if (config_string_heap_index == ~0)
285 u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
286 old = pool_elt_at_index (cm->config_pool, p[-1]);
287 new_features = old->features;
289 new_features = duplicate_feature_vector (new_features);
292 if (vec_len (new_features))
294 /* is the last feature the cuurent end node */
295 u32 last = vec_len (new_features) - 1;
296 if (new_features[last].node_index == cm->default_end_node_index)
298 vec_free (new_features->feature_config);
299 vec_set_len (new_features, last);
304 remove_reference (cm, old);
306 new = find_config_with_features (vm, cm, new_features, end_node_index);
307 new->reference_count += 1;
310 * User gets pointer to config string first element
311 * (which defines the pool index
312 * this config string comes from).
314 vec_validate (cm->config_pool_index_by_user_index,
315 new->config_string_heap_index + 1);
316 cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
317 = new - cm->config_pool;
318 return new->config_string_heap_index + 1;
322 vnet_config_get_end_node (vlib_main_t *vm, vnet_config_main_t *cm,
323 u32 config_string_heap_index)
325 if (config_string_heap_index >= vec_len (cm->end_node_indices_by_user_index))
326 return cm->default_end_node_index;
327 if (~0 == cm->end_node_indices_by_user_index[config_string_heap_index])
328 return cm->default_end_node_index;
330 return (cm->end_node_indices_by_user_index[config_string_heap_index]);
334 vnet_config_add_feature (vlib_main_t * vm,
335 vnet_config_main_t * cm,
336 u32 config_string_heap_index,
338 void *feature_config, u32 n_feature_config_bytes)
340 vnet_config_t *old, *new;
341 vnet_config_feature_t *new_features, *f;
342 u32 n_feature_config_u32s, end_node_index;
343 u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index);
345 if (node_index == ~0) // feature node does not exist
348 if (config_string_heap_index == ~0)
352 end_node_index = cm->default_end_node_index;
356 u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
357 old = pool_elt_at_index (cm->config_pool, p[-1]);
358 new_features = old->features;
360 cm->end_node_indices_by_user_index[config_string_heap_index];
362 new_features = duplicate_feature_vector (new_features);
365 vec_add2 (new_features, f, 1);
366 f->feature_index = feature_index;
367 f->node_index = node_index;
369 if (n_feature_config_bytes)
371 n_feature_config_u32s =
372 round_pow2 (n_feature_config_bytes,
373 sizeof (f->feature_config[0])) /
374 sizeof (f->feature_config[0]);
375 vec_validate (f->feature_config, n_feature_config_u32s - 1);
376 clib_memcpy_fast (f->feature_config, feature_config,
377 n_feature_config_bytes);
380 /* Sort (prioritize) features. */
381 if (vec_len (new_features) > 1)
382 vec_sort_with_function (new_features, feature_cmp);
385 remove_reference (cm, old);
387 new = find_config_with_features (vm, cm, new_features, end_node_index);
388 new->reference_count += 1;
391 * User gets pointer to config string first element
392 * (which defines the pool index
393 * this config string comes from).
395 vec_validate (cm->config_pool_index_by_user_index,
396 new->config_string_heap_index + 1);
397 cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
398 = new - cm->config_pool;
399 return new->config_string_heap_index + 1;
403 vnet_config_del_feature (vlib_main_t * vm,
404 vnet_config_main_t * cm,
405 u32 config_string_heap_index,
407 void *feature_config, u32 n_feature_config_bytes)
409 vnet_config_t *old, *new;
410 vnet_config_feature_t *new_features, *f;
411 u32 n_feature_config_u32s;
414 u32 *p = vnet_get_config_heap (cm, config_string_heap_index);
416 old = pool_elt_at_index (cm->config_pool, p[-1]);
419 n_feature_config_u32s =
420 round_pow2 (n_feature_config_bytes,
421 sizeof (f->feature_config[0])) /
422 sizeof (f->feature_config[0]);
424 /* Find feature with same index and opaque data. */
425 vec_foreach (f, old->features)
427 if (f->feature_index == feature_index
428 && vec_len (f->feature_config) == n_feature_config_u32s
429 && (n_feature_config_u32s == 0
430 || !memcmp (f->feature_config, feature_config,
431 n_feature_config_bytes)))
435 /* Feature not found. */
436 if (f >= vec_end (old->features))
439 new_features = duplicate_feature_vector (old->features);
440 f = new_features + (f - old->features);
441 vnet_config_feature_free (f);
442 vec_delete (new_features, 1, f - new_features);
444 /* must remove old from config_pool now as it may be expanded and change
445 memory location if the following function find_config_with_features()
446 adds a new config because none of existing config's has matching features
447 and so can be reused */
448 remove_reference (cm, old);
449 new = find_config_with_features (vm, cm, new_features,
450 cm->end_node_indices_by_user_index
451 [config_string_heap_index]);
452 new->reference_count += 1;
454 vec_validate (cm->config_pool_index_by_user_index,
455 new->config_string_heap_index + 1);
456 cm->config_pool_index_by_user_index[new->config_string_heap_index + 1]
457 = new - cm->config_pool;
458 return new->config_string_heap_index + 1;
462 * fd.io coding-style-patch-verification: ON
465 * eval: (c-set-style "gnu")