FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
ip4_punt_drop.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 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/ip/ip.h>
17 #include <vnet/ip/ip_punt_drop.h>
18 #include <vnet/policer/policer.h>
20 
21 /* *INDENT-OFF* */
23 {
24  .arc_name = "ip4-punt",
25  .start_nodes = VNET_FEATURES ("ip4-punt"),
26 };
27 
28 VNET_FEATURE_ARC_INIT (ip4_drop) =
29 {
30  .arc_name = "ip4-drop",
31  .start_nodes = VNET_FEATURES ("ip4-drop", "ip4-not-enabled"),
32 };
33 /* *INDENT-ON* */
34 
36 
37 #ifndef CLIB_MARCH_VARIANT
38 u8 *
39 format_ip_punt_policer_trace (u8 * s, va_list * args)
40 {
41  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
42  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
43  ip_punt_policer_trace_t *t = va_arg (*args, ip_punt_policer_trace_t *);
44 
45  s = format (s, "policer_index %d next %d", t->policer_index, t->next);
46  return s;
47 }
48 
49 ip_punt_policer_t ip4_punt_policer_cfg = {
50  .policer_index = ~0,
51 };
52 #endif /* CLIB_MARCH_VARIANT */
53 
55 #define _(sym,string) string,
57 #undef _
58 };
59 
61  vlib_node_runtime_t * node,
62  vlib_frame_t * frame)
63 {
64  return (ip_punt_policer (vm, node, frame,
65  vnet_feat_arc_ip4_punt.feature_arc_index,
66  ip4_punt_policer_cfg.policer_index));
67 }
68 
69 /* *INDENT-OFF* */
71  .name = "ip4-punt-policer",
72  .vector_size = sizeof (u32),
73  .n_next_nodes = IP_PUNT_POLICER_N_NEXT,
74  .format_trace = format_ip_punt_policer_trace,
76  .error_strings = ip4_punt_policer_error_strings,
77 
78  .next_nodes = {
79  [IP_PUNT_POLICER_NEXT_DROP] = "ip4-drop",
80  },
81 };
82 
84  .arc_name = "ip4-punt",
85  .node_name = "ip4-punt-policer",
86  .runs_before = VNET_FEATURES("ip4-punt-redirect"),
87 };
88 /* *INDENT-ON* */
89 
90 
91 #define foreach_ip4_punt_redirect_error \
92 _(DROP, "ip4 punt redirect drop")
93 
94 typedef enum
95 {
96 #define _(sym,str) IP4_PUNT_REDIRECT_ERROR_##sym,
98 #undef _
101 
103 #define _(sym,string) string,
105 #undef _
106 };
107 
109  vlib_node_runtime_t * node,
110  vlib_frame_t * frame)
111 {
112  return (ip_punt_redirect (vm, node, frame,
113  vnet_feat_arc_ip4_punt.feature_arc_index,
115 }
116 
117 /* *INDENT-OFF* */
119  .name = "ip4-punt-redirect",
120  .vector_size = sizeof (u32),
121  .n_next_nodes = IP_PUNT_REDIRECT_N_NEXT,
122  .format_trace = format_ip_punt_redirect_trace,
124  .error_strings = ip4_punt_redirect_error_strings,
125 
126  /* edit / add dispositions here */
127  .next_nodes = {
128  [IP_PUNT_REDIRECT_NEXT_DROP] = "ip4-drop",
129  [IP_PUNT_REDIRECT_NEXT_TX] = "ip4-rewrite",
130  [IP_PUNT_REDIRECT_NEXT_ARP] = "ip4-arp",
131  },
132 };
133 
135  .arc_name = "ip4-punt",
136  .node_name = "ip4-punt-redirect",
137  .runs_before = VNET_FEATURES("error-punt"),
138 };
139 /* *INDENT-ON* */
140 
142  vlib_frame_t * frame)
143 {
144  if (node->flags & VLIB_NODE_FLAG_TRACE)
145  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
146 
147  return ip_drop_or_punt (vm, node, frame,
148  vnet_feat_arc_ip4_drop.feature_arc_index);
149 
150 }
151 
153  vlib_node_runtime_t * node,
154  vlib_frame_t * frame)
155 {
156  if (node->flags & VLIB_NODE_FLAG_TRACE)
157  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
158 
159  return ip_drop_or_punt (vm, node, frame,
160  vnet_feat_arc_ip4_drop.feature_arc_index);
161 }
162 
163 static uword
165 {
166  if (node->flags & VLIB_NODE_FLAG_TRACE)
167  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
168 
169  return ip_drop_or_punt (vm, node, frame,
170  vnet_feat_arc_ip4_punt.feature_arc_index);
171 }
172 
173 /* *INDENT-OFF* */
175 {
176  .name = "ip4-drop",
177  .vector_size = sizeof (u32),
178  .format_trace = format_ip4_forward_next_trace,
179  .n_next_nodes = 1,
180  .next_nodes = {
181  [0] = "error-drop",
182  },
183 };
184 
186 {
187  .name = "ip4-not-enabled",
188  .vector_size = sizeof (u32),
189  .format_trace = format_ip4_forward_next_trace,
190  .n_next_nodes = 1,
191  .next_nodes = {
192  [0] = "error-drop",
193  },
194 };
195 
197 {
198  .function = ip4_punt,
199  .name = "ip4-punt",
200  .vector_size = sizeof (u32),
201  .format_trace = format_ip4_forward_next_trace,
202  .n_next_nodes = 1,
203  .next_nodes = {
204  [0] = "error-punt",
205  },
206 };
207 
208 VNET_FEATURE_INIT (ip4_punt_end_of_arc, static) = {
209  .arc_name = "ip4-punt",
210  .node_name = "error-punt",
211  .runs_before = 0, /* not before any other features */
212 };
213 
214 VNET_FEATURE_INIT (ip4_drop_end_of_arc, static) = {
215  .arc_name = "ip4-drop",
216  .node_name = "error-drop",
217  .runs_before = 0, /* not before any other features */
218 };
219 /* *INDENT-ON */
220 
221 #ifndef CLIB_MARCH_VARIANT
222 void
223 ip4_punt_policer_add_del (u8 is_add, u32 policer_index)
224 {
225  ip4_punt_policer_cfg.policer_index = policer_index;
226 
227  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-policer",
228  0, is_add, 0, 0);
229 }
230 #endif /* CLIB_MARCH_VARIANT */
231 
232 static clib_error_t *
234  unformat_input_t * main_input,
235  vlib_cli_command_t * cmd)
236 {
237  unformat_input_t _line_input, *line_input = &_line_input;
238  clib_error_t *error = 0;
239  u32 policer_index;
240  u8 is_add = 1;
241 
242  policer_index = ~0;
243 
244  if (!unformat_user (main_input, unformat_line_input, line_input))
245  return 0;
246 
247  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
248  {
249  if (unformat (line_input, "%d", &policer_index))
250  ;
251  else if (unformat (line_input, "del"))
252  is_add = 0;
253  else if (unformat (line_input, "add"))
254  is_add = 1;
255  else
256  {
257  error = unformat_parse_error (line_input);
258  goto done;
259  }
260  }
261 
262  if (is_add && ~0 == policer_index)
263  {
264  error = clib_error_return (0, "expected policer index `%U'",
265  format_unformat_error, line_input);
266  goto done;
267  }
268  if (!is_add)
269  policer_index = ~0;
270 
271  ip4_punt_policer_add_del(is_add, policer_index);
272 
273 done:
274  unformat_free (line_input);
275  return (error);
276 }
277 
278 /*?
279  *
280  * @cliexpar
281  * @cliexcmd{set ip punt policer <INDEX>}
282  ?*/
283 /* *INDENT-OFF* */
284 VLIB_CLI_COMMAND (ip4_punt_policer_command, static) =
285 {
286  .path = "ip punt policer",
287  .function = ip4_punt_police_cmd,
288  .short_help = "ip punt policer [add|del] <index>",
289 };
290 /* *INDENT-ON* */
291 
292 #ifndef CLIB_MARCH_VARIANT
293 
294 void
295 ip4_punt_redirect_add (u32 rx_sw_if_index,
296  u32 tx_sw_if_index, ip46_address_t * nh)
297 {
298  /* *INDENT-OFF* */
299  fib_route_path_t *rpaths = NULL, rpath = {
301  .frp_addr = *nh,
302  .frp_sw_if_index = tx_sw_if_index,
303  .frp_weight = 1,
304  .frp_fib_index = ~0,
305  };
306  /* *INDENT-ON* */
307 
308  vec_add1 (rpaths, rpath);
309 
310  ip4_punt_redirect_add_paths (rx_sw_if_index, rpaths);
311 
312  vec_free (rpaths);
313 }
314 
315 void
317 {
319  rx_sw_if_index,
321 
322  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 1, 0, 0);
323 }
324 
325 void
326 ip4_punt_redirect_del (u32 rx_sw_if_index)
327 {
328  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 0, 0, 0);
329 
330  ip_punt_redirect_del (FIB_PROTOCOL_IP4, rx_sw_if_index);
331 }
332 #endif /* CLIB_MARCH_VARIANT */
333 
334 static clib_error_t *
336  unformat_input_t * main_input,
337  vlib_cli_command_t * cmd)
338 {
339  unformat_input_t _line_input, *line_input = &_line_input;
340  ip46_address_t nh = { 0 };
341  clib_error_t *error = 0;
342  u32 rx_sw_if_index = ~0;
343  u32 tx_sw_if_index = ~0;
344  vnet_main_t *vnm;
345  u8 is_add;
346 
347  is_add = 1;
348  vnm = vnet_get_main ();
349 
350  if (!unformat_user (main_input, unformat_line_input, line_input))
351  return 0;
352 
353  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
354  {
355  if (unformat (line_input, "del"))
356  is_add = 0;
357  else if (unformat (line_input, "add"))
358  is_add = 1;
359  else if (unformat (line_input, "rx all"))
360  rx_sw_if_index = ~0;
361  else if (unformat (line_input, "rx %U",
362  unformat_vnet_sw_interface, vnm, &rx_sw_if_index))
363  ;
364  else if (unformat (line_input, "via %U %U",
365  unformat_ip4_address, &nh.ip4,
366  unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
367  ;
368  else if (unformat (line_input, "via %U",
369  unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
370  ;
371  else
372  {
373  error = unformat_parse_error (line_input);
374  goto done;
375  }
376  }
377 
378  if (~0 == rx_sw_if_index)
379  {
380  error = unformat_parse_error (line_input);
381  goto done;
382  }
383 
384  if (is_add)
385  {
386  ip4_punt_redirect_add (rx_sw_if_index, tx_sw_if_index, &nh);
387  }
388  else
389  {
390  ip4_punt_redirect_del (rx_sw_if_index);
391  }
392 
393 done:
394  unformat_free (line_input);
395  return (error);
396 }
397 
398 /*?
399  *
400  * @cliexpar
401  * @cliexcmd{set ip punt policer}
402  ?*/
403 /* *INDENT-OFF* */
404 VLIB_CLI_COMMAND (ip4_punt_redirect_command, static) =
405 {
406  .path = "ip punt redirect",
407  .function = ip4_punt_redirect_cmd,
408  .short_help = "ip punt redirect [add|del] rx [<interface>|all] via [<nh>] <tx_interface>",
409 };
410 /* *INDENT-ON* */
411 
412 static clib_error_t *
414  unformat_input_t * main_input,
415  vlib_cli_command_t * cmd)
416 {
418 
419  return (NULL);
420 }
421 
422 /*?
423  *
424  * @cliexpar
425  * @cliexcmd{set ip punt redierect}
426  ?*/
427 /* *INDENT-OFF* */
428 VLIB_CLI_COMMAND (show_ip4_punt_redirect_command, static) =
429 {
430  .path = "show ip punt redirect",
431  .function = ip4_punt_redirect_show_cmd,
432  .short_help = "show ip punt redirect",
433  .is_mp_safe = 1,
434 };
435 /* *INDENT-ON* */
436 
437 /*
438  * fd.io coding-style-patch-verification: ON
439  *
440  * Local Variables:
441  * eval: (c-set-style "gnu")
442  * End:
443  */
#define CLIB_UNUSED(x)
Definition: clib.h:83
A representation of a path as described by a route producer.
Definition: fib_types.h:485
static clib_error_t * ip4_punt_redirect_show_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
ip4_punt_redirect_error_t
Definition: ip4_punt_drop.c:94
vl_api_fib_path_nh_t nh
Definition: fib_types.api:126
vlib_node_registration_t ip4_drop_node
(constructor) VLIB_REGISTER_NODE (ip4_drop_node)
u8 * format_ip_punt_redirect_trace(u8 *s, va_list *args)
Definition: ip_punt_drop.c:25
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
static uword ip_drop_or_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index)
Definition: ip_punt_drop.h:358
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
Contribute an object that is to be used to forward IP4 packets.
Definition: fib_types.h:109
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
dpo_proto_t frp_proto
The protocol of the address below.
Definition: fib_types.h:490
unformat_function_t unformat_vnet_sw_interface
#define VLIB_NODE_FN(node)
Definition: node.h:202
void ip_punt_redirect_add(fib_protocol_t fproto, u32 rx_sw_if_index, fib_forward_chain_type_t ct, fib_route_path_t *rpaths)
Add a punt redirect entry.
Definition: ip_punt_drop.c:74
void ip4_punt_policer_add_del(u8 is_add, u32 policer_index)
unsigned char u8
Definition: types.h:56
#define foreach_ip4_punt_redirect_error
Definition: ip4_punt_drop.c:91
u8 * format_ip_punt_redirect(u8 *s, va_list *args)
Definition: ip_punt_drop.c:131
unformat_function_t unformat_ip4_address
Definition: format.h:70
vlib_node_registration_t ip4_punt_policer_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_policer_node)
Definition: ip4_punt_drop.c:70
vlib_node_registration_t ip4_not_enabled_node
(constructor) VLIB_REGISTER_NODE (ip4_not_enabled_node)
ip_punt_policer_t ip4_punt_policer_cfg
Definition: ip4_punt_drop.c:49
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned int u32
Definition: types.h:88
#define foreach_ip_punt_policer_error
Definition: ip_punt_drop.h:44
static char * ip4_punt_redirect_error_strings[]
static uword ip_punt_policer(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index, u32 policer_index)
IP punt policing node function.
Definition: ip_punt_drop.h:61
unformat_function_t unformat_line_input
Definition: format.h:283
u8 * format_ip_punt_policer_trace(u8 *s, va_list *args)
Definition: ip4_punt_drop.c:39
static char * ip4_punt_policer_error_strings[]
Definition: ip4_punt_drop.c:54
struct _unformat_input_t unformat_input_t
static clib_error_t * ip4_punt_redirect_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
vlib_node_registration_t ip4_punt_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_node)
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
vlib_main_t * vm
Definition: buffer.c:323
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
vlib_node_registration_t ip4_punt_redirect_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_redirect_node)
#define ARRAY_LEN(x)
Definition: clib.h:63
VNET_FEATURE_INIT(ip4_punt_policer_node)
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:161
static uword ip4_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
IP4 punt policer configuration we police the punt rate to prevent overloading the host...
Definition: ip_punt_drop.h:27
static clib_error_t * ip4_punt_police_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
void ip4_punt_redirect_del(u32 rx_sw_if_index)
#define VNET_FEATURES(...)
Definition: feature.h:442
static uword ip_punt_redirect(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index, fib_protocol_t fproto)
Definition: ip_punt_drop.h:277
#define unformat_parse_error(input)
Definition: format.h:269
Definition: defs.h:47
void ip_punt_redirect_del(fib_protocol_t fproto, u32 rx_sw_if_index)
Definition: ip_punt_drop.c:107
void ip4_punt_redirect_add(u32 rx_sw_if_index, u32 tx_sw_if_index, ip46_address_t *nh)
void ip4_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
Definition: ip4_forward.c:1211
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
Definition: ip4_forward.c:1161
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
u16 flags
Copy of main node flags.
Definition: node.h:509
void ip4_punt_redirect_add_paths(u32 rx_sw_if_index, fib_route_path_t *rpaths)
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:302
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:772
VNET_FEATURE_ARC_INIT(ip4_punt)
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:275
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171