From nobody Fri Sep 25 04:41:09 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F0269521221 for ; Wed, 16 Sep 2026 14:41:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789569721; cv=none; b=ljZHbamPWPtQujKls9zAf673sA8YKqgx2a5+ibVD9XtZGZAkwOQu+abPgZAvA2lxY7sBlXdG/C+6bLTYcaXO0uJ9tBtbct7xiCuQ4EdHuUbCQj0UCgE12LsjBr9LcAkntUH/yhI4E8zlmRkZ60D8Tlwpvc8gJW4HkCX4pxy/PiQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789569721; c=relaxed/simple; bh=/eadboLx+rlXWD1XZjOpLtieB9u0rVDCmpcNd7CMykk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=JETkAl3UIGHrVwepg86WcfAyQ4sSInS3rjePzcreDlhAbw+hUBa85+2L/6CUuMx0mL22gH/bqLBp/Y7taJoISYNmPILXASggvf5kCyw9aQDfeIvmYvOsREzO8x4REFprlNFAedSDjYwSDJhsc727+Pu99oUxBLzGs+g/87oCs6s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=EBePdWBI; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="EBePdWBI" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1789569717; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=bNH5x7SAmY4O0QWV34BUPLPeM7OS4osc8Eq3+VpugLg=; b=EBePdWBI8glH0vd8iBp4slkDPoPmypVG3DYegWNujJK2XOnKXspQm7suD+UmP+8tHyh1LQ 8Fa+GPgTzIkAOM72DtljGJ/LzQQh+pw113MoeAeh+v1QndCATmpUlCVB7khrMV1kEo4iIM VgJbxgL1d7cx7mmBZ9yqskQiCLO/mqY= Received: from mx-prod-mc-01.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-534-kwagSBRrN1ytxlZg2GJkZQ-1; Wed, 16 Sep 2026 10:41:52 -0400 X-MC-Unique: kwagSBRrN1ytxlZg2GJkZQ-1 X-Mimecast-MFC-AGG-ID: kwagSBRrN1ytxlZg2GJkZQ_1789569710 Received: from mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.17]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id B1744195F14F; Wed, 16 Sep 2026 14:41:49 +0000 (UTC) Received: from ShadowPeak.redhat.com (unknown [10.44.49.1]) by mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id 28D14195604D; Wed, 16 Sep 2026 14:41:44 +0000 (UTC) From: Petr Oros To: netdev@vger.kernel.org Cc: Petr Oros , Aleksandr Loktionov , Tony Nguyen , Przemek Kitszel , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Priyalee Kushwaha , Kiran Patil , Wojciech Drewek , Michal Swiatkowski , Simon Horman , intel-wired-lan@lists.osuosl.org, linux-kernel@vger.kernel.org Subject: [PATCH iwl-next v2 1/2] ice: fix TC flower filters matching more than the ip_proto key Date: Wed, 16 Sep 2026 16:41:29 +0200 Message-ID: <20260916144130.2699902-2-poros@redhat.com> In-Reply-To: <20260916144130.2699902-1-poros@redhat.com> References: <20260916144130.2699902-1-poros@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.0 on 10.30.177.17 Content-Type: text/plain; charset="utf-8" ice_parse_cls_flower() stores the ip_proto key from the flow rule but never programs a matching lookup unless the filter also matches on L4 ports or the L2TPv3 session ID. A filter like: tc filter add dev $pf ingress protocol ip flower skip_sw \ ip_proto udp action drop is silently programmed into the hardware as a match on eth_type ipv4 alone and drops every IPv4 packet, not just UDP. Program the IP protocol match through the protocol field of the IPv4 header lookup and the next header field of the IPv6 header lookup, the same lookups that are already used for ToS and TTL. The OS default and comms DDP packages provide no profile that extracts the IPv6 next header word, so the IPv6 rule programming currently fails with "Required profiles not found" and the filter falls back to software evaluation instead of over-matching, and the offload starts working with a DDP package that can extract it. Note that the lookup matches the next header byte of the base IPv6 header, so packets carrying extension headers are not matched in hardware and fall back to software evaluation, which under-matches only for skip_sw filters. GTP tunnel and PPPoE filters rewrite the parsed ethertype, the IP header lookups are not available there, so reject an unconsumed ip_proto for them instead of silently widening the match. Filters where ip_proto is implied by an L4 ports or L2TPv3 session ID lookup are not affected. Based on an earlier unapplied patch from Michal Swiatkowski that implemented the IPv4 part [1]. Link: https://lore.kernel.org/intel-wired-lan/20240222123956.2393-3-michal.= swiatkowski@linux.intel.com/ [1] Fixes: 0d08a441fb1a ("ice: ndo_setup_tc implementation for PF") Reviewed-by: Aleksandr Loktionov Signed-off-by: Petr Oros Reviewed-by: Simon Horman --- v2: - no code changes, collect Reviewed-by from Aleksandr Loktionov v1: https://lore.kernel.org/all/20260910154824.3603687-2-poros@redhat.com/ drivers/net/ethernet/intel/ice/ice_tc_lib.c | 37 +++++++++++++++++++-- drivers/net/ethernet/intel/ice/ice_tc_lib.h | 1 + 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/drivers/net/ethernet/intel/ice/ice_tc_lib.c b/drivers/net/ethe= rnet/intel/ice/ice_tc_lib.c index d20357c0412731..fbd8cbad150a98 100644 --- a/drivers/net/ethernet/intel/ice/ice_tc_lib.c +++ b/drivers/net/ethernet/intel/ice/ice_tc_lib.c @@ -78,7 +78,8 @@ static int ice_tc_count_lkups(u32 flags, struct ice_tc_fl= ower_fltr *fltr) ICE_TC_FLWR_FIELD_DEST_IPV6 | ICE_TC_FLWR_FIELD_SRC_IPV6)) lkups_cnt++; =20 - if (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL)) + if (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL | + ICE_TC_FLWR_FIELD_IP_PROTO)) lkups_cnt++; =20 /* are L2TPv3 options specified? */ @@ -552,7 +553,8 @@ ice_tc_fill_rules(struct ice_hw *hw, u32 flags, } =20 if (headers->l2_key.n_proto =3D=3D htons(ETH_P_IP) && - (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) { + (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL | + ICE_TC_FLWR_FIELD_IP_PROTO))) { list[i].type =3D ice_proto_type_from_ipv4(inner); =20 if (flags & ICE_TC_FLWR_FIELD_IP_TOS) { @@ -567,11 +569,19 @@ ice_tc_fill_rules(struct ice_hw *hw, u32 flags, headers->l3_mask.ttl; } =20 + if (flags & ICE_TC_FLWR_FIELD_IP_PROTO) { + list[i].h_u.ipv4_hdr.protocol =3D + headers->l3_key.ip_proto; + list[i].m_u.ipv4_hdr.protocol =3D + headers->l3_mask.ip_proto; + } + i++; } =20 if (headers->l2_key.n_proto =3D=3D htons(ETH_P_IPV6) && - (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL))) { + (flags & (ICE_TC_FLWR_FIELD_IP_TOS | ICE_TC_FLWR_FIELD_IP_TTL | + ICE_TC_FLWR_FIELD_IP_PROTO))) { struct ice_ipv6_hdr *hdr_h, *hdr_m; =20 hdr_h =3D &list[i].h_u.ipv6_hdr; @@ -592,6 +602,11 @@ ice_tc_fill_rules(struct ice_hw *hw, u32 flags, hdr_m->hop_limit =3D headers->l3_mask.ttl; } =20 + if (flags & ICE_TC_FLWR_FIELD_IP_PROTO) { + hdr_h->next_hdr =3D headers->l3_key.ip_proto; + hdr_m->next_hdr =3D headers->l3_mask.ip_proto; + } + i++; } =20 @@ -1737,6 +1752,9 @@ ice_parse_cls_flower(struct net_device *filter_dev, s= truct ice_vsi *vsi, headers->l2_key.n_proto =3D cpu_to_be16(n_proto_key); headers->l2_mask.n_proto =3D cpu_to_be16(n_proto_mask); headers->l3_key.ip_proto =3D match.key->ip_proto; + headers->l3_mask.ip_proto =3D match.mask->ip_proto; + if (match.mask->ip_proto) + fltr->flags |=3D ICE_TC_FLWR_FIELD_IP_PROTO; } =20 if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) { @@ -1910,6 +1928,19 @@ ice_parse_cls_flower(struct net_device *filter_dev, = struct ice_vsi *vsi, } } =20 + if (fltr->flags & (ICE_TC_FLWR_FIELD_DEST_L4_PORT | + ICE_TC_FLWR_FIELD_SRC_L4_PORT | + ICE_TC_FLWR_FIELD_L2TPV3_SESSID)) + fltr->flags &=3D ~ICE_TC_FLWR_FIELD_IP_PROTO; + + if ((fltr->flags & ICE_TC_FLWR_FIELD_IP_PROTO) && + headers->l2_key.n_proto !=3D htons(ETH_P_IP) && + headers->l2_key.n_proto !=3D htons(ETH_P_IPV6)) { + NL_SET_ERR_MSG_MOD(fltr->extack, + "IP protocol match is not supported with GTP or PPPoE"); + return -EOPNOTSUPP; + } + /* Ingress filter on representor results in an egress filter in HW * and vice versa */ diff --git a/drivers/net/ethernet/intel/ice/ice_tc_lib.h b/drivers/net/ethe= rnet/intel/ice/ice_tc_lib.h index 8a3ab2f22af9ba..752af65e70b7bf 100644 --- a/drivers/net/ethernet/intel/ice/ice_tc_lib.h +++ b/drivers/net/ethernet/intel/ice/ice_tc_lib.h @@ -38,6 +38,7 @@ #define ICE_TC_FLWR_FIELD_CVLAN_PRIO BIT(28) #define ICE_TC_FLWR_FIELD_VLAN_TPID BIT(29) #define ICE_TC_FLWR_FIELD_PFCP_OPTS BIT(30) +#define ICE_TC_FLWR_FIELD_IP_PROTO BIT(31) =20 #define ICE_TC_FLOWER_MASK_32 0xFFFFFFFF =20 --=20 2.55.0 From nobody Fri Sep 25 04:41:09 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 70AA453CA78 for ; Wed, 16 Sep 2026 14:42:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789569725; cv=none; b=J4LqNSISUZ0I2QSJCoIe4hTBj4inhbubeoknOU73zhse4MEEcolCoWLu3wGO5FlWZGuygERICaVssX3IE8aVA5ayFG8F0gGVeaKD9CmJfk7vaAKuCHvX93KgTQKgjXWVebL9iV3KAr3rVbfaXwVlVNpAD0mJDzTUjVEtwqTQ3OE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789569725; c=relaxed/simple; bh=52rXgfSwOmNkHEhGGn4mORhG1PBw3zjG5kUSL+pPOyc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=sO1rAP4hKu8URw/vkxaNXTR1bzHJM2N8ObDntbGy+XDP8X4tmggXaJhwJaXUfBAwIo4FOT5i2qFpqCWphfZf9PgzgOjacBvHOh0TXfp00R4ROOKzSV0qvFrsiAdIuAL3q/FozfKw/lyaIGf6VCDr3EpwbtWX5To5qPqEb32zAMM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=TBjYtJRx; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="TBjYtJRx" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1789569722; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=vwkxAtMc4/t7l1lYwlmK7CBbkBVAogXL7h4sRQPbgdk=; b=TBjYtJRx85wK4l6QDI9bRH6UWrnD0lSzG98+eWiEfiHMDz3eB3tAoueW6KGuT3pfV3IQWN nNGioko0q5XHdNFKADe1q7ZSZDUhVRvIYKHLu6s6DJJkxh+6JLF1ww8tB8O/QEgogfTi+m h8wkAuNExDxiOdEuV1chj2uEXG5UTH4= Received: from mx-prod-mc-06.mail-002.prod.us-west-2.aws.redhat.com (ec2-35-165-154-97.us-west-2.compute.amazonaws.com [35.165.154.97]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-628-gsA5rMVwNRq6SGVP5swV1A-1; Wed, 16 Sep 2026 10:41:56 -0400 X-MC-Unique: gsA5rMVwNRq6SGVP5swV1A-1 X-Mimecast-MFC-AGG-ID: gsA5rMVwNRq6SGVP5swV1A_1789569714 Received: from mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.17]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-06.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 22FD51800655; Wed, 16 Sep 2026 14:41:54 +0000 (UTC) Received: from ShadowPeak.redhat.com (unknown [10.44.49.1]) by mx-prod-int-05.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id 1D4A519560AB; Wed, 16 Sep 2026 14:41:49 +0000 (UTC) From: Petr Oros To: netdev@vger.kernel.org Cc: Petr Oros , Tony Nguyen , Przemek Kitszel , Andrew Lunn , "David S. Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Priyalee Kushwaha , Kiran Patil , Wojciech Drewek , Michal Swiatkowski , Aleksandr Loktionov , Simon Horman , intel-wired-lan@lists.osuosl.org, linux-kernel@vger.kernel.org Subject: [PATCH iwl-next v2 2/2] ice: don't offload drop filters that bypass higher priority filters Date: Wed, 16 Sep 2026 16:41:30 +0200 Message-ID: <20260916144130.2699902-3-poros@redhat.com> In-Reply-To: <20260916144130.2699902-1-poros@redhat.com> References: <20260916144130.2699902-1-poros@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Scanned-By: MIMEDefang 3.0 on 10.30.177.17 Content-Type: text/plain; charset="utf-8" The E810 switch gives drop rules absolute precedence over forwarding rules regardless of recipe priority (verified on E810 in every combination of installation order and match specificity). TC however requires filters to be evaluated in priority order, so when a higher priority filter stays software-only because its match or action cannot be offloaded while a lower priority drop filter is offloaded, the hardware drops packets the higher priority filter should have seen: tc filter add dev $pf ingress prio 1 protocol ip flower \ ip_proto l2tp action pass tc filter add dev $pf ingress prio 2 protocol ip flower action drop The pass filter is rejected (unsupported action), the drop filter is offloaded and the hardware drops all IPv4 traffic including the L2TP packets the prio 1 filter should accept. Track filters that were presented to the driver but not offloaded and refuse to offload a drop filter when a higher priority filter on the same device block and direction is software-only or is offloaded with a forwarding action, which the hardware drop would equally override. The refused drop filter keeps working in software. Filters are compared only within one device block since TC priorities are not ordered across blocks, and a shared block bound to multiple devices is tracked once per binding. Filters with skip_sw bypass the check because the user explicitly requested hardware-only operation and refusing would fail the filter add entirely, and the tracking applies to the legacy switch mode only, switchdev pipelines manage rule priorities themselves. The check does not analyze match overlap, so it is conservative, and it runs only at drop offload time. A conflicting filter installed after a drop filter was already offloaded cannot un-offload it, and filters the driver never saw (added while hw-tc-offload was off) are invisible to it. Installing filters in priority order with offload enabled avoids both. Fixes: 0d08a441fb1a ("ice: ndo_setup_tc implementation for PF") Signed-off-by: Petr Oros Reviewed-by: Simon Horman --- v2: - track one entry per cookie and filter_dev pair instead of one per cookie, so a shared block bound to multiple devices of one PF is protected on every binding and each DESTROY invocation removes its own entry instead of returning -EINVAL for the later bindings (sashiko review via Simon Horman) - pass the filter device to ice_del_cls_flower() for the lookup above v1: https://lore.kernel.org/all/20260910154824.3603687-3-poros@redhat.com/ drivers/net/ethernet/intel/ice/ice.h | 1 + drivers/net/ethernet/intel/ice/ice_main.c | 2 +- drivers/net/ethernet/intel/ice/ice_repr.c | 2 +- drivers/net/ethernet/intel/ice/ice_tc_lib.c | 159 +++++++++++++++++++- drivers/net/ethernet/intel/ice/ice_tc_lib.h | 23 ++- 5 files changed, 177 insertions(+), 10 deletions(-) diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/in= tel/ice/ice.h index db3c7015c56c43..6c596e5a315175 100644 --- a/drivers/net/ethernet/intel/ice/ice.h +++ b/drivers/net/ethernet/intel/ice/ice.h @@ -643,6 +643,7 @@ struct ice_pf { */ u16 num_dmac_chnl_fltrs; struct hlist_head tc_flower_fltr_list; + struct hlist_head tc_sw_fltr_list; =20 u64 supported_rxdids; =20 diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethern= et/intel/ice/ice_main.c index 3b76eb58666c07..3e6976cbb45c22 100644 --- a/drivers/net/ethernet/intel/ice/ice_main.c +++ b/drivers/net/ethernet/intel/ice/ice_main.c @@ -8392,7 +8392,7 @@ ice_setup_tc_cls_flower(struct ice_netdev_priv *np, case FLOW_CLS_REPLACE: return ice_add_cls_flower(filter_dev, vsi, cls_flower, ingress); case FLOW_CLS_DESTROY: - return ice_del_cls_flower(vsi, cls_flower); + return ice_del_cls_flower(filter_dev, vsi, cls_flower); default: return -EINVAL; } diff --git a/drivers/net/ethernet/intel/ice/ice_repr.c b/drivers/net/ethern= et/intel/ice/ice_repr.c index 096566c697f444..312a1bda460035 100644 --- a/drivers/net/ethernet/intel/ice/ice_repr.c +++ b/drivers/net/ethernet/intel/ice/ice_repr.c @@ -223,7 +223,7 @@ ice_repr_setup_tc_cls_flower(struct ice_repr *repr, return ice_add_cls_flower(repr->netdev, repr->src_vsi, flower, true); case FLOW_CLS_DESTROY: - return ice_del_cls_flower(repr->src_vsi, flower); + return ice_del_cls_flower(repr->netdev, repr->src_vsi, flower); default: return -EINVAL; } diff --git a/drivers/net/ethernet/intel/ice/ice_tc_lib.c b/drivers/net/ethe= rnet/intel/ice/ice_tc_lib.c index fbd8cbad150a98..fec6970a74cfbf 100644 --- a/drivers/net/ethernet/intel/ice/ice_tc_lib.c +++ b/drivers/net/ethernet/intel/ice/ice_tc_lib.c @@ -2269,6 +2269,117 @@ ice_find_tc_flower_fltr(struct ice_pf *pf, unsigned= long cookie) return NULL; } =20 +/** + * ice_tc_fltr_is_drop - check if a filter carries a drop action + * @cls_flower: offload request describing the filter + * + * Return: true if any action of the filter is a drop, false otherwise. + */ +static bool ice_tc_fltr_is_drop(struct flow_cls_offload *cls_flower) +{ + struct flow_rule *rule =3D flow_cls_offload_flow_rule(cls_flower); + struct flow_action_entry *act; + int i; + + if (cls_flower->classid) + return false; + + flow_action_for_each(i, act, &rule->action) + if (act->id =3D=3D FLOW_ACTION_DROP) + return true; + + return false; +} + +/** + * ice_tc_untrack_sw_fltr - forget a tracked software-only filter + * @pf: pointer to PF structure + * @filter_dev: device the filter was requested on + * @cookie: unique filter identifier from the offload request + * + * Return: true if the filter was tracked, false otherwise. + */ +static bool ice_tc_untrack_sw_fltr(struct ice_pf *pf, + struct net_device *filter_dev, + unsigned long cookie) +{ + struct ice_tc_sw_fltr *sw_fltr; + + hlist_for_each_entry(sw_fltr, &pf->tc_sw_fltr_list, node) { + if (sw_fltr->cookie !=3D cookie || + sw_fltr->filter_dev !=3D filter_dev) + continue; + + hlist_del(&sw_fltr->node); + kfree(sw_fltr); + return true; + } + + return false; +} + +/** + * ice_tc_track_sw_fltr - remember a filter that was not offloaded + * @pf: pointer to PF structure + * @filter_dev: device the filter was requested on + * @cls_flower: offload request describing the filter + * @direction: block direction the filter was requested for + */ +static void ice_tc_track_sw_fltr(struct ice_pf *pf, + struct net_device *filter_dev, + struct flow_cls_offload *cls_flower, + enum ice_eswitch_fltr_direction direction) +{ + struct ice_tc_sw_fltr *sw_fltr; + + hlist_for_each_entry(sw_fltr, &pf->tc_sw_fltr_list, node) + if (sw_fltr->cookie =3D=3D cls_flower->cookie && + sw_fltr->filter_dev =3D=3D filter_dev) + return; + + sw_fltr =3D kzalloc_obj(*sw_fltr); + if (!sw_fltr) + return; + + sw_fltr->cookie =3D cls_flower->cookie; + sw_fltr->filter_dev =3D filter_dev; + sw_fltr->prio =3D cls_flower->common.prio; + sw_fltr->direction =3D direction; + sw_fltr->is_drop =3D ice_tc_fltr_is_drop(cls_flower); + hlist_add_head(&sw_fltr->node, &pf->tc_sw_fltr_list); +} + +/** + * ice_tc_drop_bypasses_fltr - check if a drop rule would bypass a filter + * @pf: pointer to PF structure + * @filter_dev: device the drop filter is requested on + * @prio: TC priority of the drop filter + * @direction: block direction of the drop filter + * + * Return: true if such a filter exists, false otherwise. + */ +static bool +ice_tc_drop_bypasses_fltr(struct ice_pf *pf, struct net_device *filter_dev, + u32 prio, enum ice_eswitch_fltr_direction direction) +{ + struct ice_tc_flower_fltr *fltr; + struct ice_tc_sw_fltr *sw_fltr; + + hlist_for_each_entry(sw_fltr, &pf->tc_sw_fltr_list, node) + if (sw_fltr->filter_dev =3D=3D filter_dev && + sw_fltr->direction =3D=3D direction && sw_fltr->prio < prio && + !sw_fltr->is_drop) + return true; + + hlist_for_each_entry(fltr, &pf->tc_flower_fltr_list, tc_flower_node) + if (fltr->filter_dev =3D=3D filter_dev && + fltr->direction =3D=3D direction && fltr->prio < prio && + fltr->action.fltr_act !=3D ICE_DROP_PACKET) + return true; + + return false; +} + /** * ice_add_cls_flower - add TC flower filters * @netdev: Pointer to filter device @@ -2284,14 +2395,24 @@ int ice_add_cls_flower(struct net_device *netdev, s= truct ice_vsi *vsi, { struct netlink_ext_ack *extack =3D cls_flower->common.extack; struct net_device *vsi_netdev =3D vsi->netdev; + enum ice_eswitch_fltr_direction direction; struct ice_tc_flower_fltr *fltr; struct ice_pf *pf =3D vsi->back; + bool track_sw_fltrs; int err; =20 - if (ice_is_reset_in_progress(pf->state)) - return -EBUSY; - if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags)) - return -EINVAL; + direction =3D ingress ? ICE_ESWITCH_FLTR_INGRESS : + ICE_ESWITCH_FLTR_EGRESS; + track_sw_fltrs =3D !ice_is_eswitch_mode_switchdev(pf); + + if (ice_is_reset_in_progress(pf->state)) { + err =3D -EBUSY; + goto track_sw; + } + if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags)) { + err =3D -EINVAL; + goto track_sw; + } =20 if (ice_is_port_repr_netdev(netdev)) vsi_netdev =3D netdev; @@ -2304,7 +2425,8 @@ int ice_add_cls_flower(struct net_device *netdev, str= uct ice_vsi *vsi, */ if (netdev =3D=3D vsi_netdev) NL_SET_ERR_MSG_MOD(extack, "can't apply TC flower filters, turn ON hw-t= c-offload and try again"); - return -EINVAL; + err =3D -EINVAL; + goto track_sw; } =20 /* avoid duplicate entries, if exists - return error */ @@ -2314,28 +2436,51 @@ int ice_add_cls_flower(struct net_device *netdev, s= truct ice_vsi *vsi, return -EEXIST; } =20 + if (track_sw_fltrs && !cls_flower->common.skip_sw && + ice_tc_fltr_is_drop(cls_flower) && + ice_tc_drop_bypasses_fltr(pf, netdev, cls_flower->common.prio, + direction)) { + NL_SET_ERR_MSG_MOD(extack, + "Drop filter not offloaded because it would bypass a higher priorit= y filter"); + err =3D -EOPNOTSUPP; + goto track_sw; + } + /* prep and add TC-flower filter in HW */ err =3D ice_add_tc_fltr(netdev, vsi, cls_flower, &fltr, ingress); if (err) - return err; + goto track_sw; + + fltr->filter_dev =3D netdev; + fltr->prio =3D cls_flower->common.prio; =20 /* add filter into an ordered list */ hlist_add_head(&fltr->tc_flower_node, &pf->tc_flower_fltr_list); return 0; + +track_sw: + if (track_sw_fltrs && !cls_flower->common.skip_sw) + ice_tc_track_sw_fltr(pf, netdev, cls_flower, direction); + return err; } =20 /** * ice_del_cls_flower - delete TC flower filters + * @netdev: Pointer to filter device * @vsi: Pointer to VSI * @cls_flower: Pointer to struct flow_cls_offload */ int -ice_del_cls_flower(struct ice_vsi *vsi, struct flow_cls_offload *cls_flowe= r) +ice_del_cls_flower(struct net_device *netdev, struct ice_vsi *vsi, + struct flow_cls_offload *cls_flower) { struct ice_tc_flower_fltr *fltr; struct ice_pf *pf =3D vsi->back; int err; =20 + if (ice_tc_untrack_sw_fltr(pf, netdev, cls_flower->cookie)) + return 0; + /* find filter */ fltr =3D ice_find_tc_flower_fltr(pf, cls_flower->cookie); if (!fltr) { diff --git a/drivers/net/ethernet/intel/ice/ice_tc_lib.h b/drivers/net/ethe= rnet/intel/ice/ice_tc_lib.h index 752af65e70b7bf..47444b7dadd257 100644 --- a/drivers/net/ethernet/intel/ice/ice_tc_lib.h +++ b/drivers/net/ethernet/intel/ice/ice_tc_lib.h @@ -139,12 +139,33 @@ enum ice_eswitch_fltr_direction { ICE_ESWITCH_FLTR_EGRESS, }; =20 +/** + * struct ice_tc_sw_fltr - filter presented to the driver but not offloaded + * @node: node in the pf->tc_sw_fltr_list + * @cookie: unique filter identifier from the offload request + * @filter_dev: device the filter was requested on + * @prio: TC priority, lower value is evaluated first + * @direction: block direction the filter was requested for + * @is_drop: the filter carries a drop action + */ +struct ice_tc_sw_fltr { + struct hlist_node node; + unsigned long cookie; + struct net_device *filter_dev; + u32 prio; + enum ice_eswitch_fltr_direction direction; + bool is_drop; +}; + struct ice_tc_flower_fltr { struct hlist_node tc_flower_node; =20 /* cookie becomes filter_rule_id if rule is added successfully */ unsigned long cookie; =20 + struct net_device *filter_dev; + u32 prio; + /* add_adv_rule returns information like recipe ID, rule_id. Store * those values since they are needed to remove advanced rule */ @@ -214,7 +235,7 @@ static inline int ice_chnl_dmac_fltr_cnt(struct ice_pf = *pf) struct ice_vsi *ice_locate_vsi_using_queue(struct ice_vsi *vsi, int queue); int ice_add_cls_flower(struct net_device *netdev, struct ice_vsi *vsi, struct flow_cls_offload *cls_flower, bool ingress); -int ice_del_cls_flower(struct ice_vsi *vsi, +int ice_del_cls_flower(struct net_device *netdev, struct ice_vsi *vsi, struct flow_cls_offload *cls_flower); void ice_replay_tc_fltrs(struct ice_pf *pf); bool ice_is_tunnel_supported(struct net_device *dev); --=20 2.55.0