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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
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>
22 static format_function_t format_flow;
25 unformat_ip_port_and_mask (unformat_input_t * input, va_list * args)
27 ip_port_and_mask_t *pm = va_arg (*args, ip_port_and_mask_t *);
28 u32 port = 0, mask = 0;
30 if (unformat (input, "any"))
32 else if (unformat (input, "%u/%u", &port, &mask))
34 else if (unformat (input, "%u/0x%x", &port, &mask))
36 else if (unformat (input, "%u", &port))
41 if (port > 0xffff || mask > 0xffff)
50 format_ip_port_and_mask (u8 * s, va_list * args)
52 ip_port_and_mask_t *pm = va_arg (*args, ip_port_and_mask_t *);
54 if (pm->port == 0 && pm->mask == 0)
55 return format (s, "any");
57 if (pm->mask == 0xffff)
58 return format (s, "%u", pm->port);
60 return format (s, "%u/0x%x", pm->port, pm->mask);
64 format_flow_error (u8 * s, va_list * args)
66 int error = va_arg (*args, int);
69 return format (s, "no error");
71 #define _(v,n,str) if (error == v) return format (s, #str);
75 return format (s, "unknown error (%d)", error);
79 format_flow_actions (u8 * s, va_list * args)
81 u32 actions = va_arg (*args, u32);
84 #define _(a, b, c) if (actions & (1 << a)) \
85 t = format (t, "%s%s", t ? " ":"", c);
88 s = format (s, "%v", t);
94 format_flow_enabled_hw (u8 * s, va_list * args)
96 u32 flow_index = va_arg (*args, u32);
97 vnet_flow_t *f = vnet_get_flow (flow_index);
99 return format (s, "not found");
104 vnet_main_t *vnm = vnet_get_main ();
106 hash_foreach (hw_if_index, private_data, f->private_data,
108 t = format (t, "%s%U", t ? ", " : "",
109 format_vnet_hw_if_index_name, vnm, hw_if_index);
112 s = format (s, "%v", t);
117 static const char *flow_type_strings[] = { 0,
123 static clib_error_t *
124 show_flow_entry (vlib_main_t * vm, unformat_input_t * input,
125 vlib_cli_command_t * cmd_arg)
127 vnet_main_t *vnm = vnet_get_main ();
128 vnet_flow_main_t *fm = &flow_main;
129 unformat_input_t _line_input, *line_input = &_line_input;
130 vnet_hw_interface_t *hi;
131 vnet_device_class_t *dev_class;
134 u32 index = ~0, hw_if_index;
136 if (!unformat_user (input, unformat_line_input, line_input))
139 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
141 if (unformat (line_input, "index %u", &index))
144 return clib_error_return (0, "parse error: '%U'",
145 format_unformat_error, line_input);
148 unformat_free (line_input);
152 if ((f = vnet_get_flow (index)) == 0)
153 return clib_error_return (0, "no such flow");
155 vlib_cli_output (vm, "%-10s: %u", "index", f->index);
156 vlib_cli_output (vm, "%-10s: %s", "type", flow_type_strings[f->type]);
157 vlib_cli_output (vm, "%-10s: %U", "match", format_flow, f);
159 hash_foreach (hw_if_index, private_data, f->private_data,
161 hi = vnet_get_hw_interface (vnm, hw_if_index);
162 dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
163 vlib_cli_output (vm, "interface %U\n",
164 format_vnet_hw_if_index_name, vnm, hw_if_index);
165 if (dev_class->format_flow)
166 vlib_cli_output (vm, " %U\n", dev_class->format_flow,
167 hi->dev_instance, f->index, private_data);
175 pool_foreach (f, fm->global_flow_pool,
177 vlib_cli_output (vm, "%U\n", format_flow, f);
185 VLIB_CLI_COMMAND (show_flow_entry_command, static) = {
186 .path = "show flow entry",
187 .short_help = "show flow entry [index <index>]",
188 .function = show_flow_entry,
192 static clib_error_t *
193 show_flow_ranges (vlib_main_t * vm, unformat_input_t * input,
194 vlib_cli_command_t * cmd_arg)
196 vnet_flow_main_t *fm = &flow_main;
197 vnet_flow_range_t *r = 0;
199 vlib_cli_output (vm, "%8s %8s %s", "Start", "Count", "Owner");
202 vec_foreach (r, fm->ranges)
204 vlib_cli_output (vm, "%8u %8u %s", r->start, r->count, r->owner);
211 VLIB_CLI_COMMAND (show_flow_ranges_command, static) = {
212 .path = "show flow ranges",
213 .short_help = "show flow ranges",
214 .function = show_flow_ranges,
218 static clib_error_t *
219 show_flow_interface (vlib_main_t * vm, unformat_input_t * input,
220 vlib_cli_command_t * cmd_arg)
222 vnet_main_t *vnm = vnet_get_main ();
223 vnet_hw_interface_t *hi;
224 vnet_device_class_t *dev_class;
225 unformat_input_t _line_input, *line_input = &_line_input;
226 u32 hw_if_index = ~0;
228 if (unformat_user (input, unformat_line_input, line_input))
230 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
232 if (unformat (line_input, "%U",
233 unformat_vnet_hw_interface, vnm, &hw_if_index))
236 return clib_error_return (0, "parse error: '%U'",
237 format_unformat_error, line_input);
239 unformat_free (line_input);
242 if (hw_if_index == ~0)
243 return clib_error_return (0, "please specify interface");
245 hi = vnet_get_hw_interface (vnm, hw_if_index);
246 dev_class = vnet_get_device_class (vnm, hi->dev_class_index);
247 if (dev_class->format_flow == 0)
248 return clib_error_return (0, "not supported");
250 vlib_cli_output (vm, "%U", dev_class->format_flow, hi->dev_instance, ~0, 0);
255 VLIB_CLI_COMMAND (show_flow_interface_command, static) = {
256 .path = "show flow interface",
257 .short_help = "show flow interface <interface name>",
258 .function = show_flow_interface,
262 static clib_error_t *
263 test_flow (vlib_main_t * vm, unformat_input_t * input,
264 vlib_cli_command_t * cmd_arg)
267 vnet_main_t *vnm = vnet_get_main ();
268 unformat_input_t _line_input, *line_input = &_line_input;
276 } action = FLOW_UNKNOWN_ACTION;
277 u32 hw_if_index = ~0, flow_index = ~0;
279 u32 prot = 0, teid = 0, session_id = 0, spi = 0;
280 vnet_flow_type_t type = VNET_FLOW_TYPE_IP4_N_TUPLE;
281 bool is_gtpc_set = false;
282 bool is_gtpu_set = false;
283 bool is_l2tpv3oip_set = false;
284 bool is_ipsec_esp_set = false, is_ipsec_ah_set = false;
285 vnet_flow_type_t outer_type = VNET_FLOW_TYPE_UNKNOWN;
286 vnet_flow_type_t inner_type = VNET_FLOW_TYPE_UNKNOWN;
287 bool outer_ip4_set = false, inner_ip4_set = false;
288 bool outer_ip6_set = false, inner_ip6_set = false;
289 ip4_address_and_mask_t ip4s = { };
290 ip4_address_and_mask_t ip4d = { };
291 ip4_address_and_mask_t inner_ip4s = { };
292 ip4_address_and_mask_t inner_ip4d = { };
293 ip6_address_and_mask_t ip6s = { };
294 ip6_address_and_mask_t ip6d = { };
295 ip6_address_and_mask_t inner_ip6s = { };
296 ip6_address_and_mask_t inner_ip6d = { };
297 ip_port_and_mask_t sport = { };
298 ip_port_and_mask_t dport = { };
300 bool ethernet_set = false;
301 u8 *rss_type[3] = { };
304 clib_memset (&flow, 0, sizeof (vnet_flow_t));
307 flow.ip4_n_tuple.protocol = ~0;
308 if (!unformat_user (input, unformat_line_input, line_input))
311 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
313 if (unformat (line_input, "add"))
315 else if (unformat (line_input, "del"))
317 else if (unformat (line_input, "enable"))
318 action = FLOW_ENABLE;
319 else if (unformat (line_input, "disable"))
320 action = FLOW_DISABLE;
321 else if (unformat (line_input, "eth-type %U",
322 unformat_ethernet_type_host_byte_order, ð_type))
324 else if (unformat (line_input, "src-ip %U",
325 unformat_ip4_address_and_mask, &ip4s))
326 outer_ip4_set = true;
327 else if (unformat (line_input, "dst-ip %U",
328 unformat_ip4_address_and_mask, &ip4d))
329 outer_ip4_set = true;
330 else if (unformat (line_input, "ip6-src-ip %U",
331 unformat_ip6_address_and_mask, &ip6s))
332 outer_ip6_set = true;
333 else if (unformat (line_input, "ip6-dst-ip %U",
334 unformat_ip6_address_and_mask, &ip6d))
335 outer_ip6_set = true;
336 else if (unformat (line_input, "inner-src-ip %U",
337 unformat_ip4_address_and_mask, &inner_ip4s))
338 inner_ip4_set = true;
339 else if (unformat (line_input, "inner-dst-ip %U",
340 unformat_ip4_address_and_mask, &inner_ip4d))
341 inner_ip4_set = true;
342 else if (unformat (line_input, "inner-ip6-src-ip %U",
343 unformat_ip6_address_and_mask, &inner_ip6s))
344 inner_ip6_set = true;
345 else if (unformat (line_input, "inner-ip6-dst-ip %U",
346 unformat_ip6_address_and_mask, &inner_ip6d))
347 inner_ip6_set = true;
348 else if (unformat (line_input, "src-port %U", unformat_ip_port_and_mask,
351 else if (unformat (line_input, "dst-port %U", unformat_ip_port_and_mask,
354 else if (unformat (line_input, "proto %U", unformat_ip_protocol, &prot))
356 else if (unformat (line_input, "proto %u", &prot))
358 else if (unformat (line_input, "gtpc teid %u", &teid))
360 else if (unformat (line_input, "gtpu teid %u", &teid))
362 else if (unformat (line_input, "session id %u", &session_id))
364 if (prot == IP_PROTOCOL_L2TP)
365 is_l2tpv3oip_set = true;
367 else if (unformat (line_input, "spi %u", &spi))
369 if (prot == IP_PROTOCOL_IPSEC_ESP)
370 is_ipsec_esp_set = true;
371 else if (prot == IP_PROTOCOL_IPSEC_AH)
372 is_ipsec_ah_set = true;
374 else if (unformat (line_input, "index %u", &flow_index))
376 else if (unformat (line_input, "next-node %U", unformat_vlib_node, vm,
377 &flow.redirect_node_index))
378 flow.actions |= VNET_FLOW_ACTION_REDIRECT_TO_NODE;
379 else if (unformat (line_input, "mark %d", &flow.mark_flow_id))
380 flow.actions |= VNET_FLOW_ACTION_MARK;
381 else if (unformat (line_input, "buffer-advance %d",
382 &flow.buffer_advance))
383 flow.actions |= VNET_FLOW_ACTION_BUFFER_ADVANCE;
384 else if (unformat (line_input, "redirect-to-queue %d",
385 &flow.redirect_queue))
386 flow.actions |= VNET_FLOW_ACTION_REDIRECT_TO_QUEUE;
387 else if (unformat (line_input, "drop"))
388 flow.actions |= VNET_FLOW_ACTION_DROP;
389 else if (unformat (line_input, "rss function"))
395 else if (unformat (line_input, s)) \
396 flow.rss_fun = VNET_RSS_FUNC_##f;
402 return clib_error_return (0, "unknown input `%U'",
403 format_unformat_error, line_input);
406 flow.actions |= VNET_FLOW_ACTION_RSS;
408 else if (unformat (line_input, "rss types"))
415 if (unformat (line_input, "%s use %s and %s",
416 &rss_type[0], &rss_type[1], &rss_type[2]))
420 (line_input, "%s use %s", &rss_type[0], &rss_type[1]))
422 else if (unformat (line_input, "%s", &rss_type[0]))
427 else if (!clib_strcmp(c, (const char *)type_str)) \
428 flow.rss_types |= (1ULL<<a);
430 #define check_rss_types(_str) \
435 foreach_flow_rss_types \
438 return clib_error_return (0, "parse error: '%U'", \
439 format_unformat_error, line_input); \
443 check_rss_types (rss_type[0])
444 check_rss_types (rss_type[1]) check_rss_types (rss_type[2])
446 flow.actions |= VNET_FLOW_ACTION_RSS;
448 else if (unformat (line_input, "%U", unformat_vnet_hw_interface, vnm,
452 return clib_error_return (0, "parse error: '%U'",
453 format_unformat_error, line_input);
456 unformat_free (line_input);
458 if (hw_if_index == ~0 && (action == FLOW_ENABLE || action == FLOW_DISABLE))
459 return clib_error_return (0, "Please specify interface name");
461 if (flow_index == ~0 && (action == FLOW_ENABLE || action == FLOW_DISABLE ||
463 return clib_error_return (0, "Please specify flow index");
468 if (flow.actions == 0)
469 return clib_error_return (0, "Please specify at least one action");
471 /* Adjust the flow type */
472 if (ethernet_set == true)
473 outer_type = VNET_FLOW_TYPE_ETHERNET;
474 if (outer_ip4_set == true)
475 outer_type = VNET_FLOW_TYPE_IP4_N_TUPLE;
476 else if (outer_ip6_set == true)
477 outer_type = VNET_FLOW_TYPE_IP6_N_TUPLE;
478 if (inner_ip4_set == true)
479 inner_type = VNET_FLOW_TYPE_IP4_N_TUPLE;
480 else if (inner_ip6_set == true)
481 inner_type = VNET_FLOW_TYPE_IP6_N_TUPLE;
483 if (outer_type == VNET_FLOW_TYPE_UNKNOWN)
484 return clib_error_return (0, "Please specify a supported flow type");
486 if (outer_type == VNET_FLOW_TYPE_ETHERNET)
487 type = VNET_FLOW_TYPE_ETHERNET;
488 else if (outer_type == VNET_FLOW_TYPE_IP4_N_TUPLE)
490 type = VNET_FLOW_TYPE_IP4_N_TUPLE;
492 if (inner_type == VNET_FLOW_TYPE_UNKNOWN)
495 type = VNET_FLOW_TYPE_IP4_GTPC;
496 else if (is_gtpu_set)
497 type = VNET_FLOW_TYPE_IP4_GTPU;
498 else if (is_l2tpv3oip_set)
499 type = VNET_FLOW_TYPE_IP4_L2TPV3OIP;
500 else if (is_ipsec_esp_set)
501 type = VNET_FLOW_TYPE_IP4_IPSEC_ESP;
502 else if (is_ipsec_ah_set)
503 type = VNET_FLOW_TYPE_IP4_IPSEC_AH;
505 else if (inner_type == VNET_FLOW_TYPE_IP4_N_TUPLE)
508 type = VNET_FLOW_TYPE_IP4_GTPU_IP4;
510 else if (inner_type == VNET_FLOW_TYPE_IP6_N_TUPLE)
513 type = VNET_FLOW_TYPE_IP4_GTPU_IP6;
516 else if (outer_type == VNET_FLOW_TYPE_IP6_N_TUPLE)
518 type = VNET_FLOW_TYPE_IP6_N_TUPLE;
520 if (inner_type == VNET_FLOW_TYPE_UNKNOWN)
523 type = VNET_FLOW_TYPE_IP6_GTPC;
524 else if (is_gtpu_set)
525 type = VNET_FLOW_TYPE_IP6_GTPU;
527 else if (inner_type == VNET_FLOW_TYPE_IP4_N_TUPLE)
530 type = VNET_FLOW_TYPE_IP6_GTPU_IP4;
532 else if (inner_type == VNET_FLOW_TYPE_IP6_N_TUPLE)
535 type = VNET_FLOW_TYPE_IP6_GTPU_IP6;
539 //assign specific field values per flow type
542 case VNET_FLOW_TYPE_ETHERNET:
543 memset (&flow.ethernet, 0, sizeof (flow.ethernet));
544 flow.ethernet.eth_hdr.type = eth_type;
546 case VNET_FLOW_TYPE_IP4_L2TPV3OIP:
547 clib_memcpy (&flow.ip4_l2tpv3oip.src_addr, &ip4s,
548 sizeof (ip4_address_and_mask_t));
549 clib_memcpy (&flow.ip4_l2tpv3oip.dst_addr, &ip4d,
550 sizeof (ip4_address_and_mask_t));
551 flow.ip4_l2tpv3oip.protocol = prot;
552 flow.ip4_l2tpv3oip.session_id = session_id;
554 case VNET_FLOW_TYPE_IP4_IPSEC_ESP:
555 clib_memcpy (&flow.ip4_ipsec_esp.src_addr, &ip4s,
556 sizeof (ip4_address_and_mask_t));
557 clib_memcpy (&flow.ip4_ipsec_esp.dst_addr, &ip4d,
558 sizeof (ip4_address_and_mask_t));
559 flow.ip4_ipsec_esp.protocol = prot;
560 flow.ip4_ipsec_esp.spi = spi;
562 case VNET_FLOW_TYPE_IP4_IPSEC_AH:
563 clib_memcpy (&flow.ip4_ipsec_ah.src_addr, &ip4s,
564 sizeof (ip4_address_and_mask_t));
565 clib_memcpy (&flow.ip4_ipsec_ah.dst_addr, &ip4d,
566 sizeof (ip4_address_and_mask_t));
567 flow.ip4_ipsec_ah.protocol = prot;
568 flow.ip4_ipsec_ah.spi = spi;
570 case VNET_FLOW_TYPE_IP4_N_TUPLE:
571 case VNET_FLOW_TYPE_IP4_GTPC:
572 case VNET_FLOW_TYPE_IP4_GTPU:
573 case VNET_FLOW_TYPE_IP4_GTPU_IP4:
574 case VNET_FLOW_TYPE_IP4_GTPU_IP6:
575 clib_memcpy (&flow.ip4_n_tuple.src_addr, &ip4s,
576 sizeof (ip4_address_and_mask_t));
577 clib_memcpy (&flow.ip4_n_tuple.dst_addr, &ip4d,
578 sizeof (ip4_address_and_mask_t));
579 clib_memcpy (&flow.ip4_n_tuple.src_port, &sport,
580 sizeof (ip_port_and_mask_t));
581 clib_memcpy (&flow.ip4_n_tuple.dst_port, &dport,
582 sizeof (ip_port_and_mask_t));
583 flow.ip4_n_tuple.protocol = prot;
585 if (type == VNET_FLOW_TYPE_IP4_GTPC)
586 flow.ip4_gtpc.teid = teid;
587 else if (type == VNET_FLOW_TYPE_IP4_GTPU)
588 flow.ip4_gtpu.teid = teid;
589 else if (type == VNET_FLOW_TYPE_IP4_GTPU_IP4)
591 flow.ip4_gtpu_ip4.teid = teid;
592 clib_memcpy (&flow.ip4_gtpu_ip4.inner_src_addr, &inner_ip4s,
593 sizeof (ip4_address_and_mask_t));
594 clib_memcpy (&flow.ip4_gtpu_ip4.inner_dst_addr, &inner_ip4d,
595 sizeof (ip4_address_and_mask_t));
597 else if (type == VNET_FLOW_TYPE_IP4_GTPU_IP6)
599 flow.ip4_gtpu_ip6.teid = teid;
600 clib_memcpy (&flow.ip4_gtpu_ip6.inner_src_addr, &inner_ip6s,
601 sizeof (ip6_address_and_mask_t));
602 clib_memcpy (&flow.ip4_gtpu_ip6.inner_dst_addr, &inner_ip6d,
603 sizeof (ip6_address_and_mask_t));
606 if (flow.ip4_n_tuple.protocol == (ip_protocol_t) ~ 0)
607 return clib_error_return (0, "Please specify ip protocol");
608 if ((type != VNET_FLOW_TYPE_IP4_N_TUPLE) &&
609 (flow.ip4_n_tuple.protocol != IP_PROTOCOL_UDP))
610 return clib_error_return (0,
611 "For GTP related flow, ip protocol must be UDP");
614 case VNET_FLOW_TYPE_IP6_N_TUPLE:
615 case VNET_FLOW_TYPE_IP6_GTPC:
616 case VNET_FLOW_TYPE_IP6_GTPU:
617 case VNET_FLOW_TYPE_IP6_GTPU_IP4:
618 case VNET_FLOW_TYPE_IP6_GTPU_IP6:
619 clib_memcpy (&flow.ip6_n_tuple.src_addr, &ip6s,
620 sizeof (ip6_address_and_mask_t));
621 clib_memcpy (&flow.ip6_n_tuple.dst_addr, &ip6d,
622 sizeof (ip6_address_and_mask_t));
623 clib_memcpy (&flow.ip6_n_tuple.src_port, &sport,
624 sizeof (ip_port_and_mask_t));
625 clib_memcpy (&flow.ip6_n_tuple.dst_port, &dport,
626 sizeof (ip_port_and_mask_t));
627 flow.ip6_n_tuple.protocol = prot;
629 if (type == VNET_FLOW_TYPE_IP6_GTPC)
630 flow.ip6_gtpc.teid = teid;
631 else if (type == VNET_FLOW_TYPE_IP6_GTPU)
632 flow.ip6_gtpu.teid = teid;
633 else if (type == VNET_FLOW_TYPE_IP6_GTPU_IP4)
635 flow.ip6_gtpu_ip4.teid = teid;
636 clib_memcpy (&flow.ip6_gtpu_ip4.inner_src_addr, &inner_ip4s,
637 sizeof (ip4_address_and_mask_t));
638 clib_memcpy (&flow.ip6_gtpu_ip4.inner_dst_addr, &inner_ip4d,
639 sizeof (ip4_address_and_mask_t));
641 else if (type == VNET_FLOW_TYPE_IP6_GTPU_IP6)
643 flow.ip6_gtpu_ip6.teid = teid;
644 clib_memcpy (&flow.ip6_gtpu_ip6.inner_src_addr, &inner_ip6s,
645 sizeof (ip6_address_and_mask_t));
646 clib_memcpy (&flow.ip6_gtpu_ip6.inner_dst_addr, &inner_ip6d,
647 sizeof (ip6_address_and_mask_t));
650 if (flow.ip6_n_tuple.protocol == (ip_protocol_t) ~ 0)
651 return clib_error_return (0, "Please specify ip protocol");
652 if ((type != VNET_FLOW_TYPE_IP6_N_TUPLE) &&
653 (flow.ip6_n_tuple.protocol != IP_PROTOCOL_UDP))
654 return clib_error_return (0,
655 "For GTP related flow, ip protocol must be UDP");
663 rv = vnet_flow_add (vnm, &flow, &flow_index);
665 printf ("flow %u added\n", flow_index);
669 rv = vnet_flow_del (vnm, flow_index);
672 rv = vnet_flow_enable (vnm, flow_index, hw_if_index);
675 rv = vnet_flow_disable (vnm, flow_index, hw_if_index);
678 return clib_error_return (0, "please specify action (add, del, enable,"
683 return clib_error_return (0, "flow error: %U", format_flow_error, rv);
688 VLIB_CLI_COMMAND (test_flow_command, static) = {
690 .short_help = "test flow add [src-ip <ip-addr/mask>] [dst-ip "
691 "<ip-addr/mask>] [src-port <port/mask>] [dst-port <port/mask>] "
693 .function = test_flow,
699 format_flow_match_element (u8 * s, va_list * args)
701 char *type = va_arg (*args, char *);
702 void *ptr = va_arg (*args, void *);
704 if (strncmp (type, "u8", 2) == 0)
705 return format (s, "%d", *(u8 *) ptr);
707 if (strncmp (type, "u16", 3) == 0)
708 return format (s, "%d", *(u16 *) ptr);
710 if (strncmp (type, "u32", 3) == 0)
711 return format (s, "%d", *(u32 *) ptr);
713 if (strncmp (type, "ip4_address_t", 13) == 0)
714 return format (s, "%U", format_ip4_address, ptr);
716 if (strncmp (type, "ip4_address_and_mask_t", 13) == 0)
717 return format (s, "%U", format_ip4_address_and_mask, ptr);
719 if (strncmp (type, "ip6_address_t", 13) == 0)
720 return format (s, "%U", format_ip6_address, ptr);
722 if (strncmp (type, "ip6_address_and_mask_t", 13) == 0)
723 return format (s, "%U", format_ip6_address_and_mask, ptr);
725 if (strncmp (type, "ip_protocol_t", 13) == 0)
726 return format (s, "%U", format_ip_protocol, *(ip_protocol_t *) ptr);
728 if (strncmp (type, "ip_port_and_mask_t", 18) == 0)
729 return format (s, "%U", format_ip_port_and_mask, ptr);
731 s = format (s, "unknown type '%s'", type);
735 #define _fe(a,b) s2 = format (s2, "%s%s %U", s2 ? ", ":"", #b, \
736 format_flow_match_element, #a, &f->b);
738 u8 * format_flow_match_##b (u8 * s, va_list * args) \
740 vnet_flow_##b##_t *f = __builtin_va_arg (*args, vnet_flow_##b##_t *); \
742 foreach_flow_entry_##b \
743 s = format (s, "%v", s2);; \
751 format_flow_match (u8 * s, va_list * args)
753 vnet_flow_t *f = va_arg (*args, vnet_flow_t *);
756 if (f->type == VNET_FLOW_TYPE_##a) \
757 return format (s, "%U", format_flow_match_##b, &f->b);
765 format_flow (u8 * s, va_list * args)
767 vlib_main_t *vm = vlib_get_main ();
768 vnet_flow_t *f = va_arg (*args, vnet_flow_t *);
769 u32 indent = format_get_indent (s);
772 s = format (s, "flow-index %u type %s active %u",
773 f->index, flow_type_strings[f->type],
774 hash_elts (f->private_data)),
775 s = format (s, "\n%Umatch: %U", format_white_space, indent + 2,
776 format_flow_match, f);
777 s = format (s, "\n%Uaction: %U", format_white_space, indent + 2,
778 format_flow_actions, f->actions);
780 if (f->actions & VNET_FLOW_ACTION_MARK)
781 t = format (t, "%smark %u", t ? ", " : "", f->mark_flow_id);
783 if (f->actions & VNET_FLOW_ACTION_REDIRECT_TO_NODE)
784 t = format (t, "%snext-node %U", t ? ", " : "",
785 format_vlib_node_name, vm, f->redirect_node_index);
787 if (f->actions & VNET_FLOW_ACTION_BUFFER_ADVANCE)
788 t = format (t, "%sbuffer-advance %d", t ? ", " : "", f->buffer_advance);
792 s = format (s, "\n%U%v", format_white_space, indent + 4, t);
800 * fd.io coding-style-patch-verification: ON
803 * eval: (c-set-style "gnu")