Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 1 | /* |
| 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: |
| 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 | #ifndef included_features_h |
| 17 | #define included_features_h |
| 18 | |
| 19 | #include <vnet/vnet.h> |
Damjan Marion | 96b41f7 | 2016-11-10 18:01:42 +0100 | [diff] [blame] | 20 | #include <vnet/api_errno.h> |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 21 | #include <vnet/devices/devices.h> |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 22 | |
| 23 | /** feature registration object */ |
| 24 | typedef struct _vnet_feature_arc_registration |
| 25 | { |
| 26 | /** next registration in list of all registrations*/ |
| 27 | struct _vnet_feature_arc_registration *next; |
| 28 | /** Feature Arc name */ |
| 29 | char *arc_name; |
| 30 | /** Start nodes */ |
| 31 | char **start_nodes; |
| 32 | int n_start_nodes; |
Dave Barach | a25def7 | 2018-11-26 11:04:45 -0500 | [diff] [blame] | 33 | /** End of the arc (optional, for consistency-checking) */ |
| 34 | char *last_in_arc; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 35 | /* Feature arc index, assigned by init function */ |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 36 | u8 feature_arc_index; |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 37 | u8 *arc_index_ptr; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 38 | } vnet_feature_arc_registration_t; |
| 39 | |
Pavel Kotucek | 7490a75 | 2016-11-15 09:19:11 +0100 | [diff] [blame] | 40 | /* Enable feature callback. */ |
| 41 | typedef clib_error_t *(vnet_feature_enable_disable_function_t) |
| 42 | (u32 sw_if_index, int enable_disable); |
| 43 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 44 | /** feature registration object */ |
| 45 | typedef struct _vnet_feature_registration |
| 46 | { |
| 47 | /** next registration in list of all registrations*/ |
Damjan Marion | 13adc3d | 2018-04-09 20:59:53 +0200 | [diff] [blame] | 48 | struct _vnet_feature_registration *next, *next_in_arc; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 49 | /** Feature arc name */ |
| 50 | char *arc_name; |
| 51 | /** Graph node name */ |
| 52 | char *node_name; |
| 53 | /** Pointer to this feature index, filled in by vnet_feature_arc_init */ |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 54 | u32 *feature_index_ptr; |
| 55 | u32 feature_index; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 56 | /** Constraints of the form "this feature runs before X" */ |
| 57 | char **runs_before; |
| 58 | /** Constraints of the form "this feature runs after Y" */ |
| 59 | char **runs_after; |
Pavel Kotucek | 7490a75 | 2016-11-15 09:19:11 +0100 | [diff] [blame] | 60 | |
| 61 | /** Function to enable/disable feature **/ |
| 62 | vnet_feature_enable_disable_function_t *enable_disable_cb; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 63 | } vnet_feature_registration_t; |
| 64 | |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 65 | /** constraint registration object */ |
| 66 | typedef struct _vnet_feature_constraint_registration |
| 67 | { |
| 68 | /** next constraint set in list of all registrations*/ |
| 69 | struct _vnet_feature_constraint_registration *next, *next_in_arc; |
| 70 | /** Feature arc name */ |
| 71 | char *arc_name; |
| 72 | |
| 73 | /** Feature arc index, assigned by init function */ |
| 74 | u8 feature_arc_index; |
| 75 | |
| 76 | /** Node names, to run in the specified order */ |
| 77 | char **node_names; |
| 78 | } vnet_feature_constraint_registration_t; |
| 79 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 80 | typedef struct vnet_feature_config_main_t_ |
| 81 | { |
| 82 | vnet_config_main_t config_main; |
| 83 | u32 *config_index_by_sw_if_index; |
| 84 | } vnet_feature_config_main_t; |
| 85 | |
| 86 | typedef struct |
| 87 | { |
| 88 | /** feature arc configuration list */ |
| 89 | vnet_feature_arc_registration_t *next_arc; |
| 90 | uword **arc_index_by_name; |
| 91 | |
| 92 | /** feature path configuration lists */ |
| 93 | vnet_feature_registration_t *next_feature; |
| 94 | vnet_feature_registration_t **next_feature_by_arc; |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 95 | vnet_feature_constraint_registration_t *next_constraint; |
| 96 | vnet_feature_constraint_registration_t **next_constraint_by_arc; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 97 | uword **next_feature_by_name; |
| 98 | |
| 99 | /** feature config main objects */ |
| 100 | vnet_feature_config_main_t *feature_config_mains; |
| 101 | |
| 102 | /** Save partial order results for show command */ |
| 103 | char ***feature_nodes; |
| 104 | |
| 105 | /** bitmap of interfaces which have driver rx features configured */ |
| 106 | uword **sw_if_index_has_features; |
| 107 | |
| 108 | /** feature reference counts by interface */ |
| 109 | i16 **feature_count_by_sw_if_index; |
| 110 | |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 111 | /** Feature arc index for device-input */ |
| 112 | u8 device_input_feature_arc_index; |
| 113 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 114 | /** convenience */ |
| 115 | vlib_main_t *vlib_main; |
| 116 | vnet_main_t *vnet_main; |
| 117 | } vnet_feature_main_t; |
| 118 | |
| 119 | extern vnet_feature_main_t feature_main; |
| 120 | |
Damjan Marion | 6e36351 | 2018-08-10 22:39:11 +0200 | [diff] [blame] | 121 | #ifndef CLIB_MARCH_VARIANT |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 122 | #define VNET_FEATURE_ARC_INIT(x,...) \ |
| 123 | __VA_ARGS__ vnet_feature_arc_registration_t vnet_feat_arc_##x;\ |
| 124 | static void __vnet_add_feature_arc_registration_##x (void) \ |
| 125 | __attribute__((__constructor__)) ; \ |
| 126 | static void __vnet_add_feature_arc_registration_##x (void) \ |
| 127 | { \ |
| 128 | vnet_feature_main_t * fm = &feature_main; \ |
| 129 | vnet_feat_arc_##x.next = fm->next_arc; \ |
| 130 | fm->next_arc = & vnet_feat_arc_##x; \ |
| 131 | } \ |
Damjan Marion | 72d2c4f | 2018-04-05 21:32:29 +0200 | [diff] [blame] | 132 | static void __vnet_rm_feature_arc_registration_##x (void) \ |
| 133 | __attribute__((__destructor__)) ; \ |
| 134 | static void __vnet_rm_feature_arc_registration_##x (void) \ |
| 135 | { \ |
| 136 | vnet_feature_main_t * fm = &feature_main; \ |
| 137 | vnet_feature_arc_registration_t *r = &vnet_feat_arc_##x; \ |
| 138 | VLIB_REMOVE_FROM_LINKED_LIST (fm->next_arc, r, next); \ |
| 139 | } \ |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 140 | __VA_ARGS__ vnet_feature_arc_registration_t vnet_feat_arc_##x |
| 141 | |
| 142 | #define VNET_FEATURE_INIT(x,...) \ |
| 143 | __VA_ARGS__ vnet_feature_registration_t vnet_feat_##x; \ |
| 144 | static void __vnet_add_feature_registration_##x (void) \ |
| 145 | __attribute__((__constructor__)) ; \ |
| 146 | static void __vnet_add_feature_registration_##x (void) \ |
| 147 | { \ |
| 148 | vnet_feature_main_t * fm = &feature_main; \ |
| 149 | vnet_feat_##x.next = fm->next_feature; \ |
| 150 | fm->next_feature = & vnet_feat_##x; \ |
| 151 | } \ |
Damjan Marion | 72d2c4f | 2018-04-05 21:32:29 +0200 | [diff] [blame] | 152 | static void __vnet_rm_feature_registration_##x (void) \ |
| 153 | __attribute__((__destructor__)) ; \ |
| 154 | static void __vnet_rm_feature_registration_##x (void) \ |
| 155 | { \ |
| 156 | vnet_feature_main_t * fm = &feature_main; \ |
| 157 | vnet_feature_registration_t *r = &vnet_feat_##x; \ |
| 158 | VLIB_REMOVE_FROM_LINKED_LIST (fm->next_feature, r, next); \ |
| 159 | } \ |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 160 | __VA_ARGS__ vnet_feature_registration_t vnet_feat_##x |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 161 | |
| 162 | #define VNET_FEATURE_ARC_ORDER(x,...) \ |
| 163 | __VA_ARGS__ vnet_feature_constraint_registration_t \ |
| 164 | vnet_feature_constraint_##x; \ |
| 165 | static void __vnet_add_constraint_registration_##x (void) \ |
| 166 | __attribute__((__constructor__)) ; \ |
| 167 | static void __vnet_add_constraint_registration_##x (void) \ |
| 168 | { \ |
| 169 | vnet_feature_main_t * fm = &feature_main; \ |
| 170 | vnet_feature_constraint_##x.next = fm->next_constraint; \ |
| 171 | fm->next_constraint = & vnet_feature_constraint_##x; \ |
| 172 | } \ |
| 173 | static void __vnet_rm_constraint_registration_##x (void) \ |
| 174 | __attribute__((__destructor__)) ; \ |
| 175 | static void __vnet_rm_constraint_registration_##x (void) \ |
| 176 | { \ |
| 177 | vnet_feature_main_t * fm = &feature_main; \ |
| 178 | vnet_feature_constraint_registration_t *r = &vnet_feature_constraint_##x; \ |
| 179 | VLIB_REMOVE_FROM_LINKED_LIST (fm->next_constraint, r, next); \ |
| 180 | } \ |
| 181 | __VA_ARGS__ vnet_feature_constraint_registration_t vnet_feature_constraint_##x |
| 182 | |
Damjan Marion | 6e36351 | 2018-08-10 22:39:11 +0200 | [diff] [blame] | 183 | #else |
| 184 | #define VNET_FEATURE_ARC_INIT(x,...) \ |
| 185 | extern vnet_feature_arc_registration_t __clib_unused vnet_feat_arc_##x; \ |
| 186 | static vnet_feature_arc_registration_t __clib_unused __clib_unused_vnet_feat_arc_##x |
| 187 | #define VNET_FEATURE_INIT(x,...) \ |
| 188 | extern vnet_feature_registration_t __clib_unused vnet_feat_##x; \ |
| 189 | static vnet_feature_registration_t __clib_unused __clib_unused_vnet_feat_##x |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 190 | |
| 191 | #define VNET_FEATURE_ARC_ORDER(x,...) \ |
| 192 | extern vnet_feature_constraint_registration_t \ |
| 193 | __clib_unused vnet_feature_constraint_##x; \ |
| 194 | static vnet_feature_constraint_registration_t __clib_unused \ |
| 195 | __clib_unused_vnet_feature_constraint_##x |
| 196 | |
| 197 | |
Damjan Marion | 6e36351 | 2018-08-10 22:39:11 +0200 | [diff] [blame] | 198 | #endif |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 199 | |
| 200 | void |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 201 | vnet_config_update_feature_count (vnet_feature_main_t * fm, u8 arc, |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 202 | u32 sw_if_index, int is_add); |
| 203 | |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 204 | u32 vnet_get_feature_index (u8 arc, const char *s); |
| 205 | u8 vnet_get_feature_arc_index (const char *s); |
Pavel Kotucek | 7490a75 | 2016-11-15 09:19:11 +0100 | [diff] [blame] | 206 | vnet_feature_registration_t *vnet_get_feature_reg (const char *arc_name, |
| 207 | const char *node_name); |
| 208 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 209 | |
Damjan Marion | 96b41f7 | 2016-11-10 18:01:42 +0100 | [diff] [blame] | 210 | int |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 211 | vnet_feature_enable_disable_with_index (u8 arc_index, u32 feature_index, |
| 212 | u32 sw_if_index, int enable_disable, |
| 213 | void *feature_config, |
| 214 | u32 n_feature_config_bytes); |
| 215 | |
| 216 | int |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 217 | vnet_feature_enable_disable (const char *arc_name, const char *node_name, |
| 218 | u32 sw_if_index, int enable_disable, |
| 219 | void *feature_config, |
| 220 | u32 n_feature_config_bytes); |
| 221 | |
Steven Luong | 71e5b47 | 2019-10-10 11:36:41 -0700 | [diff] [blame] | 222 | static_always_inline u32 |
| 223 | vnet_get_feature_count (u8 arc, u32 sw_if_index) |
| 224 | { |
| 225 | vnet_feature_main_t *fm = &feature_main; |
| 226 | return (fm->feature_count_by_sw_if_index[arc][sw_if_index]); |
| 227 | } |
| 228 | |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 229 | static inline vnet_feature_config_main_t * |
| 230 | vnet_get_feature_arc_config_main (u8 arc_index) |
| 231 | { |
| 232 | vnet_feature_main_t *fm = &feature_main; |
| 233 | |
| 234 | if (arc_index == (u8) ~ 0) |
| 235 | return 0; |
| 236 | |
| 237 | return &fm->feature_config_mains[arc_index]; |
| 238 | } |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 239 | |
Pavel Kotucek | f6e3dc4 | 2016-11-04 09:58:01 +0100 | [diff] [blame] | 240 | static_always_inline vnet_feature_config_main_t * |
| 241 | vnet_feature_get_config_main (u16 arc) |
| 242 | { |
| 243 | vnet_feature_main_t *fm = &feature_main; |
| 244 | return &fm->feature_config_mains[arc]; |
| 245 | } |
| 246 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 247 | static_always_inline int |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 248 | vnet_have_features (u8 arc, u32 sw_if_index) |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 249 | { |
| 250 | vnet_feature_main_t *fm = &feature_main; |
| 251 | return clib_bitmap_get (fm->sw_if_index_has_features[arc], sw_if_index); |
| 252 | } |
| 253 | |
| 254 | static_always_inline u32 |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 255 | vnet_get_feature_config_index (u8 arc, u32 sw_if_index) |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 256 | { |
| 257 | vnet_feature_main_t *fm = &feature_main; |
| 258 | vnet_feature_config_main_t *cm = &fm->feature_config_mains[arc]; |
| 259 | return vec_elt (cm->config_index_by_sw_if_index, sw_if_index); |
| 260 | } |
| 261 | |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 262 | static_always_inline void * |
| 263 | vnet_feature_arc_start_with_data (u8 arc, u32 sw_if_index, u32 * next, |
| 264 | vlib_buffer_t * b, u32 n_data_bytes) |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 265 | { |
| 266 | vnet_feature_main_t *fm = &feature_main; |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 267 | vnet_feature_config_main_t *cm; |
| 268 | cm = &fm->feature_config_mains[arc]; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 269 | |
| 270 | if (PREDICT_FALSE (vnet_have_features (arc, sw_if_index))) |
| 271 | { |
Damjan Marion | aa682a3 | 2018-04-26 22:45:40 +0200 | [diff] [blame] | 272 | vnet_buffer (b)->feature_arc_index = arc; |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 273 | b->current_config_index = |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 274 | vec_elt (cm->config_index_by_sw_if_index, sw_if_index); |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 275 | return vnet_get_config_data (&cm->config_main, &b->current_config_index, |
| 276 | next, n_data_bytes); |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 277 | } |
Damjan Marion | 05bb1dd | 2016-11-08 21:28:22 +0100 | [diff] [blame] | 278 | return 0; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | static_always_inline void |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 282 | vnet_feature_arc_start (u8 arc, u32 sw_if_index, u32 * next0, |
| 283 | vlib_buffer_t * b0) |
| 284 | { |
| 285 | vnet_feature_arc_start_with_data (arc, sw_if_index, next0, b0, 0); |
| 286 | } |
| 287 | |
| 288 | static_always_inline void * |
Damjan Marion | 7d98a12 | 2018-07-19 20:42:08 +0200 | [diff] [blame] | 289 | vnet_feature_next_with_data (u32 * next0, vlib_buffer_t * b0, |
| 290 | u32 n_data_bytes) |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 291 | { |
| 292 | vnet_feature_main_t *fm = &feature_main; |
Damjan Marion | aa682a3 | 2018-04-26 22:45:40 +0200 | [diff] [blame] | 293 | u8 arc = vnet_buffer (b0)->feature_arc_index; |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 294 | vnet_feature_config_main_t *cm = &fm->feature_config_mains[arc]; |
| 295 | |
| 296 | return vnet_get_config_data (&cm->config_main, |
| 297 | &b0->current_config_index, next0, |
| 298 | n_data_bytes); |
| 299 | } |
| 300 | |
| 301 | static_always_inline void |
Damjan Marion | 7d98a12 | 2018-07-19 20:42:08 +0200 | [diff] [blame] | 302 | vnet_feature_next (u32 * next0, vlib_buffer_t * b0) |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 303 | { |
Damjan Marion | 7d98a12 | 2018-07-19 20:42:08 +0200 | [diff] [blame] | 304 | vnet_feature_next_with_data (next0, b0, 0); |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 305 | } |
| 306 | |
Damjan Marion | dc09133 | 2018-02-25 22:52:07 +0100 | [diff] [blame] | 307 | static_always_inline int |
| 308 | vnet_device_input_have_features (u32 sw_if_index) |
| 309 | { |
| 310 | vnet_feature_main_t *fm = &feature_main; |
| 311 | return vnet_have_features (fm->device_input_feature_arc_index, sw_if_index); |
| 312 | } |
| 313 | |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 314 | static_always_inline void |
| 315 | vnet_feature_start_device_input_x1 (u32 sw_if_index, u32 * next0, |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 316 | vlib_buffer_t * b0) |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 317 | { |
| 318 | vnet_feature_main_t *fm = &feature_main; |
| 319 | vnet_feature_config_main_t *cm; |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 320 | u8 feature_arc_index = fm->device_input_feature_arc_index; |
| 321 | cm = &fm->feature_config_mains[feature_arc_index]; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 322 | |
| 323 | if (PREDICT_FALSE |
| 324 | (clib_bitmap_get |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 325 | (fm->sw_if_index_has_features[feature_arc_index], sw_if_index))) |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 326 | { |
| 327 | /* |
| 328 | * Save next0 so that the last feature in the chain |
| 329 | * can skip ethernet-input if indicated... |
| 330 | */ |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 331 | u16 adv; |
| 332 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 333 | adv = device_input_next_node_advance[*next0]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 334 | vlib_buffer_advance (b0, -adv); |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 335 | |
Damjan Marion | aa682a3 | 2018-04-26 22:45:40 +0200 | [diff] [blame] | 336 | vnet_buffer (b0)->feature_arc_index = feature_arc_index; |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 337 | b0->current_config_index = |
| 338 | vec_elt (cm->config_index_by_sw_if_index, sw_if_index); |
| 339 | vnet_get_config_data (&cm->config_main, &b0->current_config_index, |
| 340 | next0, /* # bytes of config data */ 0); |
| 341 | } |
| 342 | } |
| 343 | |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 344 | static_always_inline void |
| 345 | vnet_feature_start_device_input_x2 (u32 sw_if_index, |
| 346 | u32 * next0, |
| 347 | u32 * next1, |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 348 | vlib_buffer_t * b0, vlib_buffer_t * b1) |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 349 | { |
| 350 | vnet_feature_main_t *fm = &feature_main; |
| 351 | vnet_feature_config_main_t *cm; |
| 352 | u8 feature_arc_index = fm->device_input_feature_arc_index; |
| 353 | cm = &fm->feature_config_mains[feature_arc_index]; |
| 354 | |
| 355 | if (PREDICT_FALSE |
| 356 | (clib_bitmap_get |
| 357 | (fm->sw_if_index_has_features[feature_arc_index], sw_if_index))) |
| 358 | { |
| 359 | /* |
| 360 | * Save next0 so that the last feature in the chain |
| 361 | * can skip ethernet-input if indicated... |
| 362 | */ |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 363 | u16 adv; |
| 364 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 365 | adv = device_input_next_node_advance[*next0]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 366 | vlib_buffer_advance (b0, -adv); |
| 367 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 368 | adv = device_input_next_node_advance[*next1]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 369 | vlib_buffer_advance (b1, -adv); |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 370 | |
Damjan Marion | aa682a3 | 2018-04-26 22:45:40 +0200 | [diff] [blame] | 371 | vnet_buffer (b0)->feature_arc_index = feature_arc_index; |
| 372 | vnet_buffer (b1)->feature_arc_index = feature_arc_index; |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 373 | b0->current_config_index = |
| 374 | vec_elt (cm->config_index_by_sw_if_index, sw_if_index); |
| 375 | b1->current_config_index = b0->current_config_index; |
| 376 | vnet_get_config_data (&cm->config_main, &b0->current_config_index, |
| 377 | next0, /* # bytes of config data */ 0); |
| 378 | vnet_get_config_data (&cm->config_main, &b1->current_config_index, |
| 379 | next1, /* # bytes of config data */ 0); |
| 380 | } |
| 381 | } |
| 382 | |
Damjan Marion | 7dc4146 | 2016-11-15 19:47:58 +0100 | [diff] [blame] | 383 | static_always_inline void |
| 384 | vnet_feature_start_device_input_x4 (u32 sw_if_index, |
| 385 | u32 * next0, |
| 386 | u32 * next1, |
| 387 | u32 * next2, |
| 388 | u32 * next3, |
| 389 | vlib_buffer_t * b0, |
| 390 | vlib_buffer_t * b1, |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 391 | vlib_buffer_t * b2, vlib_buffer_t * b3) |
Damjan Marion | 7dc4146 | 2016-11-15 19:47:58 +0100 | [diff] [blame] | 392 | { |
| 393 | vnet_feature_main_t *fm = &feature_main; |
| 394 | vnet_feature_config_main_t *cm; |
| 395 | u8 feature_arc_index = fm->device_input_feature_arc_index; |
| 396 | cm = &fm->feature_config_mains[feature_arc_index]; |
| 397 | |
| 398 | if (PREDICT_FALSE |
| 399 | (clib_bitmap_get |
| 400 | (fm->sw_if_index_has_features[feature_arc_index], sw_if_index))) |
| 401 | { |
| 402 | /* |
| 403 | * Save next0 so that the last feature in the chain |
| 404 | * can skip ethernet-input if indicated... |
| 405 | */ |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 406 | u16 adv; |
| 407 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 408 | adv = device_input_next_node_advance[*next0]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 409 | vlib_buffer_advance (b0, -adv); |
| 410 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 411 | adv = device_input_next_node_advance[*next1]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 412 | vlib_buffer_advance (b1, -adv); |
| 413 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 414 | adv = device_input_next_node_advance[*next2]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 415 | vlib_buffer_advance (b2, -adv); |
| 416 | |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 417 | adv = device_input_next_node_advance[*next3]; |
Damjan Marion | 35af9e5 | 2017-03-06 12:02:50 +0100 | [diff] [blame] | 418 | vlib_buffer_advance (b3, -adv); |
Damjan Marion | 7dc4146 | 2016-11-15 19:47:58 +0100 | [diff] [blame] | 419 | |
Damjan Marion | aa682a3 | 2018-04-26 22:45:40 +0200 | [diff] [blame] | 420 | vnet_buffer (b0)->feature_arc_index = feature_arc_index; |
| 421 | vnet_buffer (b1)->feature_arc_index = feature_arc_index; |
| 422 | vnet_buffer (b2)->feature_arc_index = feature_arc_index; |
| 423 | vnet_buffer (b3)->feature_arc_index = feature_arc_index; |
Damjan Marion | 7dc4146 | 2016-11-15 19:47:58 +0100 | [diff] [blame] | 424 | |
| 425 | b0->current_config_index = |
| 426 | vec_elt (cm->config_index_by_sw_if_index, sw_if_index); |
| 427 | b1->current_config_index = b0->current_config_index; |
| 428 | b2->current_config_index = b0->current_config_index; |
| 429 | b3->current_config_index = b0->current_config_index; |
| 430 | |
| 431 | vnet_get_config_data (&cm->config_main, &b0->current_config_index, |
| 432 | next0, /* # bytes of config data */ 0); |
| 433 | vnet_get_config_data (&cm->config_main, &b1->current_config_index, |
| 434 | next1, /* # bytes of config data */ 0); |
| 435 | vnet_get_config_data (&cm->config_main, &b2->current_config_index, |
| 436 | next2, /* # bytes of config data */ 0); |
| 437 | vnet_get_config_data (&cm->config_main, &b3->current_config_index, |
| 438 | next3, /* # bytes of config data */ 0); |
| 439 | } |
| 440 | } |
Damjan Marion | 87cd119 | 2016-11-04 11:00:27 +0100 | [diff] [blame] | 441 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 442 | #define VNET_FEATURES(...) (char*[]) { __VA_ARGS__, 0} |
| 443 | |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 444 | clib_error_t *vnet_feature_arc_init |
| 445 | (vlib_main_t * vm, |
| 446 | vnet_config_main_t * vcm, |
| 447 | char **feature_start_nodes, |
| 448 | int num_feature_start_nodes, |
Dave Barach | 5f9f3c8 | 2019-11-22 17:42:58 -0500 | [diff] [blame] | 449 | char *last_in_arc, |
Dave Barach | 2dd192b | 2018-11-19 09:31:48 -0500 | [diff] [blame] | 450 | vnet_feature_registration_t * first_reg, |
| 451 | vnet_feature_constraint_registration_t * first_const_set, |
| 452 | char ***in_feature_nodes); |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 453 | |
Dave Barach | 525c9d0 | 2018-05-26 10:48:55 -0400 | [diff] [blame] | 454 | void vnet_interface_features_show (vlib_main_t * vm, u32 sw_if_index, |
| 455 | int verbose); |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 456 | |
Neale Ranns | c8972fe | 2019-12-02 23:10:08 +0000 | [diff] [blame^] | 457 | typedef void (*vnet_feature_update_cb_t) (u32 sw_if_index, |
| 458 | u8 arc_index, |
| 459 | u8 is_enable, void *cb); |
| 460 | |
| 461 | extern void vnet_feature_register (vnet_feature_update_cb_t cb, void *data); |
| 462 | |
Damjan Marion | 2231150 | 2016-10-28 20:30:15 +0200 | [diff] [blame] | 463 | #endif /* included_feature_h */ |
| 464 | |
| 465 | /* |
| 466 | * fd.io coding-style-patch-verification: ON |
| 467 | * |
| 468 | * Local Variables: |
| 469 | * eval: (c-set-style "gnu") |
| 470 | * End: |
| 471 | */ |