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)
49 f->feature_config = vec_dup (f->feature_config);
55 free_feature_vector (vnet_config_feature_t * feature_vector)
57 vnet_config_feature_t * f;
59 vec_foreach (f, feature_vector)
60 vnet_config_feature_free (f);
61 vec_free (feature_vector);
65 add_next (vlib_main_t * vm,
66 vnet_config_main_t * cm,
72 if (last_node_index != ~0)
73 return vlib_node_add_next (vm, last_node_index, this_node_index);
75 for (i = 0; i < vec_len (cm->start_node_indices); i++)
78 tmp = vlib_node_add_next (vm, cm->start_node_indices[i], this_node_index);
81 /* Start nodes to first must agree on next indices. */
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)
93 u32 last_node_index = ~0;
94 vnet_config_feature_t * f;
99 config_string = cm->config_string_temp;
100 cm->config_string_temp = 0;
102 _vec_len (config_string) = 0;
104 vec_foreach (f, feature_vector)
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;
110 /* Store next index in config string. */
111 vec_add1 (config_string, f->next_index);
113 /* Store feature config. */
114 vec_add (config_string, f->feature_config, vec_len (f->feature_config));
117 /* Terminate config string with next for end node. */
118 if (last_node_index == ~0 || last_node_index != cm->end_node_index)
120 u32 next_index = add_next (vm, cm, last_node_index, cm->end_node_index);
121 vec_add1 (config_string, next_index);
124 /* See if config string is unique. */
125 p = hash_get_mem (cm->config_string_hash, config_string);
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]);
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;
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);
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);
152 clib_memcpy (d + 1, config_string, vec_bytes (config_string));
153 hash_set_mem (cm->config_string_hash, config_string, c->index);
155 c->reference_count = 0; /* will be incremented by caller. */
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)
171 memset (cm, 0, sizeof (cm[0]));
173 cm->config_string_hash = hash_create_vec (0, STRUCT_SIZE_OF (vnet_config_t, config_string_vector[0]), sizeof (uword));
175 ASSERT (n_start_node_names >= 1);
176 ASSERT (n_feature_node_names >= 1);
178 vec_resize (cm->start_node_indices, n_start_node_names);
179 for (i = 0; i < n_start_node_names; i++)
181 n = vlib_get_node_by_name (vm, (u8 *) start_node_names[i]);
182 /* Given node name must exist. */
184 cm->start_node_indices[i] = n->index;
187 vec_resize (cm->node_index_by_feature_index, n_feature_node_names);
188 for (i = 0; i < n_feature_node_names; i++)
190 if (! feature_node_names[i])
191 cm->node_index_by_feature_index[i] = ~0;
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 */
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;
202 else cm->node_index_by_feature_index[i] = ~0;
208 remove_reference (vnet_config_main_t * cm, vnet_config_t * c)
210 ASSERT (c->reference_count > 0);
211 c->reference_count -= 1;
212 if (c->reference_count == 0)
214 hash_unset (cm->config_string_hash, c->config_string_vector);
215 vnet_config_free (cm, c);
216 pool_put (cm->config_pool, c);
221 feature_cmp (void * a1, void * a2)
223 vnet_config_feature_t * f1 = a1;
224 vnet_config_feature_t * f2 = a2;
226 return (int) f1->feature_index - f2->feature_index;
230 vnet_get_config_heap (vnet_config_main_t * cm, u32 ci)
231 { return heap_elt_at_index (cm->config_string_heap, ci); }
233 u32 vnet_config_add_feature (vlib_main_t * vm,
234 vnet_config_main_t * cm,
235 u32 config_string_heap_index,
237 void * feature_config,
238 u32 n_feature_config_bytes)
240 vnet_config_t * old, * new;
241 vnet_config_feature_t * new_features, * f;
242 u32 n_feature_config_u32s;
243 u32 node_index = vec_elt (cm->node_index_by_feature_index, feature_index);
245 if (node_index == ~0) // feature node does not exist
246 return config_string_heap_index; // return original config index
248 if (config_string_heap_index == ~0)
255 u32 * p = vnet_get_config_heap (cm, config_string_heap_index);
256 old = pool_elt_at_index (cm->config_pool, p[-1]);
257 new_features = old->features;
259 new_features = duplicate_feature_vector (new_features);
262 vec_add2 (new_features, f, 1);
263 f->feature_index = feature_index;
264 f->node_index = node_index;
266 n_feature_config_u32s = round_pow2 (n_feature_config_bytes, sizeof (f->feature_config[0])) / sizeof (f->feature_config[0]);
267 vec_add (f->feature_config, feature_config, n_feature_config_u32s);
269 /* Sort (prioritize) features. */
270 if (vec_len (new_features) > 1)
271 vec_sort_with_function (new_features, feature_cmp);
274 remove_reference (cm, old);
276 new = find_config_with_features (vm, cm, new_features);
277 new->reference_count += 1;
280 * User gets pointer to config string first element
281 * (which defines the pool index
282 * this config string comes from).
284 vec_validate (cm->config_pool_index_by_user_index,
285 new->config_string_heap_index + 1);
286 cm->config_pool_index_by_user_index [new->config_string_heap_index + 1]
287 = new - cm->config_pool;
288 return new->config_string_heap_index + 1;
291 u32 vnet_config_del_feature (vlib_main_t * vm,
292 vnet_config_main_t * cm,
293 u32 config_string_heap_index,
295 void * feature_config,
296 u32 n_feature_config_bytes)
298 vnet_config_t * old, * new;
299 vnet_config_feature_t * new_features, * f;
300 u32 n_feature_config_u32s;
303 u32 * p = vnet_get_config_heap (cm, config_string_heap_index);
305 old = pool_elt_at_index (cm->config_pool, p[-1]);
308 n_feature_config_u32s = round_pow2 (n_feature_config_bytes, sizeof (f->feature_config[0])) / sizeof (f->feature_config[0]);
310 /* Find feature with same index and opaque data. */
311 vec_foreach (f, old->features)
313 if (f->feature_index == feature_index
314 && vec_len (f->feature_config) == n_feature_config_u32s
315 && (n_feature_config_u32s == 0
316 || ! memcmp (f->feature_config, feature_config, n_feature_config_bytes)))
320 /* Feature not found. */
321 if (f >= vec_end (old->features))
322 return config_string_heap_index; // return original config index
324 new_features = duplicate_feature_vector (old->features);
325 f = new_features + (f - old->features);
326 vnet_config_feature_free (f);
327 vec_delete (new_features, 1, f - new_features);
329 /* must remove old from config_pool now as it may be expanded and change
330 memory location if the following function find_config_with_features()
331 adds a new config because none of existing config's has matching features
332 and so can be reused */
333 remove_reference (cm, old);
334 new = find_config_with_features (vm, cm, new_features);
335 new->reference_count += 1;
337 vec_validate (cm->config_pool_index_by_user_index,
338 new->config_string_heap_index + 1);
339 cm->config_pool_index_by_user_index [new->config_string_heap_index + 1]
340 = new - cm->config_pool;
341 return new->config_string_heap_index + 1;