From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id A2EF5427F6 for ; Tue, 21 Mar 2023 10:24:30 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id EC27242C24; Tue, 21 Mar 2023 10:24:29 +0100 (CET) Received: from szxga03-in.huawei.com (szxga03-in.huawei.com [45.249.212.189]) by mails.dpdk.org (Postfix) with ESMTP id 7A6DE40A7A for ; Tue, 21 Mar 2023 10:24:27 +0100 (CET) Received: from kwepemm600004.china.huawei.com (unknown [172.30.72.56]) by szxga03-in.huawei.com (SkyGuard) with ESMTP id 4PgmPx3YLRz9vW9; Tue, 21 Mar 2023 17:24:05 +0800 (CST) Received: from localhost.localdomain (10.28.79.22) by kwepemm600004.china.huawei.com (7.193.23.242) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.21; Tue, 21 Mar 2023 17:24:25 +0800 From: Huisong Li To: , CC: , , , Subject: [PATCH 21.11 08/17] net/hns3: separate setting hash algorithm Date: Tue, 21 Mar 2023 17:22:57 +0800 Message-ID: <20230321092306.16918-9-lihuisong@huawei.com> X-Mailer: git-send-email 2.22.0 In-Reply-To: <20230321092306.16918-1-lihuisong@huawei.com> References: <20230321092306.16918-1-lihuisong@huawei.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain X-Originating-IP: [10.28.79.22] X-ClientProxiedBy: dggems702-chm.china.huawei.com (10.3.19.179) To kwepemm600004.china.huawei.com (7.193.23.242) X-CFilter-Loop: Reflected X-BeenThere: stable@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: patches for DPDK stable branches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: stable-bounces@dpdk.org [ upstream commit 1fcbef5ccb993b6028a3f8a68a7b01f9b8c67413 ] Currently, the setting of hash algorithm comes from the default configuration in driver and the rte_flow interface. The hash algorithm that is set to hardware in both ways is saved in hw->rss_info.conf.func. But the 'func' in struct rte_flow_action_rss is usually used in rte flow interface. And the ethdev ops interface may also set hash algorithm in the future. It is not appropriate and is a little messy for ethdev ops interface and driver default configuration to use struct rte_flow_action_rss. So we have to separate the RSS configuration from ethdev ops and rte flow interface to make codes more easier to maintain. This patch separates hash algorithm by following ways: 1) 'hash_algo' in struct hns3_rss_conf is used for ethdev ops interface or default configuration in driver. 2) Add a 'rte_flow_hash_algo' field in struct hns3_rss_conf to save algorithm from rte flow interface. The main reasons are as follows: Currently, only the last rule is used to restore the rte flow rule. If 'func' in RSS action is 'DEFAULT', it means that this rule doesn't modify algorithm and driver need to save current algorithm for restoring algorithm during reset phase. Fixes: c37ca66f2b27 ("net/hns3: support RSS") Signed-off-by: Huisong Li Signed-off-by: Dongdong Liu --- drivers/net/hns3/hns3_flow.c | 60 +++++++++++++++++++++--------------- drivers/net/hns3/hns3_rss.c | 14 +-------- drivers/net/hns3/hns3_rss.h | 1 + 3 files changed, 37 insertions(+), 38 deletions(-) diff --git a/drivers/net/hns3/hns3_flow.c b/drivers/net/hns3/hns3_flow.c index 97ea4e4de7..2ead9b3a48 100644 --- a/drivers/net/hns3/hns3_flow.c +++ b/drivers/net/hns3/hns3_flow.c @@ -1391,30 +1391,40 @@ hns3_disable_rss(struct hns3_hw *hw) } static int -hns3_parse_rss_algorithm(struct hns3_hw *hw, enum rte_eth_hash_function *func, +hns3_parse_rss_algorithm(struct hns3_hw *hw, enum rte_eth_hash_function func, uint8_t *hash_algo) { - enum rte_eth_hash_function algo_func = *func; - switch (algo_func) { - case RTE_ETH_HASH_FUNCTION_DEFAULT: - /* Keep *hash_algo as what it used to be */ - algo_func = hw->rss_info.conf.func; - break; - case RTE_ETH_HASH_FUNCTION_TOEPLITZ: - *hash_algo = HNS3_RSS_HASH_ALGO_TOEPLITZ; - break; - case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR: - *hash_algo = HNS3_RSS_HASH_ALGO_SIMPLE; - break; - case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ: - *hash_algo = HNS3_RSS_HASH_ALGO_SYMMETRIC_TOEP; - break; - default: - hns3_err(hw, "Invalid RSS algorithm configuration(%d)", - algo_func); - return -EINVAL; + const uint8_t hash_func_map[] = { + [RTE_ETH_HASH_FUNCTION_DEFAULT] = HNS3_RSS_HASH_ALGO_TOEPLITZ, + [RTE_ETH_HASH_FUNCTION_TOEPLITZ] = HNS3_RSS_HASH_ALGO_TOEPLITZ, + [RTE_ETH_HASH_FUNCTION_SIMPLE_XOR] = HNS3_RSS_HASH_ALGO_SIMPLE, + [RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ] = HNS3_RSS_HASH_ALGO_SYMMETRIC_TOEP, + }; + uint8_t key[HNS3_RSS_KEY_SIZE_MAX] = {0}; + int ret; + + if (func == RTE_ETH_HASH_FUNCTION_DEFAULT) { + ret = hns3_rss_get_algo_key(hw, hash_algo, key, + hw->rss_key_size); + if (ret != 0) { + hns3_err(hw, "fail to get current RSS hash algorithm, ret = %d", + ret); + return ret; + } + + /* + * During the phase of reset recovery, the hash algorithm + * obtained from hardware may not be the one used(saved in + * rte_flow_hash_algo) when this rule is delivered. + */ + if (__atomic_load_n(&hw->reset.resetting, __ATOMIC_RELAXED) && + *hash_algo != hw->rss_info.rte_flow_hash_algo) + *hash_algo = hw->rss_info.rte_flow_hash_algo; + + return 0; } - *func = algo_func; + + *hash_algo = hash_func_map[func]; return 0; } @@ -1424,6 +1434,7 @@ hns3_hw_rss_hash_set(struct hns3_hw *hw, struct rte_flow_action_rss *rss_config) { uint8_t rss_key[HNS3_RSS_KEY_SIZE_MAX] = {0}; bool use_default_key = false; + uint8_t hash_algo; int ret; if (rss_config->key == NULL || rss_config->key_len != hw->rss_key_size) { @@ -1433,18 +1444,17 @@ hns3_hw_rss_hash_set(struct hns3_hw *hw, struct rte_flow_action_rss *rss_config) use_default_key = true; } - ret = hns3_parse_rss_algorithm(hw, &rss_config->func, - &hw->rss_info.hash_algo); + ret = hns3_parse_rss_algorithm(hw, rss_config->func, &hash_algo); if (ret) return ret; - ret = hns3_rss_set_algo_key(hw, hw->rss_info.hash_algo, + ret = hns3_rss_set_algo_key(hw, hash_algo, use_default_key ? rss_key : rss_config->key, hw->rss_key_size); if (ret) return ret; - hw->rss_info.conf.func = rss_config->func; + hw->rss_info.rte_flow_hash_algo = hash_algo; ret = hns3_set_rss_tuple_by_rss_hf(hw, rss_config->types); if (ret) diff --git a/drivers/net/hns3/hns3_rss.c b/drivers/net/hns3/hns3_rss.c index f535161e77..417082acf2 100644 --- a/drivers/net/hns3/hns3_rss.c +++ b/drivers/net/hns3/hns3_rss.c @@ -1027,7 +1027,7 @@ hns3_rss_set_default_args(struct hns3_hw *hw) int i; /* Default hash algorithm */ - rss_cfg->conf.func = RTE_ETH_HASH_FUNCTION_TOEPLITZ; + rss_cfg->hash_algo = HNS3_RSS_HASH_ALGO_TOEPLITZ; memcpy(rss_cfg->key, hns3_hash_key, RTE_MIN(sizeof(hns3_hash_key), hw->rss_key_size)); @@ -1051,18 +1051,6 @@ hns3_config_rss(struct hns3_adapter *hns) enum rte_eth_rx_mq_mode mq_mode = hw->data->dev_conf.rxmode.mq_mode; - switch (hw->rss_info.conf.func) { - case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR: - hw->rss_info.hash_algo = HNS3_RSS_HASH_ALGO_SIMPLE; - break; - case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ: - hw->rss_info.hash_algo = HNS3_RSS_HASH_ALGO_SYMMETRIC_TOEP; - break; - default: - hw->rss_info.hash_algo = HNS3_RSS_HASH_ALGO_TOEPLITZ; - break; - } - ret = hns3_rss_set_algo_key(hw, rss_cfg->hash_algo, hash_key, hw->rss_key_size); if (ret) diff --git a/drivers/net/hns3/hns3_rss.h b/drivers/net/hns3/hns3_rss.h index cc53f363ae..7f47cc243c 100644 --- a/drivers/net/hns3/hns3_rss.h +++ b/drivers/net/hns3/hns3_rss.h @@ -45,6 +45,7 @@ struct hns3_rss_conf { /* RSS parameters :algorithm, flow_types, key, queue */ struct rte_flow_action_rss conf; uint8_t hash_algo; /* hash function type defined by hardware */ + uint8_t rte_flow_hash_algo; uint8_t key[HNS3_RSS_KEY_SIZE_MAX]; /* Hash key */ uint16_t rss_indirection_tbl[HNS3_RSS_IND_TBL_SIZE_MAX]; uint16_t queue[HNS3_RSS_QUEUES_BUFFER_NUM]; /* Queues indices to use */ -- 2.22.0