From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6C760A2EEB for ; Mon, 9 Sep 2019 17:07:59 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 1FCD61C2A1; Mon, 9 Sep 2019 17:07:59 +0200 (CEST) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by dpdk.org (Postfix) with ESMTP id 79E0B1C02C for ; Mon, 9 Sep 2019 17:07:56 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 09 Sep 2019 08:07:55 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,486,1559545200"; d="scan'208";a="359509466" Received: from fyigit-mobl.ger.corp.intel.com (HELO [10.237.221.4]) ([10.237.221.4]) by orsmga005.jf.intel.com with ESMTP; 09 Sep 2019 08:07:53 -0700 To: "Su, Simei" , "Ye, Xiaolong" Cc: "Zhang, Qi Z" , "dev@dpdk.org" References: <1567907360-287625-1-git-send-email-simei.su@intel.com> <20190908092622.GB6732@intel.com> <65F28F834D25B54B9EC1999B623071B30C446A1F@SHSMSX104.ccr.corp.intel.com> From: Ferruh Yigit Openpgp: preference=signencrypt Autocrypt: addr=ferruh.yigit@intel.com; prefer-encrypt=mutual; keydata= mQINBFXZCFABEADCujshBOAaqPZpwShdkzkyGpJ15lmxiSr3jVMqOtQS/sB3FYLT0/d3+bvy qbL9YnlbPyRvZfnP3pXiKwkRoR1RJwEo2BOf6hxdzTmLRtGtwWzI9MwrUPj6n/ldiD58VAGQ +iR1I/z9UBUN/ZMksElA2D7Jgg7vZ78iKwNnd+vLBD6I61kVrZ45Vjo3r+pPOByUBXOUlxp9 GWEKKIrJ4eogqkVNSixN16VYK7xR+5OUkBYUO+sE6etSxCr7BahMPKxH+XPlZZjKrxciaWQb +dElz3Ab4Opl+ZT/bK2huX+W+NJBEBVzjTkhjSTjcyRdxvS1gwWRuXqAml/sh+KQjPV1PPHF YK5LcqLkle+OKTCa82OvUb7cr+ALxATIZXQkgmn+zFT8UzSS3aiBBohg3BtbTIWy51jNlYdy ezUZ4UxKSsFuUTPt+JjHQBvF7WKbmNGS3fCid5Iag4tWOfZoqiCNzxApkVugltxoc6rG2TyX CmI2rP0mQ0GOsGXA3+3c1MCdQFzdIn/5tLBZyKy4F54UFo35eOX8/g7OaE+xrgY/4bZjpxC1 1pd66AAtKb3aNXpHvIfkVV6NYloo52H+FUE5ZDPNCGD0/btFGPWmWRmkPybzColTy7fmPaGz cBcEEqHK4T0aY4UJmE7Ylvg255Kz7s6wGZe6IR3N0cKNv++O7QARAQABtCVGZXJydWggWWln aXQgPGZlcnJ1aC55aWdpdEBpbnRlbC5jb20+iQJUBBMBCgA+AhsDAh4BAheABQsJCAcDBRUK CQgLBRYCAwEAFiEE0jZTh0IuwoTjmYHH+TPrQ98TYR8FAl1meboFCQlupOoACgkQ+TPrQ98T YR9ACBAAv2tomhyxY0Tp9Up7mNGLfEdBu/7joB/vIdqMRv63ojkwr9orQq5V16V/25+JEAD0 60cKodBDM6HdUvqLHatS8fooWRueSXHKYwJ3vxyB2tWDyZrLzLI1jxEvunGodoIzUOtum0Ce gPynnfQCelXBja0BwLXJMplM6TY1wXX22ap0ZViC0m714U5U4LQpzjabtFtjT8qOUR6L7hfy YQ72PBuktGb00UR/N5UrR6GqB0x4W41aZBHXfUQnvWIMmmCrRUJX36hOTYBzh+x86ULgg7H2 1499tA4o6rvE13FiGccplBNWCAIroAe/G11rdoN5NBgYVXu++38gTa/MBmIt6zRi6ch15oLA Ln2vHOdqhrgDuxjhMpG2bpNE36DG/V9WWyWdIRlz3NYPCDM/S3anbHlhjStXHOz1uHOnerXM 1jEjcsvmj1vSyYoQMyRcRJmBZLrekvgZeh7nJzbPHxtth8M7AoqiZ/o/BpYU+0xZ+J5/szWZ aYxxmIRu5ejFf+Wn9s5eXNHmyqxBidpCWvcbKYDBnkw2+Y9E5YTpL0mS0dCCOlrO7gca27ux ybtbj84aaW1g0CfIlUnOtHgMCmz6zPXThb+A8H8j3O6qmPoVqT3qnq3Uhy6GOoH8Fdu2Vchh TWiF5yo+pvUagQP6LpslffufSnu+RKAagkj7/RSuZV25Ag0EV9ZMvgEQAKc0Db17xNqtSwEv mfp4tkddwW9XA0tWWKtY4KUdd/jijYqc3fDD54ESYpV8QWj0xK4YM0dLxnDU2IYxjEshSB1T qAatVWz9WtBYvzalsyTqMKP3w34FciuL7orXP4AibPtrHuIXWQOBECcVZTTOdZYGAzaYzxiA ONzF9eTiwIqe9/oaOjTwTLnOarHt16QApTYQSnxDUQljeNvKYt1lZE/gAUUxNLWsYyTT+22/ vU0GDUahsJxs1+f1yEr+OGrFiEAmqrzpF0lCS3f/3HVTU6rS9cK3glVUeaTF4+1SK5ZNO35p iVQCwphmxa+dwTG/DvvHYCtgOZorTJ+OHfvCnSVjsM4kcXGjJPy3JZmUtyL9UxEbYlrffGPQ I3gLXIGD5AN5XdAXFCjjaID/KR1c9RHd7Oaw0Pdcq9UtMLgM1vdX8RlDuMGPrj5sQrRVbgYH fVU/TQCk1C9KhzOwg4Ap2T3tE1umY/DqrXQgsgH71PXFucVjOyHMYXXugLT8YQ0gcBPHy9mZ qw5mgOI5lCl6d4uCcUT0l/OEtPG/rA1lxz8ctdFBVOQOxCvwRG2QCgcJ/UTn5vlivul+cThi 6ERPvjqjblLncQtRg8izj2qgmwQkvfj+h7Ex88bI8iWtu5+I3K3LmNz/UxHBSWEmUnkg4fJl Rr7oItHsZ0ia6wWQ8lQnABEBAAGJAjwEGAEKACYCGwwWIQTSNlOHQi7ChOOZgcf5M+tD3xNh HwUCXWZ5wAUJB3FgggAKCRD5M+tD3xNhH2O+D/9OEz62YuJQLuIuOfL67eFTIB5/1+0j8Tsu o2psca1PUQ61SZJZOMl6VwNxpdvEaolVdrpnSxUF31kPEvR0Igy8HysQ11pj8AcgH0a9FrvU /8k2Roccd2ZIdpNLkirGFZR7LtRw41Kt1Jg+lafI0efkiHKMT/6D/P1EUp1RxOBNtWGV2hrd 0Yg9ds+VMphHHU69fDH02SwgpvXwG8Qm14Zi5WQ66R4CtTkHuYtA63sS17vMl8fDuTCtvfPF HzvdJLIhDYN3Mm1oMjKLlq4PUdYh68Fiwm+boJoBUFGuregJFlO3hM7uHBDhSEnXQr5mqpPM 6R/7Q5BjAxrwVBisH0yQGjsWlnysRWNfExAE2sRePSl0or9q19ddkRYltl6X4FDUXy2DTXa9 a+Fw4e1EvmcF3PjmTYs9IE3Vc64CRQXkhujcN4ZZh5lvOpU8WgyDxFq7bavFnSS6kx7Tk29/ wNJBp+cf9qsQxLbqhW5kfORuZGecus0TLcmpZEFKKjTJBK9gELRBB/zoN3j41hlEl7uTUXTI JQFLhpsFlEdKLujyvT/aCwP3XWT+B2uZDKrMAElF6ltpTxI53JYi22WO7NH7MR16Fhi4R6vh FHNBOkiAhUpoXRZXaCR6+X4qwA8CwHGqHRBfYFSU/Ulq1ZLR+S3hNj2mbnSx0lBs1eEqe2vh cA== Message-ID: <367c4009-7445-95b2-6984-6cd6307739f6@intel.com> Date: Mon, 9 Sep 2019 16:07:52 +0100 MIME-Version: 1.0 In-Reply-To: <65F28F834D25B54B9EC1999B623071B30C446A1F@SHSMSX104.ccr.corp.intel.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Subject: Re: [dpdk-dev] [PATCH v1] net/ice: enable advanced RSS X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" On 9/9/2019 7:34 AM, Su, Simei wrote: > > >> -----Original Message----- >> From: Ye, Xiaolong >> Sent: Sunday, September 8, 2019 5:26 PM >> To: Su, Simei >> Cc: Zhang, Qi Z ; dev@dpdk.org >> Subject: Re: [PATCH v1] net/ice: enable advanced RSS >> >> On 09/08, Simei Su wrote: >>> This patch supports the following features: >>> (1)inner header hash for tunnel packets, including comms package. >>> (2)symmetric hash by rte_flow RSS action. >>> (3)input set change by rte_flow RSS action. >>> >>> This patch depends on the following patches on patchwork: >>> (1)https://patchwork.dpdk.org/patch/58546/ >>> [2/4] net/ice: rework for generic flow enabling >>> (2)https://patchwork.dpdk.org/patch/57137/ >>> [v2,1/2] ethdev: add symmetric toeplitz hash support >>> (3)https://patchwork.dpdk.org/patch/57138/ >>> [v2,2/2] app/testpmd: add symmetric toeplitz hash support >>> (4)https://patchwork.dpdk.org/patch/57601/ >>> [1/2] ethdev: extend RSS offload types >>> (5)https://patchwork.dpdk.org/patch/57602/ >>> [2/2] app/testpmd: add RSS offload types extending support >>> >>> Signed-off-by: Simei Su >>> --- >>> drivers/net/ice/ice_ethdev.c | 7 + >>> drivers/net/ice/ice_hash.c | 540 >> +++++++++++++++++++++++++++++++++++++++++++ >>> 2 files changed, 547 insertions(+) >>> create mode 100644 drivers/net/ice/ice_hash.c >>> >>> diff --git a/drivers/net/ice/ice_ethdev.c >>> b/drivers/net/ice/ice_ethdev.c index f5cc647..3766a32 100644 >>> --- a/drivers/net/ice/ice_ethdev.c >>> +++ b/drivers/net/ice/ice_ethdev.c >>> @@ -1874,6 +1874,7 @@ static int ice_init_rss(struct ice_pf *pf) >>> uint16_t i, nb_q; >>> int ret = 0; >>> bool is_safe_mode = pf->adapter->is_safe_mode; >>> + uint32_t reg; >>> >>> rss_conf = &dev->data->dev_conf.rx_adv_conf.rss_conf; >>> nb_q = dev->data->nb_rx_queues; >>> @@ -1917,6 +1918,12 @@ static int ice_init_rss(struct ice_pf *pf) >>> if (ret) >>> return -EINVAL; >>> >>> + /* Enable registers for symmetric_toeplitz function. */ >>> + reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id)); >>> + reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) | >>> + (1 << VSIQF_HASH_CTL_HASH_SCHEME_S); >>> + ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg); >>> + >>> /* configure RSS for IPv4 with input set IPv4 src/dst */ >>> ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4, >>> ICE_FLOW_SEG_HDR_IPV4, 0); >>> diff --git a/drivers/net/ice/ice_hash.c b/drivers/net/ice/ice_hash.c >>> new file mode 100644 index 0000000..f8b7087 >>> --- /dev/null >>> +++ b/drivers/net/ice/ice_hash.c >>> @@ -0,0 +1,540 @@ >>> +/* SPDX-License-Identifier: BSD-3-Clause >>> + * Copyright(c) 2019 Intel Corporation */ >>> + >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> + >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> +#include >>> + >>> +#include "ice_logs.h" >>> +#include "base/ice_type.h" >>> +#include "base/ice_flow.h" >>> +#include "ice_ethdev.h" >>> +#include "ice_generic_flow.h" >>> + >>> +#define ICE_ACTION_RSS_MAX_QUEUE_NUM 32 >>> + >>> +static struct ice_pattern_match_item ice_hash_pattern_list_os[]; >>> +static struct ice_pattern_match_item ice_hash_pattern_list_comms[]; >>> + >>> +struct rss_type_match_hdr { >>> + uint32_t hdr_mask; >>> + uint64_t eth_rss_hint; >>> +}; >>> + >>> +struct ice_hash_match_type { >>> + uint64_t hash_type; >>> + uint64_t hash_flds; >>> +}; >>> + >>> +struct rss_meta { >>> + uint32_t pkt_hdr; >>> + uint64_t hash_flds; >>> + uint8_t hash_function; >>> +}; >>> + >>> +static int >>> +ice_hash_init(struct ice_adapter *ad); >>> + >>> +static int >>> +ice_hash_create(struct ice_adapter *ad, >>> + struct rte_flow *flow, >>> + void *meta, >>> + struct rte_flow_error *error); >>> + >>> +static int >>> +ice_hash_destroy(struct ice_adapter *ad, >>> + struct rte_flow *flow, >>> + struct rte_flow_error *error); >>> + >>> +static void >>> +ice_hash_uninit(struct ice_adapter *ad); >>> + >>> +static void >>> +ice_hash_free(struct rte_flow *flow); >>> + >>> +static int >>> +ice_hash_parse_pattern_action(struct ice_adapter *ad, >>> + struct ice_pattern_match_item *array, >>> + uint32_t array_len, >>> + const struct rte_flow_item pattern[], >>> + const struct rte_flow_action actions[], >>> + void **meta, >>> + struct rte_flow_error *error); >>> + >>> +/* The first member is protocol header, the second member is >>> +ETH_RSS_*. */ const struct rss_type_match_hdr hint_0 = { >>> + ICE_FLOW_SEG_HDR_NONE, 0}; >>> +const struct rss_type_match_hdr hint_1 = { >>> + ICE_FLOW_SEG_HDR_IPV4, ETH_RSS_IPV4}; >>> +const struct rss_type_match_hdr hint_2 = { >>> + ICE_FLOW_SEG_HDR_IPV4|ICE_FLOW_SEG_HDR_UDP, >>> +ETH_RSS_NONFRAG_IPV4_UDP}; const struct rss_type_match_hdr hint_3 = { >>> + ICE_FLOW_SEG_HDR_IPV4|ICE_FLOW_SEG_HDR_TCP, >>> +ETH_RSS_NONFRAG_IPV4_TCP}; const struct rss_type_match_hdr hint_4 = { >>> + ICE_FLOW_SEG_HDR_IPV4|ICE_FLOW_SEG_HDR_SCTP, >>> +ETH_RSS_NONFRAG_IPV4_SCTP}; const struct rss_type_match_hdr hint_5 = { >>> + ICE_FLOW_SEG_HDR_IPV6, ETH_RSS_IPV6}; >>> +const struct rss_type_match_hdr hint_6 = { >>> + ICE_FLOW_SEG_HDR_IPV6|ICE_FLOW_SEG_HDR_UDP, >>> +ETH_RSS_NONFRAG_IPV6_UDP}; const struct rss_type_match_hdr hint_7 = { >>> + ICE_FLOW_SEG_HDR_IPV6|ICE_FLOW_SEG_HDR_TCP, >>> +ETH_RSS_NONFRAG_IPV6_TCP}; const struct rss_type_match_hdr hint_8 = { >>> + ICE_FLOW_SEG_HDR_IPV6|ICE_FLOW_SEG_HDR_SCTP, >>> +ETH_RSS_NONFRAG_IPV6_SCTP}; const struct rss_type_match_hdr hint_9 = { >>> + ICE_FLOW_SEG_HDR_GTPU_IP, ETH_RSS_IPV4}; >>> +const struct rss_type_match_hdr hint_10 = { >>> + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_IPV4}; >>> +const struct rss_type_match_hdr hint_11 = { >>> + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_NONFRAG_IPV4_UDP}; >>> +const struct rss_type_match_hdr hint_12 = { >>> + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_NONFRAG_IPV4_TCP}; >>> +const struct rss_type_match_hdr hint_13 = { >>> + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_NONFRAG_IPV4_SCTP}; >>> + >>> +/* Supported pattern for os default package. */ static struct >>> +ice_pattern_match_item ice_hash_pattern_list_os[] = { >>> + {pattern_eth_ipv4, ICE_INSET_NONE, (uint64_t)(&hint_1)}, >>> + {pattern_eth_ipv4_udp, ICE_INSET_NONE, (uint64_t)(&hint_2)}, >>> + {pattern_eth_ipv4_tcp, ICE_INSET_NONE, (uint64_t)(&hint_3)}, >>> + {pattern_eth_ipv4_sctp, ICE_INSET_NONE, (uint64_t)(&hint_4)}, >>> + {pattern_eth_ipv6, ICE_INSET_NONE, (uint64_t)(&hint_5)}, >>> + {pattern_eth_ipv6_udp, ICE_INSET_NONE, (uint64_t)(&hint_6)}, >>> + {pattern_eth_ipv6_tcp, ICE_INSET_NONE, (uint64_t)(&hint_7)}, >>> + {pattern_eth_ipv6_sctp, ICE_INSET_NONE, (uint64_t)(&hint_8)}, >>> + {pattern_empty, ICE_INSET_NONE, (uint64_t)(&hint_0)}, >>> +}; >>> + >>> +/* Supported pattern for comms package. */ static struct >>> +ice_pattern_match_item ice_hash_pattern_list_comms[] = { >>> + {pattern_eth_ipv4, ICE_INSET_NONE, (uint64_t)(&hint_1)}, >>> + {pattern_eth_ipv4_udp, ICE_INSET_NONE, (uint64_t)(&hint_2)}, >>> + {pattern_eth_ipv4_tcp, ICE_INSET_NONE, (uint64_t)(&hint_3)}, >>> + {pattern_eth_ipv4_sctp, ICE_INSET_NONE, (uint64_t)(&hint_4)}, >>> + {pattern_eth_ipv6, ICE_INSET_NONE, (uint64_t)(&hint_5)}, >>> + {pattern_eth_ipv6_udp, ICE_INSET_NONE, (uint64_t)(&hint_6)}, >>> + {pattern_eth_ipv6_tcp, ICE_INSET_NONE, (uint64_t)(&hint_7)}, >>> + {pattern_eth_ipv6_sctp, ICE_INSET_NONE, (uint64_t)(&hint_8)}, >>> + {pattern_empty, ICE_INSET_NONE, (uint64_t)(&hint_0)}, >>> + {pattern_eth_ipv4_gtpu_ipv4, ICE_INSET_NONE, >> (uint64_t)(&hint_9)}, >>> + {pattern_eth_ipv4_gtpu_ipv4_udp, ICE_INSET_NONE, >> (uint64_t)(&hint_9)}, >>> + {pattern_eth_ipv4_gtpu_ipv4_tcp, ICE_INSET_NONE, >> (uint64_t)(&hint_9)}, >>> + {pattern_eth_pppoes_ipv4, ICE_INSET_NONE, (uint64_t)(&hint_10)}, >>> + {pattern_eth_pppoes_ipv4_udp, ICE_INSET_NONE, >> (uint64_t)(&hint_11)}, >>> + {pattern_eth_pppoes_ipv4_tcp, ICE_INSET_NONE, >> (uint64_t)(&hint_12)}, >>> + {pattern_eth_pppoes_ipv4_sctp, ICE_INSET_NONE, >> (uint64_t)(&hint_13)}, >>> +}; >>> + >> >> Multi-line comments format is like: >> >> /* >> * The first member is input set combination, >> * the second member is hash fields. >> */ > Ok, I will fix it in v2. >> >>> +/* The first member is input set combination, >>> + * the second member is hash fields. >>> + */ >>> +struct ice_hash_match_type ice_hash_type_list[] = { >>> + {ETH_RSS_IPV4|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)}, >>> + {ETH_RSS_IPV4|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)}, >> >> I bet checkpatches.sh script would complain about the length of these lines. > Yes, the checkpatches.sh shows "WARNING: line over 80 characters". It's a complete table, I ignore the warning for these. >> >>> + {ETH_RSS_IPV4, >> ICE_FLOW_HASH_IPV4}, >>> + >> {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|ICE_FLOW_HASH_UDP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|ICE_FLOW_HASH_UDP_PORT}, >>> + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)} >> , >>> + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)} >> , >>> + {ETH_RSS_NONFRAG_IPV4_UDP, >> ICE_HASH_UDP_IPV4}, >>> + >> {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SR >> C_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_DS >> T_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|ICE_FLOW_HASH_TCP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_SR >> C_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|ICE_FLOW_HASH_TCP_PORT}, >>> + {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_TCP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_TCP, >> ICE_HASH_TCP_IPV4}, >>> + >> {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_SA)|ICE_FLOW_HASH_SCTP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_ >> DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV4_DA)|ICE_FLOW_HASH_SCTP_PORT} >> , >>> + {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT) >> }, >>> + {ETH_RSS_NONFRAG_IPV4_SCTP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV4|BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT) >> }, >>> + {ETH_RSS_NONFRAG_IPV4_SCTP, >> ICE_HASH_SCTP_IPV4}, >>> + {ETH_RSS_IPV6|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)}, >>> + {ETH_RSS_IPV6|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)}, >>> + {ETH_RSS_IPV6, >> ICE_FLOW_HASH_IPV6}, >>> + >> {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|ICE_FLOW_HASH_UDP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _UDP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|ICE_FLOW_HASH_UDP_PORT}, >>> + {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)} >> , >>> + {ETH_RSS_NONFRAG_IPV6_UDP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_DST_PORT)} >> , >>> + {ETH_RSS_NONFRAG_IPV6_UDP, >> ICE_HASH_UDP_IPV6}, >>> + >> {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SR >> C_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_DS >> T_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|ICE_FLOW_HASH_TCP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_SR >> C_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|ICE_FLOW_HASH_TCP_PORT}, >>> + {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_TCP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_TCP, >> ICE_HASH_TCP_IPV6}, >>> + >> {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_D >> ST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_SRC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_SA)|ICE_FLOW_HASH_SCTP_PORT}, >>> + >> {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_S >> RC_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_SRC_PORT)}, >>> + >> {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_DST_ONLY|ETH_RSS_L4_ >> DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|BIT_ULL(ICE_FLOW_FIELD_IDX >> _SCTP_DST_PORT)}, >>> + {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L3_DST_ONLY, >> BIT_ULL(ICE_FLOW_FIELD_IDX_IPV6_DA)|ICE_FLOW_HASH_SCTP_PORT} >> , >>> + {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L4_SRC_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT) >> }, >>> + {ETH_RSS_NONFRAG_IPV6_SCTP|ETH_RSS_L4_DST_ONLY, >> ICE_FLOW_HASH_IPV6|BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_DST_PORT) >> }, >>> + {ETH_RSS_NONFRAG_IPV6_SCTP, >> ICE_HASH_SCTP_IPV6}, >>> +}; >>> + >>> +static struct >>> +ice_flow_engine ice_hash_engine = { >> >> You don't need to put the variable type in a separate line. > Ok, I will modify it in v2. >> >>> + .init = ice_hash_init, >>> + .create = ice_hash_create, >>> + .destroy = ice_hash_destroy, >>> + .uninit = ice_hash_uninit, >>> + .free = ice_hash_free, >>> + .type = ICE_FLOW_ENGINE_HASH, >>> +}; >>> + >>> +/* Register parser for os package. */ >>> +static struct >>> +ice_flow_parser ice_hash_parser_os = { >>> + .engine = &ice_hash_engine, >>> + .array = ice_hash_pattern_list_os, >>> + .array_len = RTE_DIM(ice_hash_pattern_list_os), >>> + .parse_pattern_action = ice_hash_parse_pattern_action, >>> + .stage = ICE_FLOW_STAGE_RSS, >>> +}; >>> + >>> +/* Register parser for comms package. */ static struct ice_flow_parser >>> +ice_hash_parser_comms = { >>> + .engine = &ice_hash_engine, >>> + .array = ice_hash_pattern_list_comms, >>> + .array_len = RTE_DIM(ice_hash_pattern_list_comms), >>> + .parse_pattern_action = ice_hash_parse_pattern_action, >>> + .stage = ICE_FLOW_STAGE_RSS, >>> +}; >>> + >>> +RTE_INIT(ice_init_log) >> >> ice_init_log is not a good name here, and it has been used by ice log module, >> seems a copy/paste issue. > Yes, it should be "ice_hash_init_log". Thanks! >> >>> +{ >>> + struct ice_flow_engine *engine = &ice_hash_engine; >>> + ice_register_flow_engine(engine); >>> +} >>> + >>> +static int >>> +ice_hash_init(struct ice_adapter *ad) >>> +{ >>> + int ret = 0; >>> + >>> + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) { >>> + struct ice_flow_parser *parser = &ice_hash_parser_os; >>> + ret = ice_register_parser(parser, ad); >>> + } else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) { >>> + struct ice_flow_parser *parser = &ice_hash_parser_comms; >>> + ret = ice_register_parser(parser, ad); >>> + } >>> + >>> + return ret; >>> +} >>> + >>> +static int >>> +ice_hash_check_inset(const struct rte_flow_item pattern[], >>> + struct rte_flow_error *error) >>> +{ >>> + const struct rte_flow_item *item = pattern; >>> + >>> + for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) { >>> + if (item->last) { >>> + rte_flow_error_set(error, EINVAL, >>> + RTE_FLOW_ERROR_TYPE_ITEM, item, >>> + "Not support range"); >>> + return -rte_errno; >>> + } >>> + >>> + /* Ignore spec and mask. */ >>> + if (item->spec || item->mask) { >>> + rte_flow_error_set(error, EINVAL, >>> + RTE_FLOW_ERROR_TYPE_ITEM, item, >>> + "Invalid mask."); >>> + return -rte_errno; >>> + } >>> + } >>> + >>> + return 0; >>> +} >>> + >>> +static int >>> +ice_hash_parse_action(struct ice_pattern_match_item >> *pattern_match_item, >>> + const struct rte_flow_action actions[], >>> + void **meta, >>> + struct rte_flow_error *error) >>> +{ >>> + const struct rte_flow_action *action; >>> + enum rte_flow_action_type action_type; >>> + const struct rte_flow_action_rss *rss; >>> + struct rss_type_match_hdr *m = (struct rss_type_match_hdr *) >>> + (pattern_match_item->meta); >>> + uint32_t type_list_len = RTE_DIM(ice_hash_type_list); >>> + >>> + /* Supported action is RSS. */ >>> + for (action = actions; action->type != >>> + RTE_FLOW_ACTION_TYPE_END; action++) { >>> + action_type = action->type; >>> + switch (action_type) { >>> + case RTE_FLOW_ACTION_TYPE_RSS: >>> + rss = action->conf; >>> + uint16_t i; >>> + >>> + /* Check if pattern is empty. */ >>> + if (((pattern_match_item->pattern_list) != >>> + pattern_empty) && (rss->func == >>> + RTE_ETH_HASH_FUNCTION_SIMPLE_XOR)) >>> + return rte_flow_error_set(error, ENOTSUP, >>> + RTE_FLOW_ERROR_TYPE_ACTION, action, >>> + "Not supported flow"); >>> + >>> + /* Check if rss types match pattern. */ >>> + if (rss->func != RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) { >>> + if (((rss->types & ETH_RSS_IPV4) != m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV4_UDP) != >> m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV4_TCP) != >> m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV4_SCTP) != >> m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_IPV6) != m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV6_UDP) != >> m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV6_TCP) != >> m->eth_rss_hint) || >>> + ((rss->types & ETH_RSS_NONFRAG_IPV6_SCTP) != >> m->eth_rss_hint)) >>> + return rte_flow_error_set(error, >>> + ENOTSUP, RTE_FLOW_ERROR_TYPE_ACTION, >>> + action, "Not supported RSS types"); >>> + } >>> + >>> + if (rss->level) >>> + return rte_flow_error_set(error, ENOTSUP, >>> + RTE_FLOW_ERROR_TYPE_ACTION, action, >>> + "a nonzero RSS encapsulation level is not supported"); >>> + >>> + if (rss->key_len == 0) >>> + return rte_flow_error_set(error, ENOTSUP, >>> + RTE_FLOW_ERROR_TYPE_ACTION, action, >>> + "RSS hash key_len mustn't be 0"); >>> + >>> + if ((rss->queue_num) > ICE_ACTION_RSS_MAX_QUEUE_NUM) >>> + return rte_flow_error_set(error, ENOTSUP, >>> + RTE_FLOW_ERROR_TYPE_ACTION, action, >>> + "too many queues for RSS context"); >>> + >>> + /* Check hash function and save it to rss_meta. */ >>> + if (rss->func == >>> + RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) >>> + ((struct rss_meta *)*meta)->hash_function = >>> + RTE_ETH_HASH_FUNCTION_SIMPLE_XOR; >>> + >>> + if (rss->func == >>> + RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) >>> + ((struct rss_meta *)*meta)->hash_function = >>> + RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ; >>> + >>> + struct ice_hash_match_type *type_match_item; >>> + type_match_item = rte_zmalloc("ice_type_match_item", >>> + sizeof(struct ice_hash_match_type), 0); >>> + if (!type_match_item) >>> + PMD_DRV_LOG(ERR, >>> + "Failed to allocate memory for type_match_item"); >>> + >>> + /* Find matched hash fields according to hash type. */ >>> + for (i = 0; i < type_list_len; i++) { >>> + if (rss->types == >>> + ice_hash_type_list[i].hash_type) { >>> + type_match_item->hash_type = >>> + ice_hash_type_list[i].hash_type; >>> + type_match_item->hash_flds = >>> + ice_hash_type_list[i].hash_flds; >>> + } >>> + } >>> + >>> + /* Save hash fileds to rss_meta. */ >>> + ((struct rss_meta *)*meta)->hash_flds = >>> + type_match_item->hash_flds; >>> + >>> + rte_free(type_match_item); >>> + break; >>> + >>> + case RTE_FLOW_ACTION_TYPE_END: >>> + return 0; >>> + break; >>> + >>> + default: >>> + rte_flow_error_set(error, EINVAL, >>> + RTE_FLOW_ERROR_TYPE_ACTION, action, >>> + "Invalid action."); >>> + return -rte_errno; >>> + } >>> + } >>> + >>> + return 0; >>> +} >>> + >>> +static int >>> +ice_hash_parse_pattern_action(__rte_unused struct ice_adapter *ad, >>> + struct ice_pattern_match_item *array, >>> + uint32_t array_len, >>> + const struct rte_flow_item pattern[], >>> + const struct rte_flow_action actions[], >>> + void **meta, >>> + struct rte_flow_error *error) >>> +{ >>> + int ret = 0; >>> + >>> + struct rss_meta *rss_meta_ptr = NULL; >>> + rss_meta_ptr = rte_zmalloc(NULL, sizeof(*rss_meta_ptr), 0); >>> + if (!rss_meta_ptr) { >>> + rte_flow_error_set(error, EINVAL, >>> + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >>> + "No memory for rss_meta_ptr"); >>> + return -rte_errno; >>> + } >>> + >>> + struct ice_pattern_match_item *pattern_match_item = NULL; >> >> I think this introduces decl-after-statement. > Ok, I will modify it in v2. >> >>> + /* Check rss supported pattern and find matched pattern. */ >>> + pattern_match_item = ice_search_pattern_match_item(pattern, >>> + array, array_len, error); >>> + if (!pattern_match_item) >>> + return -rte_errno; >>> + >>> + ret = ice_hash_check_inset(pattern, error); >>> + if (ret) >>> + return -rte_errno; >>> + >>> + /* Save protocol header to rss_meta. */ >>> + *meta = rss_meta_ptr; >>> + ((struct rss_meta *)*meta)->pkt_hdr = ((struct rss_type_match_hdr *) >>> + (pattern_match_item->meta))->hdr_mask; >>> + >>> + /* Check rss action. */ >>> + ret = ice_hash_parse_action(pattern_match_item, actions, meta, error); >>> + if (ret) >>> + return -rte_errno; >>> + >>> + rte_free(pattern_match_item); >>> + >>> + return 0; >>> +} >>> + >>> +static int >>> +ice_hash_create(struct ice_adapter *ad, >>> + struct rte_flow *flow, >>> + void *meta, >>> + __rte_unused struct rte_flow_error *error) { >>> + struct ice_pf *pf = &ad->pf; >>> + struct ice_hw *hw = ICE_PF_TO_HW(pf); >>> + struct ice_vsi *vsi = pf->main_vsi; >>> + int ret = 0; >>> + uint32_t reg; >>> + struct ice_rss_cfg *filter_ptr; >>> + >>> + uint32_t headermask = ((struct rss_meta *)meta)->pkt_hdr; >>> + uint64_t hash_field = ((struct rss_meta *)meta)->hash_flds; >>> + uint8_t hash_function = ((struct rss_meta *)meta)->hash_function; >>> + >>> + filter_ptr = rte_zmalloc("ice_rss_filter", >>> + sizeof(struct ice_rss_cfg), 0); >>> + if (!filter_ptr) { >>> + PMD_DRV_LOG(ERR, "failed to allocate memory"); >> >> Use rte_flow_error_set instead of PMD_DRV_LOG in flow ops. >> >>> + return -EINVAL; >> >> should return -ENOMEM for memory allocation failure case. > As to PMD_DRV_LOG in flow ops, I will fix all in v2. Thanks for your reminder. >> >>> + } >>> + >>> + if (hash_function == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) { >>> + /* Enable registers for simple_xor hash function. */ >>> + reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id)); >>> + reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) | >>> + (2 << VSIQF_HASH_CTL_HASH_SCHEME_S); >>> + ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg); >>> + >>> + filter_ptr->symm = hash_function; >>> + >>> + goto out; >>> + } else if (hash_function == >> RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ) { >>> + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 1); >>> + if (ret) >>> + PMD_DRV_LOG(ERR, "%s rss flow fail %d", __func__, ret); >> >> Use rte_flow_error_set instead of PMD_DRV_LOG, and is it intentional we keep >> proceeding other than return error when this failure happens. > Yes, I will change it to rte_flow_error_set. >> >> >>> + } else { >>> + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); >>> + if (ret) >>> + PMD_DRV_LOG(ERR, "%s rss flow fail %d", __func__, ret); >> >> Ditto. >> >>> + } >>> + >>> + filter_ptr->packet_hdr = headermask; >>> + filter_ptr->hashed_flds = hash_field; >>> + >>> +out: >>> + flow->rule = filter_ptr; >>> + rte_free(meta); >>> + return 0; >>> +} >>> + >>> +static int >>> +ice_hash_destroy(struct ice_adapter *ad, >>> + struct rte_flow *flow, >>> + __rte_unused struct rte_flow_error *error) { >>> + struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(ad); >>> + struct ice_hw *hw = ICE_PF_TO_HW(pf); >>> + struct ice_vsi *vsi = pf->main_vsi; >>> + int ret = 0; >>> + uint32_t reg; >>> + struct ice_rss_cfg *filter_ptr; >>> + >>> + filter_ptr = (struct ice_rss_cfg *)flow->rule; >>> + >>> + if (filter_ptr->symm == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) { >>> + /* Return to symmetric_toeplitz state. */ >>> + reg = ICE_READ_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id)); >>> + reg = (reg & (~VSIQF_HASH_CTL_HASH_SCHEME_M)) | >>> + (1 << VSIQF_HASH_CTL_HASH_SCHEME_S); >>> + ICE_WRITE_REG(hw, VSIQF_HASH_CTL(vsi->vsi_id), reg); >>> + } else { >>> + ret = ice_rem_vsi_rss_cfg(hw, vsi->idx); >>> + if (ret) >>> + PMD_DRV_LOG(ERR, "%s rss flow destroy fail %d", >>> + __func__, ret); >> >> Ditto. >> >>> + } >>> + >>> + rte_free(filter_ptr); >>> + >>> + return 0; >>> +} >>> + >>> +static void >>> +ice_hash_uninit(struct ice_adapter *ad) { >>> + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) >>> + ice_unregister_parser(&ice_hash_parser_os, ad); >>> + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) >>> + ice_unregister_parser(&ice_hash_parser_comms, ad); } >>> + >>> +static void >>> +ice_hash_free(struct rte_flow *flow) >>> +{ >>> + rte_free(flow->rule); >>> +} >>> -- >>> 1.8.3.1 >>> > The original patch was not in mail list, it has been resent, and now in: https://patches.dpdk.org/patch/59028/