* [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS [not found] <1567866291-268287-1-git-send-email-simei.su@intel.com> @ 2019-09-09 14:56 ` Simei Su 2019-09-12 16:19 ` Ye Xiaolong 2019-09-19 5:15 ` [dpdk-dev] [PATCH v3] " Simei Su 0 siblings, 2 replies; 26+ messages in thread From: Simei Su @ 2019-09-09 14:56 UTC (permalink / raw) To: qi.z.zhang, qiming.yang, beilei.xing Cc: dev, xiaolong.ye, simei.su, ferruh.yigit 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. Signed-off-by: Simei Su <simei.su@intel.com> --- 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 drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 548 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 555 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..fbd7cd7 --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,548 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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 = { + .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_hash_init_log) +{ + 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); + struct ice_hash_match_type *type_match_item; + + /* 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* 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 ice_pattern_match_item *pattern_match_item = NULL; + 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 -ENOMEM; + } + + /* 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + } + + 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) + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + } + + 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 ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS 2019-09-09 14:56 ` [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS Simei Su @ 2019-09-12 16:19 ` Ye Xiaolong 2019-09-16 1:47 ` Su, Simei 2019-09-19 5:15 ` [dpdk-dev] [PATCH v3] " Simei Su 1 sibling, 1 reply; 26+ messages in thread From: Ye Xiaolong @ 2019-09-12 16:19 UTC (permalink / raw) To: Simei Su; +Cc: qi.z.zhang, qiming.yang, beilei.xing, dev, ferruh.yigit On 09/09, 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. > >Signed-off-by: Simei Su <simei.su@intel.com> >--- >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 > > drivers/net/ice/ice_ethdev.c | 7 + > drivers/net/ice/ice_hash.c | 548 +++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 555 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..fbd7cd7 >--- /dev/null >+++ b/drivers/net/ice/ice_hash.c >@@ -0,0 +1,548 @@ >+/* SPDX-License-Identifier: BSD-3-Clause >+ * Copyright(c) 2019 Intel Corporation >+ */ >+ >+#include <sys/queue.h> >+#include <stdio.h> >+#include <errno.h> >+#include <stdint.h> >+#include <string.h> >+#include <unistd.h> >+#include <stdarg.h> >+ >+#include <rte_debug.h> >+#include <rte_ether.h> >+#include <rte_ethdev_driver.h> >+#include <rte_log.h> >+#include <rte_malloc.h> >+#include <rte_eth_ctrl.h> >+#include <rte_tailq.h> >+#include <rte_flow_driver.h> >+ >+#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[]; Above two forward declaration seems unnecessary. >+ >+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)}, >+}; >+ >+/** >+ * 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)}, >+ {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, >+ {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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 = { >+ .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_hash_init_log) I don't think this function has something to do with 'log', better to use name like ice_hash_engine_init. >+{ >+ 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; Unnecessary initialization for the ret. >+ >+ 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); >+ } >+ What about: struct ice_flow_parser *parser; if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) { parser = &ice_hash_parser_os; } else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) { parser = &ice_hash_parser_comms; } return 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."); "Invalid spec/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); >+ struct ice_hash_match_type *type_match_item; >+ >+ /* 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; >+ >+ type_match_item = rte_zmalloc("ice_type_match_item", >+ sizeof(struct ice_hash_match_type), 0); >+ if (!type_match_item) { >+ rte_flow_error_set(error, EINVAL, >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >+ "No memory for type_match_item"); >+ return -ENOMEM; >+ } >+ >+ /* 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 ice_pattern_match_item *pattern_match_item = NULL; >+ struct rss_meta *rss_meta_ptr = NULL; Unnecessary initializations. >+ >+ 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 -ENOMEM; >+ } >+ >+ /* 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) { >+ rte_flow_error_set(error, EINVAL, >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >+ "No memory for filter_ptr"); >+ return -ENOMEM; >+ } >+ >+ 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) >+ rte_flow_error_set(error, EINVAL, >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >+ "rss flow create fail"); Do we need to error out here? >+ } else { >+ ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); >+ if (ret) >+ rte_flow_error_set(error, EINVAL, >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >+ "rss flow create fail"); 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) It's actually used in this function, so just remove the __rte_unused tag. >+{ >+ 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; Unnecessary initialization. >+ 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) >+ rte_flow_error_set(error, EINVAL, >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, >+ "rss flow destroy fail"); If ice_rem_vsi_rss_cfg fails here, do we still need to proceed to free the flow other than return error here? >+ } >+ >+ 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 > ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS 2019-09-12 16:19 ` Ye Xiaolong @ 2019-09-16 1:47 ` Su, Simei 0 siblings, 0 replies; 26+ messages in thread From: Su, Simei @ 2019-09-16 1:47 UTC (permalink / raw) To: Ye, Xiaolong; +Cc: Zhang, Qi Z, Yang, Qiming, Xing, Beilei, dev, Yigit, Ferruh Hi, xiaolong > -----Original Message----- > From: Ye, Xiaolong > Sent: Friday, September 13, 2019 12:19 AM > To: Su, Simei <simei.su@intel.com> > Cc: Zhang, Qi Z <qi.z.zhang@intel.com>; Yang, Qiming <qiming.yang@intel.com>; > Xing, Beilei <beilei.xing@intel.com>; dev@dpdk.org; Yigit, Ferruh > <ferruh.yigit@intel.com> > Subject: Re: [PATCH v2] net/ice: enable advanced RSS > > On 09/09, 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. > > > >Signed-off-by: Simei Su <simei.su@intel.com> > >--- > >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 > > > > drivers/net/ice/ice_ethdev.c | 7 + > > drivers/net/ice/ice_hash.c | 548 > +++++++++++++++++++++++++++++++++++++++++++ > > 2 files changed, 555 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..fbd7cd7 > >--- /dev/null > >+++ b/drivers/net/ice/ice_hash.c > >@@ -0,0 +1,548 @@ > >+/* SPDX-License-Identifier: BSD-3-Clause > >+ * Copyright(c) 2019 Intel Corporation */ > >+ > >+#include <sys/queue.h> > >+#include <stdio.h> > >+#include <errno.h> > >+#include <stdint.h> > >+#include <string.h> > >+#include <unistd.h> > >+#include <stdarg.h> > >+ > >+#include <rte_debug.h> > >+#include <rte_ether.h> > >+#include <rte_ethdev_driver.h> > >+#include <rte_log.h> > >+#include <rte_malloc.h> > >+#include <rte_eth_ctrl.h> > >+#include <rte_tailq.h> > >+#include <rte_flow_driver.h> > >+ > >+#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[]; > > Above two forward declaration seems unnecessary. > Yes, the two declaration is unnecessary, thanks for your reminder. > >+ > >+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)}, > >+}; > >+ > >+/** > >+ * 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)}, > >+ {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 = { > >+ .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_hash_init_log) > > I don't think this function has something to do with 'log', better to use name like > ice_hash_engine_init. > I write "ice_hash_init_log" referring to other module. I also think it has nothing to do with 'log'. Ok, I will modify it. > >+{ > >+ 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; > > Unnecessary initialization for the ret. > Ok, will change it. > >+ > >+ 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); > >+ } > >+ > > What about: > > struct ice_flow_parser *parser; > > if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) { > parser = &ice_hash_parser_os; > } else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) { > parser = &ice_hash_parser_comms; > } > > return ice_register_parser(parser, ad); > It looks a good advice, can avoid unnecessary redundancy. > >+ 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."); > > "Invalid spec/mask." > Yes, I ignore it, will add it. > >+ 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); > >+ struct ice_hash_match_type *type_match_item; > >+ > >+ /* 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; > >+ > >+ type_match_item = rte_zmalloc("ice_type_match_item", > >+ sizeof(struct ice_hash_match_type), 0); > >+ if (!type_match_item) { > >+ rte_flow_error_set(error, EINVAL, > >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, > >+ "No memory for type_match_item"); > >+ return -ENOMEM; > >+ } > >+ > >+ /* 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 ice_pattern_match_item *pattern_match_item = NULL; > >+ struct rss_meta *rss_meta_ptr = NULL; > > Unnecessary initializations. > Ok, will change it. > >+ > >+ 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 -ENOMEM; > >+ } > >+ > >+ /* 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) { > >+ rte_flow_error_set(error, EINVAL, > >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, > >+ "No memory for filter_ptr"); > >+ return -ENOMEM; > >+ } > >+ > >+ 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) > >+ rte_flow_error_set(error, EINVAL, > >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, > >+ "rss flow create fail"); > > Do we need to error out here? > Yes, it's my negligence that other than return error, also need to error out here. I will add it in v3 patch. > >+ } else { > >+ ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); > >+ if (ret) > >+ rte_flow_error_set(error, EINVAL, > >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, > >+ "rss flow create fail"); > > 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) > > It's actually used in this function, so just remove the __rte_unused tag. > Yes, I forgot to remove it, thanks! > >+{ > >+ 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; > > Unnecessary initialization. > Ok, will change it. > >+ 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) > >+ rte_flow_error_set(error, EINVAL, > >+ RTE_FLOW_ERROR_TYPE_HANDLE, NULL, > >+ "rss flow destroy fail"); > > If ice_rem_vsi_rss_cfg fails here, do we still need to proceed to free the flow > other than return error here? > Yes, as to this, I will add it. > >+ } > >+ > >+ 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 > > Br Simei ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v3] net/ice: enable advanced RSS 2019-09-09 14:56 ` [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS Simei Su 2019-09-12 16:19 ` Ye Xiaolong @ 2019-09-19 5:15 ` Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 0/2] " Simei Su 1 sibling, 1 reply; 26+ messages in thread From: Simei Su @ 2019-09-19 5:15 UTC (permalink / raw) To: xiaolong.ye, qi.z.zhang, beilei.xing, qiming.yang, wenzhuo.lu Cc: dev, simei.su The v3 patch adds configuration for pppoe/pppod with input set Source MAC and Session ID in the initialization. It also updates release notes and Makefile/meson.build. 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. Signed-off-by: Simei Su <simei.su@intel.com> This patch depends on the following patches on patchwork: (1)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 --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 17 + drivers/net/ice/ice_hash.c | 556 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 576 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index 7dc4f00..4352a9e 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -63,6 +63,7 @@ New Features * Supported device-specific DDP package loading. * Generic filter enhancement - Supported pipeline mode. + * Supported input set change and symmetric hash by rte_flow RSS action. Removed Items ------------- diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index ae53c26..7c7bbb0 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -62,6 +62,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_rxtx_vec_sse.c endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 480a5ce..6cce68c 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -1870,6 +1870,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; @@ -1913,6 +1914,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); @@ -1962,6 +1969,16 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD rss flow fail %d", + __func__, ret); + return 0; } diff --git a/drivers/net/ice/ice_hash.c b/drivers/net/ice/ice_hash.c new file mode 100644 index 0000000..15105c5 --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,556 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 36b4b3c..5469e15 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -10,6 +10,7 @@ sources = files( 'ice_ethdev.c', 'ice_rxtx.c', 'ice_switch_filter.c', + 'ice_hash.c', 'ice_generic_flow.c' ) -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v4 0/2] enable advanced RSS 2019-09-19 5:15 ` [dpdk-dev] [PATCH v3] " Simei Su @ 2019-09-27 9:53 ` Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su ` (2 more replies) 0 siblings, 3 replies; 26+ messages in thread From: Simei Su @ 2019-09-27 9:53 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye, beilei.xing, qiming.yang; +Cc: dev, simei.su [PATCH v4 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. [PATCH v4 2/2] support input set change and symmetric hash by rte_flow RSS action. [PTACH v4 2/2] depends on the following patches on patchwork: (1)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/59982/ [v4,1/3] ethdev: decouple flow types and RSS offload types (5)https://patchwork.dpdk.org/patch/59983/ [v4,2/3] ethdev: extend RSS offload types (6)https://patchwork.dpdk.org/patch/59985/ [v4,3/2] app/testpmd: add RSS offload types extending support v4: * Add rss support for gtpu with teid and pppoe/pppod with session id. * Split up into patchset. v3: * Modify codes according to the comments. * Update release notes and Makefile/meson.build. v2: * Amend to resend patch that v1 is not in community. Simei Su (2): net/ice: add RSS configuration for gtpu/pppoe net/ice: enable advanced RSS doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 24 ++ drivers/net/ice/ice_hash.c | 556 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 583 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v4 1/2] net/ice: add RSS configuration for gtpu/pppoe 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 0/2] " Simei Su @ 2019-09-27 9:53 ` Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 2/2] net/ice: enable advanced RSS Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-09-27 9:53 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye, beilei.xing, qiming.yang; +Cc: dev, simei.su This patch adds rss support for gtpu with input set teid and pppoe/pppod with input set source mac and session id. Signed-off-by: Simei Su <simei.su@intel.com> --- drivers/net/ice/ice_ethdev.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 3abdaff..7570197 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2274,6 +2274,23 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /* configure RSS for gtpu with input set TEID */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_GTP_U_IPV4_TEID, + ICE_FLOW_SEG_HDR_GTPU_IP, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s GTPU_TEID rss flow fail %d", + __func__, ret); + + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD_SessionID rss flow fail %d", + __func__, ret); + return 0; } -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v4 2/2] net/ice: enable advanced RSS 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 0/2] " Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su @ 2019-09-27 9:53 ` Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-09-27 9:53 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye, beilei.xing, qiming.yang; +Cc: dev, simei.su 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. Signed-off-by: Simei Su <simei.su@intel.com> --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 556 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 566 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index bc77daf..14b598b 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -66,6 +66,7 @@ New Features * Generic filter enhancement - Supported pipeline mode. - Supported new packet type like PPPoE for switch filter. + * Supported input set change and symmetric hash by rte_flow RSS action. Removed Items ------------- diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index 4a279f1..c9bef60 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -62,6 +62,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_rxtx_vec_sse.c endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 7570197..304f5cd 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2181,6 +2181,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; @@ -2224,6 +2225,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..15105c5 --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,556 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP|ETH_RSS_L3_SRC_ONLY|ETH_RSS_L4_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 6828170..b957649 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -10,6 +10,7 @@ sources = files( 'ice_ethdev.c', 'ice_rxtx.c', 'ice_switch_filter.c', + 'ice_hash.c', 'ice_generic_flow.c' ) -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v5 0/2] net/ice: enable advanced RSS 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 0/2] " Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su 2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 2/2] net/ice: enable advanced RSS Simei Su @ 2019-09-29 10:30 ` Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su ` (3 more replies) 2 siblings, 4 replies; 26+ messages in thread From: Simei Su @ 2019-09-29 10:30 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, qiming.yang, xiaolong.ye; +Cc: dev, simei.su [PATCH v5 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. [PATCH v5 2/2] support input set change and symmetric hash by rte_flow RSS action. [PTACH v5 2/2] depends on the following patches on patchwork: (1)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/60097/ [v7,1/3] ethdev: decouple flow types and RSS offload types (5)https://patchwork.dpdk.org/patch/60098/ [v7,2/3] ethdev: extend RSS offload types (6)https://patchwork.dpdk.org/patch/60099/ [v7,3/3] app/testpmd: add RSS offload types extending support v5: * Update title for cover letter and commit log. * Fix some code style. v4: * Add rss support for gtpu with teid and pppoe/pppod with session id. * Split up into patchset. v3: * Modify codes according to the comments. * Update release notes and Makefile/meson.build. v2: * Amend to resend patch that v1 is not in community. Simei Su (2): net/ice: add RSS configuration for gtpu/pppoe net/ice: enable advanced RSS doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 24 ++ drivers/net/ice/ice_hash.c | 555 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 582 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v5 1/2] net/ice: add RSS configuration for gtpu/pppoe 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su @ 2019-09-29 10:30 ` Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 2/2] net/ice: enable advanced RSS Simei Su ` (2 subsequent siblings) 3 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-09-29 10:30 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, qiming.yang, xiaolong.ye; +Cc: dev, simei.su This patch adds rss support for gtpu with input set teid and pppoe/pppod with input set source mac and session id. Signed-off-by: Simei Su <simei.su@intel.com> --- drivers/net/ice/ice_ethdev.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 3abdaff..7570197 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2274,6 +2274,23 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /* configure RSS for gtpu with input set TEID */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_GTP_U_IPV4_TEID, + ICE_FLOW_SEG_HDR_GTPU_IP, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s GTPU_TEID rss flow fail %d", + __func__, ret); + + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD_SessionID rss flow fail %d", + __func__, ret); + return 0; } -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v5 2/2] net/ice: enable advanced RSS 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su @ 2019-09-29 10:30 ` Simei Su 2019-09-30 0:28 ` [dpdk-dev] [PATCH v5 0/2] " Zhang, Qi Z 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su 3 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-09-29 10:30 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, qiming.yang, xiaolong.ye; +Cc: dev, simei.su This patch supports: (1)symmetric hash by rte_flow RSS action. (2)input set change by rte_flow RSS action. Signed-off-by: Simei Su <simei.su@intel.com> --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 555 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 565 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index bc77daf..14b598b 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -66,6 +66,7 @@ New Features * Generic filter enhancement - Supported pipeline mode. - Supported new packet type like PPPoE for switch filter. + * Supported input set change and symmetric hash by rte_flow RSS action. Removed Items ------------- diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index 4a279f1..c9bef60 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -62,6 +62,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_rxtx_vec_sse.c endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 7570197..304f5cd 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2181,6 +2181,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; @@ -2224,6 +2225,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..11687de --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,555 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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_DST_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_SRC_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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* 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: + 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 6828170..b957649 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -10,6 +10,7 @@ sources = files( 'ice_ethdev.c', 'ice_rxtx.c', 'ice_switch_filter.c', + 'ice_hash.c', 'ice_generic_flow.c' ) -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v5 0/2] net/ice: enable advanced RSS 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 2/2] net/ice: enable advanced RSS Simei Su @ 2019-09-30 0:28 ` Zhang, Qi Z 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su 3 siblings, 0 replies; 26+ messages in thread From: Zhang, Qi Z @ 2019-09-30 0:28 UTC (permalink / raw) To: Su, Simei, Xing, Beilei, Yang, Qiming, Ye, Xiaolong; +Cc: dev > -----Original Message----- > From: Su, Simei > Sent: Sunday, September 29, 2019 6:30 PM > To: Zhang, Qi Z <qi.z.zhang@intel.com>; Xing, Beilei <beilei.xing@intel.com>; > Yang, Qiming <qiming.yang@intel.com>; Ye, Xiaolong <xiaolong.ye@intel.com> > Cc: dev@dpdk.org; Su, Simei <simei.su@intel.com> > Subject: [PATCH v5 0/2] net/ice: enable advanced RSS > > [PATCH v5 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. > [PATCH v5 2/2] support input set change and symmetric hash by rte_flow RSS > action. > > [PTACH v5 2/2] depends on the following patches on patchwork: > (1)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/60097/ > [v7,1/3] ethdev: decouple flow types and RSS offload types > (5)https://patchwork.dpdk.org/patch/60098/ > [v7,2/3] ethdev: extend RSS offload types > (6)https://patchwork.dpdk.org/patch/60099/ > [v7,3/3] app/testpmd: add RSS offload types extending support > > v5: > * Update title for cover letter and commit log. > * Fix some code style. > > v4: > * Add rss support for gtpu with teid and pppoe/pppod with session id. > * Split up into patchset. > > v3: > * Modify codes according to the comments. > * Update release notes and Makefile/meson.build. > > v2: > * Amend to resend patch that v1 is not in community. > > Simei Su (2): > net/ice: add RSS configuration for gtpu/pppoe > net/ice: enable advanced RSS > > doc/guides/rel_notes/release_19_11.rst | 1 + > drivers/net/ice/Makefile | 1 + > drivers/net/ice/ice_ethdev.c | 24 ++ > drivers/net/ice/ice_hash.c | 555 > +++++++++++++++++++++++++++++++++ > drivers/net/ice/meson.build | 1 + > 5 files changed, 582 insertions(+) > create mode 100644 drivers/net/ice/ice_hash.c > > -- > 1.8.3.1 Acked-by: Qi Zhang <qi.z.zhang@intel.com> ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v6 0/2] net/ice: enable advanced RSS 2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su ` (2 preceding siblings ...) 2019-09-30 0:28 ` [dpdk-dev] [PATCH v5 0/2] " Zhang, Qi Z @ 2019-10-16 22:16 ` Simei Su 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su ` (2 more replies) 3 siblings, 3 replies; 26+ messages in thread From: Simei Su @ 2019-10-16 22:16 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su [PATCH v6 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. [PATCH v6 2/2] support input set change and symmetric hash by rte_flow RSS action. v6: * Add simultaneous use of SRC_ONLY and DST_ONLY of the same level. * Update cases in ice_hash_type_list[]. v5: * Update title for cover letter and commit log. * Fix some code style. v4: * Add rss support for gtpu with teid and pppoe/pppod with session id. * Split up into patchset. v3: * Modify codes according to the comments. * Update release notes and Makefile/meson.build. v2: * Amend to resend patch that v1 is not in community. Simei Su (2): net/ice: add RSS configuration for gtpu/pppoe net/ice: enable advanced RSS doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 24 ++ drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 589 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v6 1/2] net/ice: add RSS configuration for gtpu/pppoe 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su @ 2019-10-16 22:16 ` Simei Su 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 2/2] net/ice: enable advanced RSS Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-10-16 22:16 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su This patch adds rss support for gtpu with input set teid and pppoe/pppod with input set source mac and session id. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- drivers/net/ice/ice_ethdev.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index dc4d1e6..2db0f9a 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2306,6 +2306,23 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /* configure RSS for gtpu with input set TEID */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_GTP_U_IPV4_TEID, + ICE_FLOW_SEG_HDR_GTPU_IP, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s GTPU_TEID rss flow fail %d", + __func__, ret); + + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD_SessionID rss flow fail %d", + __func__, ret); + return 0; } -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v6 2/2] net/ice: enable advanced RSS 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su @ 2019-10-16 22:16 ` Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-10-16 22:16 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su This patch supports: (1)symmetric hash by rte_flow RSS action. (2)input set change by rte_flow RSS action. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 1 + 5 files changed, 572 insertions(+) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index 9c3de83..52b6d82 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -103,6 +103,7 @@ New Features * Generic filter enhancement - Supported pipeline mode. - Supported new packet type like PPPoE for switch filter. + * Supported input set change and symmetric hash by rte_flow RSS action. * **Updated the enic driver.** diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index 4a279f1..c9bef60 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -62,6 +62,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_rxtx_vec_sse.c endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 2db0f9a..8e982ac 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2213,6 +2213,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; @@ -2256,6 +2257,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..5295602 --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,562 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_DST_ONLY, 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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + uint64_t rss_hf = rss->types; + + /** + * Check simultaneous use of SRC_ONLY and DST_ONLY + * of the same level. + */ + rss_hf = rte_eth_rss_hf_refine(rss_hf); + + /* 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_hf & ETH_RSS_IPV4) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_IPV6) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) != m->eth_rss_hint) || + ((rss_hf & 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* Find matched hash fields according to hash type. */ + for (i = 0; i < type_list_len; i++) { + if (rss_hf == + 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: + 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 6828170..b957649 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -10,6 +10,7 @@ sources = files( 'ice_ethdev.c', 'ice_rxtx.c', 'ice_switch_filter.c', + 'ice_hash.c', 'ice_generic_flow.c' ) -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v7 0/2] net/ice: enable advanced RSS 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su 2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 2/2] net/ice: enable advanced RSS Simei Su @ 2019-10-20 2:14 ` Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su ` (2 more replies) 2 siblings, 3 replies; 26+ messages in thread From: Simei Su @ 2019-10-20 2:14 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su [PATCH v7 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. [PATCH v7 2/2] support input set change and symmetric hash by rte_flow RSS action. v7: * Rebase patches to solve merge conflict. v6: * Add simultaneous use of SRC_ONLY and DST_ONLY of the same level. * Update cases in ice_hash_type_list[]. v5: * Update title for cover letter and commit log. * Fix some code style. v4: * Add rss support for gtpu with teid and pppoe/pppod with session id. * Split up into patchset. v3: * Modify codes according to the comments. * Update release notes and Makefile/meson.build. v2: * Amend to resend patch that v1 is not in community. Simei Su (2): net/ice: add RSS configuration for gtpu/pppoe net/ice: enable advanced RSS doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 24 ++ drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 3 +- 5 files changed, 590 insertions(+), 1 deletion(-) create mode 100644 drivers/net/ice/ice_hash.c -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v7 1/2] net/ice: add RSS configuration for gtpu/pppoe 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su @ 2019-10-20 2:14 ` Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 2/2] net/ice: enable advanced RSS Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-10-20 2:14 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su This patch adds rss support for gtpu with input set teid and pppoe/pppod with input set source mac and session id. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- drivers/net/ice/ice_ethdev.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index e4fd5bc..49d00bd 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2463,6 +2463,23 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /* configure RSS for gtpu with input set TEID */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_GTP_U_IPV4_TEID, + ICE_FLOW_SEG_HDR_GTPU_IP, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s GTPU_TEID rss flow fail %d", + __func__, ret); + + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD_SessionID rss flow fail %d", + __func__, ret); + return 0; } -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v7 2/2] net/ice: enable advanced RSS 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su @ 2019-10-20 2:14 ` Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su 2 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-10-20 2:14 UTC (permalink / raw) To: qi.z.zhang, beilei.xing, xiaolong.ye; +Cc: dev, simei.su This patch supports: (1)symmetric hash by rte_flow RSS action. (2)input set change by rte_flow RSS action. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 3 +- 5 files changed, 573 insertions(+), 1 deletion(-) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index 88086b7..6602503 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -104,6 +104,7 @@ New Features * Generic filter enhancement - Supported pipeline mode. - Supported new packet type like PPPoE for switch filter. + * Supported input set change and symmetric hash by rte_flow RSS action. * **Updated iavf PMD.** diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index 884fc40..7c3b6a7 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -63,6 +63,7 @@ endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_fdir_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 49d00bd..d746758 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2370,6 +2370,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; @@ -2413,6 +2414,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..5295602 --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,562 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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)}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_DST_ONLY, 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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + uint64_t rss_hf = rss->types; + + /** + * Check simultaneous use of SRC_ONLY and DST_ONLY + * of the same level. + */ + rss_hf = rte_eth_rss_hf_refine(rss_hf); + + /* 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_hf & ETH_RSS_IPV4) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_IPV6) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) != m->eth_rss_hint) || + ((rss_hf & 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* Find matched hash fields according to hash type. */ + for (i = 0; i < type_list_len; i++) { + if (rss_hf == + 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: + 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 908a2ca..f9e897b 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -11,7 +11,8 @@ sources = files( 'ice_rxtx.c', 'ice_switch_filter.c', 'ice_generic_flow.c', - 'ice_fdir_filter.c' + 'ice_fdir_filter.c', + 'ice_hash.c' ) deps += ['hash'] -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v8 0/3] net/ice: enable advanced RSS 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su 2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 2/2] net/ice: enable advanced RSS Simei Su @ 2019-10-21 12:06 ` Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 1/3] net/ice: add RSS configuration for gtpu/pppoe Simei Su ` (3 more replies) 2 siblings, 4 replies; 26+ messages in thread From: Simei Su @ 2019-10-21 12:06 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye; +Cc: dev, simei.su [PATCH v8 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. [PATCH v8 2/2] support input set change and symmetric hash by rte_flow RSS action. v8: * Change meta type from uint64_t to void pointer for pattern structure. * Modify related code in ice_hash.c about above change. v7: * Rebase patches to solve merge conflict. v6: * Add simultaneous use of SRC_ONLY and DST_ONLY of the same level. * Update cases in ice_hash_type_list[]. v5: * Update title for cover letter and commit log. * Fix some code style. v4: * Add rss support for gtpu with teid and pppoe/pppod with session id. * Split up into patchset. v3: * Modify codes according to the comments. * Update release notes and Makefile/meson.build. v2: * Amend to resend patch that v1 is not in community. Simei Su (3): net/ice: add RSS configuration for gtpu/pppoe net/ice: change one member type of the pattern structure net/ice: enable advanced RSS doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 24 ++ drivers/net/ice/ice_generic_flow.h | 2 +- drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 3 +- 6 files changed, 591 insertions(+), 2 deletions(-) create mode 100644 drivers/net/ice/ice_hash.c -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v8 1/3] net/ice: add RSS configuration for gtpu/pppoe 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su @ 2019-10-21 12:06 ` Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure Simei Su ` (2 subsequent siblings) 3 siblings, 0 replies; 26+ messages in thread From: Simei Su @ 2019-10-21 12:06 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye; +Cc: dev, simei.su This patch adds rss support for gtpu with input set teid and pppoe/pppod with input set source mac and session id. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- drivers/net/ice/ice_ethdev.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index e4fd5bc..49d00bd 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2463,6 +2463,23 @@ static int ice_init_rss(struct ice_pf *pf) PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d", __func__, ret); + /* configure RSS for gtpu with input set TEID */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_GTP_U_IPV4_TEID, + ICE_FLOW_SEG_HDR_GTPU_IP, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s GTPU_TEID rss flow fail %d", + __func__, ret); + + /** + * configure RSS for pppoe/pppod with input set + * Source MAC and Session ID + */ + ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_PPPOE_SESS_ID_ETH, + ICE_FLOW_SEG_HDR_PPPOE, 0); + if (ret) + PMD_DRV_LOG(ERR, "%s PPPoE/PPPoD_SessionID rss flow fail %d", + __func__, ret); + return 0; } -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 1/3] net/ice: add RSS configuration for gtpu/pppoe Simei Su @ 2019-10-21 12:06 ` Simei Su 2019-10-21 14:16 ` Ye Xiaolong 2019-10-21 17:30 ` Ferruh Yigit 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS Simei Su 2019-10-21 14:24 ` [dpdk-dev] [PATCH v8 0/3] " Ye Xiaolong 3 siblings, 2 replies; 26+ messages in thread From: Simei Su @ 2019-10-21 12:06 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye; +Cc: dev, simei.su This patch changes a variable type from uint64_t to void pointer to avoid compilation issues for converting a point to uint64_t in i686 environment. Signed-off-by: Simei Su <simei.su@intel.com> --- drivers/net/ice/ice_generic_flow.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/net/ice/ice_generic_flow.h b/drivers/net/ice/ice_generic_flow.h index 098a687..b6e4ed0 100644 --- a/drivers/net/ice/ice_generic_flow.h +++ b/drivers/net/ice/ice_generic_flow.h @@ -411,7 +411,7 @@ struct ice_pattern_match_item { enum rte_flow_item_type *pattern_list; /* pattern_list must end with RTE_FLOW_ITEM_TYPE_END */ uint64_t input_set_mask; - uint64_t meta; + void *meta; }; typedef int (*engine_init_t)(struct ice_adapter *ad); -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure Simei Su @ 2019-10-21 14:16 ` Ye Xiaolong 2019-10-21 17:30 ` Ferruh Yigit 1 sibling, 0 replies; 26+ messages in thread From: Ye Xiaolong @ 2019-10-21 14:16 UTC (permalink / raw) To: Simei Su; +Cc: qi.z.zhang, dev On 10/21, Simei Su wrote: >This patch changes a variable type from uint64_t to void pointer >to avoid compilation issues for converting a point to uint64_t >in i686 environment. > >Signed-off-by: Simei Su <simei.su@intel.com> >--- > drivers/net/ice/ice_generic_flow.h | 2 +- > 1 file changed, 1 insertion(+), 1 deletion(-) > >diff --git a/drivers/net/ice/ice_generic_flow.h b/drivers/net/ice/ice_generic_flow.h >index 098a687..b6e4ed0 100644 >--- a/drivers/net/ice/ice_generic_flow.h >+++ b/drivers/net/ice/ice_generic_flow.h >@@ -411,7 +411,7 @@ struct ice_pattern_match_item { > enum rte_flow_item_type *pattern_list; > /* pattern_list must end with RTE_FLOW_ITEM_TYPE_END */ > uint64_t input_set_mask; >- uint64_t meta; >+ void *meta; > }; > > typedef int (*engine_init_t)(struct ice_adapter *ad); >-- >1.8.3.1 > Acked-by: Xiaolong Ye <xiaolong.ye@intel.com> ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure Simei Su 2019-10-21 14:16 ` Ye Xiaolong @ 2019-10-21 17:30 ` Ferruh Yigit 1 sibling, 0 replies; 26+ messages in thread From: Ferruh Yigit @ 2019-10-21 17:30 UTC (permalink / raw) To: Simei Su, qi.z.zhang, xiaolong.ye; +Cc: dev On 10/21/2019 1:06 PM, Simei Su wrote: > This patch changes a variable type from uint64_t to void pointer > to avoid compilation issues for converting a point to uint64_t > in i686 environment. > > Signed-off-by: Simei Su <simei.su@intel.com> Squashed into relevant commit in next-net, thanks. ^ permalink raw reply [flat|nested] 26+ messages in thread
* [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 1/3] net/ice: add RSS configuration for gtpu/pppoe Simei Su 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure Simei Su @ 2019-10-21 12:06 ` Simei Su 2019-10-21 17:30 ` Ferruh Yigit 2019-10-21 14:24 ` [dpdk-dev] [PATCH v8 0/3] " Ye Xiaolong 3 siblings, 1 reply; 26+ messages in thread From: Simei Su @ 2019-10-21 12:06 UTC (permalink / raw) To: qi.z.zhang, xiaolong.ye; +Cc: dev, simei.su This patch supports: (1)symmetric hash by rte_flow RSS action. (2)input set change by rte_flow RSS action. Signed-off-by: Simei Su <simei.su@intel.com> Acked-by: Qi Zhang <qi.z.zhang@intel.com> --- doc/guides/rel_notes/release_19_11.rst | 1 + drivers/net/ice/Makefile | 1 + drivers/net/ice/ice_ethdev.c | 7 + drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ drivers/net/ice/meson.build | 3 +- 5 files changed, 573 insertions(+), 1 deletion(-) create mode 100644 drivers/net/ice/ice_hash.c diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst index 562ef1e..d905bac 100644 --- a/doc/guides/rel_notes/release_19_11.rst +++ b/doc/guides/rel_notes/release_19_11.rst @@ -104,6 +104,7 @@ New Features * Generic filter enhancement - Supported pipeline mode. - Supported new packet type like PPPoE for switch filter. + * Supported input set change and symmetric hash by rte_flow RSS action. * **Updated iavf PMD.** diff --git a/drivers/net/ice/Makefile b/drivers/net/ice/Makefile index 884fc40..7c3b6a7 100644 --- a/drivers/net/ice/Makefile +++ b/drivers/net/ice/Makefile @@ -63,6 +63,7 @@ endif SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_switch_filter.c SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_fdir_filter.c +SRCS-$(CONFIG_RTE_LIBRTE_ICE_PMD) += ice_hash.c ifeq ($(findstring RTE_MACHINE_CPUFLAG_AVX2,$(CFLAGS)),RTE_MACHINE_CPUFLAG_AVX2) CC_AVX2_SUPPORT=1 else diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index 49d00bd..d746758 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -2370,6 +2370,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; @@ -2413,6 +2414,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..8f9e83e --- /dev/null +++ b/drivers/net/ice/ice_hash.c @@ -0,0 +1,562 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2019 Intel Corporation + */ + +#include <sys/queue.h> +#include <stdio.h> +#include <errno.h> +#include <stdint.h> +#include <string.h> +#include <unistd.h> +#include <stdarg.h> + +#include <rte_debug.h> +#include <rte_ether.h> +#include <rte_ethdev_driver.h> +#include <rte_log.h> +#include <rte_malloc.h> +#include <rte_eth_ctrl.h> +#include <rte_tailq.h> +#include <rte_flow_driver.h> + +#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 + +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_*. */ +struct rss_type_match_hdr hint_0 = { + ICE_FLOW_SEG_HDR_NONE, 0}; +struct rss_type_match_hdr hint_1 = { + ICE_FLOW_SEG_HDR_IPV4, ETH_RSS_IPV4}; +struct rss_type_match_hdr hint_2 = { + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_UDP, ETH_RSS_NONFRAG_IPV4_UDP}; +struct rss_type_match_hdr hint_3 = { + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_TCP, ETH_RSS_NONFRAG_IPV4_TCP}; +struct rss_type_match_hdr hint_4 = { + ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_SCTP, ETH_RSS_NONFRAG_IPV4_SCTP}; +struct rss_type_match_hdr hint_5 = { + ICE_FLOW_SEG_HDR_IPV6, ETH_RSS_IPV6}; +struct rss_type_match_hdr hint_6 = { + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_UDP, ETH_RSS_NONFRAG_IPV6_UDP}; +struct rss_type_match_hdr hint_7 = { + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_TCP, ETH_RSS_NONFRAG_IPV6_TCP}; +struct rss_type_match_hdr hint_8 = { + ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_SCTP, ETH_RSS_NONFRAG_IPV6_SCTP}; +struct rss_type_match_hdr hint_9 = { + ICE_FLOW_SEG_HDR_GTPU_IP, ETH_RSS_IPV4}; +struct rss_type_match_hdr hint_10 = { + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_IPV4}; +struct rss_type_match_hdr hint_11 = { + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_NONFRAG_IPV4_UDP}; +struct rss_type_match_hdr hint_12 = { + ICE_FLOW_SEG_HDR_PPPOE, ETH_RSS_NONFRAG_IPV4_TCP}; +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, &hint_1}, + {pattern_eth_ipv4_udp, ICE_INSET_NONE, &hint_2}, + {pattern_eth_ipv4_tcp, ICE_INSET_NONE, &hint_3}, + {pattern_eth_ipv4_sctp, ICE_INSET_NONE, &hint_4}, + {pattern_eth_ipv6, ICE_INSET_NONE, &hint_5}, + {pattern_eth_ipv6_udp, ICE_INSET_NONE, &hint_6}, + {pattern_eth_ipv6_tcp, ICE_INSET_NONE, &hint_7}, + {pattern_eth_ipv6_sctp, ICE_INSET_NONE, &hint_8}, + {pattern_empty, ICE_INSET_NONE, &hint_0}, +}; + +/* Supported pattern for comms package. */ +static struct ice_pattern_match_item ice_hash_pattern_list_comms[] = { + {pattern_eth_ipv4, ICE_INSET_NONE, &hint_1}, + {pattern_eth_ipv4_udp, ICE_INSET_NONE, &hint_2}, + {pattern_eth_ipv4_tcp, ICE_INSET_NONE, &hint_3}, + {pattern_eth_ipv4_sctp, ICE_INSET_NONE, &hint_4}, + {pattern_eth_ipv6, ICE_INSET_NONE, &hint_5}, + {pattern_eth_ipv6_udp, ICE_INSET_NONE, &hint_6}, + {pattern_eth_ipv6_tcp, ICE_INSET_NONE, &hint_7}, + {pattern_eth_ipv6_sctp, ICE_INSET_NONE, &hint_8}, + {pattern_empty, ICE_INSET_NONE, &hint_0}, + {pattern_eth_ipv4_gtpu_ipv4, ICE_INSET_NONE, &hint_9}, + {pattern_eth_ipv4_gtpu_ipv4_udp, ICE_INSET_NONE, &hint_9}, + {pattern_eth_ipv4_gtpu_ipv4_tcp, ICE_INSET_NONE, &hint_9}, + {pattern_eth_pppoes_ipv4, ICE_INSET_NONE, &hint_10}, + {pattern_eth_pppoes_ipv4_udp, ICE_INSET_NONE, &hint_11}, + {pattern_eth_pppoes_ipv4_tcp, ICE_INSET_NONE, &hint_12}, + {pattern_eth_pppoes_ipv4_sctp, ICE_INSET_NONE, &hint_13}, +}; + +/** + * 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)}, + {ETH_RSS_IPV4, ICE_FLOW_HASH_IPV4}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_SRC_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV4_SCTP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_UDP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_UDP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_TCP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_TCP | ETH_RSS_L4_DST_ONLY, 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_SRC_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_DST_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L3_DST_ONLY | ETH_RSS_L4_SRC_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)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_SRC_ONLY, BIT_ULL(ICE_FLOW_FIELD_IDX_SCTP_SRC_PORT)}, + {ETH_RSS_NONFRAG_IPV6_SCTP | ETH_RSS_L4_DST_ONLY, 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 = { + .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_hash_engine_init) +{ + struct ice_flow_engine *engine = &ice_hash_engine; + ice_register_flow_engine(engine); +} + +static int +ice_hash_init(struct ice_adapter *ad) +{ + struct ice_flow_parser *parser = NULL; + + if (ad->active_pkg_type == ICE_PKG_TYPE_OS_DEFAULT) + parser = &ice_hash_parser_os; + else if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) + parser = &ice_hash_parser_comms; + + return ice_register_parser(parser, ad); +} + +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 spec/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); + struct ice_hash_match_type *type_match_item; + + /* 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; + uint64_t rss_hf = rss->types; + + /** + * Check simultaneous use of SRC_ONLY and DST_ONLY + * of the same level. + */ + rss_hf = rte_eth_rss_hf_refine(rss_hf); + + /* 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_hf & ETH_RSS_IPV4) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_IPV6) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) != m->eth_rss_hint) || + ((rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) != m->eth_rss_hint) || + ((rss_hf & 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; + + type_match_item = rte_zmalloc("ice_type_match_item", + sizeof(struct ice_hash_match_type), 0); + if (!type_match_item) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for type_match_item"); + return -ENOMEM; + } + + /* Find matched hash fields according to hash type. */ + for (i = 0; i < type_list_len; i++) { + if (rss_hf == + 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: + 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 ice_pattern_match_item *pattern_match_item; + struct rss_meta *rss_meta_ptr; + + 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 -ENOMEM; + } + + /* 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, + 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; + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "No memory for filter_ptr"); + return -ENOMEM; + } + + 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 = 0; + + 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } else { + ret = ice_add_rss_cfg(hw, vsi->idx, hash_field, headermask, 0); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow create fail"); + goto error; + } + } + + filter_ptr->packet_hdr = headermask; + filter_ptr->hashed_flds = hash_field; + +out: + flow->rule = filter_ptr; + rte_free(meta); + return 0; + +error: + rte_free(filter_ptr); + rte_free(meta); + return -rte_errno; +} + +static int +ice_hash_destroy(struct ice_adapter *ad, + struct rte_flow *flow, + 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; + uint32_t reg; + struct ice_rss_cfg *filter_ptr; + + filter_ptr = (struct ice_rss_cfg *)flow->rule; + + if (filter_ptr->symm == 0) { + /* 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) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "rss flow destroy fail"); + goto error; + } + } + + rte_free(filter_ptr); + return 0; + +error: + rte_free(filter_ptr); + return -rte_errno; +} + +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); +} diff --git a/drivers/net/ice/meson.build b/drivers/net/ice/meson.build index 908a2ca..f9e897b 100644 --- a/drivers/net/ice/meson.build +++ b/drivers/net/ice/meson.build @@ -11,7 +11,8 @@ sources = files( 'ice_rxtx.c', 'ice_switch_filter.c', 'ice_generic_flow.c', - 'ice_fdir_filter.c' + 'ice_fdir_filter.c', + 'ice_hash.c' ) deps += ['hash'] -- 1.8.3.1 ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS Simei Su @ 2019-10-21 17:30 ` Ferruh Yigit 2019-10-22 2:04 ` Ye Xiaolong 0 siblings, 1 reply; 26+ messages in thread From: Ferruh Yigit @ 2019-10-21 17:30 UTC (permalink / raw) To: Simei Su, qi.z.zhang, xiaolong.ye; +Cc: dev On 10/21/2019 1:06 PM, Simei Su wrote: > This patch supports: > (1)symmetric hash by rte_flow RSS action. > (2)input set change by rte_flow RSS action. > > Signed-off-by: Simei Su <simei.su@intel.com> > Acked-by: Qi Zhang <qi.z.zhang@intel.com> <...> > +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); > + struct ice_hash_match_type *type_match_item; > + > + /* 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; > + uint64_t rss_hf = rss->types; ICC is giving following error [1], it seems switch case is not a scope, so fixing the warning while merging by moving the definitions above switch. [1] error #589: transfer of control bypasses initialization of: variable "rss_hf" (declared at line 299) switch (action_type) { ^ ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS 2019-10-21 17:30 ` Ferruh Yigit @ 2019-10-22 2:04 ` Ye Xiaolong 0 siblings, 0 replies; 26+ messages in thread From: Ye Xiaolong @ 2019-10-22 2:04 UTC (permalink / raw) To: Ferruh Yigit; +Cc: Simei Su, qi.z.zhang, dev Off the list Hi, Ferruh On 10/21, Ferruh Yigit wrote: >On 10/21/2019 1:06 PM, Simei Su wrote: >> This patch supports: >> (1)symmetric hash by rte_flow RSS action. >> (2)input set change by rte_flow RSS action. >> >> Signed-off-by: Simei Su <simei.su@intel.com> >> Acked-by: Qi Zhang <qi.z.zhang@intel.com> > ><...> > >> +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); >> + struct ice_hash_match_type *type_match_item; >> + >> + /* 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; >> + uint64_t rss_hf = rss->types; > >ICC is giving following error [1], it seems switch case is not a scope, so >fixing the warning while merging by moving the definitions above switch. > > >[1] >error #589: transfer of control bypasses initialization of: > variable "rss_hf" (declared at line 299) > switch (action_type) { > ^ > Thanks for fixing this, just wonder why build report on patchwork didn't catch this issue? http://mails.dpdk.org/archives/test-report/2019-October/103686.html Thanks, Xiaolong ^ permalink raw reply [flat|nested] 26+ messages in thread
* Re: [dpdk-dev] [PATCH v8 0/3] net/ice: enable advanced RSS 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su ` (2 preceding siblings ...) 2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS Simei Su @ 2019-10-21 14:24 ` Ye Xiaolong 3 siblings, 0 replies; 26+ messages in thread From: Ye Xiaolong @ 2019-10-21 14:24 UTC (permalink / raw) To: Simei Su; +Cc: qi.z.zhang, dev On 10/21, Simei Su wrote: >[PATCH v8 1/2] add teid hash for gtupu and session id hash for pppoe/pppod. >[PATCH v8 2/2] support input set change and symmetric hash by rte_flow RSS action. > >v8: >* Change meta type from uint64_t to void pointer for pattern structure. >* Modify related code in ice_hash.c about above change. > >v7: >* Rebase patches to solve merge conflict. > >v6: >* Add simultaneous use of SRC_ONLY and DST_ONLY of the same level. >* Update cases in ice_hash_type_list[]. > >v5: >* Update title for cover letter and commit log. >* Fix some code style. > >v4: >* Add rss support for gtpu with teid and pppoe/pppod with session id. >* Split up into patchset. > >v3: >* Modify codes according to the comments. >* Update release notes and Makefile/meson.build. > >v2: >* Amend to resend patch that v1 is not in community. > >Simei Su (3): > net/ice: add RSS configuration for gtpu/pppoe > net/ice: change one member type of the pattern structure > net/ice: enable advanced RSS > > doc/guides/rel_notes/release_19_11.rst | 1 + > drivers/net/ice/Makefile | 1 + > drivers/net/ice/ice_ethdev.c | 24 ++ > drivers/net/ice/ice_generic_flow.h | 2 +- > drivers/net/ice/ice_hash.c | 562 +++++++++++++++++++++++++++++++++ > drivers/net/ice/meson.build | 3 +- > 6 files changed, 591 insertions(+), 2 deletions(-) > create mode 100644 drivers/net/ice/ice_hash.c > >-- >1.8.3.1 > Series applied to dpdk-next-net-intel. Thanks, Xiaolong ^ permalink raw reply [flat|nested] 26+ messages in thread
end of thread, other threads:[~2019-10-22 2:07 UTC | newest]
Thread overview: 26+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <1567866291-268287-1-git-send-email-simei.su@intel.com>
2019-09-09 14:56 ` [dpdk-dev] [PATCH v2] net/ice: enable advanced RSS Simei Su
2019-09-12 16:19 ` Ye Xiaolong
2019-09-16 1:47 ` Su, Simei
2019-09-19 5:15 ` [dpdk-dev] [PATCH v3] " Simei Su
2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 0/2] " Simei Su
2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su
2019-09-27 9:53 ` [dpdk-dev] [PATCH v4 2/2] net/ice: enable advanced RSS Simei Su
2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 0/2] " Simei Su
2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su
2019-09-29 10:30 ` [dpdk-dev] [PATCH v5 2/2] net/ice: enable advanced RSS Simei Su
2019-09-30 0:28 ` [dpdk-dev] [PATCH v5 0/2] " Zhang, Qi Z
2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 " Simei Su
2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su
2019-10-16 22:16 ` [dpdk-dev] [PATCH v6 2/2] net/ice: enable advanced RSS Simei Su
2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 0/2] " Simei Su
2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 1/2] net/ice: add RSS configuration for gtpu/pppoe Simei Su
2019-10-20 2:14 ` [dpdk-dev] [PATCH v7 2/2] net/ice: enable advanced RSS Simei Su
2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 0/3] " Simei Su
2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 1/3] net/ice: add RSS configuration for gtpu/pppoe Simei Su
2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 2/3] net/ice: change one member type of the pattern structure Simei Su
2019-10-21 14:16 ` Ye Xiaolong
2019-10-21 17:30 ` Ferruh Yigit
2019-10-21 12:06 ` [dpdk-dev] [PATCH v8 3/3] net/ice: enable advanced RSS Simei Su
2019-10-21 17:30 ` Ferruh Yigit
2019-10-22 2:04 ` Ye Xiaolong
2019-10-21 14:24 ` [dpdk-dev] [PATCH v8 0/3] " Ye Xiaolong
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).