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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox