From: Zhang Tengfei <zhtfdev@gmail.com>
To: dev@dpdk.org
Cc: jiawenwu@trustnetic.com, zaiyuwang@trustnetic.com,
stephen@networkplumber.org, Zhang Tengfei <zhtfdev@gmail.com>
Subject: [PATCH] net/txgbe: store flow rules without wrappers
Date: Tue, 10 Nov 2026 21:22:00 +0800 [thread overview]
Message-ID: <20261110132200.12673-1-zhtfdev@gmail.com> (raw)
The flow rule wrappers each held one filter structure after their
list links were removed. Store the filter structure directly in
rte_flow. RSS still goes through txgbe_rss_conf_init() so the saved
key and queue pointers refer to that stored copy.
Signed-off-by: Zhang Tengfei <zhtfdev@gmail.com>
---
drivers/net/txgbe/txgbe_flow.c | 105 ++++++++++++---------------------
1 file changed, 38 insertions(+), 67 deletions(-)
diff --git a/drivers/net/txgbe/txgbe_flow.c b/drivers/net/txgbe/txgbe_flow.c
index 64128dfc27..39d94eb1ea 100644
--- a/drivers/net/txgbe/txgbe_flow.c
+++ b/drivers/net/txgbe/txgbe_flow.c
@@ -16,30 +16,6 @@
#define TXGBE_MAX_N_TUPLE_PRIO 7
#define TXGBE_MAX_FLX_SOURCE_OFF 62
-/* ntuple filter list structure */
-struct txgbe_ntuple_filter_ele {
- struct rte_eth_ntuple_filter filter_info;
-};
-/* ethertype filter list structure */
-struct txgbe_ethertype_filter_ele {
- struct rte_eth_ethertype_filter filter_info;
-};
-/* syn filter list structure */
-struct txgbe_eth_syn_filter_ele {
- struct rte_eth_syn_filter filter_info;
-};
-/* fdir filter list structure */
-struct txgbe_fdir_rule_ele {
- struct txgbe_fdir_rule filter_info;
-};
-/* l2_tunnel filter list structure */
-struct txgbe_eth_l2_tunnel_conf_ele {
- struct txgbe_l2_tunnel_conf filter_info;
-};
-/* rss filter list structure */
-struct txgbe_rss_conf_ele {
- struct txgbe_rte_flow_rss_conf filter_info;
-};
/* txgbe_flow memory list structure */
struct txgbe_flow_mem {
TAILQ_ENTRY(txgbe_flow_mem) entries;
@@ -3136,12 +3112,12 @@ txgbe_flow_create(struct rte_eth_dev *dev,
struct rte_eth_fdir_conf *fdir_conf = TXGBE_DEV_FDIR_CONF(dev);
struct txgbe_rte_flow_rss_conf rss_conf;
struct rte_flow *flow = NULL;
- struct txgbe_ntuple_filter_ele *ntuple_filter_ptr;
- struct txgbe_ethertype_filter_ele *ethertype_filter_ptr;
- struct txgbe_eth_syn_filter_ele *syn_filter_ptr;
- struct txgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
- struct txgbe_fdir_rule_ele *fdir_rule_ptr = NULL;
- struct txgbe_rss_conf_ele *rss_filter_ptr;
+ struct rte_eth_ntuple_filter *ntuple_filter_ptr;
+ struct rte_eth_ethertype_filter *ethertype_filter_ptr;
+ struct rte_eth_syn_filter *syn_filter_ptr;
+ struct txgbe_l2_tunnel_conf *l2_tn_filter_ptr;
+ struct txgbe_fdir_rule *fdir_rule_ptr = NULL;
+ struct txgbe_rte_flow_rss_conf *rss_filter_ptr;
struct txgbe_flow_mem *txgbe_flow_mem_ptr;
struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
struct txgbe_filter_info *filter_info = TXGBE_DEV_FILTER(dev);
@@ -3175,13 +3151,13 @@ txgbe_flow_create(struct rte_eth_dev *dev,
if (!ret) {
ntuple_filter_ptr = rte_zmalloc("txgbe_ntuple_filter",
- sizeof(struct txgbe_ntuple_filter_ele), 0);
+ sizeof(struct rte_eth_ntuple_filter), 0);
if (!ntuple_filter_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
goto out;
}
- ntuple_filter_ptr->filter_info = ntuple_filter;
+ *ntuple_filter_ptr = ntuple_filter;
ret = txgbe_add_del_ntuple_filter(dev, &ntuple_filter, TRUE);
if (ret) {
rte_free(ntuple_filter_ptr);
@@ -3200,13 +3176,13 @@ txgbe_flow_create(struct rte_eth_dev *dev,
actions, ðertype_filter, error);
if (!ret) {
ethertype_filter_ptr = rte_zmalloc("txgbe_ethertype_filter",
- sizeof(struct txgbe_ethertype_filter_ele), 0);
+ sizeof(struct rte_eth_ethertype_filter), 0);
if (!ethertype_filter_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
goto out;
}
- ethertype_filter_ptr->filter_info = ethertype_filter;
+ *ethertype_filter_ptr = ethertype_filter;
ret = txgbe_add_del_ethertype_filter(dev,
ðertype_filter, TRUE);
if (ret) {
@@ -3223,13 +3199,13 @@ txgbe_flow_create(struct rte_eth_dev *dev,
actions, &syn_filter, error);
if (!ret) {
syn_filter_ptr = rte_zmalloc("txgbe_syn_filter",
- sizeof(struct txgbe_eth_syn_filter_ele), 0);
+ sizeof(struct rte_eth_syn_filter), 0);
if (!syn_filter_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
goto out;
}
- syn_filter_ptr->filter_info = syn_filter;
+ *syn_filter_ptr = syn_filter;
ret = txgbe_syn_filter_set(dev, &syn_filter, TRUE);
if (ret) {
rte_free(syn_filter_ptr);
@@ -3246,7 +3222,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
if (!ret) {
if (!txgbe_is_pf(TXGBE_DEV_HW(dev))) {
fdir_rule_ptr = rte_zmalloc("txgbe_fdir_filter",
- sizeof(struct txgbe_fdir_rule_ele), 0);
+ sizeof(struct txgbe_fdir_rule), 0);
if (!fdir_rule_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
@@ -3260,7 +3236,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
goto out;
}
- fdir_rule_ptr->filter_info = fdir_rule;
+ *fdir_rule_ptr = fdir_rule;
flow->rule = fdir_rule_ptr;
flow->filter_type = RTE_ETH_FILTER_FDIR;
return flow;
@@ -3272,7 +3248,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
}
fdir_rule_ptr = rte_zmalloc("txgbe_fdir_filter",
- sizeof(struct txgbe_fdir_rule_ele), 0);
+ sizeof(struct txgbe_fdir_rule), 0);
if (!fdir_rule_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
@@ -3345,7 +3321,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
if (ret)
goto fdir_out;
- fdir_rule_ptr->filter_info = fdir_rule;
+ *fdir_rule_ptr = fdir_rule;
flow->rule = fdir_rule_ptr;
flow->filter_type = RTE_ETH_FILTER_FDIR;
@@ -3357,13 +3333,13 @@ txgbe_flow_create(struct rte_eth_dev *dev,
actions, &l2_tn_filter, error);
if (!ret) {
l2_tn_filter_ptr = rte_zmalloc("txgbe_l2_tn_filter",
- sizeof(struct txgbe_eth_l2_tunnel_conf_ele), 0);
+ sizeof(struct txgbe_l2_tunnel_conf), 0);
if (!l2_tn_filter_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
goto out;
}
- l2_tn_filter_ptr->filter_info = l2_tn_filter;
+ *l2_tn_filter_ptr = l2_tn_filter;
ret = txgbe_dev_l2_tunnel_filter_add(dev, &l2_tn_filter, FALSE);
if (ret) {
rte_free(l2_tn_filter_ptr);
@@ -3379,7 +3355,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
actions, &rss_conf, error);
if (!ret) {
rss_filter_ptr = rte_zmalloc("txgbe_rss_filter",
- sizeof(struct txgbe_rss_conf_ele), 0);
+ sizeof(struct txgbe_rte_flow_rss_conf), 0);
if (!rss_filter_ptr) {
PMD_DRV_LOG(ERR, "failed to allocate memory");
ret = -ENOMEM;
@@ -3390,7 +3366,7 @@ txgbe_flow_create(struct rte_eth_dev *dev,
rte_free(rss_filter_ptr);
goto out;
}
- txgbe_rss_conf_init(&rss_filter_ptr->filter_info,
+ txgbe_rss_conf_init(rss_filter_ptr,
&rss_conf.conf);
flow->rule = rss_filter_ptr;
flow->filter_type = RTE_ETH_FILTER_HASH;
@@ -3486,16 +3462,16 @@ txgbe_flow_destroy(struct rte_eth_dev *dev,
struct rte_eth_syn_filter syn_filter;
struct txgbe_fdir_rule fdir_rule;
struct txgbe_l2_tunnel_conf l2_tn_filter;
- struct txgbe_ntuple_filter_ele *ntuple_filter_ptr;
- struct txgbe_ethertype_filter_ele *ethertype_filter_ptr;
- struct txgbe_eth_syn_filter_ele *syn_filter_ptr;
- struct txgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
- struct txgbe_fdir_rule_ele *fdir_rule_ptr;
+ struct rte_eth_ntuple_filter *ntuple_filter_ptr;
+ struct rte_eth_ethertype_filter *ethertype_filter_ptr;
+ struct rte_eth_syn_filter *syn_filter_ptr;
+ struct txgbe_l2_tunnel_conf *l2_tn_filter_ptr;
+ struct txgbe_fdir_rule *fdir_rule_ptr;
struct txgbe_flow_mem *txgbe_flow_mem_ptr;
struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
struct txgbe_hw_fdir_info *fdir_info = TXGBE_DEV_FDIR(dev);
struct rte_eth_fdir_conf *fdir_conf = TXGBE_DEV_FDIR_CONF(dev);
- struct txgbe_rss_conf_ele *rss_filter_ptr;
+ struct txgbe_rte_flow_rss_conf *rss_filter_ptr;
/*
* Confirm the handle is on this port before changing hardware.
@@ -3513,20 +3489,18 @@ txgbe_flow_destroy(struct rte_eth_dev *dev,
filter_type = pmd_flow->filter_type;
switch (filter_type) {
case RTE_ETH_FILTER_NTUPLE:
- ntuple_filter_ptr = (struct txgbe_ntuple_filter_ele *)
+ ntuple_filter_ptr = (struct rte_eth_ntuple_filter *)
pmd_flow->rule;
- rte_memcpy(&ntuple_filter,
- &ntuple_filter_ptr->filter_info,
+ rte_memcpy(&ntuple_filter, ntuple_filter_ptr,
sizeof(struct rte_eth_ntuple_filter));
ret = txgbe_add_del_ntuple_filter(dev, &ntuple_filter, FALSE);
if (!ret)
rte_free(ntuple_filter_ptr);
break;
case RTE_ETH_FILTER_ETHERTYPE:
- ethertype_filter_ptr = (struct txgbe_ethertype_filter_ele *)
+ ethertype_filter_ptr = (struct rte_eth_ethertype_filter *)
pmd_flow->rule;
- rte_memcpy(ðertype_filter,
- ðertype_filter_ptr->filter_info,
+ rte_memcpy(ðertype_filter, ethertype_filter_ptr,
sizeof(struct rte_eth_ethertype_filter));
ret = txgbe_add_del_ethertype_filter(dev,
ðertype_filter, FALSE);
@@ -3534,19 +3508,17 @@ txgbe_flow_destroy(struct rte_eth_dev *dev,
rte_free(ethertype_filter_ptr);
break;
case RTE_ETH_FILTER_SYN:
- syn_filter_ptr = (struct txgbe_eth_syn_filter_ele *)
+ syn_filter_ptr = (struct rte_eth_syn_filter *)
pmd_flow->rule;
- rte_memcpy(&syn_filter,
- &syn_filter_ptr->filter_info,
+ rte_memcpy(&syn_filter, syn_filter_ptr,
sizeof(struct rte_eth_syn_filter));
ret = txgbe_syn_filter_set(dev, &syn_filter, FALSE);
if (!ret)
rte_free(syn_filter_ptr);
break;
case RTE_ETH_FILTER_FDIR:
- fdir_rule_ptr = (struct txgbe_fdir_rule_ele *)pmd_flow->rule;
- rte_memcpy(&fdir_rule,
- &fdir_rule_ptr->filter_info,
+ fdir_rule_ptr = (struct txgbe_fdir_rule *)pmd_flow->rule;
+ rte_memcpy(&fdir_rule, fdir_rule_ptr,
sizeof(struct txgbe_fdir_rule));
if (txgbe_is_pf(TXGBE_DEV_HW(dev)))
ret = txgbe_fdir_filter_program(dev, &fdir_rule,
@@ -3570,19 +3542,18 @@ txgbe_flow_destroy(struct rte_eth_dev *dev,
}
break;
case RTE_ETH_FILTER_L2_TUNNEL:
- l2_tn_filter_ptr = (struct txgbe_eth_l2_tunnel_conf_ele *)
+ l2_tn_filter_ptr = (struct txgbe_l2_tunnel_conf *)
pmd_flow->rule;
- rte_memcpy(&l2_tn_filter, &l2_tn_filter_ptr->filter_info,
+ rte_memcpy(&l2_tn_filter, l2_tn_filter_ptr,
sizeof(struct txgbe_l2_tunnel_conf));
ret = txgbe_dev_l2_tunnel_filter_del(dev, &l2_tn_filter);
if (!ret)
rte_free(l2_tn_filter_ptr);
break;
case RTE_ETH_FILTER_HASH:
- rss_filter_ptr = (struct txgbe_rss_conf_ele *)
+ rss_filter_ptr = (struct txgbe_rte_flow_rss_conf *)
pmd_flow->rule;
- ret = txgbe_config_rss_filter(dev,
- &rss_filter_ptr->filter_info, FALSE);
+ ret = txgbe_config_rss_filter(dev, rss_filter_ptr, FALSE);
if (!ret)
rte_free(rss_filter_ptr);
break;
--
2.53.0
next reply other threads:[~2026-11-10 13:22 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-10 13:22 Zhang Tengfei [this message]
2026-11-10 15:04 ` [PATCH] net/txgbe: store flow rules without wrappers Stephen Hemminger
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261110132200.12673-1-zhtfdev@gmail.com \
--to=zhtfdev@gmail.com \
--cc=dev@dpdk.org \
--cc=jiawenwu@trustnetic.com \
--cc=stephen@networkplumber.org \
--cc=zaiyuwang@trustnetic.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.