FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
node1.c
Go to the documentation of this file.
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 #include <vnet/cop/cop.h>
17 
18 typedef struct {
22 
23 /* packet trace format function */
24 static u8 * format_cop_input_trace (u8 * s, va_list * args)
25 {
26  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
27  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
28  cop_input_trace_t * t = va_arg (*args, cop_input_trace_t *);
29 
30  s = format (s, "COP_INPUT: sw_if_index %d, next index %d",
31  t->sw_if_index, t->next_index);
32  return s;
33 }
34 
35 #define foreach_cop_input_error \
36 _(PROCESSED, "COP input packets processed")
37 
38 typedef enum {
39 #define _(sym,str) COP_INPUT_ERROR_##sym,
41 #undef _
44 
45 static char * cop_input_error_strings[] = {
46 #define _(sym,string) string,
48 #undef _
49 };
50 
52  vlib_node_runtime_t * node,
53  vlib_frame_t * frame)
54 {
55  u32 n_left_from, * from, * to_next;
56  cop_feature_type_t next_index;
58 
59  from = vlib_frame_vector_args (frame);
60  n_left_from = frame->n_vectors;
61  next_index = node->cached_next_index;
62 
63  while (n_left_from > 0)
64  {
65  u32 n_left_to_next;
66 
67  vlib_get_next_frame (vm, node, next_index,
68  to_next, n_left_to_next);
69 
70  while (n_left_from >= 4 && n_left_to_next >= 2)
71  {
72  u32 bi0, bi1;
73  vlib_buffer_t * b0, * b1;
74  u32 next0, next1;
75  u32 sw_if_index0, sw_if_index1;
76  ethernet_header_t * en0, * en1;
77  cop_config_main_t * ccm0, * ccm1;
78  u32 advance0, advance1;
79  int proto0, proto1;
80 
81  /* Prefetch next iteration. */
82  {
83  vlib_buffer_t * p2, * p3;
84 
85  p2 = vlib_get_buffer (vm, from[2]);
86  p3 = vlib_get_buffer (vm, from[3]);
87 
88  vlib_prefetch_buffer_header (p2, LOAD);
89  vlib_prefetch_buffer_header (p3, LOAD);
90 
93  }
94 
95  /* speculatively enqueue b0 and b1 to the current next frame */
96  to_next[0] = bi0 = from[0];
97  to_next[1] = bi1 = from[1];
98  from += 2;
99  to_next += 2;
100  n_left_from -= 2;
101  n_left_to_next -= 2;
102 
103  b0 = vlib_get_buffer (vm, bi0);
104  b1 = vlib_get_buffer (vm, bi1);
105 
106  en0 = vlib_buffer_get_current (b0);
107  en1 = vlib_buffer_get_current (b1);
108 
109  sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
110  sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX];
111 
112  proto0 = VNET_COP_DEFAULT;
113  proto1 = VNET_COP_DEFAULT;
114  advance0 = 0;
115  advance1 = 0;
116 
117  if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4))
118  {
119  proto0 = VNET_COP_IP4;
120  advance0 = sizeof(ethernet_header_t);
121  }
122  else if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6))
123  {
124  proto0 = VNET_COP_IP6;
125  advance0 = sizeof(ethernet_header_t);
126  }
127 
128  if (en1->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4))
129  {
130  proto1 = VNET_COP_IP4;
131  advance1 = sizeof(ethernet_header_t);
132  }
133  else if (en1->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6))
134  {
135  proto1 = VNET_COP_IP6;
136  advance1 = sizeof(ethernet_header_t);
137  }
138 
139  ccm0 = cm->cop_config_mains + proto0;
140  ccm1 = cm->cop_config_mains + proto1;
141  vnet_buffer(b0)->cop.current_config_index =
142  ccm0->config_index_by_sw_if_index [sw_if_index0];
143 
144  vnet_buffer(b1)->cop.current_config_index =
145  ccm1->config_index_by_sw_if_index [sw_if_index1];
146 
147  vlib_buffer_advance (b0, advance0);
148  vlib_buffer_advance (b1, advance1);
149 
151  &vnet_buffer(b0)->cop.current_config_index,
152  &next0, 0 /* bytes of config data */);
153 
155  &vnet_buffer(b1)->cop.current_config_index,
156  &next1, 0 /* bytes of config data */);
157 
158  if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
159  && (b0->flags & VLIB_BUFFER_IS_TRACED)))
160  {
161  cop_input_trace_t *t =
162  vlib_add_trace (vm, node, b0, sizeof (*t));
163  t->sw_if_index = sw_if_index0;
164  t->next_index = next0;
165  }
166 
167  if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
168  && (b1->flags & VLIB_BUFFER_IS_TRACED)))
169  {
170  cop_input_trace_t *t =
171  vlib_add_trace (vm, node, b1, sizeof (*t));
172  t->sw_if_index = sw_if_index1;
173  t->next_index = next1;
174  }
175  /* verify speculative enqueues, maybe switch current next frame */
176  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
177  to_next, n_left_to_next,
178  bi0, bi1, next0, next1);
179  }
180 
181  while (n_left_from > 0 && n_left_to_next > 0)
182  {
183  u32 bi0;
184  vlib_buffer_t * b0;
185  u32 next0;
186  u32 sw_if_index0;
187  ethernet_header_t *en0;
188  cop_config_main_t *ccm0;
189  u32 advance0;
190  int proto0;
191 
192  /* speculatively enqueue b0 to the current next frame */
193  bi0 = from[0];
194  to_next[0] = bi0;
195  from += 1;
196  to_next += 1;
197  n_left_from -= 1;
198  n_left_to_next -= 1;
199 
200  b0 = vlib_get_buffer (vm, bi0);
201 
202  /*
203  * Direct from the driver, we should be at offset 0
204  * aka at &b0->data[0]
205  */
206  ASSERT (b0->current_data == 0);
207 
208  en0 = vlib_buffer_get_current (b0);
209 
210  sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
211 
212  proto0 = VNET_COP_DEFAULT;
213  advance0 = 0;
214 
215  if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP4))
216  {
217  proto0 = VNET_COP_IP4;
218  advance0 = sizeof(ethernet_header_t);
219  }
220  else if (en0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6))
221  {
222  proto0 = VNET_COP_IP6;
223  advance0 = sizeof(ethernet_header_t);
224  }
225 
226  ccm0 = cm->cop_config_mains + proto0;
227  vnet_buffer(b0)->cop.current_config_index =
228  ccm0->config_index_by_sw_if_index [sw_if_index0];
229 
230  vlib_buffer_advance (b0, advance0);
231 
233  &vnet_buffer(b0)->cop.current_config_index,
234  &next0, 0 /* bytes of config data */);
235 
236  if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
237  && (b0->flags & VLIB_BUFFER_IS_TRACED)))
238  {
239  cop_input_trace_t *t =
240  vlib_add_trace (vm, node, b0, sizeof (*t));
241  t->sw_if_index = sw_if_index0;
242  t->next_index = next0;
243  }
244 
245  /* verify speculative enqueue, maybe switch current next frame */
246  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
247  to_next, n_left_to_next,
248  bi0, next0);
249  }
250 
251  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
252  }
254  COP_INPUT_ERROR_PROCESSED, frame->n_vectors);
255  return frame->n_vectors;
256 }
257 
259  .name = "cop-input",
260  .vector_size = sizeof (u32),
261  .format_trace = format_cop_input_trace,
263 
264  .n_errors = ARRAY_LEN(cop_input_error_strings),
265  .error_strings = cop_input_error_strings,
266 
267  .n_next_nodes = COP_RX_N_FEATURES,
268 
269  /* edit / add dispositions here */
270  .next_nodes = {
271  [IP4_RX_COP_WHITELIST] = "ip4-cop-whitelist",
272  [IP6_RX_COP_WHITELIST] = "ip6-cop-whitelist",
273  [DEFAULT_RX_COP_WHITELIST] = "default-cop-whitelist",
274  [IP4_RX_COP_INPUT] = "ip4-input",
275  [IP6_RX_COP_INPUT] = "ip6-input",
276  [DEFAULT_RX_COP_INPUT] = "ethernet-input",
277  [RX_COP_DROP] = "error-drop",
278  },
279 };
280 
281 #define foreach_cop_stub \
282 _(default-cop-whitelist, default_cop_whitelist)
283 
284 #define _(n,f) \
285  \
286 static uword \
287 f##_node_fn (vlib_main_t * vm, \
288  vlib_node_runtime_t * node, \
289  vlib_frame_t * frame) \
290 { \
291  clib_warning ("BUG: stub function called"); \
292  return 0; \
293 } \
294  \
295 VLIB_REGISTER_NODE (f##_input_node) = { \
296  .function = f##_node_fn, \
297  .name = #n, \
298  .vector_size = sizeof (u32), \
299  .type = VLIB_NODE_TYPE_INTERNAL, \
300  \
301  .n_errors = 0, \
302  .error_strings = 0, \
303  \
304  .n_next_nodes = 0, \
305 };
306 
308 
309 
310 
311 
312 
313 
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
#define CLIB_UNUSED(x)
Definition: clib.h:83
cop_config_main_t cop_config_mains[VNET_N_COPS]
Definition: cop.h:66
cop_input_error_t
Definition: node1.c:38
vlib_node_registration_t cop_input_node
(constructor) VLIB_REGISTER_NODE (cop_input_node)
Definition: node1.c:258
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:110
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define foreach_cop_stub
Definition: node1.c:281
#define VLIB_NODE_FN(node)
Definition: node.h:202
static char * cop_input_error_strings[]
Definition: node1.c:45
unsigned char u8
Definition: types.h:56
u32 * config_index_by_sw_if_index
Definition: cop.h:58
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:203
static u8 * format_cop_input_trace(u8 *s, va_list *args)
Definition: node1.c:24
unsigned int u32
Definition: types.h:88
vl_api_fib_path_type_t type
Definition: fib_types.api:123
vnet_crypto_main_t * cm
Definition: quic_crypto.c:41
u32 sw_if_index
Definition: node1.c:20
cop_feature_type_t
Definition: cop.h:39
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
static void * vnet_get_config_data(vnet_config_main_t *cm, u32 *config_index, u32 *next_index, u32 n_data_bytes)
Definition: config.h:122
#define PREDICT_FALSE(x)
Definition: clib.h:112
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:218
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:338
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1150
#define foreach_cop_input_error
Definition: node1.c:35
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
vlib_main_t * vm
Definition: buffer.c:323
u8 data[]
Packet data.
Definition: buffer.h:181
#define ARRAY_LEN(x)
Definition: clib.h:63
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:456
cop_main_t cop_main
Definition: cop.c:17
#define ASSERT(truth)
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:248
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
u32 next_index
Definition: node1.c:19
VLIB buffer representation.
Definition: buffer.h:102
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
#define vnet_buffer(b)
Definition: buffer.h:365
Definition: cop.h:65
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:302
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
Definition: defs.h:46
vnet_config_main_t config_main
Definition: cop.h:57