2 * gbp.h : Group Based Policy
4 * Copyright (c) 2018 Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <plugins/gbp/gbp.h>
20 typedef enum gbp_src_classify_type_t_
22 GBP_SRC_CLASSIFY_NULL,
23 GBP_SRC_CLASSIFY_PORT,
24 } gbp_src_classify_type_t;
26 #define GBP_SRC_N_CLASSIFY (GBP_SRC_CLASSIFY_PORT + 1)
29 * Grouping of global data for the GBP source EPG classification feature
31 typedef struct gbp_src_classify_main_t_
34 * Next nodes for L2 output features
36 u32 l2_input_feat_next[GBP_SRC_N_CLASSIFY][32];
37 } gbp_src_classify_main_t;
39 static gbp_src_classify_main_t gbp_src_classify_main;
42 * per-packet trace data
44 typedef struct gbp_classify_trace_t_
46 /* per-pkt trace data */
48 } gbp_classify_trace_t;
51 * determine the SRC EPG form the input port
54 gbp_classify_inline (vlib_main_t * vm,
55 vlib_node_runtime_t * node,
57 gbp_src_classify_type_t type, u8 is_l3)
59 gbp_src_classify_main_t *gscm = &gbp_src_classify_main;
60 u32 n_left_from, *from, *to_next;
64 n_left_from = frame->n_vectors;
65 from = vlib_frame_vector_args (frame);
67 while (n_left_from > 0)
71 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
73 while (n_left_from > 0 && n_left_to_next > 0)
75 u32 next0, bi0, src_epg, sw_if_index0;
85 b0 = vlib_get_buffer (vm, bi0);
87 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
89 if (GBP_SRC_CLASSIFY_NULL == type)
93 vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
94 L2INPUT_FEAT_GBP_NULL_CLASSIFY);
98 src_epg = gbp_port_to_epg (sw_if_index0);
102 * Go straight to looukp, do not pass go, do not collect $200
109 vnet_l2_feature_next (b0, gscm->l2_input_feat_next[type],
110 L2INPUT_FEAT_GBP_SRC_CLASSIFY);
114 vnet_buffer2 (b0)->gbp.src_epg = src_epg;
116 if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED)))
118 gbp_classify_trace_t *t =
119 vlib_add_trace (vm, node, b0, sizeof (*t));
120 t->src_epg = src_epg;
123 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
124 to_next, n_left_to_next,
128 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
131 return frame->n_vectors;
135 gbp_src_classify (vlib_main_t * vm,
136 vlib_node_runtime_t * node, vlib_frame_t * frame)
138 return (gbp_classify_inline (vm, node, frame, GBP_SRC_CLASSIFY_PORT, 0));
142 gbp_null_classify (vlib_main_t * vm,
143 vlib_node_runtime_t * node, vlib_frame_t * frame)
145 return (gbp_classify_inline (vm, node, frame, GBP_SRC_CLASSIFY_NULL, 0));
149 gbp_ip4_src_classify (vlib_main_t * vm,
150 vlib_node_runtime_t * node, vlib_frame_t * frame)
152 return (gbp_classify_inline (vm, node, frame, 0, 1));
156 gbp_ip6_src_classify (vlib_main_t * vm,
157 vlib_node_runtime_t * node, vlib_frame_t * frame)
159 return (gbp_classify_inline (vm, node, frame, 0, 1));
163 /* packet trace format function */
165 format_gbp_classify_trace (u8 * s, va_list * args)
167 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
168 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
169 gbp_classify_trace_t *t = va_arg (*args, gbp_classify_trace_t *);
171 s = format (s, "src-epg:%d", t->src_epg);
177 VLIB_REGISTER_NODE (gbp_null_classify_node) = {
178 .function = gbp_null_classify,
179 .name = "gbp-null-classify",
180 .vector_size = sizeof (u32),
181 .format_trace = format_gbp_classify_trace,
182 .type = VLIB_NODE_TYPE_INTERNAL,
188 VLIB_NODE_FUNCTION_MULTIARCH (gbp_null_classify_node, gbp_null_classify);
190 VLIB_REGISTER_NODE (gbp_src_classify_node) = {
191 .function = gbp_src_classify,
192 .name = "gbp-src-classify",
193 .vector_size = sizeof (u32),
194 .format_trace = format_gbp_classify_trace,
195 .type = VLIB_NODE_TYPE_INTERNAL,
201 VLIB_NODE_FUNCTION_MULTIARCH (gbp_src_classify_node, gbp_src_classify);
203 VLIB_REGISTER_NODE (gbp_ip4_src_classify_node) = {
204 .function = gbp_ip4_src_classify,
205 .name = "ip4-gbp-src-classify",
206 .vector_size = sizeof (u32),
207 .format_trace = format_gbp_classify_trace,
208 .type = VLIB_NODE_TYPE_INTERNAL,
217 VLIB_NODE_FUNCTION_MULTIARCH (gbp_ip4_src_classify_node, gbp_ip4_src_classify);
219 VLIB_REGISTER_NODE (gbp_ip6_src_classify_node) = {
220 .function = gbp_ip6_src_classify,
221 .name = "ip6-gbp-src-classify",
222 .vector_size = sizeof (u32),
223 .format_trace = format_gbp_classify_trace,
224 .type = VLIB_NODE_TYPE_INTERNAL,
233 VLIB_NODE_FUNCTION_MULTIARCH (gbp_ip6_src_classify_node, gbp_ip6_src_classify);
235 VNET_FEATURE_INIT (gbp_ip4_src_classify_feat_node, static) =
237 .arc_name = "ip4-unicast",
238 .node_name = "ip4-gbp-src-classify",
239 .runs_before = VNET_FEATURES ("nat44-out2in"),
241 VNET_FEATURE_INIT (gbp_ip6_src_classify_feat_node, static) =
243 .arc_name = "ip6-unicast",
244 .node_name = "ip6-gbp-src-classify",
245 .runs_before = VNET_FEATURES ("nat66-out2in"),
248 static clib_error_t *
249 gbp_src_classify_init (vlib_main_t * vm)
251 gbp_src_classify_main_t *em = &gbp_src_classify_main;
253 /* Initialize the feature next-node indexes */
254 feat_bitmap_init_next_nodes (vm,
255 gbp_src_classify_node.index,
257 l2input_get_feat_names (),
258 em->l2_input_feat_next[GBP_SRC_CLASSIFY_NULL]);
259 feat_bitmap_init_next_nodes (vm,
260 gbp_null_classify_node.index,
262 l2input_get_feat_names (),
263 em->l2_input_feat_next[GBP_SRC_CLASSIFY_PORT]);
268 VLIB_INIT_FUNCTION (gbp_src_classify_init);
271 * fd.io coding-style-patch-verification: ON
274 * eval: (c-set-style "gnu")