diff --git a/0220-examples-kni-close-port-before-exit.patch b/0220-examples-kni-close-port-before-exit.patch new file mode 100644 index 0000000000000000000000000000000000000000..8032bdffe0111daddf205279f87ce0a7396f1a8f --- /dev/null +++ b/0220-examples-kni-close-port-before-exit.patch @@ -0,0 +1,30 @@ +From 96fdb80048e279289e012fafe762f5b53e2ecd23 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Tue, 14 Sep 2021 14:02:19 +0800 +Subject: [PATCH 01/17] examples/kni: close port before exit + +This patch adds dev_close() step to release network adapter resources +when kni free. + +Signed-off-by: Huisong Li +Signed-off-by: Min Hu (Connor) +Acked-by: Ferruh Yigit +--- + examples/kni/main.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/examples/kni/main.c b/examples/kni/main.c +index fe93b8618..40e1790c4 100644 +--- a/examples/kni/main.c ++++ b/examples/kni/main.c +@@ -1031,6 +1031,7 @@ kni_free_kni(uint16_t port_id) + if (ret != 0) + RTE_LOG(ERR, APP, "Failed to stop port %d: %s\n", + port_id, rte_strerror(-ret)); ++ rte_eth_dev_close(port_id); + + return 0; + } +-- +2.23.0 + diff --git a/0221-net-hns3-fix-residual-MAC-after-setting-default-MAC.patch b/0221-net-hns3-fix-residual-MAC-after-setting-default-MAC.patch new file mode 100644 index 0000000000000000000000000000000000000000..73f59f3a2885fc4c542b92791410af0c1601adec --- /dev/null +++ b/0221-net-hns3-fix-residual-MAC-after-setting-default-MAC.patch @@ -0,0 +1,141 @@ +From 5fcd00f784f9b984bf1f8a084a6be32816585717 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Wed, 22 Sep 2021 11:41:51 +0800 +Subject: [PATCH 02/17] net/hns3: fix residual MAC after setting default MAC + +This problem occurs in the following scenarios: +1) reset is encountered when the adapter is running. +2) set a new default MAC address + +After the above two steps, the old default MAC address should be not +take effect. But the current behavior is contrary to that. This is due +to the change of the "default_addr_setted" in hw->mac from 'true' to +'false' after the reset. As a result, the old MAC address is not removed +when the new default MAC address is set. This variable controls whether +to delete the old default MAC address when setting the default MAC +address. It is only used when the mac_addr_set API is called for the +first time. In fact, when a unicast MAC address is deleted, if the +address isn't in the MAC address table, the driver doesn't return +failure. So this patch remove the redundant and troublesome variables to +resolve this problem. + +Fixes: 7d7f9f80bbfb ("net/hns3: support MAC address related operations") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Signed-off-by: Min Hu (Connor) +--- + drivers/net/hns3/hns3_ethdev.c | 38 ++++++++++------------------------ + drivers/net/hns3/hns3_ethdev.h | 1 - + 2 files changed, 11 insertions(+), 28 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index 2fb0c466c..d6228601f 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -1651,7 +1651,7 @@ hns3_remove_mc_addr_common(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + + static int + hns3_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr, +- uint32_t idx, __rte_unused uint32_t pool) ++ __rte_unused uint32_t idx, __rte_unused uint32_t pool) + { + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; +@@ -1682,8 +1682,6 @@ hns3_add_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr, + return ret; + } + +- if (idx == 0) +- hw->mac.default_addr_setted = true; + rte_spinlock_unlock(&hw->lock); + + return ret; +@@ -1748,30 +1746,19 @@ hns3_set_default_mac_addr(struct rte_eth_dev *dev, + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct rte_ether_addr *oaddr; + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; +- bool default_addr_setted; + int ret, ret_val; + +- /* +- * It has been guaranteed that input parameter named mac_addr is valid +- * address in the rte layer of DPDK framework. +- */ +- oaddr = (struct rte_ether_addr *)hw->mac.mac_addr; +- default_addr_setted = hw->mac.default_addr_setted; +- if (default_addr_setted && !!rte_is_same_ether_addr(mac_addr, oaddr)) +- return 0; +- + rte_spinlock_lock(&hw->lock); +- if (default_addr_setted) { +- ret = hns3_remove_uc_addr_common(hw, oaddr); +- if (ret) { +- hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, +- oaddr); +- hns3_warn(hw, "Remove old uc mac address(%s) fail: %d", +- mac_str, ret); ++ oaddr = (struct rte_ether_addr *)hw->mac.mac_addr; ++ ret = hns3_remove_uc_addr_common(hw, oaddr); ++ if (ret) { ++ hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, ++ oaddr); ++ hns3_warn(hw, "Remove old uc mac address(%s) fail: %d", ++ mac_str, ret); + +- rte_spinlock_unlock(&hw->lock); +- return ret; +- } ++ rte_spinlock_unlock(&hw->lock); ++ return ret; + } + + ret = hns3_add_uc_addr_common(hw, mac_addr); +@@ -1790,7 +1777,6 @@ hns3_set_default_mac_addr(struct rte_eth_dev *dev, + + rte_ether_addr_copy(mac_addr, + (struct rte_ether_addr *)hw->mac.mac_addr); +- hw->mac.default_addr_setted = true; + rte_spinlock_unlock(&hw->lock); + + return 0; +@@ -1811,7 +1797,6 @@ hns3_set_default_mac_addr(struct rte_eth_dev *dev, + hns3_ether_format_addr(mac_str, RTE_ETHER_ADDR_FMT_SIZE, oaddr); + hns3_warn(hw, "Failed to restore old uc mac addr(%s): %d", + mac_str, ret_val); +- hw->mac.default_addr_setted = false; + } + rte_spinlock_unlock(&hw->lock); + +@@ -3470,7 +3455,6 @@ hns3_get_board_configuration(struct hns3_hw *hw) + hw->rss_dis_flag = false; + memcpy(hw->mac.mac_addr, cfg.mac_addr, RTE_ETHER_ADDR_LEN); + hw->mac.phy_addr = cfg.phy_addr; +- hw->mac.default_addr_setted = false; + hw->num_tx_desc = cfg.tqp_desc_num; + hw->num_rx_desc = cfg.tqp_desc_num; + hw->dcb_info.num_pg = 1; +@@ -5928,7 +5912,7 @@ hns3_do_stop(struct hns3_adapter *hns) + return ret; + } + } +- hw->mac.default_addr_setted = false; ++ + return 0; + } + +diff --git a/drivers/net/hns3/hns3_ethdev.h b/drivers/net/hns3/hns3_ethdev.h +index ab44894a8..57387e05b 100644 +--- a/drivers/net/hns3/hns3_ethdev.h ++++ b/drivers/net/hns3/hns3_ethdev.h +@@ -188,7 +188,6 @@ enum hns3_media_type { + + struct hns3_mac { + uint8_t mac_addr[RTE_ETHER_ADDR_LEN]; +- bool default_addr_setted; /* whether default addr(mac_addr) is set */ + uint8_t media_type; + uint8_t phy_addr; + uint8_t link_duplex : 1; /* ETH_LINK_[HALF/FULL]_DUPLEX */ +-- +2.23.0 + diff --git a/0222-net-hns3-fix-input-parameters-of-MAC-functions.patch b/0222-net-hns3-fix-input-parameters-of-MAC-functions.patch new file mode 100644 index 0000000000000000000000000000000000000000..91c7ef66aaca14cf75b09582f15f3d35e3594ce4 --- /dev/null +++ b/0222-net-hns3-fix-input-parameters-of-MAC-functions.patch @@ -0,0 +1,210 @@ +From bc25acd9ac200067f0f1a68c192076a65e4c76e6 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Wed, 22 Sep 2021 11:41:52 +0800 +Subject: [PATCH 03/17] net/hns3: fix input parameters of MAC functions + +When adding multicast and unicast MAC addresses, three descriptors and +one descriptor are required for querying or adding MAC VLAN table, +respectively. This patch uses the number of descriptors as input +parameter to complete this task to make the function more secure. + +Fixes: 7d7f9f80bbfb ("net/hns3: support MAC address related operations") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Signed-off-by: Min Hu (Connor) +--- + drivers/net/hns3/hns3_cmd.h | 3 +- + drivers/net/hns3/hns3_ethdev.c | 88 +++++++++++++++++++--------------- + 2 files changed, 51 insertions(+), 40 deletions(-) + +diff --git a/drivers/net/hns3/hns3_cmd.h b/drivers/net/hns3/hns3_cmd.h +index a4683de0a..81bc9e9d9 100644 +--- a/drivers/net/hns3/hns3_cmd.h ++++ b/drivers/net/hns3/hns3_cmd.h +@@ -923,7 +923,8 @@ enum hns3_mac_vlan_add_resp_code { + HNS3_ADD_MC_OVERFLOW, /* ADD failed for MC overflow */ + }; + +-#define HNS3_MC_MAC_VLAN_ADD_DESC_NUM 3 ++#define HNS3_MC_MAC_VLAN_OPS_DESC_NUM 3 ++#define HNS3_UC_MAC_VLAN_OPS_DESC_NUM 1 + + #define HNS3_MAC_VLAN_BIT0_EN_B 0 + #define HNS3_MAC_VLAN_BIT1_EN_B 1 +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index d6228601f..02d68e496 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -1427,28 +1427,31 @@ hns3_get_mac_vlan_cmd_status(struct hns3_hw *hw, uint16_t cmdq_resp, + static int + hns3_lookup_mac_vlan_tbl(struct hns3_hw *hw, + struct hns3_mac_vlan_tbl_entry_cmd *req, +- struct hns3_cmd_desc *desc, bool is_mc) ++ struct hns3_cmd_desc *desc, uint8_t desc_num) + { + uint8_t resp_code; + uint16_t retval; + int ret; ++ int i; + +- hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_MAC_VLAN_ADD, true); +- if (is_mc) { +- desc[0].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); +- memcpy(desc[0].data, req, +- sizeof(struct hns3_mac_vlan_tbl_entry_cmd)); +- hns3_cmd_setup_basic_desc(&desc[1], HNS3_OPC_MAC_VLAN_ADD, +- true); +- desc[1].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); +- hns3_cmd_setup_basic_desc(&desc[2], HNS3_OPC_MAC_VLAN_ADD, ++ if (desc_num == HNS3_MC_MAC_VLAN_OPS_DESC_NUM) { ++ for (i = 0; i < desc_num - 1; i++) { ++ hns3_cmd_setup_basic_desc(&desc[i], ++ HNS3_OPC_MAC_VLAN_ADD, true); ++ desc[i].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); ++ if (i == 0) ++ memcpy(desc[i].data, req, ++ sizeof(struct hns3_mac_vlan_tbl_entry_cmd)); ++ } ++ hns3_cmd_setup_basic_desc(&desc[i], HNS3_OPC_MAC_VLAN_ADD, + true); +- ret = hns3_cmd_send(hw, desc, HNS3_MC_MAC_VLAN_ADD_DESC_NUM); + } else { ++ hns3_cmd_setup_basic_desc(&desc[0], HNS3_OPC_MAC_VLAN_ADD, ++ true); + memcpy(desc[0].data, req, + sizeof(struct hns3_mac_vlan_tbl_entry_cmd)); +- ret = hns3_cmd_send(hw, desc, 1); + } ++ ret = hns3_cmd_send(hw, desc, desc_num); + if (ret) { + hns3_err(hw, "lookup mac addr failed for cmd_send, ret =%d.", + ret); +@@ -1464,38 +1467,40 @@ hns3_lookup_mac_vlan_tbl(struct hns3_hw *hw, + static int + hns3_add_mac_vlan_tbl(struct hns3_hw *hw, + struct hns3_mac_vlan_tbl_entry_cmd *req, +- struct hns3_cmd_desc *mc_desc) ++ struct hns3_cmd_desc *desc, uint8_t desc_num) + { + uint8_t resp_code; + uint16_t retval; + int cfg_status; + int ret; ++ int i; + +- if (mc_desc == NULL) { +- struct hns3_cmd_desc desc; +- +- hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_MAC_VLAN_ADD, false); +- memcpy(desc.data, req, ++ if (desc_num == HNS3_UC_MAC_VLAN_OPS_DESC_NUM) { ++ hns3_cmd_setup_basic_desc(desc, HNS3_OPC_MAC_VLAN_ADD, false); ++ memcpy(desc->data, req, + sizeof(struct hns3_mac_vlan_tbl_entry_cmd)); +- ret = hns3_cmd_send(hw, &desc, 1); +- resp_code = (rte_le_to_cpu_32(desc.data[0]) >> 8) & 0xff; +- retval = rte_le_to_cpu_16(desc.retval); ++ ret = hns3_cmd_send(hw, desc, desc_num); ++ resp_code = (rte_le_to_cpu_32(desc->data[0]) >> 8) & 0xff; ++ retval = rte_le_to_cpu_16(desc->retval); + + cfg_status = hns3_get_mac_vlan_cmd_status(hw, retval, resp_code, + HNS3_MAC_VLAN_ADD); + } else { +- hns3_cmd_reuse_desc(&mc_desc[0], false); +- mc_desc[0].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); +- hns3_cmd_reuse_desc(&mc_desc[1], false); +- mc_desc[1].flag |= rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); +- hns3_cmd_reuse_desc(&mc_desc[2], false); +- mc_desc[2].flag &= rte_cpu_to_le_16(~HNS3_CMD_FLAG_NEXT); +- memcpy(mc_desc[0].data, req, ++ for (i = 0; i < desc_num; i++) { ++ hns3_cmd_reuse_desc(&desc[i], false); ++ if (i == desc_num - 1) ++ desc[i].flag &= ++ rte_cpu_to_le_16(~HNS3_CMD_FLAG_NEXT); ++ else ++ desc[i].flag |= ++ rte_cpu_to_le_16(HNS3_CMD_FLAG_NEXT); ++ } ++ memcpy(desc[0].data, req, + sizeof(struct hns3_mac_vlan_tbl_entry_cmd)); +- mc_desc[0].retval = 0; +- ret = hns3_cmd_send(hw, mc_desc, HNS3_MC_MAC_VLAN_ADD_DESC_NUM); +- resp_code = (rte_le_to_cpu_32(mc_desc[0].data[0]) >> 8) & 0xff; +- retval = rte_le_to_cpu_16(mc_desc[0].retval); ++ desc[0].retval = 0; ++ ret = hns3_cmd_send(hw, desc, desc_num); ++ resp_code = (rte_le_to_cpu_32(desc[0].data[0]) >> 8) & 0xff; ++ retval = rte_le_to_cpu_16(desc[0].retval); + + cfg_status = hns3_get_mac_vlan_cmd_status(hw, retval, resp_code, + HNS3_MAC_VLAN_ADD); +@@ -1540,7 +1545,7 @@ hns3_add_uc_addr_common(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + struct hns3_mac_vlan_tbl_entry_cmd req; + struct hns3_pf *pf = &hns->pf; +- struct hns3_cmd_desc desc[3]; ++ struct hns3_cmd_desc desc; + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; + uint16_t egress_port = 0; + uint8_t vf_id; +@@ -1574,10 +1579,12 @@ hns3_add_uc_addr_common(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + * it if the entry is inexistent. Repeated unicast entry + * is not allowed in the mac vlan table. + */ +- ret = hns3_lookup_mac_vlan_tbl(hw, &req, desc, false); ++ ret = hns3_lookup_mac_vlan_tbl(hw, &req, &desc, ++ HNS3_UC_MAC_VLAN_OPS_DESC_NUM); + if (ret == -ENOENT) { + if (!hns3_is_umv_space_full(hw)) { +- ret = hns3_add_mac_vlan_tbl(hw, &req, NULL); ++ ret = hns3_add_mac_vlan_tbl(hw, &req, &desc, ++ HNS3_UC_MAC_VLAN_OPS_DESC_NUM); + if (!ret) + hns3_update_umv_space(hw, false); + return ret; +@@ -1867,8 +1874,8 @@ hns3_update_desc_vfid(struct hns3_cmd_desc *desc, uint8_t vfid, bool clr) + static int + hns3_add_mc_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + { ++ struct hns3_cmd_desc desc[HNS3_MC_MAC_VLAN_OPS_DESC_NUM]; + struct hns3_mac_vlan_tbl_entry_cmd req; +- struct hns3_cmd_desc desc[3]; + char mac_str[RTE_ETHER_ADDR_FMT_SIZE]; + uint8_t vf_id; + int ret; +@@ -1885,7 +1892,8 @@ hns3_add_mc_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + memset(&req, 0, sizeof(req)); + hns3_set_bit(req.entry_type, HNS3_MAC_VLAN_BIT0_EN_B, 0); + hns3_prepare_mac_addr(&req, mac_addr->addr_bytes, true); +- ret = hns3_lookup_mac_vlan_tbl(hw, &req, desc, true); ++ ret = hns3_lookup_mac_vlan_tbl(hw, &req, desc, ++ HNS3_MC_MAC_VLAN_OPS_DESC_NUM); + if (ret) { + /* This mac addr do not exist, add new entry for it */ + memset(desc[0].data, 0, sizeof(desc[0].data)); +@@ -1899,7 +1907,8 @@ hns3_add_mc_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + */ + vf_id = HNS3_PF_FUNC_ID; + hns3_update_desc_vfid(desc, vf_id, false); +- ret = hns3_add_mac_vlan_tbl(hw, &req, desc); ++ ret = hns3_add_mac_vlan_tbl(hw, &req, desc, ++ HNS3_MC_MAC_VLAN_OPS_DESC_NUM); + if (ret) { + if (ret == -ENOSPC) + hns3_err(hw, "mc mac vlan table is full"); +@@ -1932,7 +1941,8 @@ hns3_remove_mc_addr(struct hns3_hw *hw, struct rte_ether_addr *mac_addr) + memset(&req, 0, sizeof(req)); + hns3_set_bit(req.entry_type, HNS3_MAC_VLAN_BIT0_EN_B, 0); + hns3_prepare_mac_addr(&req, mac_addr->addr_bytes, true); +- ret = hns3_lookup_mac_vlan_tbl(hw, &req, desc, true); ++ ret = hns3_lookup_mac_vlan_tbl(hw, &req, desc, ++ HNS3_MC_MAC_VLAN_OPS_DESC_NUM); + if (ret == 0) { + /* + * This mac addr exist, remove this handle's VFID for it. +-- +2.23.0 + diff --git a/0223-net-bonding-fix-dedicated-queue-mode-in-vector-burst.patch b/0223-net-bonding-fix-dedicated-queue-mode-in-vector-burst.patch new file mode 100644 index 0000000000000000000000000000000000000000..031c285552c82ee00600324932843daf4ad351ec --- /dev/null +++ b/0223-net-bonding-fix-dedicated-queue-mode-in-vector-burst.patch @@ -0,0 +1,84 @@ +From 19dc6356916c60f282b6d3046f5d2f1d74d48d35 Mon Sep 17 00:00:00 2001 +From: Chengchang Tang +Date: Wed, 22 Sep 2021 15:09:12 +0800 +Subject: [PATCH 10/17] net/bonding: fix dedicated queue mode in vector burst + +If the vector burst mode is selected, the dedicated queue mode will not +take effect on some PMDs because these PMDs may have some limitations +in vector burst mode. For example, the limit on burst size. Currently, +both hns3 and intel I40E require four alignments when receiving packets +in vector mode. As a result, they can't accept packets if burst size +below four. However, in dedicated queue mode, the burst size of periodic +packets processing is one. + +This patch fixes the above problem by modifying the burst size to 32. +This approach also makes the packet processing of the dedicated queue +mode more reasonable. Currently, if multiple LACP protocol packets are +received in the hardware queue in a cycle, only one LACP packet will be +processed in this cycle, and the left packets will be processed in the +following cycle. After the modification, all the LACP packets will be +processed at one time, which seems more reasonable and closer to the +behavior of the bonding driver when the dedicated queue is not turned on. + +Fixes: 112891cd27e5 ("net/bonding: add dedicated HW queues for LACP control") +Cc: stable@dpdk.org + +Signed-off-by: Chengchang Tang +Signed-off-by: Min Hu (Connor) +--- + drivers/net/bonding/rte_eth_bond_8023ad.c | 32 ++++++++++++++++------- + 1 file changed, 23 insertions(+), 9 deletions(-) + +diff --git a/drivers/net/bonding/rte_eth_bond_8023ad.c b/drivers/net/bonding/rte_eth_bond_8023ad.c +index 67ca0730f..0bcce6652 100644 +--- a/drivers/net/bonding/rte_eth_bond_8023ad.c ++++ b/drivers/net/bonding/rte_eth_bond_8023ad.c +@@ -823,6 +823,27 @@ rx_machine_update(struct bond_dev_private *internals, uint16_t slave_id, + rx_machine(internals, slave_id, NULL); + } + ++static void ++bond_mode_8023ad_dedicated_rxq_process(struct bond_dev_private *internals, ++ uint16_t slave_id) ++{ ++#define DEDICATED_QUEUE_BURST_SIZE 32 ++ struct rte_mbuf *lacp_pkt[DEDICATED_QUEUE_BURST_SIZE]; ++ uint16_t rx_count = rte_eth_rx_burst(slave_id, ++ internals->mode4.dedicated_queues.rx_qid, ++ lacp_pkt, DEDICATED_QUEUE_BURST_SIZE); ++ ++ if (rx_count) { ++ uint16_t i; ++ ++ for (i = 0; i < rx_count; i++) ++ bond_mode_8023ad_handle_slow_pkt(internals, slave_id, ++ lacp_pkt[i]); ++ } else { ++ rx_machine_update(internals, slave_id, NULL); ++ } ++} ++ + static void + bond_mode_8023ad_periodic_cb(void *arg) + { +@@ -911,15 +932,8 @@ bond_mode_8023ad_periodic_cb(void *arg) + + rx_machine_update(internals, slave_id, lacp_pkt); + } else { +- uint16_t rx_count = rte_eth_rx_burst(slave_id, +- internals->mode4.dedicated_queues.rx_qid, +- &lacp_pkt, 1); +- +- if (rx_count == 1) +- bond_mode_8023ad_handle_slow_pkt(internals, +- slave_id, lacp_pkt); +- else +- rx_machine_update(internals, slave_id, NULL); ++ bond_mode_8023ad_dedicated_rxq_process(internals, ++ slave_id); + } + + periodic_machine(internals, slave_id); +-- +2.23.0 + diff --git a/0224-net-bonding-fix-RSS-key-length.patch b/0224-net-bonding-fix-RSS-key-length.patch new file mode 100644 index 0000000000000000000000000000000000000000..fbf9a1ef6772d510b9fd7e4267b400afe1b4804b --- /dev/null +++ b/0224-net-bonding-fix-RSS-key-length.patch @@ -0,0 +1,143 @@ +From 464bfbd345224ddb04399297988c0d99cbe8acc6 Mon Sep 17 00:00:00 2001 +From: Chengchang Tang +Date: Wed, 22 Sep 2021 15:09:13 +0800 +Subject: [PATCH 11/17] net/bonding: fix RSS key length + +Currently the hash_key_size information has not been set. So, apps can +not get the key size from dev_info(), this make some problem. + +e.g, in testpmd, the hash_key_size will be checked before configure +or get the hash key: +testpmd> show port 4 rss-hash +dev_info did not provide a valid hash key size +testpmd> show port 4 rss-hash key +dev_info did not provide a valid hash key size +testpmd> port config 4 rss-hash-key ipv4 (hash key) +dev_info did not provide a valid hash key size + +In this patch, the meaning of rss_key_len has been modified. It only +indicated the length of the configured hash key before. Therefore, +its value depends on the user's configuration. This seems unreasonable. +And now, it indicates the minimum hash key length required by the +bonded device. Its value will be the shortest hash key among all slave +drivers. + +Fixes: 734ce47f71e0 ("bonding: support RSS dynamic configuration") +Cc: stable@dpdk.org + +Signed-off-by: Chengchang Tang +Signed-off-by: Min Hu (Connor) +--- + drivers/net/bonding/rte_eth_bond_api.c | 6 ++++ + drivers/net/bonding/rte_eth_bond_pmd.c | 44 ++++++++++++++++---------- + 2 files changed, 33 insertions(+), 17 deletions(-) + +diff --git a/drivers/net/bonding/rte_eth_bond_api.c b/drivers/net/bonding/rte_eth_bond_api.c +index 44775f61e..c751a1242 100644 +--- a/drivers/net/bonding/rte_eth_bond_api.c ++++ b/drivers/net/bonding/rte_eth_bond_api.c +@@ -290,6 +290,7 @@ eth_bond_slave_inherit_dev_info_rx_first(struct bond_dev_private *internals, + struct rte_eth_rxconf *rxconf_i = &internals->default_rxconf; + + internals->reta_size = di->reta_size; ++ internals->rss_key_len = di->hash_key_size; + + /* Inherit Rx offload capabilities from the first slave device */ + internals->rx_offload_capa = di->rx_offload_capa; +@@ -385,6 +386,11 @@ eth_bond_slave_inherit_dev_info_rx_next(struct bond_dev_private *internals, + */ + if (internals->reta_size > di->reta_size) + internals->reta_size = di->reta_size; ++ if (internals->rss_key_len > di->hash_key_size) { ++ RTE_BOND_LOG(WARNING, "slave has different rss key size, " ++ "configuring rss may fail"); ++ internals->rss_key_len = di->hash_key_size; ++ } + + if (!internals->max_rx_pktlen && + di->max_rx_pktlen < internals->candidate_max_rx_pktlen) +diff --git a/drivers/net/bonding/rte_eth_bond_pmd.c b/drivers/net/bonding/rte_eth_bond_pmd.c +index 057b1ada5..c21df6d6f 100644 +--- a/drivers/net/bonding/rte_eth_bond_pmd.c ++++ b/drivers/net/bonding/rte_eth_bond_pmd.c +@@ -1705,14 +1705,11 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev, + + /* If RSS is enabled for bonding, try to enable it for slaves */ + if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) { +- if (internals->rss_key_len != 0) { +- slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len = ++ /* rss_key won't be empty if RSS is configured in bonded dev */ ++ slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len = + internals->rss_key_len; +- slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = ++ slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = + internals->rss_key; +- } else { +- slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL; +- } + + slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf = + bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf; +@@ -2234,6 +2231,7 @@ bond_ethdev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) + dev_info->flow_type_rss_offloads = internals->flow_type_rss_offloads; + + dev_info->reta_size = internals->reta_size; ++ dev_info->hash_key_size = internals->rss_key_len; + + return 0; + } +@@ -3023,13 +3021,15 @@ bond_ethdev_rss_hash_update(struct rte_eth_dev *dev, + if (bond_rss_conf.rss_hf != 0) + dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf = bond_rss_conf.rss_hf; + +- if (bond_rss_conf.rss_key && bond_rss_conf.rss_key_len < +- sizeof(internals->rss_key)) { +- if (bond_rss_conf.rss_key_len == 0) +- bond_rss_conf.rss_key_len = 40; +- internals->rss_key_len = bond_rss_conf.rss_key_len; ++ if (bond_rss_conf.rss_key) { ++ if (bond_rss_conf.rss_key_len < internals->rss_key_len) ++ return -EINVAL; ++ else if (bond_rss_conf.rss_key_len > internals->rss_key_len) ++ RTE_BOND_LOG(WARNING, "rss_key will be truncated"); ++ + memcpy(internals->rss_key, bond_rss_conf.rss_key, + internals->rss_key_len); ++ bond_rss_conf.rss_key_len = internals->rss_key_len; + } + + for (i = 0; i < internals->slave_count; i++) { +@@ -3491,14 +3491,24 @@ bond_ethdev_configure(struct rte_eth_dev *dev) + * Fall back to default RSS key if the key is not specified + */ + if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) { +- if (dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key != NULL) { +- internals->rss_key_len = +- dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len; +- memcpy(internals->rss_key, +- dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key, ++ struct rte_eth_rss_conf *rss_conf = ++ &dev->data->dev_conf.rx_adv_conf.rss_conf; ++ if (rss_conf->rss_key != NULL) { ++ if (internals->rss_key_len > rss_conf->rss_key_len) { ++ RTE_BOND_LOG(ERR, "Invalid rss key length(%u)", ++ rss_conf->rss_key_len); ++ return -EINVAL; ++ } ++ ++ memcpy(internals->rss_key, rss_conf->rss_key, + internals->rss_key_len); + } else { +- internals->rss_key_len = sizeof(default_rss_key); ++ if (internals->rss_key_len > sizeof(default_rss_key)) { ++ RTE_BOND_LOG(ERR, ++ "There is no suitable default hash key"); ++ return -EINVAL; ++ } ++ + memcpy(internals->rss_key, default_rss_key, + internals->rss_key_len); + } +-- +2.23.0 + diff --git a/0225-app-testpmd-add-command-to-show-LACP-bonding-info.patch b/0225-app-testpmd-add-command-to-show-LACP-bonding-info.patch new file mode 100644 index 0000000000000000000000000000000000000000..380433f536c9e006222845a3207588924c0684ee --- /dev/null +++ b/0225-app-testpmd-add-command-to-show-LACP-bonding-info.patch @@ -0,0 +1,247 @@ +From 992fb12f5a2061144190986a1a82c64f9b324e5b Mon Sep 17 00:00:00 2001 +From: Chengchang Tang +Date: Fri, 24 Sep 2021 17:57:20 +0800 +Subject: [PATCH 12/17] app/testpmd: add command to show LACP bonding info + +Add a new cmdline to help diagnostic the bonding mode 4 in testpmd. + +Show the lacp information about the bonded device and its slaves: +show bonding lacp info + +Signed-off-by: Chengchang Tang +Signed-off-by: Min Hu (Connor) +Acked-by: Xiaoyun Li +--- + app/test-pmd/cmdline.c | 184 ++++++++++++++++++++ + doc/guides/testpmd_app_ug/testpmd_funcs.rst | 6 + + 2 files changed, 190 insertions(+) + +diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c +index b69c648bf..5691fab94 100644 +--- a/app/test-pmd/cmdline.c ++++ b/app/test-pmd/cmdline.c +@@ -631,6 +631,9 @@ static void cmd_help_long_parsed(void *parsed_result, + "show bonding config (port_id)\n" + " Show the bonding config for port_id.\n\n" + ++ "show bonding lacp info (port_id)\n" ++ " Show the bonding lacp information for port_id.\n\n" ++ + "set bonding mac_addr (port_id) (address)\n" + " Set the MAC address of a bonded device.\n\n" + +@@ -6040,6 +6043,186 @@ cmdline_parse_inst_t cmd_set_balance_xmit_policy = { + } + }; + ++/* *** SHOW IEEE802.3 BONDING INFORMATION *** */ ++struct cmd_show_bonding_lacp_info_result { ++ cmdline_fixed_string_t show; ++ cmdline_fixed_string_t bonding; ++ cmdline_fixed_string_t lacp; ++ cmdline_fixed_string_t info; ++ portid_t port_id; ++}; ++ ++static void port_param_show(struct port_params *params) ++{ ++ char buf[RTE_ETHER_ADDR_FMT_SIZE]; ++ ++ printf("\t\tsystem priority: %u\n", params->system_priority); ++ rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, ¶ms->system); ++ printf("\t\tsystem mac address: %s\n", buf); ++ printf("\t\tport key: %u\n", params->key); ++ printf("\t\tport priority: %u\n", params->port_priority); ++ printf("\t\tport number: %u\n", params->port_number); ++} ++ ++static void lacp_slave_info_show(struct rte_eth_bond_8023ad_slave_info *info) ++{ ++ char a_state[256] = { 0 }; ++ char p_state[256] = { 0 }; ++ int a_len = 0; ++ int p_len = 0; ++ uint32_t i; ++ ++ static const char * const state[] = { ++ "ACTIVE", ++ "TIMEOUT", ++ "AGGREGATION", ++ "SYNCHRONIZATION", ++ "COLLECTING", ++ "DISTRIBUTING", ++ "DEFAULTED", ++ "EXPIRED" ++ }; ++ static const char * const selection[] = { ++ "UNSELECTED", ++ "STANDBY", ++ "SELECTED" ++ }; ++ ++ for (i = 0; i < RTE_DIM(state); i++) { ++ if ((info->actor_state >> i) & 1) ++ a_len += snprintf(&a_state[a_len], ++ RTE_DIM(a_state) - a_len, "%s ", ++ state[i]); ++ ++ if ((info->partner_state >> i) & 1) ++ p_len += snprintf(&p_state[p_len], ++ RTE_DIM(p_state) - p_len, "%s ", ++ state[i]); ++ } ++ printf("\tAggregator port id: %u\n", info->agg_port_id); ++ printf("\tselection: %s\n", selection[info->selected]); ++ printf("\tActor detail info:\n"); ++ port_param_show(&info->actor); ++ printf("\t\tport state: %s\n", a_state); ++ printf("\tPartner detail info:\n"); ++ port_param_show(&info->partner); ++ printf("\t\tport state: %s\n", p_state); ++ printf("\n"); ++} ++ ++static void lacp_conf_show(struct rte_eth_bond_8023ad_conf *conf) ++{ ++ printf("\tfast period: %u ms\n", conf->fast_periodic_ms); ++ printf("\tslow period: %u ms\n", conf->slow_periodic_ms); ++ printf("\tshort timeout: %u ms\n", conf->short_timeout_ms); ++ printf("\tlong timeout: %u ms\n", conf->long_timeout_ms); ++ printf("\taggregate wait timeout: %u ms\n", ++ conf->aggregate_wait_timeout_ms); ++ printf("\ttx period: %u ms\n", conf->tx_period_ms); ++ printf("\trx marker period: %u ms\n", conf->rx_marker_period_ms); ++ printf("\tupdate timeout: %u ms\n", conf->update_timeout_ms); ++ switch (conf->agg_selection) { ++ case AGG_BANDWIDTH: ++ printf("\taggregation mode: bandwidth\n"); ++ break; ++ case AGG_STABLE: ++ printf("\taggregation mode: stable\n"); ++ break; ++ case AGG_COUNT: ++ printf("\taggregation mode: count\n"); ++ break; ++ default: ++ printf("\taggregation mode: invalid\n"); ++ break; ++ } ++ ++ printf("\n"); ++} ++ ++static void cmd_show_bonding_lacp_info_parsed(void *parsed_result, ++ __rte_unused struct cmdline *cl, ++ __rte_unused void *data) ++{ ++ struct cmd_show_bonding_lacp_info_result *res = parsed_result; ++ struct rte_eth_bond_8023ad_slave_info slave_info; ++ struct rte_eth_bond_8023ad_conf port_conf; ++ portid_t slaves[RTE_MAX_ETHPORTS]; ++ portid_t port_id = res->port_id; ++ int num_active_slaves; ++ int bonding_mode; ++ int i; ++ int ret; ++ ++ bonding_mode = rte_eth_bond_mode_get(port_id); ++ if (bonding_mode != BONDING_MODE_8023AD) { ++ fprintf(stderr, "\tBonding mode is not mode 4\n"); ++ return; ++ } ++ ++ num_active_slaves = rte_eth_bond_active_slaves_get(port_id, slaves, ++ RTE_MAX_ETHPORTS); ++ if (num_active_slaves < 0) { ++ fprintf(stderr, "\tFailed to get active slave list for port = %u\n", ++ port_id); ++ return; ++ } ++ if (num_active_slaves == 0) ++ fprintf(stderr, "\tIEEE802.3 port %u has no active slave\n", ++ port_id); ++ ++ printf("\tIEEE802.3 port: %u\n", port_id); ++ ret = rte_eth_bond_8023ad_conf_get(port_id, &port_conf); ++ if (ret) { ++ fprintf(stderr, "\tGet bonded device %u info failed\n", ++ port_id); ++ return; ++ } ++ lacp_conf_show(&port_conf); ++ ++ for (i = 0; i < num_active_slaves; i++) { ++ ret = rte_eth_bond_8023ad_slave_info(port_id, slaves[i], ++ &slave_info); ++ if (ret) { ++ fprintf(stderr, "\tGet slave device %u info failed\n", ++ slaves[i]); ++ return; ++ } ++ printf("\tSlave Port: %u\n", slaves[i]); ++ lacp_slave_info_show(&slave_info); ++ } ++} ++ ++cmdline_parse_token_string_t cmd_show_bonding_lacp_info_show = ++TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, ++ show, "show"); ++cmdline_parse_token_string_t cmd_show_bonding_lacp_info_bonding = ++TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, ++ bonding, "bonding"); ++cmdline_parse_token_string_t cmd_show_bonding_lacp_info_lacp = ++TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, ++ bonding, "lacp"); ++cmdline_parse_token_string_t cmd_show_bonding_lacp_info_info = ++TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, ++ info, "info"); ++cmdline_parse_token_num_t cmd_show_bonding_lacp_info_port_id = ++TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_lacp_info_result, ++ port_id, RTE_UINT16); ++ ++cmdline_parse_inst_t cmd_show_bonding_lacp_info = { ++ .f = cmd_show_bonding_lacp_info_parsed, ++ .help_str = "show bonding lacp info : " ++ "Show bonding IEEE802.3 information for port_id", ++ .data = NULL, ++ .tokens = { ++ (void *)&cmd_show_bonding_lacp_info_show, ++ (void *)&cmd_show_bonding_lacp_info_bonding, ++ (void *)&cmd_show_bonding_lacp_info_lacp, ++ (void *)&cmd_show_bonding_lacp_info_info, ++ (void *)&cmd_show_bonding_lacp_info_port_id, ++ NULL ++ } ++}; ++ + /* *** SHOW NIC BONDING CONFIGURATION *** */ + struct cmd_show_bonding_config_result { + cmdline_fixed_string_t show; +@@ -17027,6 +17210,7 @@ cmdline_parse_ctx_t main_ctx[] = { + #ifdef RTE_NET_BOND + (cmdline_parse_inst_t *) &cmd_set_bonding_mode, + (cmdline_parse_inst_t *) &cmd_show_bonding_config, ++ (cmdline_parse_inst_t *) &cmd_show_bonding_lacp_info, + (cmdline_parse_inst_t *) &cmd_set_bonding_primary, + (cmdline_parse_inst_t *) &cmd_add_bonding_slave, + (cmdline_parse_inst_t *) &cmd_remove_bonding_slave, +diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst +index f0e04232a..d5e85b083 100644 +--- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst ++++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst +@@ -2609,6 +2609,12 @@ in balance mode with a transmission policy of layer 2+3:: + Active Slaves (3): [1 3 4] + Primary: [3] + ++show bonding lacp info ++~~~~~~~~~~~~~~~~~~~~~~ ++ ++Show information about the Link Bonding device in mode 4 (link-aggregation-802.3ad):: ++ ++ testpmd> show bonding lacp info (port_id) + + Register Functions + ------------------ +-- +2.23.0 + diff --git a/0226-app-testpmd-retain-all-original-dev-conf-when-config.patch b/0226-app-testpmd-retain-all-original-dev-conf-when-config.patch new file mode 100644 index 0000000000000000000000000000000000000000..3dc1ec418b8ecd14375a0b4aa234c6034418ce5f --- /dev/null +++ b/0226-app-testpmd-retain-all-original-dev-conf-when-config.patch @@ -0,0 +1,40 @@ +From 65de76da4d8fc270af6bce73334399d0d3c20fa3 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 11 Oct 2021 17:12:46 +0800 +Subject: [PATCH 13/17] app/testpmd: retain all original dev conf when config + DCB + +When configuring DCB, testpmd retains the rx_mode/tx_mode configuration in +rte_port->dev_conf. But some configurations, such as the link_speed, were +not saved if they were set before configuring DCB. + +Fixes: 1a572499beb6 ("app/testpmd: setup DCB forwarding based on traffic class") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Signed-off-by: Min Hu (Connor) +Acked-by: Xiaoyun Li +--- + app/test-pmd/testpmd.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c +index 3098df6c5..0eaa4852d 100644 +--- a/app/test-pmd/testpmd.c ++++ b/app/test-pmd/testpmd.c +@@ -3484,10 +3484,8 @@ init_port_dcb_config(portid_t pid, + + rte_port = &ports[pid]; + +- memset(&port_conf, 0, sizeof(struct rte_eth_conf)); +- +- port_conf.rxmode = rte_port->dev_conf.rxmode; +- port_conf.txmode = rte_port->dev_conf.txmode; ++ /* retain the original device configuration. */ ++ memcpy(&port_conf, &rte_port->dev_conf, sizeof(struct rte_eth_conf)); + + /*set configuration of DCB in vt mode and DCB in non-vt mode*/ + retval = get_eth_dcb_conf(pid, &port_conf, dcb_mode, num_tcs, pfc_en); +-- +2.23.0 + diff --git a/0227-net-hns3-remove-similar-macro-function-definitions.patch b/0227-net-hns3-remove-similar-macro-function-definitions.patch new file mode 100644 index 0000000000000000000000000000000000000000..076e76c9c0bf5f0fac994bb2ec28caf3e543a758 --- /dev/null +++ b/0227-net-hns3-remove-similar-macro-function-definitions.patch @@ -0,0 +1,593 @@ +From 637fc8040d4aa52eba9c7c78a5c826f4a13c4da0 Mon Sep 17 00:00:00 2001 +From: Chengchang Tang +Date: Sat, 9 Oct 2021 15:48:05 +0800 +Subject: [PATCH 14/17] net/hns3: remove similar macro function definitions + +For different capabilities, we declare different macro functions to +determine whether the capabilities are supported. + +This patch declare a unified macro function to judge capabilities. + +Signed-off-by: Chengchang Tang +Signed-off-by: Min Hu (Connor) +--- + drivers/net/hns3/hns3_cmd.c | 6 ++--- + drivers/net/hns3/hns3_dcb.c | 4 +-- + drivers/net/hns3/hns3_ethdev.c | 24 +++++++++--------- + drivers/net/hns3/hns3_ethdev.h | 41 ++----------------------------- + drivers/net/hns3/hns3_ethdev_vf.c | 6 ++--- + drivers/net/hns3/hns3_flow.c | 2 +- + drivers/net/hns3/hns3_intr.c | 2 +- + drivers/net/hns3/hns3_ptp.c | 18 +++++++------- + drivers/net/hns3/hns3_rxtx.c | 32 ++++++++++++------------ + drivers/net/hns3/hns3_rxtx_vec.c | 4 +-- + drivers/net/hns3/hns3_tm.c | 10 ++++---- + 11 files changed, 56 insertions(+), 93 deletions(-) + +diff --git a/drivers/net/hns3/hns3_cmd.c b/drivers/net/hns3/hns3_cmd.c +index cfa943523..6e49108d2 100644 +--- a/drivers/net/hns3/hns3_cmd.c ++++ b/drivers/net/hns3/hns3_cmd.c +@@ -619,7 +619,7 @@ hns3_update_dev_lsc_cap(struct hns3_hw *hw, int fw_compact_cmd_result) + static int + hns3_apply_fw_compat_cmd_result(struct hns3_hw *hw, int result) + { +- if (result != 0 && hns3_dev_copper_supported(hw)) { ++ if (result != 0 && hns3_dev_get_support(hw, COPPER)) { + hns3_err(hw, "firmware fails to initialize the PHY, ret = %d.", + result); + return result; +@@ -658,7 +658,7 @@ hns3_firmware_compat_config(struct hns3_hw *hw, bool is_init) + } + if (revision == PCI_REVISION_ID_HIP09_A) { + struct hns3_pf *pf = HNS3_DEV_HW_TO_PF(hw); +- if (hns3_dev_copper_supported(hw) == 0 || pf->is_tmp_phy) { ++ if (hns3_dev_get_support(hw, COPPER) == 0 || pf->is_tmp_phy) { + PMD_INIT_LOG(ERR, "***use temp phy driver in dpdk***"); + pf->is_tmp_phy = true; + hns3_set_bit(hw->capability, +@@ -676,7 +676,7 @@ hns3_firmware_compat_config(struct hns3_hw *hw, bool is_init) + if (is_init) { + hns3_set_bit(compat, HNS3_LINK_EVENT_REPORT_EN_B, 1); + hns3_set_bit(compat, HNS3_NCSI_ERROR_REPORT_EN_B, 0); +- if (hns3_dev_copper_supported(hw)) ++ if (hns3_dev_get_support(hw, COPPER)) + hns3_set_bit(compat, HNS3_FIRMWARE_PHY_DRIVER_EN_B, 1); + } + req->compat = rte_cpu_to_le_32(compat); +diff --git a/drivers/net/hns3/hns3_dcb.c b/drivers/net/hns3/hns3_dcb.c +index b71e2e9ea..8753c340e 100644 +--- a/drivers/net/hns3/hns3_dcb.c ++++ b/drivers/net/hns3/hns3_dcb.c +@@ -918,7 +918,7 @@ hns3_dcb_pri_dwrr_cfg(struct hns3_hw *hw) + if (ret) + return ret; + +- if (!hns3_dev_dcb_supported(hw)) ++ if (!hns3_dev_get_support(hw, DCB)) + return 0; + + ret = hns3_dcb_ets_tc_dwrr_cfg(hw); +@@ -1368,7 +1368,7 @@ hns3_dcb_pause_setup_hw(struct hns3_hw *hw) + } + + /* Only DCB-supported dev supports qset back pressure and pfc cmd */ +- if (!hns3_dev_dcb_supported(hw)) ++ if (!hns3_dev_get_support(hw, DCB)) + return 0; + + ret = hns3_pfc_setup_hw(hw); +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index 02d68e496..c5c355d95 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -2408,7 +2408,7 @@ hns3_setup_dcb(struct rte_eth_dev *dev) + struct hns3_hw *hw = &hns->hw; + int ret; + +- if (!hns3_dev_dcb_supported(hw)) { ++ if (!hns3_dev_get_support(hw, DCB)) { + hns3_err(hw, "this port does not support dcb configurations."); + return -EOPNOTSUPP; + } +@@ -2746,14 +2746,14 @@ hns3_dev_infos_get(struct rte_eth_dev *eth_dev, struct rte_eth_dev_info *info) + DEV_TX_OFFLOAD_MBUF_FAST_FREE | + hns3_txvlan_cap_get(hw)); + +- if (hns3_dev_outer_udp_cksum_supported(hw)) ++ if (hns3_dev_get_support(hw, OUTER_UDP_CKSUM)) + info->tx_offload_capa |= DEV_TX_OFFLOAD_OUTER_UDP_CKSUM; + +- if (hns3_dev_indep_txrx_supported(hw)) ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) + info->dev_capa = RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP | + RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP; + +- if (hns3_dev_ptp_supported(hw)) ++ if (hns3_dev_get_support(hw, PTP)) + info->rx_offload_capa |= DEV_RX_OFFLOAD_TIMESTAMP; + + info->rx_desc_lim = (struct rte_eth_desc_lim) { +@@ -3418,7 +3418,7 @@ hns3_check_media_type(struct hns3_hw *hw, uint8_t media_type) + + switch (media_type) { + case HNS3_MEDIA_TYPE_COPPER: +- if (!hns3_dev_copper_supported(hw)) { ++ if (!hns3_dev_get_support(hw, COPPER)) { + PMD_INIT_LOG(ERR, + "Media type is copper, not supported."); + ret = -EOPNOTSUPP; +@@ -3486,7 +3486,7 @@ hns3_get_board_configuration(struct hns3_hw *hw) + } + + /* Dev does not support DCB */ +- if (!hns3_dev_dcb_supported(hw)) { ++ if (!hns3_dev_get_support(hw, DCB)) { + pf->tc_max = 1; + pf->pfc_max = 0; + } else +@@ -3799,7 +3799,7 @@ hns3_is_rx_buf_ok(struct hns3_hw *hw, struct hns3_pkt_buf_alloc *buf_alloc, + tc_num = hns3_get_tc_num(hw); + aligned_mps = roundup(pf->mps, HNS3_BUF_SIZE_UNIT); + +- if (hns3_dev_dcb_supported(hw)) ++ if (hns3_dev_get_support(hw, DCB)) + shared_buf_min = HNS3_BUF_MUL_BY * aligned_mps + + pf->dv_buf_size; + else +@@ -3816,7 +3816,7 @@ hns3_is_rx_buf_ok(struct hns3_hw *hw, struct hns3_pkt_buf_alloc *buf_alloc, + + shared_buf = rounddown(rx_all - rx_priv, HNS3_BUF_SIZE_UNIT); + buf_alloc->s_buf.buf_size = shared_buf; +- if (hns3_dev_dcb_supported(hw)) { ++ if (hns3_dev_get_support(hw, DCB)) { + buf_alloc->s_buf.self.high = shared_buf - pf->dv_buf_size; + buf_alloc->s_buf.self.low = buf_alloc->s_buf.self.high + - roundup(aligned_mps / HNS3_BUF_DIV_BY, +@@ -3827,7 +3827,7 @@ hns3_is_rx_buf_ok(struct hns3_hw *hw, struct hns3_pkt_buf_alloc *buf_alloc, + buf_alloc->s_buf.self.low = aligned_mps; + } + +- if (hns3_dev_dcb_supported(hw)) { ++ if (hns3_dev_get_support(hw, DCB)) { + hi_thrd = shared_buf - pf->dv_buf_size; + + if (tc_num <= NEED_RESERVE_TC_NUM) +@@ -4033,7 +4033,7 @@ static int + hns3_rx_buffer_calc(struct hns3_hw *hw, struct hns3_pkt_buf_alloc *buf_alloc) + { + /* When DCB is not supported, rx private buffer is not allocated. */ +- if (!hns3_dev_dcb_supported(hw)) { ++ if (!hns3_dev_get_support(hw, DCB)) { + struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + struct hns3_pf *pf = &hns->pf; + uint32_t rx_all = pf->pkt_buf_size; +@@ -4261,7 +4261,7 @@ hns3_buffer_alloc(struct hns3_hw *hw) + return ret; + } + +- if (hns3_dev_dcb_supported(hw)) { ++ if (hns3_dev_get_support(hw, DCB)) { + ret = hns3_rx_priv_wl_config(hw, &pkt_buf); + if (ret) { + PMD_INIT_LOG(ERR, +@@ -6230,7 +6230,7 @@ hns3_priority_flow_ctrl_set(struct rte_eth_dev *dev, + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + int ret; + +- if (!hns3_dev_dcb_supported(hw)) { ++ if (!hns3_dev_get_support(hw, DCB)) { + hns3_err(hw, "This port does not support dcb configurations."); + return -EOPNOTSUPP; + } +diff --git a/drivers/net/hns3/hns3_ethdev.h b/drivers/net/hns3/hns3_ethdev.h +index 57387e05b..94fd14bfc 100644 +--- a/drivers/net/hns3/hns3_ethdev.h ++++ b/drivers/net/hns3/hns3_ethdev.h +@@ -883,45 +883,8 @@ enum { + HNS3_DEV_SUPPORT_VF_VLAN_FLT_MOD_B, + }; + +-#define hns3_dev_dcb_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_DCB_B) +- +-/* Support copper media type */ +-#define hns3_dev_copper_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_COPPER_B) +- +-/* Support the queue region action rule of flow directory */ +-#define hns3_dev_fd_queue_region_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_FD_QUEUE_REGION_B) +- +-/* Support PTP timestamp offload */ +-#define hns3_dev_ptp_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_PTP_B) +- +-/* Support to Independently enable/disable/reset Tx or Rx queues */ +-#define hns3_dev_indep_txrx_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_INDEP_TXRX_B) +- +-#define hns3_dev_stash_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_STASH_B) +- +-#define hns3_dev_rxd_adv_layout_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_RXD_ADV_LAYOUT_B) +- +-#define hns3_dev_outer_udp_cksum_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_OUTER_UDP_CKSUM_B) +- +-#define hns3_dev_ras_imp_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_RAS_IMP_B) +- +-#define hns3_dev_tx_push_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_TX_PUSH_B) +- +-#define hns3_dev_tm_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_TM_B) +- +-#define hns3_dev_vf_vlan_flt_supported(hw) \ +- hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_VF_VLAN_FLT_MOD_B) ++#define hns3_dev_get_support(hw, _name) \ ++ hns3_get_bit((hw)->capability, HNS3_DEV_SUPPORT_##_name##_B) + + #define HNS3_DEV_PRIVATE_TO_HW(adapter) \ + (&((struct hns3_adapter *)adapter)->hw) +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index e07eb2088..d2895b140 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -988,10 +988,10 @@ hns3vf_dev_infos_get(struct rte_eth_dev *eth_dev, struct rte_eth_dev_info *info) + DEV_TX_OFFLOAD_MBUF_FAST_FREE | + hns3_txvlan_cap_get(hw)); + +- if (hns3_dev_outer_udp_cksum_supported(hw)) ++ if (hns3_dev_get_support(hw, OUTER_UDP_CKSUM)) + info->tx_offload_capa |= DEV_TX_OFFLOAD_OUTER_UDP_CKSUM; + +- if (hns3_dev_indep_txrx_supported(hw)) ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) + info->dev_capa = RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP | + RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP; + +@@ -1623,7 +1623,7 @@ hns3vf_en_vlan_filter(struct hns3_hw *hw, bool enable) + uint8_t msg_data; + int ret; + +- if (!hns3_dev_vf_vlan_flt_supported(hw)) ++ if (!hns3_dev_get_support(hw, VF_VLAN_FLT_MOD)) + return 0; + + msg_data = enable ? 1 : 0; +diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c +index 6844a5dbe..b25fccbca 100644 +--- a/drivers/net/hns3/hns3_flow.c ++++ b/drivers/net/hns3/hns3_flow.c +@@ -301,7 +301,7 @@ hns3_handle_action_queue_region(struct rte_eth_dev *dev, + struct hns3_hw *hw = &hns->hw; + uint16_t idx; + +- if (!hns3_dev_fd_queue_region_supported(hw)) ++ if (!hns3_dev_get_support(hw, FD_QUEUE_REGION)) + return rte_flow_error_set(error, ENOTSUP, + RTE_FLOW_ERROR_TYPE_ACTION, action, + "Not support config queue region!"); +diff --git a/drivers/net/hns3/hns3_intr.c b/drivers/net/hns3/hns3_intr.c +index 0b307fdd1..3484c76d2 100644 +--- a/drivers/net/hns3/hns3_intr.c ++++ b/drivers/net/hns3/hns3_intr.c +@@ -2368,7 +2368,7 @@ hns3_handle_error(struct hns3_adapter *hns) + { + struct hns3_hw *hw = &hns->hw; + +- if (hns3_dev_ras_imp_supported(hw)) { ++ if (hns3_dev_get_support(hw, RAS_IMP)) { + hns3_handle_hw_error_v2(hw); + hns3_schedule_reset(hns); + } else { +diff --git a/drivers/net/hns3/hns3_ptp.c b/drivers/net/hns3/hns3_ptp.c +index 146b69db7..14c1ad3e4 100644 +--- a/drivers/net/hns3/hns3_ptp.c ++++ b/drivers/net/hns3/hns3_ptp.c +@@ -61,7 +61,7 @@ hns3_ptp_init(struct hns3_hw *hw) + { + int ret; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return 0; + + ret = hns3_ptp_int_en(hw, true); +@@ -120,7 +120,7 @@ hns3_timesync_enable(struct rte_eth_dev *dev) + struct hns3_pf *pf = &hns->pf; + int ret; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + if (pf->ptp_enable) +@@ -140,7 +140,7 @@ hns3_timesync_disable(struct rte_eth_dev *dev) + struct hns3_pf *pf = &hns->pf; + int ret; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + if (!pf->ptp_enable) +@@ -164,7 +164,7 @@ hns3_timesync_read_rx_timestamp(struct rte_eth_dev *dev, + struct hns3_pf *pf = &hns->pf; + uint64_t ns, sec; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + ns = pf->rx_timestamp & TIME_RX_STAMP_NS_MASK; +@@ -190,7 +190,7 @@ hns3_timesync_read_tx_timestamp(struct rte_eth_dev *dev, + uint64_t ns; + int ts_cnt; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + ts_cnt = hns3_read_dev(hw, HNS3_TX_1588_BACK_TSP_CNT) & +@@ -219,7 +219,7 @@ hns3_timesync_read_time(struct rte_eth_dev *dev, struct timespec *ts) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + uint64_t ns, sec; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + sec = hns3_read_dev(hw, HNS3_CURR_TIME_OUT_L); +@@ -240,7 +240,7 @@ hns3_timesync_write_time(struct rte_eth_dev *dev, const struct timespec *ts) + uint64_t sec = ts->tv_sec; + uint64_t ns = ts->tv_nsec; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + /* Set the timecounters to a new value. */ +@@ -261,7 +261,7 @@ hns3_timesync_adjust_time(struct rte_eth_dev *dev, int64_t delta) + struct timespec cur_time; + uint64_t ns; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + (void)hns3_timesync_read_time(dev, &cur_time); +@@ -280,7 +280,7 @@ hns3_restore_ptp(struct hns3_adapter *hns) + bool en = pf->ptp_enable; + int ret; + +- if (!hns3_dev_ptp_supported(hw)) ++ if (!hns3_dev_get_support(hw, PTP)) + return 0; + + ret = hns3_timesync_configure(hns, en); +diff --git a/drivers/net/hns3/hns3_rxtx.c b/drivers/net/hns3/hns3_rxtx.c +index 80d2614d2..bb1723e29 100644 +--- a/drivers/net/hns3/hns3_rxtx.c ++++ b/drivers/net/hns3/hns3_rxtx.c +@@ -381,7 +381,7 @@ hns3_enable_all_queues(struct hns3_hw *hw, bool en) + int i; + + for (i = 0; i < hw->cfg_max_queues; i++) { +- if (hns3_dev_indep_txrx_supported(hw)) { ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) { + rxq = i < nb_rx_q ? hw->data->rx_queues[i] : NULL; + txq = i < nb_tx_q ? hw->data->tx_queues[i] : NULL; + +@@ -426,7 +426,7 @@ hns3_enable_txq(struct hns3_tx_queue *txq, bool en) + struct hns3_hw *hw = &txq->hns->hw; + uint32_t reg; + +- if (hns3_dev_indep_txrx_supported(hw)) { ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) { + reg = hns3_read_dev(txq, HNS3_RING_TX_EN_REG); + if (en) + reg |= BIT(HNS3_RING_EN_B); +@@ -443,7 +443,7 @@ hns3_enable_rxq(struct hns3_rx_queue *rxq, bool en) + struct hns3_hw *hw = &rxq->hns->hw; + uint32_t reg; + +- if (hns3_dev_indep_txrx_supported(hw)) { ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) { + reg = hns3_read_dev(rxq, HNS3_RING_RX_EN_REG); + if (en) + reg |= BIT(HNS3_RING_EN_B); +@@ -1618,7 +1618,7 @@ hns3_set_fake_rx_or_tx_queues(struct rte_eth_dev *dev, uint16_t nb_rx_q, + uint16_t q; + int ret; + +- if (hns3_dev_indep_txrx_supported(hw)) ++ if (hns3_dev_get_support(hw, INDEP_TXRX)) + return 0; + + /* Setup new number of fake RX/TX queues and reconfigure device. */ +@@ -1862,7 +1862,7 @@ hns3_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t nb_desc, + conf->rx_free_thresh : HNS3_DEFAULT_RX_FREE_THRESH; + + rxq->rx_deferred_start = conf->rx_deferred_start; +- if (rxq->rx_deferred_start && !hns3_dev_indep_txrx_supported(hw)) { ++ if (rxq->rx_deferred_start && !hns3_dev_get_support(hw, INDEP_TXRX)) { + hns3_warn(hw, "deferred start is not supported."); + rxq->rx_deferred_start = false; + } +@@ -1898,7 +1898,7 @@ hns3_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t nb_desc, + HNS3_PORT_BASE_VLAN_ENABLE; + else + rxq->pvid_sw_discard_en = false; +- rxq->ptype_en = hns3_dev_rxd_adv_layout_supported(hw) ? true : false; ++ rxq->ptype_en = hns3_dev_get_support(hw, RXD_ADV_LAYOUT) ? true : false; + rxq->configured = true; + rxq->io_base = (void *)((char *)hw->io_base + HNS3_TQP_REG_OFFSET + + idx * HNS3_TQP_REG_SIZE); +@@ -2026,7 +2026,7 @@ hns3_dev_supported_ptypes_get(struct rte_eth_dev *dev) + dev->rx_pkt_burst == hns3_recv_scattered_pkts || + dev->rx_pkt_burst == hns3_recv_pkts_vec || + dev->rx_pkt_burst == hns3_recv_pkts_vec_sve) { +- if (hns3_dev_rxd_adv_layout_supported(hw)) ++ if (hns3_dev_get_support(hw, RXD_ADV_LAYOUT)) + return adv_layout_ptypes; + else + return ptypes; +@@ -2928,7 +2928,7 @@ hns3_tx_push_init(struct rte_eth_dev *dev) + volatile uint32_t *reg; + uint32_t val; + +- if (!hns3_dev_tx_push_supported(hw)) ++ if (!hns3_dev_get_support(hw, TX_PUSH)) + return; + + reg = (volatile uint32_t *)hns3_tx_push_get_queue_tail_reg(dev, 0); +@@ -2949,7 +2949,7 @@ hns3_tx_push_queue_init(struct rte_eth_dev *dev, + struct hns3_tx_queue *txq) + { + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); +- if (!hns3_dev_tx_push_supported(hw)) { ++ if (!hns3_dev_get_support(hw, TX_PUSH)) { + txq->tx_push_enable = false; + return; + } +@@ -2994,7 +2994,7 @@ hns3_tx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t nb_desc, + } + + txq->tx_deferred_start = conf->tx_deferred_start; +- if (txq->tx_deferred_start && !hns3_dev_indep_txrx_supported(hw)) { ++ if (txq->tx_deferred_start && !hns3_dev_get_support(hw, INDEP_TXRX)) { + hns3_warn(hw, "deferred start is not supported."); + txq->tx_deferred_start = false; + } +@@ -4276,7 +4276,7 @@ hns3_tx_check_simple_support(struct rte_eth_dev *dev) + uint64_t offloads = dev->data->dev_conf.txmode.offloads; + + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); +- if (hns3_dev_ptp_supported(hw)) ++ if (hns3_dev_get_support(hw, PTP)) + return false; + + return (offloads == (offloads & DEV_TX_OFFLOAD_MBUF_FAST_FREE)); +@@ -4437,7 +4437,7 @@ hns3_dev_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id) + struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + int ret; + +- if (!hns3_dev_indep_txrx_supported(hw)) ++ if (!hns3_dev_get_support(hw, INDEP_TXRX)) + return -ENOTSUP; + + rte_spinlock_lock(&hw->lock); +@@ -4483,7 +4483,7 @@ hns3_dev_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_rx_queue *rxq = dev->data->rx_queues[rx_queue_id]; + +- if (!hns3_dev_indep_txrx_supported(hw)) ++ if (!hns3_dev_get_support(hw, INDEP_TXRX)) + return -ENOTSUP; + + rte_spinlock_lock(&hw->lock); +@@ -4505,7 +4505,7 @@ hns3_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id) + struct hns3_tx_queue *txq = dev->data->tx_queues[tx_queue_id]; + int ret; + +- if (!hns3_dev_indep_txrx_supported(hw)) ++ if (!hns3_dev_get_support(hw, INDEP_TXRX)) + return -ENOTSUP; + + rte_spinlock_lock(&hw->lock); +@@ -4531,7 +4531,7 @@ hns3_dev_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + struct hns3_tx_queue *txq = dev->data->tx_queues[tx_queue_id]; + +- if (!hns3_dev_indep_txrx_supported(hw)) ++ if (!hns3_dev_get_support(hw, INDEP_TXRX)) + return -ENOTSUP; + + rte_spinlock_lock(&hw->lock); +@@ -4704,7 +4704,7 @@ hns3_enable_rxd_adv_layout(struct hns3_hw *hw) + * If the hardware support rxd advanced layout, then driver enable it + * default. + */ +- if (hns3_dev_rxd_adv_layout_supported(hw)) ++ if (hns3_dev_get_support(hw, RXD_ADV_LAYOUT)) + hns3_write_dev(hw, HNS3_RXD_ADV_LAYOUT_EN_REG, 1); + } + +diff --git a/drivers/net/hns3/hns3_rxtx_vec.c b/drivers/net/hns3/hns3_rxtx_vec.c +index 15a0bd075..bfe84e833 100644 +--- a/drivers/net/hns3/hns3_rxtx_vec.c ++++ b/drivers/net/hns3/hns3_rxtx_vec.c +@@ -19,7 +19,7 @@ hns3_tx_check_vec_support(struct rte_eth_dev *dev) + struct rte_eth_txmode *txmode = &dev->data->dev_conf.txmode; + + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); +- if (hns3_dev_ptp_supported(hw)) ++ if (hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + /* Only support DEV_TX_OFFLOAD_MBUF_FAST_FREE */ +@@ -234,7 +234,7 @@ hns3_rx_check_vec_support(struct rte_eth_dev *dev) + DEV_RX_OFFLOAD_VLAN; + + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); +- if (hns3_dev_ptp_supported(hw)) ++ if (hns3_dev_get_support(hw, PTP)) + return -ENOTSUP; + + if (dev->data->scattered_rx) +diff --git a/drivers/net/hns3/hns3_tm.c b/drivers/net/hns3/hns3_tm.c +index db5ac786c..44b607af7 100644 +--- a/drivers/net/hns3/hns3_tm.c ++++ b/drivers/net/hns3/hns3_tm.c +@@ -31,7 +31,7 @@ hns3_tm_conf_init(struct rte_eth_dev *dev) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + uint32_t max_tx_queues = hns3_tm_max_tx_queues_get(dev); + +- if (!hns3_dev_tm_supported(hw)) ++ if (!hns3_dev_get_support(hw, TM)) + return; + + pf->tm_conf.nb_leaf_nodes_max = max_tx_queues; +@@ -58,7 +58,7 @@ hns3_tm_conf_uninit(struct rte_eth_dev *dev) + struct hns3_tm_shaper_profile *shaper_profile; + struct hns3_tm_node *tm_node; + +- if (!hns3_dev_tm_supported(hw)) ++ if (!hns3_dev_get_support(hw, TM)) + return; + + if (pf->tm_conf.nb_queue_node > 0) { +@@ -1233,7 +1233,7 @@ hns3_tm_ops_get(struct rte_eth_dev *dev, void *arg) + if (arg == NULL) + return -EINVAL; + +- if (!hns3_dev_tm_supported(hw)) ++ if (!hns3_dev_get_support(hw, TM)) + return -EOPNOTSUPP; + + *(const void **)arg = &hns3_tm_ops; +@@ -1246,7 +1246,7 @@ hns3_tm_dev_start_proc(struct hns3_hw *hw) + { + struct hns3_pf *pf = HNS3_DEV_HW_TO_PF(hw); + +- if (!hns3_dev_tm_supported(hw)) ++ if (!hns3_dev_get_support(hw, TM)) + return; + + if (pf->tm_conf.root && !pf->tm_conf.committed) +@@ -1295,7 +1295,7 @@ hns3_tm_conf_update(struct hns3_hw *hw) + struct hns3_pf *pf = HNS3_DEV_HW_TO_PF(hw); + struct rte_tm_error error; + +- if (!hns3_dev_tm_supported(hw)) ++ if (!hns3_dev_get_support(hw, TM)) + return 0; + + if (pf->tm_conf.root == NULL || !pf->tm_conf.committed) +-- +2.23.0 + diff --git a/0228-net-hns3-fix-interrupt-vector-freeing.patch b/0228-net-hns3-fix-interrupt-vector-freeing.patch new file mode 100644 index 0000000000000000000000000000000000000000..bf906a5d41908643090f439c67d001309c6bf9f6 --- /dev/null +++ b/0228-net-hns3-fix-interrupt-vector-freeing.patch @@ -0,0 +1,33 @@ +From b00fefaae559f49fbbbc39ec6ec1aaa1f4f5ba39 Mon Sep 17 00:00:00 2001 +From: Chengwen Feng +Date: Wed, 13 Oct 2021 16:09:08 +0800 +Subject: [PATCH 15/17] net/hns3: fix interrupt vector freeing + +The intr_handle->intr_vec is allocated by rte_zmalloc(), but freed by +free(), this patch fixes it. + +Fixes: 02a7b55657b2 ("net/hns3: support Rx interrupt") +Cc: stable@dpdk.org + +Signed-off-by: Chengwen Feng +Reviewed-by: Ferruh Yigit +--- + drivers/net/hns3/hns3_ethdev_vf.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index d2895b140..9dfc22d2d 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -2355,7 +2355,7 @@ hns3vf_map_rx_interrupt(struct rte_eth_dev *dev) + return 0; + + vf_bind_vector_error: +- free(intr_handle->intr_vec); ++ rte_free(intr_handle->intr_vec); + intr_handle->intr_vec = NULL; + vf_alloc_intr_vec_error: + rte_intr_efd_disable(intr_handle); +-- +2.23.0 + diff --git a/0229-net-hns3-add-runtime-config-for-mailbox-limit-time.patch b/0229-net-hns3-add-runtime-config-for-mailbox-limit-time.patch new file mode 100644 index 0000000000000000000000000000000000000000..2f9b1dbc8f1fa824ae77142af9e6b4c19a15a659 --- /dev/null +++ b/0229-net-hns3-add-runtime-config-for-mailbox-limit-time.patch @@ -0,0 +1,179 @@ +From 61c8349bbed069317c59da812598b74d2e076ced Mon Sep 17 00:00:00 2001 +From: Chengchang Tang +Date: Fri, 22 Oct 2021 09:38:40 +0800 +Subject: [PATCH 16/17] net/hns3: add runtime config for mailbox limit time + +Current, the max waiting time for MBX response is 500ms, but in +some scenarios, it is not enough. Since it depends on the response +of the kernel mode driver, and its response time is related to the +scheduling of the system. In this special scenario, most of the +cores are isolated, and only a few cores are used for system +scheduling. When a large number of services are started, the +scheduling of the system will be very busy, and the reply of the +mbx message will time out, which will cause our PMD initialization +to fail. + +This patch add a runtime config to set the max wait time. For the +above scenes, users can adjust the waiting time to a suitable value +by themselves. + +Fixes: 463e748964f5 ("net/hns3: support mailbox") +Cc: stable@dpdk.org + +Signed-off-by: Chengchang Tang +Signed-off-by: Min Hu (Connor) +--- + drivers/net/hns3/hns3_ethdev.c | 32 ++++++++++++++++++++++++++++++- + drivers/net/hns3/hns3_ethdev.h | 3 +++ + drivers/net/hns3/hns3_ethdev_vf.c | 3 ++- + drivers/net/hns3/hns3_mbx.c | 8 +++++--- + drivers/net/hns3/hns3_mbx.h | 1 + + 5 files changed, 42 insertions(+), 5 deletions(-) + +diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c +index c5c355d95..2ae4cb9b7 100644 +--- a/drivers/net/hns3/hns3_ethdev.c ++++ b/drivers/net/hns3/hns3_ethdev.c +@@ -7348,9 +7348,30 @@ hns3_parse_dev_caps_mask(const char *key, const char *value, void *extra_args) + return 0; + } + ++static int ++hns3_parse_mbx_time_limit(const char *key, const char *value, void *extra_args) ++{ ++ uint32_t val; ++ ++ RTE_SET_USED(key); ++ ++ val = strtoul(value, NULL, 10); ++ ++ /* ++ * 500ms is empirical value in process of mailbox communication. If ++ * the delay value is set to one lower thanthe empirical value, mailbox ++ * communication may fail. ++ */ ++ if (val > HNS3_MBX_DEF_TIME_LIMIT_MS && val <= UINT16_MAX) ++ *(uint16_t *)extra_args = val; ++ ++ return 0; ++} ++ + void + hns3_parse_devargs(struct rte_eth_dev *dev) + { ++ uint16_t mbx_time_limit_ms = HNS3_MBX_DEF_TIME_LIMIT_MS; + struct hns3_adapter *hns = dev->data->dev_private; + uint32_t rx_func_hint = HNS3_IO_FUNC_HINT_NONE; + uint32_t tx_func_hint = HNS3_IO_FUNC_HINT_NONE; +@@ -7371,6 +7392,9 @@ hns3_parse_devargs(struct rte_eth_dev *dev) + &hns3_parse_io_hint_func, &tx_func_hint); + (void)rte_kvargs_process(kvlist, HNS3_DEVARG_DEV_CAPS_MASK, + &hns3_parse_dev_caps_mask, &dev_caps_mask); ++ (void)rte_kvargs_process(kvlist, HNS3_DEVARG_MBX_TIME_LIMIT_MS, ++ &hns3_parse_mbx_time_limit, &mbx_time_limit_ms); ++ + rte_kvargs_free(kvlist); + + if (rx_func_hint != HNS3_IO_FUNC_HINT_NONE) +@@ -7386,6 +7410,11 @@ hns3_parse_devargs(struct rte_eth_dev *dev) + hns3_warn(hw, "parsed %s = 0x%" PRIx64 ".", + HNS3_DEVARG_DEV_CAPS_MASK, dev_caps_mask); + hns->dev_caps_mask = dev_caps_mask; ++ ++ if (mbx_time_limit_ms != HNS3_MBX_DEF_TIME_LIMIT_MS) ++ hns3_warn(hw, "parsed %s = %u.", HNS3_DEVARG_MBX_TIME_LIMIT_MS, ++ mbx_time_limit_ms); ++ hns->mbx_time_limit_ms = mbx_time_limit_ms; + } + + static const struct eth_dev_ops hns3_eth_dev_ops = { +@@ -7642,6 +7671,7 @@ RTE_PMD_REGISTER_KMOD_DEP(net_hns3, "* igb_uio | vfio-pci"); + RTE_PMD_REGISTER_PARAM_STRING(net_hns3, + HNS3_DEVARG_RX_FUNC_HINT "=vec|sve|simple|common " + HNS3_DEVARG_TX_FUNC_HINT "=vec|sve|simple|common " +- HNS3_DEVARG_DEV_CAPS_MASK "=<1-65535> "); ++ HNS3_DEVARG_DEV_CAPS_MASK "=<1-65535> " ++ HNS3_DEVARG_MBX_TIME_LIMIT_MS "= "); + RTE_LOG_REGISTER(hns3_logtype_init, pmd.net.hns3.init, NOTICE); + RTE_LOG_REGISTER(hns3_logtype_driver, pmd.net.hns3.driver, NOTICE); +diff --git a/drivers/net/hns3/hns3_ethdev.h b/drivers/net/hns3/hns3_ethdev.h +index 94fd14bfc..84f5a9f29 100644 +--- a/drivers/net/hns3/hns3_ethdev.h ++++ b/drivers/net/hns3/hns3_ethdev.h +@@ -851,6 +851,7 @@ struct hns3_adapter { + uint32_t tx_func_hint; + + uint64_t dev_caps_mask; ++ uint16_t mbx_time_limit_ms; /* wait time for mbx message */ + + struct hns3_ptype_table ptype_tbl __rte_cache_aligned; + }; +@@ -868,6 +869,8 @@ enum { + + #define HNS3_DEVARG_DEV_CAPS_MASK "dev_caps_mask" + ++#define HNS3_DEVARG_MBX_TIME_LIMIT_MS "mbx_time_limit_ms" ++ + enum { + HNS3_DEV_SUPPORT_DCB_B, + HNS3_DEV_SUPPORT_COPPER_B, +diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c +index 9dfc22d2d..29313c2f7 100644 +--- a/drivers/net/hns3/hns3_ethdev_vf.c ++++ b/drivers/net/hns3/hns3_ethdev_vf.c +@@ -3112,4 +3112,5 @@ RTE_PMD_REGISTER_KMOD_DEP(net_hns3_vf, "* igb_uio | vfio-pci"); + RTE_PMD_REGISTER_PARAM_STRING(net_hns3_vf, + HNS3_DEVARG_RX_FUNC_HINT "=vec|sve|simple|common " + HNS3_DEVARG_TX_FUNC_HINT "=vec|sve|simple|common " +- HNS3_DEVARG_DEV_CAPS_MASK "=<1-65535> "); ++ HNS3_DEVARG_DEV_CAPS_MASK "=<1-65535> " ++ HNS3_DEVARG_MBX_TIME_LIMIT_MS "= "); +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index 411c5ebe9..a4d9afc45 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -61,8 +61,9 @@ static int + hns3_get_mbx_resp(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + uint8_t *resp_data, uint16_t resp_len) + { +-#define HNS3_MAX_RETRY_US 500000 + #define HNS3_WAIT_RESP_US 100 ++#define US_PER_MS 1000 ++ uint32_t mbx_time_limit; + struct hns3_adapter *hns = HNS3_DEV_HW_TO_ADAPTER(hw); + struct hns3_mbx_resp_status *mbx_resp; + uint32_t wait_time = 0; +@@ -74,7 +75,8 @@ hns3_get_mbx_resp(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + return -EINVAL; + } + +- while (wait_time < HNS3_MAX_RETRY_US) { ++ mbx_time_limit = (uint32_t)hns->mbx_time_limit_ms * US_PER_MS; ++ while (wait_time < mbx_time_limit) { + if (__atomic_load_n(&hw->reset.disable_cmd, __ATOMIC_RELAXED)) { + hns3_err(hw, "Don't wait for mbx respone because of " + "disable_cmd"); +@@ -103,7 +105,7 @@ hns3_get_mbx_resp(struct hns3_hw *hw, uint16_t code, uint16_t subcode, + wait_time += HNS3_WAIT_RESP_US; + } + hw->mbx_resp.req_msg_data = 0; +- if (wait_time >= HNS3_MAX_RETRY_US) { ++ if (wait_time >= mbx_time_limit) { + hns3_mbx_proc_timeout(hw, code, subcode); + return -ETIME; + } +diff --git a/drivers/net/hns3/hns3_mbx.h b/drivers/net/hns3/hns3_mbx.h +index f868e33a9..d637bd2b2 100644 +--- a/drivers/net/hns3/hns3_mbx.h ++++ b/drivers/net/hns3/hns3_mbx.h +@@ -87,6 +87,7 @@ enum hns3_mbx_link_fail_subcode { + + #define HNS3_MBX_MAX_MSG_SIZE 16 + #define HNS3_MBX_MAX_RESP_DATA_SIZE 8 ++#define HNS3_MBX_DEF_TIME_LIMIT_MS 500 + + enum { + HNS3_MBX_RESP_MATCHING_SCHEME_OF_ORIGINAL = 0, +-- +2.23.0 + diff --git a/0230-net-hns3-fix-mailbox-communication-with-HW.patch b/0230-net-hns3-fix-mailbox-communication-with-HW.patch new file mode 100644 index 0000000000000000000000000000000000000000..989fdc25c1050ce574b10131ba94ee4c50ff02ee --- /dev/null +++ b/0230-net-hns3-fix-mailbox-communication-with-HW.patch @@ -0,0 +1,39 @@ +From a277f7dbaa54e8ea10f41a7dc4dadec5f08b61b3 Mon Sep 17 00:00:00 2001 +From: "Min Hu (Connor)" +Date: Thu, 28 Oct 2021 19:52:30 +0800 +Subject: [PATCH 17/17] net/hns3: fix mailbox communication with HW + +Mailbox is the communication mechanism between SW and HW. There exist +two approaches for SW to recognize mailbox message from HW. One way is +using match_id, the other is to compare the message code. The two +approaches are independent and used in different scenarios. + +But for the second approach, "next_to_use" should be updated and written +to HW register. If it not done, HW do not know the position SW steps, +then, the communication between SW and HW will turn to be failed. + +Fixes: dbbbad23e380 ("net/hns3: fix VF handling LSC event in secondary process") +Cc: stable@dpdk.org + +Signed-off-by: Min Hu (Connor) +--- + drivers/net/hns3/hns3_mbx.c | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/drivers/net/hns3/hns3_mbx.c b/drivers/net/hns3/hns3_mbx.c +index a4d9afc45..3ad85e721 100644 +--- a/drivers/net/hns3/hns3_mbx.c ++++ b/drivers/net/hns3/hns3_mbx.c +@@ -435,6 +435,9 @@ hns3_handle_mbx_msg_out_intr(struct hns3_hw *hw) + scan_next: + next_to_use = (next_to_use + 1) % hw->cmq.crq.desc_num; + } ++ ++ crq->next_to_use = next_to_use; ++ hns3_write_dev(hw, HNS3_CMDQ_RX_HEAD_REG, crq->next_to_use); + } + + void +-- +2.23.0 + diff --git a/0231-app-testpmd-support-multi-process.patch b/0231-app-testpmd-support-multi-process.patch new file mode 100644 index 0000000000000000000000000000000000000000..3ace44b393cedf11a447711faa379325e36111f6 --- /dev/null +++ b/0231-app-testpmd-support-multi-process.patch @@ -0,0 +1,421 @@ +From c7a841ce328cda8338494640b103d5182268fd1e Mon Sep 17 00:00:00 2001 +From: "Min Hu (Connor)" +Date: Wed, 25 Aug 2021 10:06:38 +0800 +Subject: [PATCH] app/testpmd: support multi-process + +This patch adds multi-process support for testpmd. +For example the following commands run two testpmd +processes: + + * the primary process: + +./dpdk-testpmd --proc-type=auto -l 0-1 -- -i \ + --rxq=4 --txq=4 --num-procs=2 --proc-id=0 + + * the secondary process: + +./dpdk-testpmd --proc-type=auto -l 2-3 -- -i \ + --rxq=4 --txq=4 --num-procs=2 --proc-id=1 + +Signed-off-by: Min Hu (Connor) +Signed-off-by: Lijun Ou +Signed-off-by: Andrew Rybchenko +Acked-by: Xiaoyun Li +Acked-by: Ajit Khaparde +Reviewed-by: Ferruh Yigit +Acked-by: Aman Deep Singh +--- + app/test-pmd/cmdline.c | 6 ++ + app/test-pmd/config.c | 20 +++++- + app/test-pmd/parameters.c | 9 +++ + app/test-pmd/testpmd.c | 92 +++++++++++++++++++++++---- + app/test-pmd/testpmd.h | 11 ++++ + doc/guides/testpmd_app_ug/run_app.rst | 84 ++++++++++++++++++++++++ + 6 files changed, 210 insertions(+), 12 deletions(-) + +diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c +index 5691fab94..b701129d8 100644 +--- a/app/test-pmd/cmdline.c ++++ b/app/test-pmd/cmdline.c +@@ -5441,6 +5441,12 @@ cmd_set_flush_rx_parsed(void *parsed_result, + __rte_unused void *data) + { + struct cmd_set_flush_rx *res = parsed_result; ++ ++ if (num_procs > 1 && (strcmp(res->mode, "on") == 0)) { ++ printf("multi-process doesn't support to flush Rx queues.\n"); ++ return; ++ } ++ + no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); + } + +diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c +index 7af13f65c..0d6639020 100644 +--- a/app/test-pmd/config.c ++++ b/app/test-pmd/config.c +@@ -3117,6 +3117,8 @@ rss_fwd_config_setup(void) + queueid_t rxq; + queueid_t nb_q; + streamid_t sm_id; ++ int start; ++ int end; + + nb_q = nb_rxq; + if (nb_q > nb_txq) +@@ -3134,7 +3136,21 @@ rss_fwd_config_setup(void) + init_fwd_streams(); + + setup_fwd_config_of_each_lcore(&cur_fwd_config); +- rxp = 0; rxq = 0; ++ ++ if (proc_id > 0 && nb_q % num_procs != 0) ++ printf("Warning! queue numbers should be multiple of processes, or packet loss will happen.\n"); ++ ++ /** ++ * In multi-process, All queues are allocated to different ++ * processes based on num_procs and proc_id. For example: ++ * if supports 4 queues(nb_q), 2 processes(num_procs), ++ * the 0~1 queue for primary process. ++ * the 2~3 queue for secondary process. ++ */ ++ start = proc_id * nb_q / num_procs; ++ end = start + nb_q / num_procs; ++ rxp = 0; ++ rxq = start; + for (sm_id = 0; sm_id < cur_fwd_config.nb_fwd_streams; sm_id++) { + struct fwd_stream *fs; + +@@ -3151,6 +3167,8 @@ rss_fwd_config_setup(void) + continue; + rxp = 0; + rxq++; ++ if (rxq >= end) ++ rxq = start; + } + } + +diff --git a/app/test-pmd/parameters.c b/app/test-pmd/parameters.c +index 414a0068f..c464c42f6 100644 +--- a/app/test-pmd/parameters.c ++++ b/app/test-pmd/parameters.c +@@ -487,6 +487,9 @@ parse_event_printing_config(const char *optarg, int enable) + void + launch_args_parse(int argc, char** argv) + { ++#define PARAM_PROC_ID "proc-id" ++#define PARAM_NUM_PROCS "num-procs" ++ + int n, opt; + char **argvopt; + int opt_idx; +@@ -603,6 +606,8 @@ launch_args_parse(int argc, char** argv) + { "rx-mq-mode", 1, 0, 0 }, + { "record-core-cycles", 0, 0, 0 }, + { "record-burst-stats", 0, 0, 0 }, ++ { PARAM_NUM_PROCS, 1, 0, 0 }, ++ { PARAM_PROC_ID, 1, 0, 0 }, + { 0, 0, 0, 0 }, + }; + +@@ -1359,6 +1364,10 @@ launch_args_parse(int argc, char** argv) + record_core_cycles = 1; + if (!strcmp(lgopts[opt_idx].name, "record-burst-stats")) + record_burst_stats = 1; ++ if (!strcmp(lgopts[opt_idx].name, PARAM_NUM_PROCS)) ++ num_procs = atoi(optarg); ++ if (!strcmp(lgopts[opt_idx].name, PARAM_PROC_ID)) ++ proc_id = atoi(optarg); + break; + case 'h': + usage(argv[0]); +diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c +index 0eaa4852d..983d8827d 100644 +--- a/app/test-pmd/testpmd.c ++++ b/app/test-pmd/testpmd.c +@@ -505,6 +505,61 @@ uint8_t gro_flush_cycles = GRO_DEFAULT_FLUSH_CYCLES; + * hexadecimal bitmask of RX mq mode can be enabled. + */ + enum rte_eth_rx_mq_mode rx_mq_mode = ETH_MQ_RX_VMDQ_DCB_RSS; ++/* ++ * ID of the current process in multi-process, used to ++ * configure the queues to be polled. ++ */ ++int proc_id; ++ ++/* ++ * Number of processes in multi-process, used to ++ * configure the queues to be polled. ++ */ ++unsigned int num_procs = 1; ++ ++static int ++eth_dev_configure_mp(uint16_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q, ++ const struct rte_eth_conf *dev_conf) ++{ ++ if (is_proc_primary()) ++ return rte_eth_dev_configure(port_id, nb_rx_q, nb_tx_q, ++ dev_conf); ++ return 0; ++} ++ ++static int ++eth_dev_start_mp(uint16_t port_id) ++{ ++ if (is_proc_primary()) ++ return rte_eth_dev_start(port_id); ++ ++ return 0; ++} ++ ++static int ++eth_dev_stop_mp(uint16_t port_id) ++{ ++ if (is_proc_primary()) ++ return rte_eth_dev_stop(port_id); ++ ++ return 0; ++} ++ ++static void ++mempool_free_mp(struct rte_mempool *mp) ++{ ++ if (is_proc_primary()) ++ rte_mempool_free(mp); ++} ++ ++static int ++eth_dev_set_mtu_mp(uint16_t port_id, uint16_t mtu) ++{ ++ if (is_proc_primary()) ++ return rte_eth_dev_set_mtu(port_id, mtu); ++ ++ return 0; ++} + + /* Forward function declarations */ + static void setup_attached_port(portid_t pi); +@@ -964,6 +1019,14 @@ mbuf_pool_create(uint16_t mbuf_seg_size, unsigned nb_mbuf, + + mb_size = sizeof(struct rte_mbuf) + mbuf_seg_size; + mbuf_poolname_build(socket_id, pool_name, sizeof(pool_name), size_idx); ++ if (!is_proc_primary()) { ++ rte_mp = rte_mempool_lookup(pool_name); ++ if (rte_mp == NULL) ++ rte_exit(EXIT_FAILURE, ++ "Get mbuf pool for socket %u failed: %s\n", ++ socket_id, rte_strerror(rte_errno)); ++ return rte_mp; ++ } + + TESTPMD_LOG(INFO, + "create a new mbuf pool <%s>: n=%u, size=%u, socket=%u\n", +@@ -1969,6 +2032,11 @@ flush_fwd_rx_queues(void) + uint64_t prev_tsc = 0, diff_tsc, cur_tsc, timer_tsc = 0; + uint64_t timer_period; + ++ if (num_procs > 1) { ++ printf("multi-process not support for flushing fwd Rx queues, skip the below lines and return.\n"); ++ return; ++ } ++ + /* convert to number of cycles */ + timer_period = rte_get_timer_hz(); /* 1 second timeout */ + +@@ -2456,7 +2524,7 @@ start_port(portid_t pid) + return -1; + } + /* configure port */ +- diag = rte_eth_dev_configure(pi, nb_rxq + nb_hairpinq, ++ diag = eth_dev_configure_mp(pi, nb_rxq + nb_hairpinq, + nb_txq + nb_hairpinq, + &(port->dev_conf)); + if (diag != 0) { +@@ -2470,7 +2538,7 @@ start_port(portid_t pid) + return -1; + } + } +- if (port->need_reconfig_queues > 0) { ++ if (port->need_reconfig_queues > 0 && is_proc_primary()) { + port->need_reconfig_queues = 0; + /* setup tx queues */ + for (qi = 0; qi < nb_txq; qi++) { +@@ -2571,7 +2639,7 @@ start_port(portid_t pid) + cnt_pi++; + + /* start port */ +- if (rte_eth_dev_start(pi) < 0) { ++ if (eth_dev_start_mp(pi) < 0) { + printf("Fail to start port %d\n", pi); + + /* Fail to setup rx queue, return */ +@@ -2700,7 +2768,7 @@ stop_port(portid_t pid) + } + } + +- if (rte_eth_dev_stop(pi) != 0) ++ if (eth_dev_stop_mp(pi) != 0) + RTE_LOG(ERR, EAL, "rte_eth_dev_stop failed for port %u\n", + pi); + +@@ -2769,8 +2837,10 @@ close_port(portid_t pid) + continue; + } + +- port_flow_flush(pi); +- rte_eth_dev_close(pi); ++ if (is_proc_primary()) { ++ port_flow_flush(pi); ++ rte_eth_dev_close(pi); ++ } + } + + remove_invalid_ports(); +@@ -3035,7 +3105,7 @@ pmd_test_exit(void) + } + for (i = 0 ; i < RTE_DIM(mempools) ; i++) { + if (mempools[i]) +- rte_mempool_free(mempools[i]); ++ mempool_free_mp(mempools[i]); + } + + printf("\nBye...\n"); +@@ -3482,6 +3552,10 @@ init_port_dcb_config(portid_t pid, + int retval; + uint16_t i; + ++ if (num_procs > 1) { ++ printf("The multi-process feature doesn't support dcb.\n"); ++ return -ENOTSUP; ++ } + rte_port = &ports[pid]; + + /* retain the original device configuration. */ +@@ -3646,10 +3720,6 @@ main(int argc, char** argv) + rte_exit(EXIT_FAILURE, "Cannot init EAL: %s\n", + rte_strerror(rte_errno)); + +- if (rte_eal_process_type() == RTE_PROC_SECONDARY) +- rte_exit(EXIT_FAILURE, +- "Secondary process type not supported.\n"); +- + ret = register_eth_event_callback(); + if (ret != 0) + rte_exit(EXIT_FAILURE, "Cannot register for ethdev events"); +diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h +index 303bed830..122fca29c 100644 +--- a/app/test-pmd/testpmd.h ++++ b/app/test-pmd/testpmd.h +@@ -626,6 +626,17 @@ extern struct mplsoudp_decap_conf mplsoudp_decap_conf; + + extern enum rte_eth_rx_mq_mode rx_mq_mode; + ++extern struct rte_flow_action_conntrack conntrack_context; ++ ++extern int proc_id; ++extern unsigned int num_procs; ++ ++static inline bool ++is_proc_primary(void) ++{ ++ return rte_eal_process_type() == RTE_PROC_PRIMARY; ++} ++ + static inline unsigned int + lcore_num(void) + { +diff --git a/doc/guides/testpmd_app_ug/run_app.rst b/doc/guides/testpmd_app_ug/run_app.rst +index ca67105b7..098cbbd43 100644 +--- a/doc/guides/testpmd_app_ug/run_app.rst ++++ b/doc/guides/testpmd_app_ug/run_app.rst +@@ -529,3 +529,87 @@ The command line options are: + bit 1 - two hairpin ports paired + bit 0 - two hairpin ports loop + The default value is 0. Hairpin will use single port mode and implicit Tx flow mode. ++ ++ ++Testpmd Multi-Process Command-line Options ++~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++ ++The following are the command-line options for testpmd multi-process support: ++ ++* primary process: ++ ++.. code-block:: console ++ ++ sudo ./dpdk-testpmd -a xxx --proc-type=auto -l 0-1 -- -i --rxq=4 --txq=4 \ ++ --num-procs=2 --proc-id=0 ++ ++* secondary process: ++ ++.. code-block:: console ++ ++ sudo ./dpdk-testpmd -a xxx --proc-type=auto -l 2-3 -- -i --rxq=4 --txq=4 \ ++ --num-procs=2 --proc-id=1 ++ ++The command line options are: ++ ++* ``--num-procs=N`` ++ ++ The number of processes which will be used. ++ ++* ``--proc-id=ID`` ++ ++ The ID of the current process (ID < num-procs). ID should be different in ++ primary process and secondary process, which starts from '0'. ++ ++Calculation rule for queue: ++All queues are allocated to different processes based on ``proc_num`` and ++``proc_id``. ++Calculation rule for the testpmd to allocate queues to each process: ++* start(queue start id) = proc_id * nb_q / num_procs£» ++ ++* end(queue end id) = start + nb_q / num_procs£» ++ ++For example, if testpmd is configured to have 4 Tx and Rx queues, ++queues 0 and 1 will be used by the primary process and ++queues 2 and 3 will be used by the secondary process. ++ ++The number of queues should be a multiple of the number of processes. If not, ++redundant queues will exist after queues are allocated to processes. If RSS ++is enabled, packet loss occurs when traffic is sent to all processes at the same ++time. Some traffic goes to redundant queues and cannot be forwarded. ++ ++All the dev ops is supported in primary process. While secondary process is ++not permitted to allocate or release shared memory, so some ops are not supported ++as follows: ++ ++- ``dev_configure`` ++- ``dev_start`` ++- ``dev_stop`` ++- ``rx_queue_setup`` ++- ``tx_queue_setup`` ++- ``rx_queue_release`` ++- ``tx_queue_release`` ++ ++So, any command from testpmd which calls those APIs will not be supported in ++secondary process, like: ++ ++.. code-block:: console ++ ++ port config all rxq|txq|rxd|txd ++ port config rx_offload xxx on/off ++ port config tx_offload xxx on/off ++ ++etc. ++ ++When secondary is running, port in primary is not permitted to be stopped. ++Reconfigure operation is only valid in primary. ++ ++Stats is supported, stats will not change when one quits and starts, as they ++share the same buffer to store the stats. Flow rules are maintained in process ++level: primary and secondary has its own flow list (but one flow list in HW). ++The two can see all the queues, so setting the flow rules for the other is OK. ++But in the testpmd primary process receiving or transmitting packets from the ++queue allocated for secondary process is not permitted, and same for secondary ++process. ++ ++Flow API and RSS are supported. +-- +2.23.0 + diff --git a/dpdk.spec b/dpdk.spec index 0b0e7c13c0a4b09228f88e62c135718639db0f06..9a6fd0336521df966469bea32989f2ef6fa21769 100644 --- a/dpdk.spec +++ b/dpdk.spec @@ -1,6 +1,6 @@ Name: dpdk Version: 20.11 -Release: 11 +Release: 12 Packager: packaging@6wind.com URL: http://dpdk.org %global source_version 20.11 @@ -226,7 +226,18 @@ Patch216: 0216-net-hns3-support-set-link-up-down-for-PF.patch Patch217: 0217-net-hns3-fix-queue-flow-action-validation.patch Patch218: 0218-net-hns3-fix-taskqueue-pair-reset-command.patch Patch219: 0219-net-hns3-fix-Tx-push-capability.patch - +Patch220: 0220-examples-kni-close-port-before-exit.patch +Patch221: 0221-net-hns3-fix-residual-MAC-after-setting-default-MAC.patch +Patch222: 0222-net-hns3-fix-input-parameters-of-MAC-functions.patch +Patch223: 0223-net-bonding-fix-dedicated-queue-mode-in-vector-burst.patch +Patch224: 0224-net-bonding-fix-RSS-key-length.patch +Patch225: 0225-app-testpmd-add-command-to-show-LACP-bonding-info.patch +Patch226: 0226-app-testpmd-retain-all-original-dev-conf-when-config.patch +Patch227: 0227-net-hns3-remove-similar-macro-function-definitions.patch +Patch228: 0228-net-hns3-fix-interrupt-vector-freeing.patch +Patch229: 0229-net-hns3-add-runtime-config-for-mailbox-limit-time.patch +Patch230: 0230-net-hns3-fix-mailbox-communication-with-HW.patch +Patch231: 0231-app-testpmd-support-multi-process.patch Summary: Data Plane Development Kit core Group: System Environment/Libraries @@ -365,6 +376,9 @@ strip -g $RPM_BUILD_ROOT/lib/modules/${namer}/extra/dpdk/rte_kni.ko /usr/sbin/depmod %changelog +* Mon Nov 01 2021 Min Hu - 20.11-12 +- synchronize dmadev and hns3 bugfixes from upstream + * Mon Sep 13 2021 chenchen - 20.11-11 - del rpath from some binaries and bin - add debug package to strip