blob: 11f3bcfad97bb847233569b0dd06c8828fff2aae [file] [log] [blame]
Damjan Mariona35cc142018-03-16 01:25:27 +01001/*
2 * Copyright (c) 2018 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/vnet.h>
17#include <vnet/devices/devices.h>
18#include <vnet/ip/ip.h>
19#include <vnet/ethernet/ethernet.h>
20#include <vnet/flow/flow.h>
21
22static format_function_t format_flow;
23
24uword
25unformat_ip_port_and_mask (unformat_input_t * input, va_list * args)
26{
27 ip_port_and_mask_t *pm = va_arg (*args, ip_port_and_mask_t *);
28 u32 port = 0, mask = 0;
29
30 if (unformat (input, "any"))
31 ;
32 else if (unformat (input, "%u/%u", &port, &mask))
33 ;
34 else if (unformat (input, "%u/0x%x", &port, &mask))
35 ;
36 else if (unformat (input, "%u", &port))
37 mask = 0xffff;
38 else
39 return 0;
40
41 if (port > 0xffff || mask > 0xffff)
42 return 0;
43
44 pm->port = port;
45 pm->mask = mask;
46 return 1;
47}
48
49u8 *
50format_ip_port_and_mask (u8 * s, va_list * args)
51{
52 ip_port_and_mask_t *pm = va_arg (*args, ip_port_and_mask_t *);
53
54 if (pm->port == 0 && pm->mask == 0)
55 return format (s, "any");
56
57 if (pm->mask == 0xffff)
58 return format (s, "%u", pm->port);
59
60 return format (s, "%u/0x%x", pm->port, pm->mask);
61}
62
63u8 *
64format_flow_error (u8 * s, va_list * args)
65{
66 int error = va_arg (*args, int);
67
68 if (error == 0)
69 return format (s, "no error");
70
71#define _(v,n,str) if (error == v) return format (s, #str);
72 foreach_flow_error;
73#undef _
74
75 return format (s, "unknown error (%d)", error);
76}
77
78u8 *
79format_flow_actions (u8 * s, va_list * args)
80{
81 u32 actions = va_arg (*args, u32);
82 u8 *t = 0;
83
84#define _(a, b, c) if (actions & (1 << a)) \
85 t = format (t, "%s%s", t ? " ":"", c);
86 foreach_flow_action
87#undef _
88 s = format (s, "%v", t);
89 vec_free (t);
90 return s;
91}
92
93static const char *flow_type_strings[] = { 0,
94#define _(a,b,c) c,
95 foreach_flow_type
96#undef _
97};
98
99static clib_error_t *
100show_flow_entry (vlib_main_t * vm, unformat_input_t * input,
101 vlib_cli_command_t * cmd_arg)
102{
103 vnet_main_t *vnm = vnet_get_main ();
104 vnet_flow_main_t *fm = &flow_main;
105 unformat_input_t _line_input, *line_input = &_line_input;
106 vnet_hw_interface_t *hi;
107 vnet_device_class_t *dev_class;
108 vnet_flow_t *f;
109 uword private_data;
110 u32 index = ~0, hw_if_index;
111
112 if (!unformat_user (input, unformat_line_input, line_input))
113 goto no_args;
114
115 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
116 {
117 if (unformat (line_input, "index %u", &index))
118 ;
119 else
120 return clib_error_return (0, "parse error: '%U'",
121 format_unformat_error, line_input);
122 }
123
124 unformat_free (line_input);
125
126 if (index != ~0)
127 {
128 if ((f = vnet_get_flow (index)) == 0)
129 return clib_error_return (0, "no such flow");
130
131 vlib_cli_output (vm, "%-10s: %u", "index", f->index);
132 vlib_cli_output (vm, "%-10s: %s", "type", flow_type_strings[f->type]);
133 vlib_cli_output (vm, "%-10s: %U", "match", format_flow, f);
134 /* *INDENT-OFF* */
135 hash_foreach (hw_if_index, private_data, f->private_data,
136 ({
137 hi = vnet_get_hw_interface (vnm, hw_if_index);
138 dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
139 vlib_cli_output (vm, "interface %U\n",
140 format_vnet_hw_if_index_name, vnm, hw_if_index);
141 if (dev_class->format_flow)
142 vlib_cli_output (vm, " %U\n", dev_class->format_flow,
143 hi->dev_instance, f->index, private_data);
144 }));
145 /* *INDENT-ON* */
146 return 0;
147 }
148
149no_args:
150 /* *INDENT-OFF* */
151 pool_foreach (f, fm->global_flow_pool,
152 {
153 vlib_cli_output (vm, "%U\n", format_flow, f);
154 });
155 /* *INDENT-ON* */
156
157 return 0;
158}
159
160/* *INDENT-OFF* */
161VLIB_CLI_COMMAND (show_flow_entry_command, static) = {
162 .path = "show flow entry",
163 .short_help = "show flow entry [index <index>]",
164 .function = show_flow_entry,
165};
166/* *INDENT-ON* */
167
168static clib_error_t *
169show_flow_ranges (vlib_main_t * vm, unformat_input_t * input,
170 vlib_cli_command_t * cmd_arg)
171{
172 vnet_flow_main_t *fm = &flow_main;
173 vnet_flow_range_t *r = 0;
174
175 vlib_cli_output (vm, "%8s %8s %s", "Start", "Count", "Owner");
176
177 /* *INDENT-OFF* */
178 vec_foreach (r, fm->ranges)
179 {
180 vlib_cli_output (vm, "%8u %8u %s", r->start, r->count, r->owner);
181 };
182 /* *INDENT-ON* */
183 return 0;
184}
185
186/* *INDENT-OFF* */
187VLIB_CLI_COMMAND (show_flow_ranges_command, static) = {
188 .path = "show flow ranges",
189 .short_help = "show flow ranges",
190 .function = show_flow_ranges,
191};
192/* *INDENT-ON* */
193
194static clib_error_t *
195show_flow_interface (vlib_main_t * vm, unformat_input_t * input,
196 vlib_cli_command_t * cmd_arg)
197{
198 vnet_main_t *vnm = vnet_get_main ();
199 vnet_hw_interface_t *hi;
200 vnet_device_class_t *dev_class;
201 unformat_input_t _line_input, *line_input = &_line_input;
202 u32 hw_if_index = ~0;
203
204 if (unformat_user (input, unformat_line_input, line_input))
205 {
206 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
207 {
208 if (unformat (line_input, "%U",
209 unformat_vnet_hw_interface, vnm, &hw_if_index))
210 ;
211 else
212 return clib_error_return (0, "parse error: '%U'",
213 format_unformat_error, line_input);
214 }
215 unformat_free (line_input);
216 }
217
218 if (hw_if_index == ~0)
219 return clib_error_return (0, "please specify interface");
220
221 hi = vnet_get_hw_interface (vnm, hw_if_index);
222 dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
223 if (dev_class->format_flow == 0)
224 return clib_error_return (0, "not supported");
225
226 vlib_cli_output (vm, "%U", dev_class->format_flow, hi->dev_instance, ~0, 0);
227 return 0;
228}
229
230/* *INDENT-OFF* */
231VLIB_CLI_COMMAND (show_flow_interface_command, static) = {
232 .path = "show flow interface",
233 .short_help = "show flow interface <interface name>",
234 .function = show_flow_interface,
235};
236/* *INDENT-ON* */
237
238static clib_error_t *
239test_flow (vlib_main_t * vm, unformat_input_t * input,
240 vlib_cli_command_t * cmd_arg)
241{
242 vnet_flow_t flow;
243 vnet_main_t *vnm = vnet_get_main ();
244 unformat_input_t _line_input, *line_input = &_line_input;
245 enum
246 {
247 FLOW_UNKNOWN_ACTION,
248 FLOW_ADD,
249 FLOW_DEL,
250 FLOW_ENABLE,
251 FLOW_DISABLE
252 } action = FLOW_UNKNOWN_ACTION;
253 u32 hw_if_index = ~0, tmp, flow_index = ~0;
254 int rv;
255 u8 prot;
256
257 memset (&flow, 0, sizeof (vnet_flow_t));
258 flow.index = ~0;
259 flow.actions = 0;
260 flow.ip4_n_tuple.protocol = ~0;
261 if (!unformat_user (input, unformat_line_input, line_input))
262 return 0;
263
264 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
265 {
266 if (unformat (line_input, "add"))
267 action = FLOW_ADD;
268 else if (unformat (line_input, "del"))
269 action = FLOW_DEL;
270 else if (unformat (line_input, "enable"))
271 action = FLOW_ENABLE;
272 else if (unformat (line_input, "disable"))
273 action = FLOW_DISABLE;
274 else if (unformat (line_input, "src-ip %U",
275 unformat_ip4_address_and_mask,
276 &flow.ip4_n_tuple.src_addr))
277 ;
278 else if (unformat (line_input, "dst-ip %U",
279 unformat_ip4_address_and_mask,
280 &flow.ip4_n_tuple.dst_addr))
281 ;
282 else if (unformat (line_input, "src-port %U", unformat_ip_port_and_mask,
283 &flow.ip4_n_tuple.src_port))
284 ;
285 else if (unformat (line_input, "dst-port %U", unformat_ip_port_and_mask,
286 &flow.ip4_n_tuple.dst_port))
287 ;
288 else if (unformat (line_input, "proto %U", unformat_ip_protocol, &prot))
289 flow.ip4_n_tuple.protocol = prot;
290 else if (unformat (line_input, "proto %u", &tmp))
291 flow.ip4_n_tuple.protocol = tmp;
292 else if (unformat (line_input, "index %u", &flow_index))
293 ;
294 else if (unformat (line_input, "next-node %U", unformat_vlib_node, vm,
295 &flow.redirect_node_index))
296 flow.actions |= VNET_FLOW_ACTION_REDIRECT_TO_NODE;
297 else if (unformat (line_input, "mark %d", &flow.mark_flow_id))
298 flow.actions |= VNET_FLOW_ACTION_MARK;
299 else if (unformat (line_input, "buffer-advance %d",
300 &flow.buffer_advance))
301 flow.actions |= VNET_FLOW_ACTION_BUFFER_ADVANCE;
302 else if (unformat (line_input, "%U", unformat_vnet_hw_interface, vnm,
303 &hw_if_index))
304 ;
305 else
306 return clib_error_return (0, "parse error: '%U'",
307 format_unformat_error, line_input);
308 }
309
310 unformat_free (line_input);
311
312 if (hw_if_index == ~0 && (action == FLOW_ENABLE || action == FLOW_DISABLE))
313 return clib_error_return (0, "Please specify interface name");
314
315 if (flow_index == ~0 && (action == FLOW_ENABLE || action == FLOW_DISABLE ||
316 action == FLOW_DEL))
317 return clib_error_return (0, "Please specify flow index");
318
319 switch (action)
320 {
321 case FLOW_ADD:
322 if (flow.ip4_n_tuple.protocol == (ip_protocol_t) ~ 0)
323 return clib_error_return (0, "Please specify ip protocol");
324
325 if (flow.actions == 0)
326 return clib_error_return (0, "Please specify at least one action");
327 flow.type = VNET_FLOW_TYPE_IP4_N_TUPLE;
328 rv = vnet_flow_add (vnm, &flow, &flow_index);
329 break;
330 case FLOW_DEL:
331 rv = vnet_flow_del (vnm, flow_index);
332 break;
333 case FLOW_ENABLE:
334 rv = vnet_flow_enable (vnm, flow_index, hw_if_index);
335 break;
336 case FLOW_DISABLE:
337 rv = vnet_flow_disable (vnm, flow_index, hw_if_index);
338 break;
339 default:
340 return clib_error_return (0, "please specify action (add, del, enable,"
341 " disable)");
342 }
343
344 if (rv < 0)
345 return clib_error_return (0, "flow error: %U", format_flow_error, rv);
346 return 0;
347}
348
349/* *INDENT-OFF* */
350VLIB_CLI_COMMAND (test_flow_command, static) = {
351 .path = "test flow",
352 .short_help = "test flow add [src-ip <ip-addr/mask>] [dst-ip "
353 "<ip-addr/mask>] [src-port <port/mask>] [dst-port <port/mask>] "
354 "[proto <ip-proto>",
355 .function = test_flow,
356};
357/* *INDENT-ON* */
358
359
360static u8 *
361format_flow_match_element (u8 * s, va_list * args)
362{
363 char *type = va_arg (*args, char *);
364 void *ptr = va_arg (*args, void *);
365
366 if (strncmp (type, "u8", 2) == 0)
367 return format (s, "%d", *(u8 *) ptr);
368
369 if (strncmp (type, "u16", 3) == 0)
370 return format (s, "%d", *(u16 *) ptr);
371
372 if (strncmp (type, "u32", 3) == 0)
373 return format (s, "%d", *(u32 *) ptr);
374
375 if (strncmp (type, "ip4_address_t", 13) == 0)
376 return format (s, "%U", format_ip4_address, ptr);
377
378 if (strncmp (type, "ip4_address_and_mask_t", 13) == 0)
379 return format (s, "%U", format_ip4_address_and_mask, ptr);
380
381 if (strncmp (type, "ip6_address_t", 13) == 0)
382 return format (s, "%U", format_ip6_address, ptr);
383
384 if (strncmp (type, "ip6_address_and_mask_t", 13) == 0)
385 return format (s, "%U", format_ip6_address_and_mask, ptr);
386
387 if (strncmp (type, "ip_protocol_t", 13) == 0)
388 return format (s, "%U", format_ip_protocol, *(ip_protocol_t *) ptr);
389
390 if (strncmp (type, "ip_port_and_mask_t", 18) == 0)
391 return format (s, "%U", format_ip_port_and_mask, ptr);
392
393 s = format (s, "unknown type '%s'", type);
394 return s;
395}
396
397#define _fe(a,b) s2 = format (s2, "%s%s %U", s2 ? ", ":"", #b, \
398 format_flow_match_element, #a, &f->b);
399#define _(a,b,c) \
400u8 * format_flow_match_##b (u8 * s, va_list * args) \
401{ \
402 vnet_flow_##b##_t *f = __builtin_va_arg (*args, vnet_flow_##b##_t *); \
403 u8 *s2 = 0; \
404foreach_flow_entry_##b \
405 s = format (s, "%v", s2);; \
406 vec_free (s2); \
407return s; \
408}
409foreach_flow_type
410#undef _
411#undef _fe
412static u8 *
413format_flow_match (u8 * s, va_list * args)
414{
415 vnet_flow_t *f = va_arg (*args, vnet_flow_t *);
416
417#define _(a,b,c) \
418 if (f->type == VNET_FLOW_TYPE_##a) \
419 return format (s, "%U", format_flow_match_##b, &f->b);
420 foreach_flow_type;
421#undef _
422
423 return s;
424}
425
426static u8 *
427format_flow (u8 * s, va_list * args)
428{
429 vlib_main_t *vm = vlib_get_main ();
430 vnet_flow_t *f = va_arg (*args, vnet_flow_t *);
431 u32 indent = format_get_indent (s);
432 u8 *t = 0;
433
434 s = format (s, "flow-index %u type %s active %u",
435 f->index, flow_type_strings[f->type],
436 hash_elts (f->private_data)),
437 s = format (s, "\n%Umatch: %U", format_white_space, indent + 2,
438 format_flow_match, f);
439 s = format (s, "\n%Uaction: %U", format_white_space, indent + 2,
440 format_flow_actions, f->actions);
441
442 if (f->actions & VNET_FLOW_ACTION_MARK)
443 t = format (t, "%smark %u", t ? ", " : "", f->mark_flow_id);
444
445 if (f->actions & VNET_FLOW_ACTION_REDIRECT_TO_NODE)
446 t = format (t, "%snext-node %U", t ? ", " : "",
447 format_vlib_node_name, vm, f->redirect_node_index);
448
449 if (f->actions & VNET_FLOW_ACTION_BUFFER_ADVANCE)
450 t = format (t, "%sbuffer-advance %d", t ? ", " : "", f->buffer_advance);
451
452 if (t)
453 {
454 s = format (s, "\n%U%v", format_white_space, indent + 4, t);
455 vec_free (t);
456 }
457
458 return s;
459}
460
461/*
462 * fd.io coding-style-patch-verification: ON
463 *
464 * Local Variables:
465 * eval: (c-set-style "gnu")
466 * End:
467 */