2 * Copyright (c) 2016 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 #include <vnet/feature/feature.h>
18 vnet_feature_main_t feature_main;
21 vnet_feature_init (vlib_main_t * vm)
23 vnet_feature_main_t *fm = &feature_main;
24 vnet_feature_registration_t *freg;
25 vnet_feature_arc_registration_t *areg;
28 fm->arc_index_by_name = hash_create_string (0, sizeof (uword));
31 /* process feature arc registrations */
36 areg->feature_arc_index = arc_index;
37 if (areg->arc_index_ptr)
38 *areg->arc_index_ptr = arc_index;
39 hash_set_mem (fm->arc_index_by_name, areg->arc_name,
40 pointer_to_uword (areg));
42 /* process start nodes */
43 while ((s = areg->start_nodes[i]))
47 areg->n_start_nodes = i;
54 vec_validate (fm->next_feature_by_arc, arc_index - 1);
55 vec_validate (fm->feature_nodes, arc_index - 1);
56 vec_validate (fm->feature_config_mains, arc_index - 1);
57 vec_validate (fm->next_feature_by_name, arc_index - 1);
58 vec_validate (fm->sw_if_index_has_features, arc_index - 1);
59 vec_validate (fm->feature_count_by_sw_if_index, arc_index - 1);
61 freg = fm->next_feature;
64 vnet_feature_registration_t *next;
65 uword *p = hash_get_mem (fm->arc_index_by_name, freg->arc_name);
67 return clib_error_return (0, "Unknown feature arc '%s'",
70 areg = uword_to_pointer (p[0], vnet_feature_arc_registration_t *);
71 arc_index = areg->feature_arc_index;
74 freg->next = fm->next_feature_by_arc[arc_index];
75 fm->next_feature_by_arc[arc_index] = freg;
85 vnet_feature_config_main_t *cm;
86 vnet_config_main_t *vcm;
88 arc_index = areg->feature_arc_index;
89 cm = &fm->feature_config_mains[arc_index];
90 vcm = &cm->config_main;
91 if ((error = vnet_feature_arc_init (vm, vcm,
94 fm->next_feature_by_arc[arc_index],
95 &fm->feature_nodes[arc_index])))
100 fm->next_feature_by_name[arc_index] =
101 hash_create_string (0, sizeof (uword));
102 freg = fm->next_feature_by_arc[arc_index];
106 hash_set_mem (fm->next_feature_by_name[arc_index],
107 freg->node_name, pointer_to_uword (freg));
119 VLIB_INIT_FUNCTION (vnet_feature_init);
122 vnet_config_update_feature_count (vnet_feature_main_t * fm, u8 arc,
123 u32 sw_if_index, int is_add)
127 vec_validate (fm->feature_count_by_sw_if_index[arc], sw_if_index);
129 fm->feature_count_by_sw_if_index[arc][sw_if_index] += is_add ? 1 : -1;
131 ASSERT (fm->feature_count_by_sw_if_index[arc][sw_if_index] >= 0);
133 bit_value = fm->feature_count_by_sw_if_index[arc][sw_if_index] > 0;
135 fm->sw_if_index_has_features[arc] =
136 clib_bitmap_set (fm->sw_if_index_has_features[arc], sw_if_index,
141 vnet_get_feature_arc_index (const char *s)
143 vnet_feature_main_t *fm = &feature_main;
144 vnet_feature_arc_registration_t *reg;
147 p = hash_get_mem (fm->arc_index_by_name, s);
151 reg = uword_to_pointer (p[0], vnet_feature_arc_registration_t *);
152 return reg->feature_arc_index;
155 vnet_feature_registration_t *
156 vnet_get_feature_reg (const char *arc_name, const char *node_name)
160 arc_index = vnet_get_feature_arc_index (arc_name);
161 if (arc_index == (u8) ~ 0)
164 vnet_feature_main_t *fm = &feature_main;
165 vnet_feature_registration_t *reg;
168 p = hash_get_mem (fm->next_feature_by_name[arc_index], node_name);
172 reg = uword_to_pointer (p[0], vnet_feature_registration_t *);
177 vnet_get_feature_index (u8 arc, const char *s)
179 vnet_feature_main_t *fm = &feature_main;
180 vnet_feature_registration_t *reg;
183 p = hash_get_mem (fm->next_feature_by_name[arc], s);
187 reg = uword_to_pointer (p[0], vnet_feature_registration_t *);
188 return reg->feature_index;
192 vnet_feature_enable_disable_with_index (u8 arc_index, u32 feature_index,
193 u32 sw_if_index, int enable_disable,
194 void *feature_config,
195 u32 n_feature_config_bytes)
197 vnet_feature_main_t *fm = &feature_main;
198 vnet_feature_config_main_t *cm;
201 if (arc_index == (u8) ~ 0)
202 return VNET_API_ERROR_INVALID_VALUE;
204 if (feature_index == ~0)
205 return VNET_API_ERROR_INVALID_VALUE_2;
207 cm = &fm->feature_config_mains[arc_index];
208 vec_validate_init_empty (cm->config_index_by_sw_if_index, sw_if_index, ~0);
209 ci = cm->config_index_by_sw_if_index[sw_if_index];
211 vec_validate (fm->feature_count_by_sw_if_index[arc_index], sw_if_index);
213 && fm->feature_count_by_sw_if_index[arc_index][sw_if_index] < 1)
217 ? vnet_config_add_feature
218 : vnet_config_del_feature)
219 (vlib_get_main (), &cm->config_main, ci, feature_index, feature_config,
220 n_feature_config_bytes);
221 cm->config_index_by_sw_if_index[sw_if_index] = ci;
223 vnet_config_update_feature_count (fm, arc_index, sw_if_index,
230 vnet_feature_enable_disable (const char *arc_name, const char *node_name,
231 u32 sw_if_index, int enable_disable,
232 void *feature_config, u32 n_feature_config_bytes)
237 arc_index = vnet_get_feature_arc_index (arc_name);
239 if (arc_index == (u8) ~ 0)
240 return VNET_API_ERROR_INVALID_VALUE;
242 feature_index = vnet_get_feature_index (arc_index, node_name);
244 return vnet_feature_enable_disable_with_index (arc_index, feature_index,
245 sw_if_index, enable_disable,
247 n_feature_config_bytes);
251 /** Display the set of available driver features.
252 Useful for verifying that expected features are present
255 static clib_error_t *
256 show_features_command_fn (vlib_main_t * vm,
257 unformat_input_t * input, vlib_cli_command_t * cmd)
259 vnet_feature_main_t *fm = &feature_main;
260 vnet_feature_arc_registration_t *areg;
261 vnet_feature_registration_t *freg;
263 vlib_cli_output (vm, "Available feature paths");
268 vlib_cli_output (vm, "%s:", areg->arc_name);
269 freg = fm->next_feature_by_arc[areg->feature_arc_index];
272 vlib_cli_output (vm, " %s\n", freg->node_name);
285 * Display the set of available driver features
289 * @cliexcmd{show ip features}
294 VLIB_CLI_COMMAND (show_features_command, static) = {
295 .path = "show features",
296 .short_help = "show features",
297 .function = show_features_command_fn,
301 /** Display the set of driver features configured on a specific interface
302 * Called by "show interface" handler
306 vnet_interface_features_show (vlib_main_t * vm, u32 sw_if_index)
308 vnet_feature_main_t *fm = &feature_main;
309 u32 node_index, current_config_index;
311 vnet_feature_config_main_t *cm = fm->feature_config_mains;
312 vnet_feature_arc_registration_t *areg;
313 vnet_config_main_t *vcm;
316 vnet_config_feature_t *feat;
320 vlib_cli_output (vm, "Driver feature paths configured on %U...",
321 format_vnet_sw_if_index_name,
322 vnet_get_main (), sw_if_index);
327 feature_arc = areg->feature_arc_index;
328 vcm = &(cm[feature_arc].config_main);
330 vlib_cli_output (vm, "\n%s:", areg->arc_name);
333 if (NULL == cm[feature_arc].config_index_by_sw_if_index ||
334 vec_len (cm[feature_arc].config_index_by_sw_if_index) <=
337 vlib_cli_output (vm, " none configured");
341 current_config_index =
342 vec_elt (cm[feature_arc].config_index_by_sw_if_index, sw_if_index);
344 if (current_config_index == ~0)
346 vlib_cli_output (vm, " none configured");
350 ASSERT (current_config_index
351 < vec_len (vcm->config_pool_index_by_user_index));
353 cfg_index = vcm->config_pool_index_by_user_index[current_config_index];
354 cfg = pool_elt_at_index (vcm->config_pool, cfg_index);
356 for (i = 0; i < vec_len (cfg->features); i++)
358 feat = cfg->features + i;
359 node_index = feat->node_index;
360 n = vlib_get_node (vm, node_index);
361 vlib_cli_output (vm, " %v", n->name);
366 static clib_error_t *
367 set_interface_features_command_fn (vlib_main_t * vm,
368 unformat_input_t * input,
369 vlib_cli_command_t * cmd)
371 vnet_main_t *vnm = vnet_get_main ();
372 unformat_input_t _line_input, *line_input = &_line_input;
373 clib_error_t *error = 0;
376 u8 *feature_name = 0;
377 u32 sw_if_index = ~0;
380 /* Get a line of input. */
381 if (!unformat_user (input, unformat_line_input, line_input))
384 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
387 (line_input, "%U %v", unformat_vnet_sw_interface, vnm, &sw_if_index,
390 else if (unformat (line_input, "arc %v", &arc_name))
392 else if (unformat (line_input, "disable"))
396 error = unformat_parse_error (line_input);
401 if (sw_if_index == ~0)
403 error = clib_error_return (0, "Interface not specified...");
407 vec_add1 (arc_name, 0);
408 vec_add1 (feature_name, 0);
410 vnet_feature_registration_t *reg;
412 vnet_get_feature_reg ((const char *) arc_name,
413 (const char *) feature_name);
416 error = clib_error_return (0, "Unknown feature...");
419 if (reg->enable_disable_cb)
420 error = reg->enable_disable_cb (sw_if_index, enable);
422 vnet_feature_enable_disable ((const char *) arc_name,
423 (const char *) feature_name, sw_if_index,
427 vec_free (feature_name);
433 * Set feature for given interface
437 * @cliexcmd{set interface feature GigabitEthernet2/0/0 ip4_flow_classify arc ip4_unicast}
442 VLIB_CLI_COMMAND (set_interface_feature_command, static) = {
443 .path = "set interface feature",
444 .short_help = "set interface feature <intfc> <feature_name> arc <arc_name>",
445 .function = set_interface_features_command_fn,
450 * fd.io coding-style-patch-verification: ON
453 * eval: (c-set-style "gnu")