Commands are added which can be used to test adding or deleting 8 flow
types of the flow director filters: ipv4, tcpv4, udpv4, sctpv4,
ipv6, tcpv6, udpv6, sctpv6.
Signed-off-by: Jingjing Wu <jingjing.wu at intel.com>
---
app/test-pmd/cmdline.c | 447 +++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 447 insertions(+)
diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 47162e9..bfa7656 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -678,6 +678,28 @@ static void cmd_help_long_parsed(void *parsed_result,
"get_flex_filter (port_id) index (idx)\n"
" get info of a flex filter.\n\n"
+
+ "flow_director_filter (port_id) (add|del|update)"
+ " flow (ip4|ip6) src (src_ip_address) dst
(dst_ip_address)"
+ " flexwords (flexwords_value)"
+ " (drop|fwd) queue (queue_id) fd_id (fd_id_value)\n"
+ " Add/Del an IP type flow director filter.\n\n"
+
+ "flow_director_filter (port_id) (add|del|update)"
+ " flow (udp4|tcp4|udp6|tcp6)"
+ " src (src_ip_address) (src_port)"
+ " dst (dst_ip_address) (dst_port)"
+ " flexwords (flexwords_value)"
+ " (drop|fwd) queue (queue_id) fd_id (fd_id_value)\n"
+ " Add/Del an UDP/TCP type flow director filter.\n\n"
+
+ "flow_director_filter (port_id) (add|del|update)"
+ " flow (sctp4|sctp6)"
+ " src (src_ip_address) dst (dst_ip_address)"
+ " tag (verification_tag)"
+ " flexwords (flexwords_value) (drop|fwd)"
+ " queue (queue_id) fd_id (fd_id_value)\n"
+ " Add/Del a SCTP type flow director filter.\n\n"
);
}
}
@@ -7633,6 +7655,428 @@ cmdline_parse_inst_t cmd_get_flex_filter = {
},
};
+/* *** Filters Control *** */
+
+/* *** deal with flow director filter *** */
+struct cmd_flow_director_result {
+ cmdline_fixed_string_t flow_director_filter;
+ uint8_t port_id;
+ cmdline_fixed_string_t ops;
+ cmdline_fixed_string_t flow;
+ cmdline_fixed_string_t flow_type;
+ cmdline_fixed_string_t src;
+ cmdline_ipaddr_t ip_src;
+ uint16_t port_src;
+ cmdline_fixed_string_t dst;
+ cmdline_ipaddr_t ip_dst;
+ uint16_t port_dst;
+ cmdline_fixed_string_t verify_tag;
+ uint32_t verify_tag_value;
+ cmdline_fixed_string_t flexwords;
+ cmdline_fixed_string_t flexwords_value;
+ cmdline_fixed_string_t drop;
+ cmdline_fixed_string_t queue;
+ uint16_t queue_id;
+ cmdline_fixed_string_t fd_id;
+ uint32_t fd_id_value;
+};
+
+static inline int
+parse_flexwords(const char *q_arg, uint16_t *flexwords)
+{
+#define MAX_NUM_WORD 8
+ char s[256];
+ const char *p, *p0 = q_arg;
+ char *end;
+ unsigned long int_fld[MAX_NUM_WORD];
+ char *str_fld[MAX_NUM_WORD];
+ int i;
+ unsigned size;
+ int num_words = -1;
+
+ p = strchr(p0, '(');
+ if (p == NULL)
+ return -1;
+ ++p;
+ p0 = strchr(p, ')');
+ if (p0 == NULL)
+ return -1;
+
+ size = p0 - p;
+ if (size >= sizeof(s))
+ return -1;
+
+ snprintf(s, sizeof(s), "%.*s", size, p);
+ num_words = rte_strsplit(s, sizeof(s), str_fld, MAX_NUM_WORD, ',');
+ if (num_words < 0 || num_words > MAX_NUM_WORD)
+ return -1;
+ for (i = 0; i < num_words; i++) {
+ errno = 0;
+ int_fld[i] = strtoul(str_fld[i], &end, 0);
+ if (errno != 0 || end == str_fld[i] || int_fld[i] > UINT16_MAX)
+ return -1;
+ flexwords[i] = rte_cpu_to_be_16((uint16_t)int_fld[i]);
+ }
+ return num_words;
+}
+
+static void
+cmd_flow_director_filter_parsed(void *parsed_result,
+ __attribute__((unused)) struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_flow_director_result *res = parsed_result;
+ struct rte_eth_fdir_filter entry;
+ uint16_t flexwords[8];
+ int num_flexwords;
+ int ret = 0;
+
+ ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
+ if (ret < 0) {
+ printf("flow director is not supported on port %u.\n",
+ res->port_id);
+ return;
+ }
+ memset(flexwords, 0, sizeof(flexwords));
+ memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
+ num_flexwords = parse_flexwords(res->flexwords_value, flexwords);
+ if (num_flexwords < 0) {
+ printf("error: Cannot parse flexwords input.\n");
+ return;
+ }
+
+ if (!strcmp(res->flow_type, "ip4")) {
+ /* no need to convert, already big endian. */
+ if (res->ip_dst.family == AF_INET)
+ entry.input.flow.ip4_flow.dst_ip =
+ res->ip_dst.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_src.family == AF_INET)
+ entry.input.flow.ip4_flow.src_ip =
+ res->ip_src.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_IPV4_OTHER;
+ } else if (!strcmp(res->flow_type, "udp4")) {
+ /* no need to convert, already big endian. */
+ if (res->ip_dst.family == AF_INET)
+ entry.input.flow.udp4_flow.dst_ip =
+ res->ip_dst.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_src.family == AF_INET)
+ entry.input.flow.udp4_flow.src_ip =
+ res->ip_src.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ /* need convert to big endian. */
+ entry.input.flow.udp4_flow.dst_port =
+ rte_cpu_to_be_16(res->port_dst);
+ entry.input.flow.udp4_flow.src_port =
+ rte_cpu_to_be_16(res->port_src);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_UDPV4;
+ } else if (!strcmp(res->flow_type, "tcp4")) {
+ if (res->ip_dst.family == AF_INET)
+ entry.input.flow.tcp4_flow.dst_ip =
+ res->ip_dst.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_src.family == AF_INET)
+ entry.input.flow.tcp4_flow.src_ip =
+ res->ip_src.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ /* need convert to big endian. */
+ entry.input.flow.tcp4_flow.dst_port =
+ rte_cpu_to_be_16(res->port_dst);
+ entry.input.flow.tcp4_flow.src_port =
+ rte_cpu_to_be_16(res->port_src);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_TCPV4;
+ } else if (!strcmp(res->flow_type, "sctp4")) {
+ if (res->ip_dst.family == AF_INET)
+ entry.input.flow.sctp4_flow.dst_ip =
+ res->ip_dst.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_src.family == AF_INET)
+ entry.input.flow.sctp4_flow.src_ip =
+ res->ip_src.addr.ipv4.s_addr;
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ /* need convert to big endian. */
+ entry.input.flow.sctp4_flow.verify_tag =
+ rte_cpu_to_be_32(res->verify_tag_value);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_SCTPV4;
+ } else if (!strcmp(res->flow_type, "ip6")) {
+ if (res->ip_src.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.ip6_flow.src_ip),
+ &(res->ip_src.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_dst.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.ip6_flow.dst_ip),
+ &(res->ip_dst.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_IPV6_OTHER;
+ } else if (!strcmp(res->flow_type, "udp6")) {
+ if (res->ip_src.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.udp6_flow.src_ip),
+ &(res->ip_src.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_dst.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.udp6_flow.dst_ip),
+ &(res->ip_dst.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ entry.input.flow.udp6_flow.dst_port =
+ rte_cpu_to_be_16(res->port_dst);
+ entry.input.flow.udp6_flow.src_port =
+ rte_cpu_to_be_16(res->port_src);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_UDPV6;
+ } else if (!strcmp(res->flow_type, "tcp6")) {
+ if (res->ip_src.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.tcp6_flow.src_ip),
+ &(res->ip_src.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_dst.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.tcp6_flow.dst_ip),
+ &(res->ip_dst.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ entry.input.flow.tcp6_flow.dst_port =
+ rte_cpu_to_be_16(res->port_dst);
+ entry.input.flow.tcp6_flow.src_port =
+ rte_cpu_to_be_16(res->port_src);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_TCPV6;
+ } else if (!strcmp(res->flow_type, "sctp6")) {
+ if (res->ip_src.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.sctp6_flow.src_ip),
+ &(res->ip_src.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ if (res->ip_dst.family == AF_INET6)
+ (void)rte_memcpy(&(entry.input.flow.sctp6_flow.dst_ip),
+ &(res->ip_dst.addr.ipv6),
+ sizeof(struct in6_addr));
+ else {
+ printf("error parameters.\n");
+ return;
+ }
+ entry.input.flow.sctp6_flow.verify_tag =
+ rte_cpu_to_be_32(res->verify_tag_value);
+ entry.input.flow_type = RTE_ETH_FLOW_TYPE_SCTPV6;
+ }
+
+ entry.input.flow_ext.num_flexwords = num_flexwords;
+ rte_memcpy(entry.input.flow_ext.flexwords,
+ flexwords,
+ sizeof(flexwords[0]) * num_flexwords);
+
+ entry.input.flow_ext.dest_id = 0;
+ entry.action.flex_off = 0; /*use 0 by default */
+ if (!strcmp(res->drop, "drop"))
+ entry.action.drop = 1;
+ else
+ entry.action.drop = 0;
+ /* set to report FD ID by default */
+ entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
+ entry.action.rx_queue = res->queue_id;
+ /* use 0 by default, will set it to fdir counter per dev */
+ entry.action.cnt_idx = 0;
+ entry.soft_id = res->fd_id_value;
+ if (!strcmp(res->ops, "add"))
+ ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
+ RTE_ETH_FILTER_ADD, &entry);
+ else
+ ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
+ RTE_ETH_FILTER_DELETE, &entry);
+ if (ret < 0)
+ printf("flow director programming error: (%s)\n",
+ strerror(-ret));
+}
+
+cmdline_parse_token_string_t cmd_flow_director_filter =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ flow_director_filter, "flow_director_filter");
+cmdline_parse_token_num_t cmd_flow_director_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ port_id, UINT8);
+cmdline_parse_token_string_t cmd_flow_director_ops =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ ops, "add#del#update");
+cmdline_parse_token_string_t cmd_flow_director_flow =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ flow, "flow");
+cmdline_parse_token_string_t cmd_flow_director_flow_type =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ flow_type,
+ "ip4#tcp4#udp4#sctp4#ip6#tcp6#udp6#sctp6");
+cmdline_parse_token_string_t cmd_flow_director_src =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ src, "src");
+cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
+ TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
+ ip_src);
+cmdline_parse_token_num_t cmd_flow_director_port_src =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ port_src, UINT16);
+cmdline_parse_token_string_t cmd_flow_director_dst =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ dst, "dst");
+cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
+ TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
+ ip_dst);
+cmdline_parse_token_num_t cmd_flow_director_port_dst =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ port_dst, UINT16);
+cmdline_parse_token_string_t cmd_flow_director_verify_tag =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ verify_tag, "verify_tag");
+cmdline_parse_token_num_t cmd_flow_director_verify_tag_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ verify_tag_value, UINT32);
+cmdline_parse_token_string_t cmd_flow_director_flexwords =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ flexwords, "flexwords");
+cmdline_parse_token_string_t cmd_flow_director_flexwords_value =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ flexwords_value, NULL);
+cmdline_parse_token_string_t cmd_flow_director_drop =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ drop, "drop#fwd");
+cmdline_parse_token_string_t cmd_flow_director_queue =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ queue, "queue");
+cmdline_parse_token_num_t cmd_flow_director_queue_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ queue_id, UINT16);
+cmdline_parse_token_string_t cmd_flow_director_fd_id =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+ fd_id, "fd_id");
+cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+ fd_id_value, UINT32);
+
+cmdline_parse_inst_t cmd_add_del_ip_flow_director = {
+ .f = cmd_flow_director_filter_parsed,
+ .data = NULL,
+ .help_str = "add or delete an ip flow director entry on NIC",
+ .tokens = {
+ (void *)&cmd_flow_director_filter,
+ (void *)&cmd_flow_director_port_id,
+ (void *)&cmd_flow_director_ops,
+ (void *)&cmd_flow_director_flow,
+ (void *)&cmd_flow_director_flow_type,
+ (void *)&cmd_flow_director_src,
+ (void *)&cmd_flow_director_ip_src,
+ (void *)&cmd_flow_director_dst,
+ (void *)&cmd_flow_director_ip_dst,
+ (void *)&cmd_flow_director_flexwords,
+ (void *)&cmd_flow_director_flexwords_value,
+ (void *)&cmd_flow_director_drop,
+ (void *)&cmd_flow_director_queue,
+ (void *)&cmd_flow_director_queue_id,
+ (void *)&cmd_flow_director_fd_id,
+ (void *)&cmd_flow_director_fd_id_value,
+ NULL,
+ },
+};
+
+cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
+ .f = cmd_flow_director_filter_parsed,
+ .data = NULL,
+ .help_str = "add or delete an udp/tcp flow director entry on NIC",
+ .tokens = {
+ (void *)&cmd_flow_director_filter,
+ (void *)&cmd_flow_director_port_id,
+ (void *)&cmd_flow_director_ops,
+ (void *)&cmd_flow_director_flow,
+ (void *)&cmd_flow_director_flow_type,
+ (void *)&cmd_flow_director_src,
+ (void *)&cmd_flow_director_ip_src,
+ (void *)&cmd_flow_director_port_src,
+ (void *)&cmd_flow_director_dst,
+ (void *)&cmd_flow_director_ip_dst,
+ (void *)&cmd_flow_director_port_dst,
+ (void *)&cmd_flow_director_flexwords,
+ (void *)&cmd_flow_director_flexwords_value,
+ (void *)&cmd_flow_director_drop,
+ (void *)&cmd_flow_director_queue,
+ (void *)&cmd_flow_director_queue_id,
+ (void *)&cmd_flow_director_fd_id,
+ (void *)&cmd_flow_director_fd_id_value,
+ NULL,
+ },
+};
+
+cmdline_parse_inst_t cmd_add_del_sctp_flow_director = {
+ .f = cmd_flow_director_filter_parsed,
+ .data = NULL,
+ .help_str = "add or delete a sctp flow director entry on NIC",
+ .tokens = {
+ (void *)&cmd_flow_director_filter,
+ (void *)&cmd_flow_director_port_id,
+ (void *)&cmd_flow_director_ops,
+ (void *)&cmd_flow_director_flow,
+ (void *)&cmd_flow_director_flow_type,
+ (void *)&cmd_flow_director_src,
+ (void *)&cmd_flow_director_ip_src,
+ (void *)&cmd_flow_director_dst,
+ (void *)&cmd_flow_director_ip_dst,
+ (void *)&cmd_flow_director_verify_tag,
+ (void *)&cmd_flow_director_verify_tag_value,
+ (void *)&cmd_flow_director_flexwords,
+ (void *)&cmd_flow_director_flexwords_value,
+ (void *)&cmd_flow_director_drop,
+ (void *)&cmd_flow_director_queue,
+ (void *)&cmd_flow_director_queue_id,
+ (void *)&cmd_flow_director_fd_id,
+ (void *)&cmd_flow_director_fd_id_value,
+ NULL,
+ },
+};
+
/*
********************************************************************************
*/
/* list of instructions */
@@ -7761,6 +8205,9 @@ cmdline_parse_ctx_t main_ctx[] = {
(cmdline_parse_inst_t *)&cmd_add_flex_filter,
(cmdline_parse_inst_t *)&cmd_remove_flex_filter,
(cmdline_parse_inst_t *)&cmd_get_flex_filter,
+ (cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director,
+ (cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director,
+ (cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director,
NULL,
};
--
1.8.1.4
