[PATCH] net/txgbe: store flow rules without wrappers

[PATCH] net/txgbe: store flow rules without wrappers

[Zhang Tengfei]

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, &ethertype_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,
 				&ethertype_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(&ethertype_filter,
-			&ethertype_filter_ptr->filter_info,
+		rte_memcpy(&ethertype_filter, ethertype_filter_ptr,
 			sizeof(struct rte_eth_ethertype_filter));
 		ret = txgbe_add_del_ethertype_filter(dev,
 				&ethertype_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

Re: [PATCH] net/txgbe: store flow rules without wrappers

[Stephen Hemminger]

On Tue, 10 Nov 2026 21:22:00 +0800
Zhang Tengfei <zhtfdev@gmail.com> wrote:

> 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>
> ---
 
Looks good, AI review did have some observations to consider for later releases

[PATCH] net/txgbe: store flow rules without wrappers

Mechanical change; the conversion is correct. Allocation sizes match
the copied types, every flow->rule consumer is updated, and the RSS
path still goes through txgbe_rss_conf_init() so conf.key and
conf.queue point into the stored copy rather than the parse-time
stack buffer. txgbe_config_rss_filter(..., FALSE) and
txgbe_action_rss_same() therefore still see valid pointers on
destroy.

Info

flow->rule is void *, so the casts on the lines being touched in
txgbe_flow_destroy() are unnecessary. Since those lines are being
rewritten anyway, plain struct assignment is simpler than
rte_memcpy() in the control path:

	case RTE_ETH_FILTER_NTUPLE:
		ntuple_filter_ptr = pmd_flow->rule;
		ntuple_filter = *ntuple_filter_ptr;
		ret = txgbe_add_del_ntuple_filter(dev, &ntuple_filter, FALSE);

Same for the ethertype, syn, fdir and l2_tunnel cases.

Not introduced here, but worth a follow-up: these rule copies are
CPU-only bookkeeping and do not need hugepage memory; malloc()/free()
would do.