d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ethdev: remove legacy flexible filter type support

Browse Source 
Instead of FLEXIBLE filter RTE flow API should be used.

Temporarily preserve helper defines in public interface.

Signed-off-by: Andrew Rybchenko <arybchenko@solarflare.com>
Acked-by: Haiyue Wang <haiyue.wang@intel.com>
Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
This commit is contained in:
Andrew Rybchenko 2020-10-22 10:42:27 +01:00 committed by Ferruh Yigit
parent 35b1c68af2
commit 2be70bcdb8
6 changed files with 1 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
app/test-pmd/cmdline.c
View File

@ -993,11 +993,6 @@ static void cmd_help_long_parsed(void *parsed_result,
"syn_filter (port_id) (add|del) priority (high|low) queue (queue_id)"
" Add/Del syn filter.\n\n"
"flex_filter (port_id) (add|del) len (len_value)"
" bytes (bytes_value) mask (mask_value)"
" priority (prio_value) queue (queue_id)\n"
" Add/Del a flex filter.\n\n"
"flow_director_filter (port_id) mode IP (add|del|update)"
" flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
" src (src_ip_address) dst (dst_ip_address)"
@ -10873,195 +10868,6 @@ cmdline_parse_inst_t cmd_5tuple_filter = {
},
};
/* *** ADD/REMOVE A flex FILTER *** */
struct cmd_flex_filter_result {
cmdline_fixed_string_t filter;
cmdline_fixed_string_t ops;
portid_t port_id;
cmdline_fixed_string_t len;
uint8_t len_value;
cmdline_fixed_string_t bytes;
cmdline_fixed_string_t bytes_value;
cmdline_fixed_string_t mask;
cmdline_fixed_string_t mask_value;
cmdline_fixed_string_t priority;
uint8_t priority_value;
cmdline_fixed_string_t queue;
uint16_t queue_id;
};
static int xdigit2val(unsigned char c)
{
int val;
if (isdigit(c))
val = c - '0';
else if (isupper(c))
val = c - 'A' + 10;
else
val = c - 'a' + 10;
return val;
}
static void
cmd_flex_filter_parsed(void *parsed_result,
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
int ret = 0;
struct rte_eth_flex_filter filter;
struct cmd_flex_filter_result *res = parsed_result;
char *bytes_ptr, *mask_ptr;
uint16_t len, i, j = 0;
char c;
int val;
uint8_t byte = 0;
if (res->len_value > RTE_FLEX_FILTER_MAXLEN) {
printf("the len exceed the max length 128\n");
return;
}
memset(&filter, 0, sizeof(struct rte_eth_flex_filter));
filter.len = res->len_value;
filter.priority = res->priority_value;
filter.queue = res->queue_id;
bytes_ptr = res->bytes_value;
mask_ptr = res->mask_value;
/* translate bytes string to array. */
if (bytes_ptr[0] == '0' && ((bytes_ptr[1] == 'x') ||
(bytes_ptr[1] == 'X')))
bytes_ptr += 2;
len = strnlen(bytes_ptr, res->len_value * 2);
if (len == 0 || (len % 8 != 0)) {
printf("please check len and bytes input\n");
return;
}
for (i = 0; i < len; i++) {
c = bytes_ptr[i];
if (isxdigit(c) == 0) {
/* invalid characters. */
printf("invalid input\n");
return;
}
val = xdigit2val(c);
if (i % 2) {
byte |= val;
filter.bytes[j] = byte;
printf("bytes[%d]:%02x ", j, filter.bytes[j]);
j++;
byte = 0;
} else
byte |= val << 4;
}
printf("\n");
/* translate mask string to uint8_t array. */
if (mask_ptr[0] == '0' && ((mask_ptr[1] == 'x') ||
(mask_ptr[1] == 'X')))
mask_ptr += 2;
len = strnlen(mask_ptr, (res->len_value + 3) / 4);
if (len == 0) {
printf("invalid input\n");
return;
}
j = 0;
byte = 0;
for (i = 0; i < len; i++) {
c = mask_ptr[i];
if (isxdigit(c) == 0) {
/* invalid characters. */
printf("invalid input\n");
return;
}
val = xdigit2val(c);
if (i % 2) {
byte |= val;
filter.mask[j] = byte;
printf("mask[%d]:%02x ", j, filter.mask[j]);
j++;
byte = 0;
} else
byte |= val << 4;
}
printf("\n");
if (!strcmp(res->ops, "add"))
ret = rte_eth_dev_filter_ctrl(res->port_id,
RTE_ETH_FILTER_FLEXIBLE,
RTE_ETH_FILTER_ADD,
&filter);
else
ret = rte_eth_dev_filter_ctrl(res->port_id,
RTE_ETH_FILTER_FLEXIBLE,
RTE_ETH_FILTER_DELETE,
&filter);
if (ret < 0)
printf("flex filter setting error: (%s)\n", strerror(-ret));
}
cmdline_parse_token_string_t cmd_flex_filter_filter =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
filter, "flex_filter");
cmdline_parse_token_num_t cmd_flex_filter_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
port_id, UINT16);
cmdline_parse_token_string_t cmd_flex_filter_ops =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
ops, "add#del");
cmdline_parse_token_string_t cmd_flex_filter_len =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
len, "len");
cmdline_parse_token_num_t cmd_flex_filter_len_value =
TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
len_value, UINT8);
cmdline_parse_token_string_t cmd_flex_filter_bytes =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
bytes, "bytes");
cmdline_parse_token_string_t cmd_flex_filter_bytes_value =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
bytes_value, NULL);
cmdline_parse_token_string_t cmd_flex_filter_mask =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
mask, "mask");
cmdline_parse_token_string_t cmd_flex_filter_mask_value =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
mask_value, NULL);
cmdline_parse_token_string_t cmd_flex_filter_priority =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
priority, "priority");
cmdline_parse_token_num_t cmd_flex_filter_priority_value =
TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
priority_value, UINT8);
cmdline_parse_token_string_t cmd_flex_filter_queue =
TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
queue, "queue");
cmdline_parse_token_num_t cmd_flex_filter_queue_id =
TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
queue_id, UINT16);
cmdline_parse_inst_t cmd_flex_filter = {
.f = cmd_flex_filter_parsed,
.data = NULL,
.help_str = "flex_filter <port_id> add|del len <value> bytes "
"<value> mask <value> priority <value> queue <queue_id>: "
"Add/Del a flex filter",
.tokens = {
(void *)&cmd_flex_filter_filter,
(void *)&cmd_flex_filter_port_id,
(void *)&cmd_flex_filter_ops,
(void *)&cmd_flex_filter_len,
(void *)&cmd_flex_filter_len_value,
(void *)&cmd_flex_filter_bytes,
(void *)&cmd_flex_filter_bytes_value,
(void *)&cmd_flex_filter_mask,
(void *)&cmd_flex_filter_mask_value,
(void *)&cmd_flex_filter_priority,
(void *)&cmd_flex_filter_priority_value,
(void *)&cmd_flex_filter_queue,
(void *)&cmd_flex_filter_queue_id,
NULL,
},
};
/* *** Filters Control *** */
/* *** deal with flow director filter *** */
@ -19833,7 +19639,6 @@ cmdline_parse_ctx_t main_ctx[] = {
(cmdline_parse_inst_t *)&cmd_syn_filter,
(cmdline_parse_inst_t *)&cmd_2tuple_filter,
(cmdline_parse_inst_t *)&cmd_5tuple_filter,
(cmdline_parse_inst_t *)&cmd_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,

2
doc/guides/rel_notes/deprecation.rst
View File

@ -91,7 +91,7 @@ Deprecation Notices
* ethdev: the legacy filter API, including
``rte_eth_dev_filter_supported()``, ``rte_eth_dev_filter_ctrl()`` as well
as filter types FLEXIBLE, SYN, NTUPLE, TUNNEL, FDIR,
as filter types SYN, NTUPLE, TUNNEL, FDIR,
HASH and L2_TUNNEL, is superseded by the generic flow API (rte_flow) in
PMDs that implement the latter.
The legacy API will be removed in DPDK 20.11.

32
doc/guides/testpmd_app_ug/testpmd_funcs.rst
View File

@ -3373,38 +3373,6 @@ Example::
testpmd> syn_filter 0 add priority high queue 3
flex_filter
~~~~~~~~~~~
With flex filter, packets can be recognized by any arbitrary pattern within the first 128 bytes of the packet
and routed into one of the receive queues::
flex_filter (port_id) (add|del) len (len_value) bytes (bytes_value) \
mask (mask_value) priority (prio_value) queue (queue_id)
The available information parameters are:
* ``port_id``: The port which the Flex filter is assigned on.
* ``len_value``: Filter length in bytes, no greater than 128.
* ``bytes_value``: A string in hexadecimal, means the value the flex filter needs to match.
* ``mask_value``: A string in hexadecimal, bit 1 means corresponding byte participates in the match.
* ``prio_value``: The priority of this filter.
* ``queue_id``: The receive queue associated with this Flex filter.
Example::
testpmd> flex_filter 0 add len 16 bytes 0x00000000000000000000000008060000 \
mask 000C priority 3 queue 3
testpmd> flex_filter 0 del len 16 bytes 0x00000000000000000000000008060000 \
mask 000C priority 3 queue 3
.. _testpmd_flow_director:
flow_director_filter

104
drivers/net/e1000/igb_ethdev.c
View File

@ -195,11 +195,6 @@ static int igb_add_2tuple_filter(struct rte_eth_dev *dev,
struct rte_eth_ntuple_filter *ntuple_filter);
static int igb_remove_2tuple_filter(struct rte_eth_dev *dev,
struct rte_eth_ntuple_filter *ntuple_filter);
static int eth_igb_get_flex_filter(struct rte_eth_dev *dev,
struct rte_eth_flex_filter *filter);
static int eth_igb_flex_filter_handle(struct rte_eth_dev *dev,
enum rte_filter_op filter_op,
void *arg);
static int igb_add_5tuple_filter_82576(struct rte_eth_dev *dev,
struct rte_eth_ntuple_filter *ntuple_filter);
static int igb_remove_5tuple_filter_82576(struct rte_eth_dev *dev,
@ -4127,102 +4122,6 @@ eth_igb_add_del_flex_filter(struct rte_eth_dev *dev,
return 0;
}
static int
eth_igb_get_flex_filter(struct rte_eth_dev *dev,
struct rte_eth_flex_filter *filter)
{
struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
struct e1000_filter_info *filter_info =
E1000_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
struct e1000_flex_filter flex_filter, *it;
uint32_t wufc, queueing, wufc_en = 0;
memset(&flex_filter, 0, sizeof(struct e1000_flex_filter));
flex_filter.filter_info.len = filter->len;
flex_filter.filter_info.priority = filter->priority;
memcpy(flex_filter.filter_info.dwords, filter->bytes, filter->len);
memcpy(flex_filter.filter_info.mask, filter->mask,
RTE_ALIGN(filter->len, CHAR_BIT) / CHAR_BIT);
it = eth_igb_flex_filter_lookup(&filter_info->flex_list,
&flex_filter.filter_info);
if (it == NULL) {
PMD_DRV_LOG(ERR, "filter doesn't exist.");
return -ENOENT;
}
wufc = E1000_READ_REG(hw, E1000_WUFC);
wufc_en = E1000_WUFC_FLEX_HQ | (E1000_WUFC_FLX0 << it->index);
if ((wufc & wufc_en) == wufc_en) {
uint32_t reg_off = 0;
if (it->index < E1000_MAX_FHFT)
reg_off = E1000_FHFT(it->index);
else
reg_off = E1000_FHFT_EXT(it->index - E1000_MAX_FHFT);
queueing = E1000_READ_REG(hw,
reg_off + E1000_FHFT_QUEUEING_OFFSET);
filter->len = queueing & E1000_FHFT_QUEUEING_LEN;
filter->priority = (queueing & E1000_FHFT_QUEUEING_PRIO) >>
E1000_FHFT_QUEUEING_PRIO_SHIFT;
filter->queue = (queueing & E1000_FHFT_QUEUEING_QUEUE) >>
E1000_FHFT_QUEUEING_QUEUE_SHIFT;
return 0;
}
return -ENOENT;
}
static int
eth_igb_flex_filter_handle(struct rte_eth_dev *dev,
enum rte_filter_op filter_op,
void *arg)
{
struct e1000_hw *hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
struct rte_eth_flex_filter *filter;
int ret = 0;
MAC_TYPE_FILTER_SUP_EXT(hw->mac.type);
if (filter_op == RTE_ETH_FILTER_NOP)
return ret;
if (arg == NULL) {
PMD_DRV_LOG(ERR, "arg shouldn't be NULL for operation %u",
filter_op);
return -EINVAL;
}
filter = (struct rte_eth_flex_filter *)arg;
if (filter->len == 0 || filter->len > E1000_MAX_FLEX_FILTER_LEN
|| filter->len % sizeof(uint64_t) != 0) {
PMD_DRV_LOG(ERR, "filter's length is out of range");
return -EINVAL;
}
if (filter->priority > E1000_MAX_FLEX_FILTER_PRI) {
PMD_DRV_LOG(ERR, "filter's priority is out of range");
return -EINVAL;
}
switch (filter_op) {
case RTE_ETH_FILTER_ADD:
ret = eth_igb_add_del_flex_filter(dev, filter, TRUE);
break;
case RTE_ETH_FILTER_DELETE:
ret = eth_igb_add_del_flex_filter(dev, filter, FALSE);
break;
case RTE_ETH_FILTER_GET:
ret = eth_igb_get_flex_filter(dev, filter);
break;
default:
PMD_DRV_LOG(ERR, "unsupported operation %u", filter_op);
ret = -EINVAL;
break;
}
return ret;
}
/* translate elements in struct rte_eth_ntuple_filter to struct e1000_5tuple_filter_info*/
static inline int
ntuple_filter_to_5tuple_82576(struct rte_eth_ntuple_filter *filter,
@ -4852,9 +4751,6 @@ eth_igb_filter_ctrl(struct rte_eth_dev *dev,
case RTE_ETH_FILTER_SYN:
ret = eth_igb_syn_filter_handle(dev, filter_op, arg);
break;
case RTE_ETH_FILTER_FLEXIBLE:
ret = eth_igb_flex_filter_handle(dev, filter_op, arg);
break;
case RTE_ETH_FILTER_GENERIC:
if (filter_op != RTE_ETH_FILTER_GET)
return -EINVAL;

1
drivers/net/qede/qede_filter.c
View File

@ -1561,7 +1561,6 @@ int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev,
*(const void **)arg = &qede_flow_ops;
return 0;
case RTE_ETH_FILTER_FLEXIBLE:
case RTE_ETH_FILTER_SYN:
case RTE_ETH_FILTER_HASH:
case RTE_ETH_FILTER_L2_TUNNEL:

3
drivers/net/sfc/sfc_ethdev.c
View File

@ -1755,9 +1755,6 @@ sfc_dev_filter_ctrl(struct rte_eth_dev *dev, enum rte_filter_type filter_type,
case RTE_ETH_FILTER_NONE:
sfc_err(sa, "Global filters configuration not supported");
break;
case RTE_ETH_FILTER_FLEXIBLE:
sfc_err(sa, "Flexible filters not supported");
break;
case RTE_ETH_FILTER_SYN:
sfc_err(sa, "SYN filters not supported");
break;