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;
20 typedef struct vnet_feature_upd_registration_t_
22 vnet_feature_update_cb_t cb;
24 } vnet_feature_upd_registration_t;
26 static vnet_feature_upd_registration_t *regs;
29 vnet_feature_register (vnet_feature_update_cb_t cb, void *data)
31 vnet_feature_upd_registration_t *reg;
33 vec_add2 (regs, reg, 1);
40 vnet_feature_reg_invoke (u32 sw_if_index, u8 arc_index, u8 is_enable)
42 vnet_feature_upd_registration_t *reg;
44 vec_foreach (reg, regs)
45 reg->cb (sw_if_index, arc_index, is_enable, reg->data);
50 vnet_feature_init (vlib_main_t * vm)
52 vnet_feature_main_t *fm = &feature_main;
53 vnet_feature_registration_t *freg;
54 vnet_feature_arc_registration_t *areg;
55 vnet_feature_constraint_registration_t *creg;
58 fm->arc_index_by_name = hash_create_string (0, sizeof (uword));
61 /* process feature arc registrations */
66 areg->feature_arc_index = arc_index;
67 if (areg->arc_index_ptr)
68 *areg->arc_index_ptr = arc_index;
69 hash_set_mem (fm->arc_index_by_name, areg->arc_name,
70 pointer_to_uword (areg));
72 /* process start nodes */
73 while ((s = areg->start_nodes[i]))
77 areg->n_start_nodes = i;
84 vec_validate (fm->next_feature_by_arc, arc_index - 1);
85 vec_validate (fm->feature_nodes, arc_index - 1);
86 vec_validate (fm->feature_config_mains, arc_index - 1);
87 vec_validate (fm->next_feature_by_name, arc_index - 1);
88 vec_validate (fm->sw_if_index_has_features, arc_index - 1);
89 vec_validate (fm->feature_count_by_sw_if_index, arc_index - 1);
90 vec_validate (fm->next_constraint_by_arc, arc_index - 1);
92 freg = fm->next_feature;
95 vnet_feature_registration_t *next;
96 uword *p = hash_get_mem (fm->arc_index_by_name, freg->arc_name);
99 /* Don't start vpp with broken features arcs */
100 clib_warning ("Unknown feature arc '%s'", freg->arc_name);
104 areg = uword_to_pointer (p[0], vnet_feature_arc_registration_t *);
105 arc_index = areg->feature_arc_index;
108 freg->next_in_arc = fm->next_feature_by_arc[arc_index];
109 fm->next_feature_by_arc[arc_index] = freg;
115 /* Move bulk constraints to the constraint by arc lists */
116 creg = fm->next_constraint;
119 vnet_feature_constraint_registration_t *next;
120 uword *p = hash_get_mem (fm->arc_index_by_name, creg->arc_name);
123 /* Don't start vpp with broken features arcs */
124 clib_warning ("Unknown feature arc '%s'", creg->arc_name);
128 areg = uword_to_pointer (p[0], vnet_feature_arc_registration_t *);
129 arc_index = areg->feature_arc_index;
132 creg->next_in_arc = fm->next_constraint_by_arc[arc_index];
133 fm->next_constraint_by_arc[arc_index] = creg;
144 vnet_feature_config_main_t *cm;
145 vnet_config_main_t *vcm;
146 char **features_in_order, *last_feature;
148 arc_index = areg->feature_arc_index;
149 cm = &fm->feature_config_mains[arc_index];
150 vcm = &cm->config_main;
151 if ((error = vnet_feature_arc_init
152 (vm, vcm, areg->start_nodes, areg->n_start_nodes,
154 fm->next_feature_by_arc[arc_index],
155 fm->next_constraint_by_arc[arc_index],
156 &fm->feature_nodes[arc_index])))
158 clib_error_report (error);
162 features_in_order = fm->feature_nodes[arc_index];
164 /* If specified, verify that the last node in the arc is actually last */
165 if (areg->last_in_arc && vec_len (features_in_order) > 0)
167 last_feature = features_in_order[vec_len (features_in_order) - 1];
168 if (strncmp (areg->last_in_arc, last_feature,
169 strlen (areg->last_in_arc)))
171 ("WARNING: %s arc: last node is %s, but expected %s!",
172 areg->arc_name, last_feature, areg->last_in_arc);
175 fm->next_feature_by_name[arc_index] =
176 hash_create_string (0, sizeof (uword));
177 freg = fm->next_feature_by_arc[arc_index];
181 hash_set_mem (fm->next_feature_by_name[arc_index],
182 freg->node_name, pointer_to_uword (freg));
183 freg = freg->next_in_arc;
194 VLIB_INIT_FUNCTION (vnet_feature_init);
197 vnet_get_feature_arc_index (const char *s)
199 vnet_feature_main_t *fm = &feature_main;
200 vnet_feature_arc_registration_t *reg;
203 p = hash_get_mem (fm->arc_index_by_name, s);
207 reg = uword_to_pointer (p[0], vnet_feature_arc_registration_t *);
208 return reg->feature_arc_index;
211 vnet_feature_registration_t *
212 vnet_get_feature_reg (const char *arc_name, const char *node_name)
216 arc_index = vnet_get_feature_arc_index (arc_name);
217 if (arc_index == (u8) ~ 0)
220 vnet_feature_main_t *fm = &feature_main;
221 vnet_feature_registration_t *reg;
224 p = hash_get_mem (fm->next_feature_by_name[arc_index], node_name);
228 reg = uword_to_pointer (p[0], vnet_feature_registration_t *);
233 vnet_get_feature_index (u8 arc, const char *s)
235 vnet_feature_main_t *fm = &feature_main;
236 vnet_feature_registration_t *reg;
242 p = hash_get_mem (fm->next_feature_by_name[arc], s);
246 reg = uword_to_pointer (p[0], vnet_feature_registration_t *);
247 return reg->feature_index;
251 vnet_feature_enable_disable_with_index (u8 arc_index, u32 feature_index,
252 u32 sw_if_index, int enable_disable,
253 void *feature_config,
254 u32 n_feature_config_bytes)
256 vnet_feature_main_t *fm = &feature_main;
257 vnet_feature_config_main_t *cm;
261 if (arc_index == (u8) ~ 0)
262 return VNET_API_ERROR_INVALID_VALUE;
264 if (feature_index == ~0)
265 return VNET_API_ERROR_INVALID_VALUE_2;
267 cm = &fm->feature_config_mains[arc_index];
268 vec_validate_init_empty (cm->config_index_by_sw_if_index, sw_if_index, ~0);
269 ci = cm->config_index_by_sw_if_index[sw_if_index];
271 vec_validate (fm->feature_count_by_sw_if_index[arc_index], sw_if_index);
272 feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
274 if (!enable_disable && feature_count < 1)
278 ? vnet_config_add_feature
279 : vnet_config_del_feature)
280 (vlib_get_main (), &cm->config_main, ci, feature_index, feature_config,
281 n_feature_config_bytes);
286 cm->config_index_by_sw_if_index[sw_if_index] = ci;
288 /* update feature count */
289 enable_disable = (enable_disable > 0);
290 feature_count += enable_disable ? 1 : -1;
291 ASSERT (feature_count >= 0);
293 fm->sw_if_index_has_features[arc_index] =
294 clib_bitmap_set (fm->sw_if_index_has_features[arc_index], sw_if_index,
295 (feature_count > 0));
296 fm->feature_count_by_sw_if_index[arc_index][sw_if_index] = feature_count;
298 vnet_feature_reg_invoke (sw_if_index, arc_index, (feature_count > 0));
304 vnet_feature_enable_disable (const char *arc_name, const char *node_name,
305 u32 sw_if_index, int enable_disable,
306 void *feature_config, u32 n_feature_config_bytes)
311 arc_index = vnet_get_feature_arc_index (arc_name);
313 if (arc_index == (u8) ~ 0)
314 return VNET_API_ERROR_INVALID_VALUE;
316 feature_index = vnet_get_feature_index (arc_index, node_name);
318 return vnet_feature_enable_disable_with_index (arc_index, feature_index,
319 sw_if_index, enable_disable,
321 n_feature_config_bytes);
325 vnet_feature_is_enabled (const char *arc_name, const char *feature_node_name,
328 vnet_feature_main_t *fm = &feature_main;
329 vnet_feature_config_main_t *cm;
330 vnet_config_main_t *ccm;
331 vnet_config_t *current_config;
332 vnet_config_feature_t *f;
338 arc_index = vnet_get_feature_arc_index (arc_name);
341 if (arc_index == (u8) ~ 0)
342 return VNET_API_ERROR_INVALID_VALUE;
344 feature_index = vnet_get_feature_index (arc_index, feature_node_name);
346 /* No such feature? */
347 if (feature_index == (u32) ~ 0)
348 return VNET_API_ERROR_INVALID_VALUE_2;
350 cm = &fm->feature_config_mains[arc_index];
352 if (sw_if_index < vec_len (cm->config_index_by_sw_if_index))
353 ci = vec_elt (cm->config_index_by_sw_if_index, sw_if_index);
355 /* sw_if_index out of range, certainly not enabled */
356 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
358 /* No features were ever configured? */
362 ccm = &cm->config_main;
364 p = heap_elt_at_index (ccm->config_string_heap, ci);
366 current_config = pool_elt_at_index (ccm->config_pool, p[-1]);
368 /* Find feature with the required index */
369 vec_foreach (f, current_config->features)
371 if (f->feature_index == feature_index)
372 /* Feature was enabled */
375 /* feature wasn't enabled */
380 vnet_feature_get_end_node (u8 arc_index, u32 sw_if_index)
382 vnet_feature_main_t *fm = &feature_main;
383 vnet_feature_config_main_t *cm;
386 if (arc_index == (u8) ~0)
387 return VNET_API_ERROR_INVALID_VALUE;
389 cm = &fm->feature_config_mains[arc_index];
390 vec_validate_init_empty (cm->config_index_by_sw_if_index, sw_if_index, ~0);
391 ci = cm->config_index_by_sw_if_index[sw_if_index];
393 return (vnet_config_get_end_node (vlib_get_main (), &cm->config_main, ci));
397 vnet_feature_reset_end_node (u8 arc_index, u32 sw_if_index)
399 vnet_feature_main_t *fm = &feature_main;
400 vnet_feature_config_main_t *cm;
403 cm = &fm->feature_config_mains[arc_index];
404 vec_validate_init_empty (cm->config_index_by_sw_if_index, sw_if_index, ~0);
405 ci = cm->config_index_by_sw_if_index[sw_if_index];
407 ci = vnet_config_reset_end_node (vlib_get_main (), &cm->config_main, ci);
410 cm->config_index_by_sw_if_index[sw_if_index] = ci;
414 if (NULL == fm->feature_count_by_sw_if_index ||
415 vec_len (fm->feature_count_by_sw_if_index) <= arc_index ||
416 vec_len (fm->feature_count_by_sw_if_index[arc_index]) <= sw_if_index)
419 feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
421 vnet_feature_reg_invoke (sw_if_index, arc_index, (feature_count > 0));
427 vnet_feature_modify_end_node (u8 arc_index,
428 u32 sw_if_index, u32 end_node_index)
430 vnet_feature_main_t *fm = &feature_main;
431 vnet_feature_config_main_t *cm;
434 if (arc_index == (u8) ~ 0)
435 return VNET_API_ERROR_INVALID_VALUE;
437 if (end_node_index == ~0)
438 return VNET_API_ERROR_INVALID_VALUE_2;
440 cm = &fm->feature_config_mains[arc_index];
441 vec_validate_init_empty (cm->config_index_by_sw_if_index, sw_if_index, ~0);
442 ci = cm->config_index_by_sw_if_index[sw_if_index];
444 ci = vnet_config_modify_end_node (vlib_get_main (), &cm->config_main,
448 cm->config_index_by_sw_if_index[sw_if_index] = ci;
452 if (NULL == fm->feature_count_by_sw_if_index ||
453 vec_len (fm->feature_count_by_sw_if_index) <= arc_index ||
454 vec_len (fm->feature_count_by_sw_if_index[arc_index]) <= sw_if_index)
457 feature_count = fm->feature_count_by_sw_if_index[arc_index][sw_if_index];
459 vnet_feature_reg_invoke (sw_if_index, arc_index, (feature_count > 0));
465 feature_cmp (void *a1, void *a2)
467 vnet_feature_registration_t *reg1 = a1;
468 vnet_feature_registration_t *reg2 = a2;
470 return (int) reg1->feature_index - reg2->feature_index;
473 /** Display the set of available driver features.
474 Useful for verifying that expected features are present
477 static clib_error_t *
478 show_features_command_fn (vlib_main_t * vm,
479 unformat_input_t * input, vlib_cli_command_t * cmd)
481 vnet_feature_main_t *fm = &feature_main;
482 vnet_feature_arc_registration_t *areg;
483 vnet_feature_registration_t *freg;
484 vnet_feature_registration_t *feature_regs = 0;
487 if (unformat (input, "verbose"))
490 vlib_cli_output (vm, "Available feature paths");
496 vlib_cli_output (vm, "[%2d] %s:", areg->feature_arc_index,
499 vlib_cli_output (vm, "%s:", areg->arc_name);
501 freg = fm->next_feature_by_arc[areg->feature_arc_index];
504 vec_add1 (feature_regs, freg[0]);
505 freg = freg->next_in_arc;
508 vec_sort_with_function (feature_regs, feature_cmp);
510 vec_foreach (freg, feature_regs)
513 vlib_cli_output (vm, " [%2d]: %s\n", freg->feature_index,
516 vlib_cli_output (vm, " %s\n", freg->node_name);
518 vec_reset_length (feature_regs);
522 vec_free (feature_regs);
528 * Display the set of available driver features
532 * @cliexcmd{show features [verbose]}
536 VLIB_CLI_COMMAND (show_features_command, static) = {
537 .path = "show features",
538 .short_help = "show features [verbose]",
539 .function = show_features_command_fn,
542 /** Display the set of driver features configured on a specific interface
543 * Called by "show interface" handler
547 vnet_interface_features_show (vlib_main_t * vm, u32 sw_if_index, int verbose)
549 vnet_feature_main_t *fm = &feature_main;
550 u32 node_index, current_config_index;
552 vnet_feature_config_main_t *cm = fm->feature_config_mains;
553 vnet_feature_arc_registration_t *areg;
554 vnet_config_main_t *vcm;
557 vnet_config_feature_t *feat;
561 vlib_cli_output (vm, "Feature paths configured on %U...",
562 format_vnet_sw_if_index_name,
563 vnet_get_main (), sw_if_index);
568 feature_arc = areg->feature_arc_index;
569 vcm = &(cm[feature_arc].config_main);
571 vlib_cli_output (vm, "\n%s:", areg->arc_name);
574 if (!vnet_have_features (feature_arc, sw_if_index))
576 vlib_cli_output (vm, " none configured");
580 current_config_index =
581 vec_elt (cm[feature_arc].config_index_by_sw_if_index, sw_if_index);
583 vec_elt (vcm->config_pool_index_by_user_index, current_config_index);
584 cfg = pool_elt_at_index (vcm->config_pool, cfg_index);
586 for (i = 0; i < vec_len (cfg->features); i++)
588 feat = cfg->features + i;
589 node_index = feat->node_index;
590 n = vlib_get_node (vm, node_index);
592 vlib_cli_output (vm, " [%2d] %v", feat->feature_index, n->name);
594 vlib_cli_output (vm, " %v", n->name);
600 vcm->end_node_indices_by_user_index
601 [current_config_index]);
602 vlib_cli_output (vm, " [end] %v", n->name);
607 static clib_error_t *
608 set_interface_features_command_fn (vlib_main_t * vm,
609 unformat_input_t * input,
610 vlib_cli_command_t * cmd)
612 vnet_main_t *vnm = vnet_get_main ();
613 unformat_input_t _line_input, *line_input = &_line_input;
614 clib_error_t *error = 0;
617 u8 *feature_name = 0;
618 u32 sw_if_index = ~0;
621 /* Get a line of input. */
622 if (!unformat_user (input, unformat_line_input, line_input))
625 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
628 (line_input, "%U %s arc %s", unformat_vnet_sw_interface, vnm,
629 &sw_if_index, &feature_name, &arc_name))
631 else if (unformat (line_input, "disable"))
635 error = unformat_parse_error (line_input);
639 if (!feature_name || !arc_name)
641 error = clib_error_return (0, "Both feature name and arc required...");
645 if (sw_if_index == ~0)
647 error = clib_error_return (0, "Interface not specified...");
651 vec_add1 (arc_name, 0);
652 vec_add1 (feature_name, 0);
656 arc_index = vnet_get_feature_arc_index ((const char *) arc_name);
658 if (arc_index == (u8) ~ 0)
661 clib_error_return (0, "Unknown arc name (%s)... ",
662 (const char *) arc_name);
666 vnet_feature_registration_t *reg;
668 vnet_get_feature_reg ((const char *) arc_name,
669 (const char *) feature_name);
673 clib_error_return (0,
674 "Feature (%s) not registered to arc (%s)... See 'show features verbose' for valid feature/arc combinations. ",
675 feature_name, arc_name);
678 if (reg->enable_disable_cb)
679 error = reg->enable_disable_cb (sw_if_index, enable);
681 vnet_feature_enable_disable ((const char *) arc_name,
682 (const char *) feature_name, sw_if_index,
686 vec_free (feature_name);
688 unformat_free (line_input);
693 * Set feature for given interface
697 * @cliexcmd{set interface feature GigabitEthernet2/0/0 ip4_flow_classify arc ip4_unicast}
701 VLIB_CLI_COMMAND (set_interface_feature_command, static) = {
702 .path = "set interface feature",
703 .short_help = "set interface feature <intfc> <feature_name> arc <arc_name> "
705 .function = set_interface_features_command_fn,
708 static clib_error_t *
709 vnet_feature_add_del_sw_interface (vnet_main_t * vnm, u32 sw_if_index,
712 vnet_feature_main_t *fm = &feature_main;
713 const vnet_feature_arc_registration_t *far;
719 * remove all enabled features from an interface on deletion
721 for (far = fm->next_arc; far != 0; far = far->next)
723 const u8 arc_index = far->feature_arc_index;
724 vnet_feature_config_main_t *cm =
725 vec_elt_at_index (fm->feature_config_mains, arc_index);
727 vec_len (cm->config_index_by_sw_if_index) <=
728 sw_if_index ? ~0 : vec_elt (cm->config_index_by_sw_if_index,
734 fm->sw_if_index_has_features[arc_index] =
735 clib_bitmap_set (fm->sw_if_index_has_features[arc_index], sw_if_index,
738 vnet_feature_reg_invoke (sw_if_index, arc_index, 0);
740 if (vec_len (fm->feature_count_by_sw_if_index[arc_index]) > sw_if_index)
741 vec_elt (fm->feature_count_by_sw_if_index[arc_index], sw_if_index) =
744 vec_elt (cm->config_index_by_sw_if_index, sw_if_index) = ~0;
745 vnet_config_del (&cm->config_main, ci);
751 VNET_SW_INTERFACE_ADD_DEL_FUNCTION_PRIO (vnet_feature_add_del_sw_interface,
752 VNET_ITF_FUNC_PRIORITY_HIGH);
755 * fd.io coding-style-patch-verification: ON
758 * eval: (c-set-style "gnu")