FD.io VPP  v18.07-34-g55fbdb9
Vector Packet Processing
config.c
Go to the documentation of this file.
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 *
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
55 {
57 
58  vec_foreach (f, feature_vector) vnet_config_feature_free (f);
59  vec_free (feature_vector);
60 }
61 
62 static u32
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 *
87  vnet_config_main_t * cm,
88  vnet_config_feature_t * feature_vector)
89 {
90  u32 last_node_index = ~0;
92  u32 *config_string;
93  uword *p;
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. */
143  = heap_alloc (cm->config_string_heap, vec_len (config_string) + 1,
145 
146  /* First element in heap points back to pool index. */
147  d =
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
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;
202  }
203  else
204  cm->node_index_by_feature_index[i] = ~0;
205  }
206  }
207 }
208 
209 static void
211 {
212  ASSERT (c->reference_count > 0);
213  c->reference_count -= 1;
214  if (c->reference_count == 0)
215  {
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 
233 {
234  return heap_elt_at_index (cm->config_string_heap, ci);
235 }
236 
237 u32
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 ~0;
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  */
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
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 ~0;
334 
335  new_features = duplicate_feature_vector (old->features);
336  f = new_features + (f - old->features);
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 
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  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:437
vnet_config_feature_t * features
Definition: config.h:71
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)
Definition: config.c:161
#define hash_unset(h, key)
Definition: hash.h:261
u32 index
Definition: node.h:273
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)
Definition: config.c:299
static void remove_reference(vnet_config_main_t *cm, vnet_config_t *c)
Definition: config.c:210
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:523
#define heap_elt_at_index(v, index)
Definition: heap.h:296
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:562
int i
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u32 config_string_heap_handle
Definition: config.h:77
u32 * config_string_vector
Definition: config.h:74
#define vec_bytes(v)
Number of data bytes in vector.
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1110
unsigned char u8
Definition: types.h:56
u32 * node_index_by_feature_index
Definition: config.h:101
#define vec_add(V, E, N)
Add N elements to end of vector V (no header, unspecified alignment)
Definition: vec.h:600
#define always_inline
Definition: clib.h:92
static int feature_cmp(void *a1, void *a2)
Definition: config.c:223
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static void vnet_config_feature_free(vnet_config_feature_t *f)
Definition: config.h:63
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:240
unsigned int u32
Definition: types.h:88
#define vec_end(v)
End (last data address) of vector.
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
u32 * start_node_indices
Definition: config.h:98
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:373
static void free_feature_vector(vnet_config_feature_t *feature_vector)
Definition: config.c:54
static vnet_config_t * find_config_with_features(vlib_main_t *vm, vnet_config_main_t *cm, vnet_config_feature_t *feature_vector)
Definition: config.c:86
u32 * config_pool_index_by_user_index
Definition: config.h:104
svmdb_client_t * c
static void vnet_config_free(vnet_config_main_t *cm, vnet_config_t *c)
Definition: config.h:112
static u32 * vnet_get_config_heap(vnet_config_main_t *cm, u32 ci)
Definition: config.c:232
vlib_main_t * vm
Definition: buffer.c:294
u32 * config_string_heap
Definition: config.h:95
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
#define clib_memcpy(a, b, c)
Definition: string.h:75
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
static uword round_pow2(uword x, uword pow2)
Definition: clib.h:235
static vnet_config_feature_t * duplicate_feature_vector(vnet_config_feature_t *feature_vector)
Definition: config.c:43
#define ASSERT(truth)
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:786
u32 end_node_index
Definition: config.h:98
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)
Definition: config.c:238
u32 index
Definition: config.h:80
#define heap_alloc(v, size, handle)
Definition: heap.h:337
static u32 add_next(vlib_main_t *vm, vnet_config_main_t *cm, u32 last_node_index, u32 this_node_index)
Definition: config.c:63
#define vec_elt(v, i)
Get vector value at index i.
u32 * config_string_temp
Definition: config.h:108
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:668
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:982
#define hash_get_mem(h, key)
Definition: hash.h:269
#define STRUCT_SIZE_OF(t, f)
Definition: clib.h:64
vnet_config_t * config_pool
Definition: config.h:89
#define vec_foreach(var, vec)
Vector iterator.
u32 reference_count
Definition: config.h:83
uword * config_string_hash
Definition: config.h:92
u32 config_string_heap_index
Definition: config.h:77
u32 * feature_config
Definition: config.h:59