diff --git a/0109-net-hns3-fix-inconsistent-lock.patch b/0109-net-hns3-fix-inconsistent-lock.patch new file mode 100644 index 0000000000000000000000000000000000000000..f8312c56a02896749d26b402a111898b96ac5202 --- /dev/null +++ b/0109-net-hns3-fix-inconsistent-lock.patch @@ -0,0 +1,271 @@ +From 90e60da994c84d138a444e294c5933fe41c8ab9c Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Wed, 13 Aug 2025 15:33:15 +0800 +Subject: [PATCH] net/hns3: fix inconsistent lock + +The hns3 driver supports configuring RSS through both ops API and +rte_flow API. The ops API uses spin lock, while the rte_flow API uses +pthread mutex. When concurrent calls occur, issues may arise. +This patch replaces the lock in the flow API with spin lock. + +With the pthread mutex no longer needed, the pthread attributes +can also be removed. + +Fixes: 1bdcca8006e4 ("net/hns3: fix flow director lock") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +--- + drivers/net/hns3/hns3_ethdev.h | 2 -- + drivers/net/hns3/hns3_fdir.c | 13 -------- + drivers/net/hns3/hns3_flow.c | 60 +++++++++++++--------------------- + 3 files changed, 22 insertions(+), 53 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.h b/drivers/net/hns3/hns3_ethdev.h +index 0ce4974..1b105dc 100644 +--- a/drivers/net/hns3/hns3_ethdev.h ++++ b/drivers/net/hns3/hns3_ethdev.h +@@ -5,7 +5,6 @@ + #ifndef HNS3_ETHDEV_H + #define HNS3_ETHDEV_H + +-#include + #include + #include + #include +@@ -680,7 +679,6 @@ struct hns3_hw { + + struct hns3_port_base_vlan_config port_base_vlan_cfg; + +- pthread_mutex_t flows_lock; /* rte_flow ops lock */ + struct hns3_fdir_rule_list flow_fdir_list; /* flow fdir rule list */ + struct hns3_rss_filter_list flow_rss_list; /* flow RSS rule list */ + struct hns3_flow_mem_list flow_list; +diff --git a/drivers/net/hns3/hns3_fdir.c b/drivers/net/hns3/hns3_fdir.c +index d645471..bbd0453 100644 +--- a/drivers/net/hns3/hns3_fdir.c ++++ b/drivers/net/hns3/hns3_fdir.c +@@ -1145,17 +1145,6 @@ int hns3_restore_all_fdir_filter(struct hns3_adapter *hns) + if (hns->is_vf) + return 0; + +- /* +- * This API is called in the reset recovery process, the parent function +- * must hold hw->lock. +- * There maybe deadlock if acquire hw->flows_lock directly because rte +- * flow driver ops first acquire hw->flows_lock and then may acquire +- * hw->lock. +- * So here first release the hw->lock and then acquire the +- * hw->flows_lock to avoid deadlock. +- */ +- rte_spinlock_unlock(&hw->lock); +- pthread_mutex_lock(&hw->flows_lock); + TAILQ_FOREACH(fdir_filter, &fdir_info->fdir_list, entries) { + ret = hns3_config_action(hw, &fdir_filter->fdir_conf); + if (!ret) +@@ -1166,8 +1155,6 @@ int hns3_restore_all_fdir_filter(struct hns3_adapter *hns) + break; + } + } +- pthread_mutex_unlock(&hw->flows_lock); +- rte_spinlock_lock(&hw->lock); + + if (err) { + hns3_err(hw, "Fail to restore FDIR filter, ret = %d", ret); +diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c +index 73a78ed..aa528b4 100644 +--- a/drivers/net/hns3/hns3_flow.c ++++ b/drivers/net/hns3/hns3_flow.c +@@ -2210,18 +2210,6 @@ hns3_reconfig_all_rss_filter(struct hns3_hw *hw) + return 0; + } + +-static int +-hns3_restore_rss_filter(struct hns3_hw *hw) +-{ +- int ret; +- +- pthread_mutex_lock(&hw->flows_lock); +- ret = hns3_reconfig_all_rss_filter(hw); +- pthread_mutex_unlock(&hw->flows_lock); +- +- return ret; +-} +- + int + hns3_restore_filter(struct hns3_adapter *hns) + { +@@ -2232,7 +2220,7 @@ hns3_restore_filter(struct hns3_adapter *hns) + if (ret != 0) + return ret; + +- return hns3_restore_rss_filter(hw); ++ return hns3_reconfig_all_rss_filter(hw); + } + + static int +@@ -2624,10 +2612,10 @@ hns3_flow_validate_wrap(struct rte_eth_dev *dev, + struct hns3_filter_info filter_info = {0}; + int ret; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + ret = hns3_flow_validate(dev, attr, pattern, actions, error, + &filter_info); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + + return ret; + } +@@ -2641,9 +2629,9 @@ hns3_flow_create_wrap(struct rte_eth_dev *dev, const struct rte_flow_attr *attr, + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct rte_flow *flow; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + flow = hns3_flow_create(dev, attr, pattern, actions, error); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + + return flow; + } +@@ -2655,9 +2643,9 @@ hns3_flow_destroy_wrap(struct rte_eth_dev *dev, struct rte_flow *flow, + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + int ret; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + ret = hns3_flow_destroy(dev, flow, error); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + + return ret; + } +@@ -2668,9 +2656,9 @@ hns3_flow_flush_wrap(struct rte_eth_dev *dev, struct rte_flow_error *error) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + int ret; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + ret = hns3_flow_flush(dev, error); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + + return ret; + } +@@ -2683,9 +2671,9 @@ hns3_flow_query_wrap(struct rte_eth_dev *dev, struct rte_flow *flow, + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + int ret; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + ret = hns3_flow_query(dev, flow, actions, data, error); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + + return ret; + } +@@ -2733,7 +2721,7 @@ hns3_flow_action_create(struct rte_eth_dev *dev, + if (hns3_check_indir_action(conf, action, error)) + return NULL; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + + act_count = (const struct rte_flow_action_count *)action->conf; + if (act_count->id >= pf->fdir.fd_cfg.cnt_num[HNS3_FD_STAGE_1]) { +@@ -2758,11 +2746,11 @@ hns3_flow_action_create(struct rte_eth_dev *dev, + handle.indirect_type = HNS3_INDIRECT_ACTION_TYPE_COUNT; + handle.counter_id = counter->id; + +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return (struct rte_flow_action_handle *)handle.val64; + + err_exit: +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return NULL; + } + +@@ -2775,11 +2763,11 @@ hns3_flow_action_destroy(struct rte_eth_dev *dev, + struct rte_flow_action_handle indir; + struct hns3_flow_counter *counter; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + + indir.val64 = (uint64_t)handle; + if (indir.indirect_type != HNS3_INDIRECT_ACTION_TYPE_COUNT) { +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Invalid indirect type"); +@@ -2787,14 +2775,14 @@ hns3_flow_action_destroy(struct rte_eth_dev *dev, + + counter = hns3_counter_lookup(dev, indir.counter_id); + if (counter == NULL) { +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Counter id not exist"); + } + + if (counter->ref_cnt > 1) { +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return rte_flow_error_set(error, EBUSY, + RTE_FLOW_ERROR_TYPE_HANDLE, + handle, "Counter id in use"); +@@ -2802,7 +2790,7 @@ hns3_flow_action_destroy(struct rte_eth_dev *dev, + + (void)hns3_counter_release(dev, indir.counter_id); + +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return 0; + } + +@@ -2817,11 +2805,11 @@ hns3_flow_action_query(struct rte_eth_dev *dev, + struct rte_flow flow; + int ret; + +- pthread_mutex_lock(&hw->flows_lock); ++ rte_spinlock_lock(&hw->lock); + + indir.val64 = (uint64_t)handle; + if (indir.indirect_type != HNS3_INDIRECT_ACTION_TYPE_COUNT) { +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ACTION_CONF, + handle, "Invalid indirect type"); +@@ -2831,7 +2819,7 @@ hns3_flow_action_query(struct rte_eth_dev *dev, + flow.counter_id = indir.counter_id; + ret = hns3_counter_query(dev, &flow, + (struct rte_flow_query_count *)data, error); +- pthread_mutex_unlock(&hw->flows_lock); ++ rte_spinlock_unlock(&hw->lock); + return ret; + } + +@@ -2865,14 +2853,10 @@ void + hns3_flow_init(struct rte_eth_dev *dev) + { + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); +- pthread_mutexattr_t attr; + + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return; + +- pthread_mutexattr_init(&attr); +- pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); +- pthread_mutex_init(&hw->flows_lock, &attr); + dev->data->dev_flags |= RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE; + + TAILQ_INIT(&hw->flow_fdir_list); +-- +2.33.0 + diff --git a/0110-net-hns3-fix-overwrite-mbuf-in-vector-path.patch b/0110-net-hns3-fix-overwrite-mbuf-in-vector-path.patch new file mode 100644 index 0000000000000000000000000000000000000000..44faa78a4ede27ee4d5984121a3806ad45a28022 --- /dev/null +++ b/0110-net-hns3-fix-overwrite-mbuf-in-vector-path.patch @@ -0,0 +1,43 @@ +From 602b58abd69a04d156eaea8739545d5791f43ab2 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Fri, 22 Aug 2025 14:04:29 +0800 +Subject: [PATCH] net/hns3: fix overwrite mbuf in vector path + +The vector path processes multiple descriptors at a time and modifies +the corresponding mbufs accordingly. When the mbufs cannot be applied +for, the previous patch [1] only clears the first descriptor's valid +bit, which is not enough. In this patch, the mbufs points to the +fake_mbuf to prevent overwrite. + +[1] 'commit 01843ab2f2fc ("net/hns3: fix crash for NEON and SVE")' + +Fixes: a3d4f4d291d7 ("net/hns3: support NEON Rx") +Fixes: 01843ab2f2fc ("net/hns3: fix crash for NEON and SVE") +Cc: stable@dpdk.org + +Signed-off-by: Chengwen Feng +Signed-off-by: Dengdui Huang +--- + drivers/net/hns3/hns3_rxtx_vec.h | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/drivers/net/hns3/hns3_rxtx_vec.h b/drivers/net/hns3/hns3_rxtx_vec.h +index 9018e79..6afa2fb 100644 +--- a/drivers/net/hns3/hns3_rxtx_vec.h ++++ b/drivers/net/hns3/hns3_rxtx_vec.h +@@ -109,8 +109,12 @@ hns3_rxq_rearm_mbuf(struct hns3_rx_queue *rxq) + /* + * Clear VLD bit for the first descriptor rearmed in case + * of going to receive packets later. ++ * And also point mbufs to fake_mbuf to prevent modification ++ * of the mbuf field during vector packet receiving. + */ + rxdp[0].rx.bd_base_info = 0; ++ for (i = 0; i < HNS3_VECTOR_RX_OFFSET_TABLE_LEN; i++) ++ rxep[i].mbuf = &rxq->fake_mbuf; + rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed++; + return; + } +-- +2.33.0 + diff --git a/0111-net-hns3-fix-unrelease-VLAN-resource-when-init-fail.patch b/0111-net-hns3-fix-unrelease-VLAN-resource-when-init-fail.patch new file mode 100644 index 0000000000000000000000000000000000000000..1abfac7223a060f34d12207134c9b6b25f7df4f7 --- /dev/null +++ b/0111-net-hns3-fix-unrelease-VLAN-resource-when-init-fail.patch @@ -0,0 +1,113 @@ +From 5eb20ce968fe08c63d983e23bd66ccf1e21adf74 Mon Sep 17 00:00:00 2001 +From: Dengdui Huang +Date: Fri, 22 Aug 2025 14:04:28 +0800 +Subject: [PATCH] net/hns3: fix unrelease VLAN resource when init fail + +In the initialization process, it is necessary to release VLAN resources +on the failure branch. + +Additionally, encapsulate a function hns3_uninit_hardware() to release +the resources allocated by the hns3_init_hardware() function. + +Fixes: 411d23b9eafb ("net/hns3: support VLAN") +Cc: stable@dpdk.org + +Signed-off-by: Dengdui Huang +--- + drivers/net/hns3/hns3_ethdev.c | 31 ++++++++++++++++++++----------- + 1 file changed, 20 insertions(+), 11 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index 9e82f41..f74fad4 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -4432,25 +4432,25 @@ hns3_init_hardware(struct hns3_adapter *hns) + ret = hns3_dcb_init(hw); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to init dcb: %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + ret = hns3_init_fd_config(hns); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to init flow director: %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + ret = hns3_config_tso(hw, HNS3_TSO_MSS_MIN, HNS3_TSO_MSS_MAX); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to config tso: %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + ret = hns3_config_gro(hw, false); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to config gro: %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + /* +@@ -4462,22 +4462,33 @@ hns3_init_hardware(struct hns3_adapter *hns) + ret = hns3_init_ring_with_vector(hw); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to init ring intr vector: %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + ret = hns3_ptp_init(hw); + if (ret) { + PMD_INIT_LOG(ERR, "Failed to init PTP, ret = %d", ret); +- goto err_mac_init; ++ goto rm_vlan_table; + } + + return 0; +- ++rm_vlan_table: ++ hns3_rm_all_vlan_table(hns, true); + err_mac_init: + hns3_uninit_umv_space(hw); + return ret; + } + ++static void ++hns3_uninit_hardware(struct hns3_hw *hw) ++{ ++ struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); ++ ++ (void)hns3_uninit_umv_space(hw); ++ hns3_ptp_uninit(hw); ++ hns3_rm_all_vlan_table(hns, true); ++} ++ + static int + hns3_clear_hw(struct hns3_hw *hw) + { +@@ -4689,8 +4700,7 @@ hns3_init_pf(struct rte_eth_dev *eth_dev) + err_enable_intr: + hns3_fdir_filter_uninit(hns); + err_fdir: +- hns3_uninit_umv_space(hw); +- hns3_ptp_uninit(hw); ++ hns3_uninit_hardware(hw); + err_init_hw: + hns3_stats_uninit(hw); + err_get_config: +@@ -4725,8 +4735,7 @@ hns3_uninit_pf(struct rte_eth_dev *eth_dev) + hns3_promisc_uninit(hw); + hns3_flow_uninit(eth_dev); + hns3_fdir_filter_uninit(hns); +- hns3_uninit_umv_space(hw); +- hns3_ptp_uninit(hw); ++ hns3_uninit_hardware(hw); + hns3_stats_uninit(hw); + hns3_config_mac_tnl_int(hw, false); + hns3_pf_disable_irq0(hw); +-- +2.33.0 + diff --git a/dpdk.spec b/dpdk.spec index ef119d7939eb5c2ca0baad86a3284ea09183e5ed..7a090da1e62c2a131d184ac286195ac10272d74f 100644 --- a/dpdk.spec +++ b/dpdk.spec @@ -11,7 +11,7 @@ Name: dpdk Version: 23.11 -Release: 35 +Release: 36 URL: http://dpdk.org Source: https://fast.dpdk.org/rel/dpdk-%{version}.tar.xz @@ -141,6 +141,9 @@ Patch6105: 0105-net-fix-GTP-packet-parsing.patch Patch6106: 0106-net-add-tunnel-length-in-UDP-tunnel-parsing.patch Patch6107: 0107-app-testpmd-fix-tunnel-inner-info.patch Patch6108: 0108-config-arm-adapt-RTE_MAX_NUMA_NODES-to-16.patch +Patch6109: 0109-net-hns3-fix-inconsistent-lock.patch +Patch6110: 0110-net-hns3-fix-overwrite-mbuf-in-vector-path.patch +Patch6111: 0111-net-hns3-fix-unrelease-VLAN-resource-when-init-fail.patch BuildRequires: meson BuildRequires: python3-pyelftools @@ -345,6 +348,12 @@ fi /usr/sbin/depmod %changelog +* Wed Sep 17 2025 huangdonghua - 23.11-36 + Unify locks, fix Rx path and resource release: + - net/hns3: fix inconsistent lock + - net/hns3: fix overwrite mbuf in vector path + - net/hns3: fix unrelease VLAN resource when init fail + * Fri Aug 29 2025 huangdengdui - 23.11-35 - config: arm adapt RTE_MAX_NUMA_NODES to 16