From patchwork Fri Mar 13 02:08:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66621 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 73BBBA0567; Fri, 13 Mar 2020 03:28:50 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 5C6C01C02D; Fri, 13 Mar 2020 03:28:45 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id 8AC671C02B for ; Fri, 13 Mar 2020 03:28:43 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:43 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587167" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:41 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, Wei Zhao Date: Fri, 13 Mar 2020 10:08:00 +0800 Message-Id: <20200313020806.21654-2-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 1/7] net/ice: enable switch flow on DCF X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" DCF on CVL is a control plane VF which take the responsibility to configure all the PF/global resources, this patch add support DCF on to program forward rule to direct packetS to VFs. Signed-off-by: Wei Zhao --- drivers/net/ice/ice_dcf_ethdev.c | 10 ++++++-- drivers/net/ice/ice_dcf_parent.c | 7 ++++++ drivers/net/ice/ice_fdir_filter.c | 6 +++++ drivers/net/ice/ice_hash.c | 6 +++++ drivers/net/ice/ice_switch_filter.c | 39 ++++++++++++++++++++++++++++- 5 files changed, 65 insertions(+), 3 deletions(-) diff --git a/drivers/net/ice/ice_dcf_ethdev.c b/drivers/net/ice/ice_dcf_ethdev.c index f65b962d4..759d92afb 100644 --- a/drivers/net/ice/ice_dcf_ethdev.c +++ b/drivers/net/ice/ice_dcf_ethdev.c @@ -115,8 +115,8 @@ ice_dcf_dev_allmulticast_disable(__rte_unused struct rte_eth_dev *dev) static int ice_dcf_dev_filter_ctrl(struct rte_eth_dev *dev, enum rte_filter_type filter_type, - __rte_unused enum rte_filter_op filter_op, - __rte_unused void *arg) + enum rte_filter_op filter_op, + void *arg) { int ret = 0; @@ -124,6 +124,12 @@ ice_dcf_dev_filter_ctrl(struct rte_eth_dev *dev, return -EINVAL; switch (filter_type) { + case RTE_ETH_FILTER_GENERIC: + if (filter_op != RTE_ETH_FILTER_GET) + return -EINVAL; + *(const void **)arg = &ice_flow_ops; + break; + default: PMD_DRV_LOG(WARNING, "Filter type (%d) not supported", filter_type); diff --git a/drivers/net/ice/ice_dcf_parent.c b/drivers/net/ice/ice_dcf_parent.c index bca9cd34a..c2dc13936 100644 --- a/drivers/net/ice/ice_dcf_parent.c +++ b/drivers/net/ice/ice_dcf_parent.c @@ -314,6 +314,12 @@ ice_dcf_init_parent_adapter(struct rte_eth_dev *eth_dev) } parent_adapter->active_pkg_type = ice_load_pkg_type(parent_hw); + err = ice_flow_init(parent_adapter); + if (err) { + PMD_INIT_LOG(ERR, "Failed to initialize flow"); + goto uninit_hw; + } + ice_dcf_update_vf_vsi_map(parent_hw, hw->num_vfs, hw->vf_vsi_map); @@ -344,5 +350,6 @@ ice_dcf_uninit_parent_adapter(struct rte_eth_dev *eth_dev) rte_eal_alarm_cancel(ice_dcf_vsi_update_service_handler, &adapter->real_hw); + ice_flow_uninit(parent_adapter); ice_dcf_uninit_parent_hw(parent_hw); } diff --git a/drivers/net/ice/ice_fdir_filter.c b/drivers/net/ice/ice_fdir_filter.c index d737c1acd..c9343c1fa 100644 --- a/drivers/net/ice/ice_fdir_filter.c +++ b/drivers/net/ice/ice_fdir_filter.c @@ -1061,6 +1061,9 @@ ice_fdir_init(struct ice_adapter *ad) struct ice_flow_parser *parser; int ret; + if (ad->hw.dcf_enabled) + return 0; + ret = ice_fdir_setup(pf); if (ret) return ret; @@ -1081,6 +1084,9 @@ ice_fdir_uninit(struct ice_adapter *ad) struct ice_pf *pf = &ad->pf; struct ice_flow_parser *parser; + if (ad->hw.dcf_enabled) + return; + if (ad->active_pkg_type == ICE_PKG_TYPE_COMMS) parser = &ice_fdir_parser_comms; else diff --git a/drivers/net/ice/ice_hash.c b/drivers/net/ice/ice_hash.c index d891538bd..69d805248 100644 --- a/drivers/net/ice/ice_hash.c +++ b/drivers/net/ice/ice_hash.c @@ -243,6 +243,9 @@ ice_hash_init(struct ice_adapter *ad) { struct ice_flow_parser *parser = NULL; + if (ad->hw.dcf_enabled) + return 0; + 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) @@ -560,6 +563,9 @@ ice_hash_destroy(struct ice_adapter *ad, static void ice_hash_uninit(struct ice_adapter *ad) { + if (ad->hw.dcf_enabled) + return; + 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) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 4a9356b31..c55e44e1a 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -913,6 +913,39 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], return 0; } +static int +ice_switch_parse_dcf_action(const struct rte_flow_action *actions, + struct rte_flow_error *error, + struct ice_adv_rule_info *rule_info) +{ + const struct rte_flow_action_vf *act_vf; + const struct rte_flow_action *action; + enum rte_flow_action_type action_type; + + for (action = actions; action->type != + RTE_FLOW_ACTION_TYPE_END; action++) { + action_type = action->type; + switch (action_type) { + case RTE_FLOW_ACTION_TYPE_VF: + rule_info->sw_act.fltr_act = ICE_FWD_TO_VSI; + act_vf = action->conf; + rule_info->sw_act.vsi_handle = act_vf->id; + break; + default: + rte_flow_error_set(error, + EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, + actions, + "Invalid action type or queue number"); + return -rte_errno; + } + } + + rule_info->sw_act.src = rule_info->sw_act.vsi_handle; + rule_info->rx = 1; + rule_info->priority = 5; + + return 0; +} static int ice_switch_parse_action(struct ice_pf *pf, @@ -1081,7 +1114,11 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad, goto error; } - ret = ice_switch_parse_action(pf, actions, error, &rule_info); + if (ad->hw.dcf_enabled) + ret = ice_switch_parse_dcf_action(actions, error, &rule_info); + else + ret = ice_switch_parse_action(pf, actions, error, &rule_info); + if (ret) { rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_HANDLE, NULL, From patchwork Fri Mar 13 02:08:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66622 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id AFCE3A0567; Fri, 13 Mar 2020 03:29:00 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id BA2EE1C044; Fri, 13 Mar 2020 03:28:48 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id 1CC6D1C02B for ; Fri, 13 Mar 2020 03:28:44 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:45 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587172" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:43 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, Wei Zhao Date: Fri, 13 Mar 2020 10:08:01 +0800 Message-Id: <20200313020806.21654-3-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 2/7] net/ice: support for more PPPoE input set X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This patch add more support for PPPoE packet, it enable swicth filter to direct PPPoE packet base on session id and PPP protocol type. Signed-off-by: Wei Zhao --- config/common_linux | 1 + drivers/net/ice/ice_generic_flow.c | 13 +++++ drivers/net/ice/ice_generic_flow.h | 9 ++++ drivers/net/ice/ice_switch_filter.c | 82 +++++++++++++++++++++++++++-- 4 files changed, 100 insertions(+), 5 deletions(-) diff --git a/config/common_linux b/config/common_linux index 816810671..c6630d2bd 100644 --- a/config/common_linux +++ b/config/common_linux @@ -8,6 +8,7 @@ CONFIG_RTE_EXEC_ENV_LINUX=y CONFIG_RTE_EXEC_ENV_LINUXAPP=y CONFIG_RTE_EAL_NUMA_AWARE_HUGEPAGES=y +CONFIG_RTE_EAL_IGB_UIO=y CONFIG_RTE_EAL_VFIO=y CONFIG_RTE_LIBRTE_KNI=y CONFIG_RTE_LIBRTE_PMD_KNI=y diff --git a/drivers/net/ice/ice_generic_flow.c b/drivers/net/ice/ice_generic_flow.c index 38ac799d8..af0fff814 100644 --- a/drivers/net/ice/ice_generic_flow.c +++ b/drivers/net/ice/ice_generic_flow.c @@ -1122,12 +1122,25 @@ enum rte_flow_item_type pattern_eth_pppoes[] = { RTE_FLOW_ITEM_TYPE_PPPOES, RTE_FLOW_ITEM_TYPE_END, }; +enum rte_flow_item_type pattern_eth_pppoes_proto[] = { + RTE_FLOW_ITEM_TYPE_ETH, + RTE_FLOW_ITEM_TYPE_PPPOES, + RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID, + RTE_FLOW_ITEM_TYPE_END, +}; enum rte_flow_item_type pattern_eth_vlan_pppoes[] = { RTE_FLOW_ITEM_TYPE_ETH, RTE_FLOW_ITEM_TYPE_VLAN, RTE_FLOW_ITEM_TYPE_PPPOES, RTE_FLOW_ITEM_TYPE_END, }; +enum rte_flow_item_type pattern_eth_vlan_pppoes_proto[] = { + RTE_FLOW_ITEM_TYPE_ETH, + RTE_FLOW_ITEM_TYPE_VLAN, + RTE_FLOW_ITEM_TYPE_PPPOES, + RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID, + RTE_FLOW_ITEM_TYPE_END, +}; enum rte_flow_item_type pattern_eth_qinq_pppoes[] = { RTE_FLOW_ITEM_TYPE_ETH, RTE_FLOW_ITEM_TYPE_VLAN, diff --git a/drivers/net/ice/ice_generic_flow.h b/drivers/net/ice/ice_generic_flow.h index adc30ee2a..f1139c690 100644 --- a/drivers/net/ice/ice_generic_flow.h +++ b/drivers/net/ice/ice_generic_flow.h @@ -30,6 +30,7 @@ #define ICE_PROT_VXLAN (1ULL << 19) #define ICE_PROT_NVGRE (1ULL << 20) #define ICE_PROT_GTPU (1ULL << 21) +#define ICE_PROT_PPPoE (1ULL << 22) /* field */ @@ -49,6 +50,8 @@ #define ICE_NVGRE_TNI (1ULL << 50) #define ICE_GTPU_TEID (1ULL << 49) #define ICE_GTPU_QFI (1ULL << 48) +#define ICE_PPPOE_SESSION (1ULL << 47) +#define ICE_PPPOE_PROTO (1ULL << 46) /* input set */ @@ -177,6 +180,10 @@ (ICE_PROT_GTPU | ICE_GTPU_TEID) #define ICE_INSET_GTPU_QFI \ (ICE_PROT_GTPU | ICE_GTPU_QFI) +#define ICE_INSET_PPPOE_SESSION \ + (ICE_PROT_PPPoE | ICE_PPPOE_SESSION) +#define ICE_INSET_PPPOE_PROTO \ + (ICE_PROT_PPPoE | ICE_PPPOE_PROTO) /* empty pattern */ extern enum rte_flow_item_type pattern_empty[]; @@ -349,7 +356,9 @@ extern enum rte_flow_item_type pattern_eth_pppoed[]; extern enum rte_flow_item_type pattern_eth_vlan_pppoed[]; extern enum rte_flow_item_type pattern_eth_qinq_pppoed[]; extern enum rte_flow_item_type pattern_eth_pppoes[]; +extern enum rte_flow_item_type pattern_eth_pppoes_proto[]; extern enum rte_flow_item_type pattern_eth_vlan_pppoes[]; +extern enum rte_flow_item_type pattern_eth_vlan_pppoes_proto[]; extern enum rte_flow_item_type pattern_eth_qinq_pppoes[]; extern enum rte_flow_item_type pattern_eth_pppoes_ipv4[]; extern enum rte_flow_item_type pattern_eth_vlan_pppoes_ipv4[]; diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index c55e44e1a..39b5c7266 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -87,7 +87,11 @@ ICE_INSET_TUN_IPV4_TOS) #define ICE_SW_INSET_MAC_PPPOE ( \ ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \ - ICE_INSET_DMAC | ICE_INSET_ETHERTYPE) + ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION) +#define ICE_SW_INSET_MAC_PPPOE_PROTO ( \ + ICE_INSET_VLAN_OUTER | ICE_INSET_VLAN_INNER | \ + ICE_INSET_DMAC | ICE_INSET_ETHERTYPE | ICE_INSET_PPPOE_SESSION | \ + ICE_INSET_PPPOE_PROTO) struct sw_meta { struct ice_adv_lkup_elem *list; @@ -135,6 +139,10 @@ ice_pattern_match_item ice_switch_pattern_dist_comms[] = { ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE}, {pattern_eth_vlan_pppoes, ICE_SW_INSET_MAC_PPPOE, ICE_INSET_NONE}, + {pattern_eth_pppoes_proto, + ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE}, + {pattern_eth_vlan_pppoes_proto, + ICE_SW_INSET_MAC_PPPOE_PROTO, ICE_INSET_NONE}, }; static struct @@ -316,12 +324,15 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask; const struct rte_flow_item_vlan *vlan_spec, *vlan_mask; const struct rte_flow_item_pppoe *pppoe_spec, *pppoe_mask; + const struct rte_flow_item_pppoe_proto_id *pppoe_proto_spec, + *pppoe_proto_mask; uint8_t ipv6_addr_mask[16] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; uint64_t input_set = ICE_INSET_NONE; uint16_t j, t = 0; uint16_t tunnel_valid = 0; + uint16_t pppoe_valid = 0; for (item = pattern; item->type != @@ -885,14 +896,75 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], pppoe_mask = item->mask; /* Check if PPPoE item is used to describe protocol. * If yes, both spec and mask should be NULL. + * If no, both spec and mask shouldn't be NULL. */ - if (pppoe_spec || pppoe_mask) { + if ((!pppoe_spec && pppoe_mask) || + (pppoe_spec && !pppoe_mask)) { rte_flow_error_set(error, EINVAL, - RTE_FLOW_ERROR_TYPE_ITEM, - item, - "Invalid pppoe item"); + RTE_FLOW_ERROR_TYPE_ITEM, + item, + "Invalid pppoe item"); return 0; } + if (pppoe_spec && pppoe_mask) { + /* Check pppoe mask and update input set */ + if (pppoe_mask->length || + pppoe_mask->code || + pppoe_mask->version_type) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + item, + "Invalid pppoe mask"); + return 0; + } + list[t].type = ICE_PPPOE; + if (pppoe_mask->session_id == UINT16_MAX) { + list[t].h_u.pppoe_hdr.session_id = + pppoe_spec->session_id; + list[t].m_u.pppoe_hdr.session_id = + UINT16_MAX; + input_set |= ICE_INSET_PPPOE_SESSION; + } + t++; + pppoe_valid = 1; + } else if (!pppoe_spec && !pppoe_mask) { + list[t].type = ICE_PPPOE; + } + + break; + + case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID: + pppoe_proto_spec = item->spec; + pppoe_proto_mask = item->mask; + /* Check if PPPoE optional proto_id item + * is used to describe protocol. + * If yes, both spec and mask should be NULL. + * If no, both spec and mask shouldn't be NULL. + */ + if ((!pppoe_proto_spec && pppoe_proto_mask) || + (pppoe_proto_spec && !pppoe_proto_mask)) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_ITEM, + item, + "Invalid pppoe proto item"); + return 0; + } + if (pppoe_proto_spec && pppoe_proto_mask) { + if (pppoe_valid) + t--; + list[t].type = ICE_PPPOE; + if (pppoe_proto_mask->proto_id == UINT16_MAX) { + list[t].h_u.pppoe_hdr.ppp_prot_id = + pppoe_proto_spec->proto_id; + list[t].m_u.pppoe_hdr.ppp_prot_id = + UINT16_MAX; + input_set |= ICE_INSET_PPPOE_PROTO; + } + t++; + } else if (!pppoe_proto_spec && !pppoe_proto_mask) { + list[t].type = ICE_PPPOE; + } + break; case RTE_FLOW_ITEM_TYPE_VOID: From patchwork Fri Mar 13 02:08:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66623 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 22CA7A0567; Fri, 13 Mar 2020 03:29:11 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 0A3A61C06A; Fri, 13 Mar 2020 03:28:50 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id EBE281C038 for ; Fri, 13 Mar 2020 03:28:46 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:47 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587180" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:44 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, Wei Zhao Date: Fri, 13 Mar 2020 10:08:02 +0800 Message-Id: <20200313020806.21654-4-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 3/7] net/ice: change swicth parser to support flexible mask X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" DCF need to make configuration of flexible mask, that is to say some iput set mask may be not 0xFFFF type all one bit. In order to direct L2/IP multicast packets, the mask for source IP maybe 0xF0000000, this patch enable switch filter parser for it. Signed-off-by: Wei Zhao --- drivers/net/ice/ice_switch_filter.c | 298 +++++++++++++--------------- 1 file changed, 133 insertions(+), 165 deletions(-) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 39b5c7266..af7e9cb0b 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -326,9 +326,6 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], const struct rte_flow_item_pppoe *pppoe_spec, *pppoe_mask; const struct rte_flow_item_pppoe_proto_id *pppoe_proto_spec, *pppoe_proto_mask; - uint8_t ipv6_addr_mask[16] = { - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; uint64_t input_set = ICE_INSET_NONE; uint16_t j, t = 0; uint16_t tunnel_valid = 0; @@ -351,19 +348,29 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], eth_spec = item->spec; eth_mask = item->mask; if (eth_spec && eth_mask) { - if (tunnel_valid && - rte_is_broadcast_ether_addr(ð_mask->src)) - input_set |= ICE_INSET_TUN_SMAC; - else if ( - rte_is_broadcast_ether_addr(ð_mask->src)) - input_set |= ICE_INSET_SMAC; - if (tunnel_valid && - rte_is_broadcast_ether_addr(ð_mask->dst)) - input_set |= ICE_INSET_TUN_DMAC; - else if ( - rte_is_broadcast_ether_addr(ð_mask->dst)) - input_set |= ICE_INSET_DMAC; - if (eth_mask->type == RTE_BE16(0xffff)) + for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { + if (eth_mask->src.addr_bytes[j]) { + if (tunnel_valid) + input_set |= + ICE_INSET_TUN_SMAC; + else + input_set |= + ICE_INSET_SMAC; + break; + } + } + for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { + if (eth_mask->dst.addr_bytes[j]) { + if (tunnel_valid) + input_set |= + ICE_INSET_TUN_DMAC; + else + input_set |= + ICE_INSET_DMAC; + break; + } + } + if (eth_mask->type) input_set |= ICE_INSET_ETHERTYPE; list[t].type = (tunnel_valid == 0) ? ICE_MAC_OFOS : ICE_MAC_IL; @@ -373,16 +380,14 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], h = &list[t].h_u.eth_hdr; m = &list[t].m_u.eth_hdr; for (j = 0; j < RTE_ETHER_ADDR_LEN; j++) { - if (eth_mask->src.addr_bytes[j] == - UINT8_MAX) { + if (eth_mask->src.addr_bytes[j]) { h->src_addr[j] = eth_spec->src.addr_bytes[j]; m->src_addr[j] = eth_mask->src.addr_bytes[j]; i = 1; } - if (eth_mask->dst.addr_bytes[j] == - UINT8_MAX) { + if (eth_mask->dst.addr_bytes[j]) { h->dst_addr[j] = eth_spec->dst.addr_bytes[j]; m->dst_addr[j] = @@ -392,17 +397,14 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (i) t++; - if (eth_mask->type == UINT16_MAX) { + if (eth_mask->type) { list[t].type = ICE_ETYPE_OL; list[t].h_u.ethertype.ethtype_id = eth_spec->type; list[t].m_u.ethertype.ethtype_id = - UINT16_MAX; + eth_mask->type; t++; } - } else if (!eth_spec && !eth_mask) { - list[t].type = (tun_type == ICE_NON_TUN) ? - ICE_MAC_OFOS : ICE_MAC_IL; } break; @@ -423,81 +425,68 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (tunnel_valid) { - if (ipv4_mask->hdr.type_of_service == - UINT8_MAX) + if (ipv4_mask->hdr.type_of_service) input_set |= ICE_INSET_TUN_IPV4_TOS; - if (ipv4_mask->hdr.src_addr == - UINT32_MAX) + if (ipv4_mask->hdr.src_addr) input_set |= ICE_INSET_TUN_IPV4_SRC; - if (ipv4_mask->hdr.dst_addr == - UINT32_MAX) + if (ipv4_mask->hdr.dst_addr) input_set |= ICE_INSET_TUN_IPV4_DST; - if (ipv4_mask->hdr.time_to_live == - UINT8_MAX) + if (ipv4_mask->hdr.time_to_live) input_set |= ICE_INSET_TUN_IPV4_TTL; - if (ipv4_mask->hdr.next_proto_id == - UINT8_MAX) + if (ipv4_mask->hdr.next_proto_id) input_set |= ICE_INSET_TUN_IPV4_PROTO; } else { - if (ipv4_mask->hdr.src_addr == - UINT32_MAX) + if (ipv4_mask->hdr.src_addr) input_set |= ICE_INSET_IPV4_SRC; - if (ipv4_mask->hdr.dst_addr == - UINT32_MAX) + if (ipv4_mask->hdr.dst_addr) input_set |= ICE_INSET_IPV4_DST; - if (ipv4_mask->hdr.time_to_live == - UINT8_MAX) + if (ipv4_mask->hdr.time_to_live) input_set |= ICE_INSET_IPV4_TTL; - if (ipv4_mask->hdr.next_proto_id == - UINT8_MAX) + if (ipv4_mask->hdr.next_proto_id) input_set |= ICE_INSET_IPV4_PROTO; - if (ipv4_mask->hdr.type_of_service == - UINT8_MAX) + if (ipv4_mask->hdr.type_of_service) input_set |= ICE_INSET_IPV4_TOS; } list[t].type = (tunnel_valid == 0) ? ICE_IPV4_OFOS : ICE_IPV4_IL; - if (ipv4_mask->hdr.src_addr == UINT32_MAX) { + if (ipv4_mask->hdr.src_addr) { list[t].h_u.ipv4_hdr.src_addr = ipv4_spec->hdr.src_addr; list[t].m_u.ipv4_hdr.src_addr = - UINT32_MAX; + ipv4_mask->hdr.src_addr; } - if (ipv4_mask->hdr.dst_addr == UINT32_MAX) { + if (ipv4_mask->hdr.dst_addr) { list[t].h_u.ipv4_hdr.dst_addr = ipv4_spec->hdr.dst_addr; list[t].m_u.ipv4_hdr.dst_addr = - UINT32_MAX; + ipv4_mask->hdr.dst_addr; } - if (ipv4_mask->hdr.time_to_live == UINT8_MAX) { + if (ipv4_mask->hdr.time_to_live) { list[t].h_u.ipv4_hdr.time_to_live = ipv4_spec->hdr.time_to_live; list[t].m_u.ipv4_hdr.time_to_live = - UINT8_MAX; + ipv4_mask->hdr.time_to_live; } - if (ipv4_mask->hdr.next_proto_id == UINT8_MAX) { + if (ipv4_mask->hdr.next_proto_id) { list[t].h_u.ipv4_hdr.protocol = ipv4_spec->hdr.next_proto_id; list[t].m_u.ipv4_hdr.protocol = - UINT8_MAX; + ipv4_mask->hdr.next_proto_id; } - if (ipv4_mask->hdr.type_of_service == - UINT8_MAX) { + if (ipv4_mask->hdr.type_of_service) { list[t].h_u.ipv4_hdr.tos = ipv4_spec->hdr.type_of_service; - list[t].m_u.ipv4_hdr.tos = UINT8_MAX; + list[t].m_u.ipv4_hdr.tos = + ipv4_mask->hdr.type_of_service; } t++; - } else if (!ipv4_spec && !ipv4_mask) { - list[t].type = (tunnel_valid == 0) ? - ICE_IPV4_OFOS : ICE_IPV4_IL; } break; @@ -514,51 +503,58 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (tunnel_valid) { - if (!memcmp(ipv6_mask->hdr.src_addr, - ipv6_addr_mask, - RTE_DIM(ipv6_mask->hdr.src_addr))) + for (j = 0; j < ICE_IPV6_ADDR_LENGTH; + j++) { + if (ipv6_mask->hdr.src_addr[j]) { input_set |= - ICE_INSET_TUN_IPV6_SRC; - if (!memcmp(ipv6_mask->hdr.dst_addr, - ipv6_addr_mask, - RTE_DIM(ipv6_mask->hdr.dst_addr))) + ICE_INSET_TUN_IPV6_SRC; + break; + } + } + for (j = 0; j < ICE_IPV6_ADDR_LENGTH; + j++) { + if (ipv6_mask->hdr.dst_addr[j]) { input_set |= - ICE_INSET_TUN_IPV6_DST; - if (ipv6_mask->hdr.proto == UINT8_MAX) + ICE_INSET_TUN_IPV6_DST; + break; + } + } + if (ipv6_mask->hdr.proto) input_set |= ICE_INSET_TUN_IPV6_NEXT_HDR; - if (ipv6_mask->hdr.hop_limits == - UINT8_MAX) + if (ipv6_mask->hdr.hop_limits) input_set |= ICE_INSET_TUN_IPV6_HOP_LIMIT; - if ((ipv6_mask->hdr.vtc_flow & + if (ipv6_mask->hdr.vtc_flow & rte_cpu_to_be_32 (RTE_IPV6_HDR_TC_MASK)) - == rte_cpu_to_be_32 - (RTE_IPV6_HDR_TC_MASK)) input_set |= ICE_INSET_TUN_IPV6_TC; } else { - if (!memcmp(ipv6_mask->hdr.src_addr, - ipv6_addr_mask, - RTE_DIM(ipv6_mask->hdr.src_addr))) + for (j = 0; j < ICE_IPV6_ADDR_LENGTH; + j++) { + if (ipv6_mask->hdr.src_addr[j]) { input_set |= ICE_INSET_IPV6_SRC; - if (!memcmp(ipv6_mask->hdr.dst_addr, - ipv6_addr_mask, - RTE_DIM(ipv6_mask->hdr.dst_addr))) - input_set |= ICE_INSET_IPV6_DST; - if (ipv6_mask->hdr.proto == UINT8_MAX) + break; + } + } + for (j = 0; j < ICE_IPV6_ADDR_LENGTH; + j++) { + if (ipv6_mask->hdr.dst_addr[j]) { + input_set |= + ICE_INSET_IPV6_DST; + break; + } + } + if (ipv6_mask->hdr.proto) input_set |= ICE_INSET_IPV6_NEXT_HDR; - if (ipv6_mask->hdr.hop_limits == - UINT8_MAX) + if (ipv6_mask->hdr.hop_limits) input_set |= ICE_INSET_IPV6_HOP_LIMIT; - if ((ipv6_mask->hdr.vtc_flow & + if (ipv6_mask->hdr.vtc_flow & rte_cpu_to_be_32 (RTE_IPV6_HDR_TC_MASK)) - == rte_cpu_to_be_32 - (RTE_IPV6_HDR_TC_MASK)) input_set |= ICE_INSET_IPV6_TC; } list[t].type = (tunnel_valid == 0) ? @@ -568,35 +564,33 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], f = &list[t].h_u.ipv6_hdr; s = &list[t].m_u.ipv6_hdr; for (j = 0; j < ICE_IPV6_ADDR_LENGTH; j++) { - if (ipv6_mask->hdr.src_addr[j] == - UINT8_MAX) { + if (ipv6_mask->hdr.src_addr[j]) { f->src_addr[j] = ipv6_spec->hdr.src_addr[j]; s->src_addr[j] = ipv6_mask->hdr.src_addr[j]; } - if (ipv6_mask->hdr.dst_addr[j] == - UINT8_MAX) { + if (ipv6_mask->hdr.dst_addr[j]) { f->dst_addr[j] = ipv6_spec->hdr.dst_addr[j]; s->dst_addr[j] = ipv6_mask->hdr.dst_addr[j]; } } - if (ipv6_mask->hdr.proto == UINT8_MAX) { + if (ipv6_mask->hdr.proto) { f->next_hdr = ipv6_spec->hdr.proto; - s->next_hdr = UINT8_MAX; + s->next_hdr = + ipv6_mask->hdr.proto; } - if (ipv6_mask->hdr.hop_limits == UINT8_MAX) { + if (ipv6_mask->hdr.hop_limits) { f->hop_limit = ipv6_spec->hdr.hop_limits; - s->hop_limit = UINT8_MAX; + s->hop_limit = + ipv6_mask->hdr.hop_limits; } - if ((ipv6_mask->hdr.vtc_flow & + if (ipv6_mask->hdr.vtc_flow & rte_cpu_to_be_32 - (RTE_IPV6_HDR_TC_MASK)) - == rte_cpu_to_be_32 (RTE_IPV6_HDR_TC_MASK)) { struct ice_le_ver_tc_flow vtf; vtf.u.fld.version = 0; @@ -606,13 +600,13 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], RTE_IPV6_HDR_TC_MASK) >> RTE_IPV6_HDR_TC_SHIFT; f->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val); - vtf.u.fld.tc = UINT8_MAX; + vtf.u.fld.tc = (rte_be_to_cpu_32 + (ipv6_mask->hdr.vtc_flow) & + RTE_IPV6_HDR_TC_MASK) >> + RTE_IPV6_HDR_TC_SHIFT; s->be_ver_tc_flow = CPU_TO_BE32(vtf.u.val); } t++; - } else if (!ipv6_spec && !ipv6_mask) { - list[t].type = (tun_type == ICE_NON_TUN) ? - ICE_IPV4_OFOS : ICE_IPV4_IL; } break; @@ -631,21 +625,17 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (tunnel_valid) { - if (udp_mask->hdr.src_port == - UINT16_MAX) + if (udp_mask->hdr.src_port) input_set |= ICE_INSET_TUN_UDP_SRC_PORT; - if (udp_mask->hdr.dst_port == - UINT16_MAX) + if (udp_mask->hdr.dst_port) input_set |= ICE_INSET_TUN_UDP_DST_PORT; } else { - if (udp_mask->hdr.src_port == - UINT16_MAX) + if (udp_mask->hdr.src_port) input_set |= ICE_INSET_UDP_SRC_PORT; - if (udp_mask->hdr.dst_port == - UINT16_MAX) + if (udp_mask->hdr.dst_port) input_set |= ICE_INSET_UDP_DST_PORT; } @@ -654,21 +644,19 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], list[t].type = ICE_UDP_OF; else list[t].type = ICE_UDP_ILOS; - if (udp_mask->hdr.src_port == UINT16_MAX) { + if (udp_mask->hdr.src_port) { list[t].h_u.l4_hdr.src_port = udp_spec->hdr.src_port; list[t].m_u.l4_hdr.src_port = udp_mask->hdr.src_port; } - if (udp_mask->hdr.dst_port == UINT16_MAX) { + if (udp_mask->hdr.dst_port) { list[t].h_u.l4_hdr.dst_port = udp_spec->hdr.dst_port; list[t].m_u.l4_hdr.dst_port = udp_mask->hdr.dst_port; } t++; - } else if (!udp_spec && !udp_mask) { - list[t].type = ICE_UDP_ILOS; } break; @@ -692,40 +680,34 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (tunnel_valid) { - if (tcp_mask->hdr.src_port == - UINT16_MAX) + if (tcp_mask->hdr.src_port) input_set |= ICE_INSET_TUN_TCP_SRC_PORT; - if (tcp_mask->hdr.dst_port == - UINT16_MAX) + if (tcp_mask->hdr.dst_port) input_set |= ICE_INSET_TUN_TCP_DST_PORT; } else { - if (tcp_mask->hdr.src_port == - UINT16_MAX) + if (tcp_mask->hdr.src_port) input_set |= ICE_INSET_TCP_SRC_PORT; - if (tcp_mask->hdr.dst_port == - UINT16_MAX) + if (tcp_mask->hdr.dst_port) input_set |= ICE_INSET_TCP_DST_PORT; } list[t].type = ICE_TCP_IL; - if (tcp_mask->hdr.src_port == UINT16_MAX) { + if (tcp_mask->hdr.src_port) { list[t].h_u.l4_hdr.src_port = tcp_spec->hdr.src_port; list[t].m_u.l4_hdr.src_port = tcp_mask->hdr.src_port; } - if (tcp_mask->hdr.dst_port == UINT16_MAX) { + if (tcp_mask->hdr.dst_port) { list[t].h_u.l4_hdr.dst_port = tcp_spec->hdr.dst_port; list[t].m_u.l4_hdr.dst_port = tcp_mask->hdr.dst_port; } t++; - } else if (!tcp_spec && !tcp_mask) { - list[t].type = ICE_TCP_IL; } break; @@ -743,40 +725,34 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (tunnel_valid) { - if (sctp_mask->hdr.src_port == - UINT16_MAX) + if (sctp_mask->hdr.src_port) input_set |= ICE_INSET_TUN_SCTP_SRC_PORT; - if (sctp_mask->hdr.dst_port == - UINT16_MAX) + if (sctp_mask->hdr.dst_port) input_set |= ICE_INSET_TUN_SCTP_DST_PORT; } else { - if (sctp_mask->hdr.src_port == - UINT16_MAX) + if (sctp_mask->hdr.src_port) input_set |= ICE_INSET_SCTP_SRC_PORT; - if (sctp_mask->hdr.dst_port == - UINT16_MAX) + if (sctp_mask->hdr.dst_port) input_set |= ICE_INSET_SCTP_DST_PORT; } list[t].type = ICE_SCTP_IL; - if (sctp_mask->hdr.src_port == UINT16_MAX) { + if (sctp_mask->hdr.src_port) { list[t].h_u.sctp_hdr.src_port = sctp_spec->hdr.src_port; list[t].m_u.sctp_hdr.src_port = sctp_mask->hdr.src_port; } - if (sctp_mask->hdr.dst_port == UINT16_MAX) { + if (sctp_mask->hdr.dst_port) { list[t].h_u.sctp_hdr.dst_port = sctp_spec->hdr.dst_port; list[t].m_u.sctp_hdr.dst_port = sctp_mask->hdr.dst_port; } t++; - } else if (!sctp_spec && !sctp_mask) { - list[t].type = ICE_SCTP_IL; } break; @@ -799,21 +775,21 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], tunnel_valid = 1; if (vxlan_spec && vxlan_mask) { list[t].type = ICE_VXLAN; - if (vxlan_mask->vni[0] == UINT8_MAX && - vxlan_mask->vni[1] == UINT8_MAX && - vxlan_mask->vni[2] == UINT8_MAX) { + if (vxlan_mask->vni[0] || + vxlan_mask->vni[1] || + vxlan_mask->vni[2]) { list[t].h_u.tnl_hdr.vni = (vxlan_spec->vni[2] << 16) | (vxlan_spec->vni[1] << 8) | vxlan_spec->vni[0]; list[t].m_u.tnl_hdr.vni = - UINT32_MAX; + (vxlan_mask->vni[2] << 16) | + (vxlan_mask->vni[1] << 8) | + vxlan_mask->vni[0]; input_set |= ICE_INSET_TUN_VXLAN_VNI; } t++; - } else if (!vxlan_spec && !vxlan_mask) { - list[t].type = ICE_VXLAN; } break; @@ -835,21 +811,21 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], tunnel_valid = 1; if (nvgre_spec && nvgre_mask) { list[t].type = ICE_NVGRE; - if (nvgre_mask->tni[0] == UINT8_MAX && - nvgre_mask->tni[1] == UINT8_MAX && - nvgre_mask->tni[2] == UINT8_MAX) { + if (nvgre_mask->tni[0] || + nvgre_mask->tni[1] || + nvgre_mask->tni[2]) { list[t].h_u.nvgre_hdr.tni_flow = (nvgre_spec->tni[2] << 16) | (nvgre_spec->tni[1] << 8) | nvgre_spec->tni[0]; list[t].m_u.nvgre_hdr.tni_flow = - UINT32_MAX; + (nvgre_mask->tni[2] << 16) | + (nvgre_mask->tni[1] << 8) | + nvgre_mask->tni[0]; input_set |= ICE_INSET_TUN_NVGRE_TNI; } t++; - } else if (!nvgre_spec && !nvgre_mask) { - list[t].type = ICE_NVGRE; } break; @@ -870,23 +846,21 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], } if (vlan_spec && vlan_mask) { list[t].type = ICE_VLAN_OFOS; - if (vlan_mask->tci == UINT16_MAX) { + if (vlan_mask->tci) { list[t].h_u.vlan_hdr.vlan = vlan_spec->tci; list[t].m_u.vlan_hdr.vlan = - UINT16_MAX; + vlan_mask->tci; input_set |= ICE_INSET_VLAN_OUTER; } - if (vlan_mask->inner_type == UINT16_MAX) { + if (vlan_mask->inner_type) { list[t].h_u.vlan_hdr.type = vlan_spec->inner_type; list[t].m_u.vlan_hdr.type = - UINT16_MAX; + vlan_mask->inner_type; input_set |= ICE_INSET_VLAN_OUTER; } t++; - } else if (!vlan_spec && !vlan_mask) { - list[t].type = ICE_VLAN_OFOS; } break; @@ -918,19 +892,16 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], return 0; } list[t].type = ICE_PPPOE; - if (pppoe_mask->session_id == UINT16_MAX) { + if (pppoe_mask->session_id) { list[t].h_u.pppoe_hdr.session_id = pppoe_spec->session_id; list[t].m_u.pppoe_hdr.session_id = - UINT16_MAX; + pppoe_mask->session_id; input_set |= ICE_INSET_PPPOE_SESSION; } t++; pppoe_valid = 1; - } else if (!pppoe_spec && !pppoe_mask) { - list[t].type = ICE_PPPOE; } - break; case RTE_FLOW_ITEM_TYPE_PPPOE_PROTO_ID: @@ -953,18 +924,15 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], if (pppoe_valid) t--; list[t].type = ICE_PPPOE; - if (pppoe_proto_mask->proto_id == UINT16_MAX) { + if (pppoe_proto_mask->proto_id) { list[t].h_u.pppoe_hdr.ppp_prot_id = pppoe_proto_spec->proto_id; list[t].m_u.pppoe_hdr.ppp_prot_id = - UINT16_MAX; + pppoe_proto_mask->proto_id; input_set |= ICE_INSET_PPPOE_PROTO; } t++; - } else if (!pppoe_proto_spec && !pppoe_proto_mask) { - list[t].type = ICE_PPPOE; } - break; case RTE_FLOW_ITEM_TYPE_VOID: From patchwork Fri Mar 13 02:08:03 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66624 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 4B185A0567; Fri, 13 Mar 2020 03:29:25 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id DDD941C08C; Fri, 13 Mar 2020 03:28:51 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id 3BB9C1C038 for ; Fri, 13 Mar 2020 03:28:48 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:48 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587188" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:46 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, Wei Zhao Date: Fri, 13 Mar 2020 10:08:03 +0800 Message-Id: <20200313020806.21654-5-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 4/7] net/ice: add support for MAC VLAN rule X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This patch add support for MAC VLAN rule, it enable swicth filter to direct packet base on mac address and vlan id. Signed-off-by: Wei Zhao --- drivers/net/ice/ice_switch_filter.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index af7e9cb0b..20d0577b5 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -29,6 +29,9 @@ #define ICE_SW_INSET_ETHER ( \ ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE) +#define ICE_SW_INSET_MAC_VLAN ( \ + ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE | \ + ICE_INSET_VLAN_OUTER) #define ICE_SW_INSET_MAC_IPV4 ( \ ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \ ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS) @@ -107,6 +110,8 @@ static struct ice_pattern_match_item ice_switch_pattern_dist_comms[] = { {pattern_ethertype, ICE_SW_INSET_ETHER, ICE_INSET_NONE}, + {pattern_ethertype_vlan, + ICE_SW_INSET_MAC_VLAN, ICE_INSET_NONE}, {pattern_eth_ipv4, ICE_SW_INSET_MAC_IPV4, ICE_INSET_NONE}, {pattern_eth_ipv4_udp, @@ -149,6 +154,8 @@ static struct ice_pattern_match_item ice_switch_pattern_dist_os[] = { {pattern_ethertype, ICE_SW_INSET_ETHER, ICE_INSET_NONE}, + {pattern_ethertype_vlan, + ICE_SW_INSET_MAC_VLAN, ICE_INSET_NONE}, {pattern_eth_arp, ICE_INSET_NONE, ICE_INSET_NONE}, {pattern_eth_ipv4, @@ -179,6 +186,8 @@ ice_pattern_match_item ice_switch_pattern_dist_os[] = { static struct ice_pattern_match_item ice_switch_pattern_perm[] = { + {pattern_ethertype_vlan, + ICE_SW_INSET_MAC_VLAN, ICE_INSET_NONE}, {pattern_eth_ipv4, ICE_SW_INSET_MAC_IPV4, ICE_INSET_NONE}, {pattern_eth_ipv4_udp, From patchwork Fri Mar 13 02:08:04 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66625 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 3E3F0A0567; Fri, 13 Mar 2020 03:29:36 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 9317B1C0AD; Fri, 13 Mar 2020 03:28:53 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id E66FF1C068; Fri, 13 Mar 2020 03:28:49 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:50 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587193" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:48 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, stable@dpdk.org, Wei Zhao Date: Fri, 13 Mar 2020 10:08:04 +0800 Message-Id: <20200313020806.21654-6-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 5/7] net/ice: change default tunnle type X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" The default tunnle type for swicth filter change to new defination of ICE_SW_TUN_AND_NON_TUN in order that the rule will be apply to more packet type. Cc: stable@dpdk.org Fixes: 47d460d63233 ("net/ice: rework switch filter") Signed-off-by: Wei Zhao --- drivers/net/ice/ice_switch_filter.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 20d0577b5..7ca922602 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -1097,7 +1097,8 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad, uint16_t lkups_num = 0; const struct rte_flow_item *item = pattern; uint16_t item_num = 0; - enum ice_sw_tunnel_type tun_type = ICE_NON_TUN; + enum ice_sw_tunnel_type tun_type = + ICE_SW_TUN_AND_NON_TUN; struct ice_pattern_match_item *pattern_match_item = NULL; for (; item->type != RTE_FLOW_ITEM_TYPE_END; item++) { From patchwork Fri Mar 13 02:08:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66626 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 01417A0567; Fri, 13 Mar 2020 03:29:49 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 7535E1C0B5; Fri, 13 Mar 2020 03:28:55 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id A2FDE1C00E; Fri, 13 Mar 2020 03:28:51 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:51 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587201" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:49 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, stable@dpdk.org, Wei Zhao Date: Fri, 13 Mar 2020 10:08:05 +0800 Message-Id: <20200313020806.21654-7-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 6/7] net/ice: add action number check for swicth X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" The action number can only be one for DCF or PF switch filter, not support large action. Cc: stable@dpdk.org Fixes: 47d460d63233 ("net/ice: rework switch filter") Signed-off-by: Wei Zhao --- drivers/net/ice/ice_switch_filter.c | 48 +++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 7ca922602..48d689deb 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -1079,6 +1079,46 @@ ice_switch_parse_action(struct ice_pf *pf, return -rte_errno; } +static int +ice_switch_check_action(const struct rte_flow_action *actions, + struct rte_flow_error *error) +{ + const struct rte_flow_action *action; + enum rte_flow_action_type action_type; + uint16_t actions_num = 0; + + for (action = actions; action->type != + RTE_FLOW_ACTION_TYPE_END; action++) { + action_type = action->type; + switch (action_type) { + case RTE_FLOW_ACTION_TYPE_VF: + case RTE_FLOW_ACTION_TYPE_RSS: + case RTE_FLOW_ACTION_TYPE_QUEUE: + case RTE_FLOW_ACTION_TYPE_DROP: + actions_num++; + break; + case RTE_FLOW_ACTION_TYPE_VOID: + continue; + default: + rte_flow_error_set(error, + EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, + actions, + "Invalid action type"); + return -rte_errno; + } + } + + if (actions_num > 1) { + rte_flow_error_set(error, + EINVAL, RTE_FLOW_ERROR_TYPE_ACTION, + actions, + "Invalid action number"); + return -rte_errno; + } + + return 0; +} + static int ice_switch_parse_pattern_action(struct ice_adapter *ad, struct ice_pattern_match_item *array, @@ -1164,6 +1204,14 @@ ice_switch_parse_pattern_action(struct ice_adapter *ad, goto error; } + ret = ice_switch_check_action(actions, error); + if (ret) { + rte_flow_error_set(error, EINVAL, + RTE_FLOW_ERROR_TYPE_HANDLE, NULL, + "Invalid input action number"); + goto error; + } + if (ad->hw.dcf_enabled) ret = ice_switch_parse_dcf_action(actions, error, &rule_info); else From patchwork Fri Mar 13 02:08:06 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zhao1, Wei" X-Patchwork-Id: 66627 X-Patchwork-Delegate: xiaolong.ye@intel.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id BA444A0567; Fri, 13 Mar 2020 03:29:59 +0100 (CET) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id C67A01C0BD; Fri, 13 Mar 2020 03:28:56 +0100 (CET) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id 245851C02C; Fri, 13 Mar 2020 03:28:52 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 12 Mar 2020 19:28:53 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,546,1574150400"; d="scan'208";a="266587215" Received: from unknown (HELO localhost.localdomain.bj.intel.com) ([172.16.182.123]) by fmsmga004.fm.intel.com with ESMTP; 12 Mar 2020 19:28:51 -0700 From: Wei Zhao To: dev@dpdk.org Cc: qi.z.zhang@intel.com, xiaolong.ye@intel.com, stable@dpdk.org, Wei Zhao Date: Fri, 13 Mar 2020 10:08:06 +0800 Message-Id: <20200313020806.21654-8-wei.zhao1@intel.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20200313020806.21654-1-wei.zhao1@intel.com> References: <20200313020806.21654-1-wei.zhao1@intel.com> MIME-Version: 1.0 Subject: [dpdk-dev] [PATCH 7/7] net/ice: fix input set of VLAN item X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" The input set for inner type of vlan item should be ICE_INSET_ETHERTYPE, not ICE_INSET_VLAN_OUTER. This mac vlan filter is also part of DCF switch filter. Cc: stable@dpdk.org Fixes: 47d460d63233 ("net/ice: rework switch filter") Signed-off-by: Wei Zhao --- drivers/net/ice/ice_switch_filter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c index 48d689deb..ecd7c75aa 100644 --- a/drivers/net/ice/ice_switch_filter.c +++ b/drivers/net/ice/ice_switch_filter.c @@ -867,7 +867,7 @@ ice_switch_inset_get(const struct rte_flow_item pattern[], vlan_spec->inner_type; list[t].m_u.vlan_hdr.type = vlan_mask->inner_type; - input_set |= ICE_INSET_VLAN_OUTER; + input_set |= ICE_INSET_ETHERTYPE; } t++; }