From 7cd468a3d7dee7d6c92f69a0bb7061ae208ec727 Mon Sep 17 00:00:00 2001 From: Damjan Marion Date: Mon, 19 Dec 2016 23:05:39 +0100 Subject: Reorganize source tree to use single autotools instance Change-Id: I7b51f88292e057c6443b12224486f2d0c9f8ae23 Signed-off-by: Damjan Marion --- src/vnet/config.c | 361 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 src/vnet/config.c (limited to 'src/vnet/config.c') diff --git a/src/vnet/config.c b/src/vnet/config.c new file mode 100644 index 00000000..03189d77 --- /dev/null +++ b/src/vnet/config.c @@ -0,0 +1,361 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * config.c: feature configuration + * + * Copyright (c) 2008 Eliot Dresselhaus + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include + +static vnet_config_feature_t * +duplicate_feature_vector (vnet_config_feature_t * feature_vector) +{ + vnet_config_feature_t *result, *f; + + result = vec_dup (feature_vector); + vec_foreach (f, result) f->feature_config = vec_dup (f->feature_config); + + return result; +} + +static void +free_feature_vector (vnet_config_feature_t * feature_vector) +{ + vnet_config_feature_t *f; + + vec_foreach (f, feature_vector) vnet_config_feature_free (f); + vec_free (feature_vector); +} + +static u32 +add_next (vlib_main_t * vm, + vnet_config_main_t * cm, u32 last_node_index, u32 this_node_index) +{ + u32 i, ni = ~0; + + if (last_node_index != ~0) + return vlib_node_add_next (vm, last_node_index, this_node_index); + + for (i = 0; i < vec_len (cm->start_node_indices); i++) + { + u32 tmp; + tmp = + vlib_node_add_next (vm, cm->start_node_indices[i], this_node_index); + if (ni == ~0) + ni = tmp; + /* Start nodes to first must agree on next indices. */ + ASSERT (ni == tmp); + } + + return ni; +} + +static vnet_config_t * +find_config_with_features (vlib_main_t * vm, + vnet_config_main_t * cm, + vnet_config_feature_t * feature_vector) +{ + u32 last_node_index = ~0; + vnet_config_feature_t *f; + u32 *config_string; + uword *p; + vnet_config_t *c; + + config_string = cm->config_string_temp; + cm->config_string_temp = 0; + if (config_string) + _vec_len (config_string) = 0; + + vec_foreach (f, feature_vector) + { + /* Connect node graph. */ + f->next_index = add_next (vm, cm, last_node_index, f->node_index); + last_node_index = f->node_index; + + /* Store next index in config string. */ + vec_add1 (config_string, f->next_index); + + /* Store feature config. */ + vec_add (config_string, f->feature_config, vec_len (f->feature_config)); + } + + /* Terminate config string with next for end node. */ + if (last_node_index == ~0 || last_node_index != cm->end_node_index) + { + u32 next_index = add_next (vm, cm, last_node_index, cm->end_node_index); + vec_add1 (config_string, next_index); + } + + /* See if config string is unique. */ + p = hash_get_mem (cm->config_string_hash, config_string); + if (p) + { + /* Not unique. Share existing config. */ + cm->config_string_temp = config_string; /* we'll use it again later. */ + free_feature_vector (feature_vector); + c = pool_elt_at_index (cm->config_pool, p[0]); + } + else + { + u32 *d; + + pool_get (cm->config_pool, c); + c->index = c - cm->config_pool; + c->features = feature_vector; + c->config_string_vector = config_string; + + /* Allocate copy of config string in heap. + VLIB buffers will maintain pointers to heap as they read out + configuration data. */ + c->config_string_heap_index + = heap_alloc (cm->config_string_heap, vec_len (config_string) + 1, + c->config_string_heap_handle); + + /* First element in heap points back to pool index. */ + d = + vec_elt_at_index (cm->config_string_heap, + c->config_string_heap_index); + d[0] = c->index; + clib_memcpy (d + 1, config_string, vec_bytes (config_string)); + hash_set_mem (cm->config_string_hash, config_string, c->index); + + c->reference_count = 0; /* will be incremented by caller. */ + } + + return c; +} + +void +vnet_config_init (vlib_main_t * vm, + vnet_config_main_t * cm, + char *start_node_names[], + int n_start_node_names, + char *feature_node_names[], int n_feature_node_names) +{ + vlib_node_t *n; + u32 i; + + memset (cm, 0, sizeof (cm[0])); + + cm->config_string_hash = + hash_create_vec (0, + STRUCT_SIZE_OF (vnet_config_t, config_string_vector[0]), + sizeof (uword)); + + ASSERT (n_feature_node_names >= 1); + + vec_resize (cm->start_node_indices, n_start_node_names); + for (i = 0; i < n_start_node_names; i++) + { + n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]); + /* Given node name must exist. */ + ASSERT (n != 0); + cm->start_node_indices[i] = n->index; + } + + vec_resize (cm->node_index_by_feature_index, n_feature_node_names); + for (i = 0; i < n_feature_node_names; i++) + { + if (!feature_node_names[i]) + cm->node_index_by_feature_index[i] = ~0; + else + { + n = vlib_get_node_by_name (vm, (u8 *) feature_node_names[i]); + /* Given node may exist in plug-in library which is not present */ + if (n) + { + if (i + 1 == n_feature_node_names) + cm->end_node_index = n->index; + cm->node_index_by_feature_index[i] = n->index; + } + else + cm->node_index_by_feature_index[i] = ~0; + } + } +} + +static void +remove_reference (vnet_config_main_t * cm, vnet_config_t * c) +{ + ASSERT (c->reference_count > 0); + c->reference_count -= 1; + if (c->reference_count == 0) + { + hash_unset (cm->config_string_hash, c->config_string_vector); + vnet_config_free (cm, c); + pool_put (cm->config_pool, c); + } +} + +static int +feature_cmp (void *a1, void *a2) +{ + vnet_config_feature_t *f1 = a1; + vnet_config_feature_t *f2 = a2; + + return (int) f1->feature_index - f2->feature_index; +} + +always_inline u32 * +vnet_get_config_heap (vnet_config_main_t * cm, u32 ci) +{ + return heap_elt_at_index (cm->config_string_heap, ci); +} + +u32 +vnet_config_add_feature (vlib_main_t * vm, + vnet_config_main_t * cm, + u32 config_string_heap_index, + u32 feature_index, + void *feature_config, u32 n_feature_config_bytes) +{ + vnet_config_t *old, *new; + vnet_config_feature_t *new_features, *f; + u32 n_feature_config_u32s; + u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index); + + if (node_index == ~0) // feature node does not exist + return config_string_heap_index; // return original config index + + if (config_string_heap_index == ~0) + { + old = 0; + new_features = 0; + } + else + { + u32 *p = vnet_get_config_heap (cm, config_string_heap_index); + old = pool_elt_at_index (cm->config_pool, p[-1]); + new_features = old->features; + if (new_features) + new_features = duplicate_feature_vector (new_features); + } + + vec_add2 (new_features, f, 1); + f->feature_index = feature_index; + f->node_index = node_index; + + n_feature_config_u32s = + round_pow2 (n_feature_config_bytes, + sizeof (f->feature_config[0])) / + sizeof (f->feature_config[0]); + vec_add (f->feature_config, feature_config, n_feature_config_u32s); + + /* Sort (prioritize) features. */ + if (vec_len (new_features) > 1) + vec_sort_with_function (new_features, feature_cmp); + + if (old) + remove_reference (cm, old); + + new = find_config_with_features (vm, cm, new_features); + new->reference_count += 1; + + /* + * User gets pointer to config string first element + * (which defines the pool index + * this config string comes from). + */ + vec_validate (cm->config_pool_index_by_user_index, + new->config_string_heap_index + 1); + cm->config_pool_index_by_user_index[new->config_string_heap_index + 1] + = new - cm->config_pool; + return new->config_string_heap_index + 1; +} + +u32 +vnet_config_del_feature (vlib_main_t * vm, + vnet_config_main_t * cm, + u32 config_string_heap_index, + u32 feature_index, + void *feature_config, u32 n_feature_config_bytes) +{ + vnet_config_t *old, *new; + vnet_config_feature_t *new_features, *f; + u32 n_feature_config_u32s; + + { + u32 *p = vnet_get_config_heap (cm, config_string_heap_index); + + old = pool_elt_at_index (cm->config_pool, p[-1]); + } + + n_feature_config_u32s = + round_pow2 (n_feature_config_bytes, + sizeof (f->feature_config[0])) / + sizeof (f->feature_config[0]); + + /* Find feature with same index and opaque data. */ + vec_foreach (f, old->features) + { + if (f->feature_index == feature_index + && vec_len (f->feature_config) == n_feature_config_u32s + && (n_feature_config_u32s == 0 + || !memcmp (f->feature_config, feature_config, + n_feature_config_bytes))) + break; + } + + /* Feature not found. */ + if (f >= vec_end (old->features)) + return config_string_heap_index; // return original config index + + new_features = duplicate_feature_vector (old->features); + f = new_features + (f - old->features); + vnet_config_feature_free (f); + vec_delete (new_features, 1, f - new_features); + + /* must remove old from config_pool now as it may be expanded and change + memory location if the following function find_config_with_features() + adds a new config because none of existing config's has matching features + and so can be reused */ + remove_reference (cm, old); + new = find_config_with_features (vm, cm, new_features); + new->reference_count += 1; + + vec_validate (cm->config_pool_index_by_user_index, + new->config_string_heap_index + 1); + cm->config_pool_index_by_user_index[new->config_string_heap_index + 1] + = new - cm->config_pool; + return new->config_string_heap_index + 1; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ -- cgit 1.2.3-korg