From patchwork Sun Aug 4 15:09:03 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141764 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="kPUfZU9E"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqK5Npxz9sN4 for ; Mon, 5 Aug 2019 01:10:37 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726519AbfHDPK1 (ORCPT ); Sun, 4 Aug 2019 11:10:27 -0400 Received: from mail-wm1-f68.google.com ([209.85.128.68]:37979 "EHLO mail-wm1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726181AbfHDPK1 (ORCPT ); Sun, 4 Aug 2019 11:10:27 -0400 Received: by mail-wm1-f68.google.com with SMTP id s15so49384270wmj.3 for ; Sun, 04 Aug 2019 08:10:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=3SGrb+RQF9ki5vYBnH9UJLtaJKTkIWuOgwt/Nyd92Z4=; b=kPUfZU9ErkmJfal6Q7iC9f8qz/8DOjdpNTTQD7R/o52+9R+GX102SJDh+m2mh0oSyj 4w/IUU87gW2PcZaiOsDlqOvU+uIlNzVQzpnoVsxccoQ9ZEdFRExB0Hma3EzSeCkLgXLs ayH3CRtAHwpc7EeYgKkyPLfVdeOD88Ecs8woACgjnEJOFqje0czyFmNwqoqJa7jBSK6N fedUMFoK5zdv5Fr0omRIj5K2Vlagl4wnmNd9XNsEaKKZXg5bTHiMNNO45fFCMUqytLrl wooEIU6PaiWqNB+aIBivp8bKDukU9uCJGFO97kX0HaGtPa8TEbi3/f39b96ud8IL/OiQ iY/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=3SGrb+RQF9ki5vYBnH9UJLtaJKTkIWuOgwt/Nyd92Z4=; b=qSmlpfSK/40APYKzm1+cq8l3onxqGRH31GspgRYJtU7IFLSHhuNgwYGhDxL3Df6muV /A+I3eTPPqUGcWJ5PvGUr9nAWLoYEk5GRyRLfotQcJ4Ar7eYhNPZCSn+IKUSmhbuFQoV UH0e2VR/Hr9WR0D3X5nHS/TYV6aq1pAEu++jEztAzPoPDMuFcExB8nhdyJURTiYhtHCV sQ/bJoGVd96RXtG7P7P1q2Dut1Xq/Ym63KC2APszAJXyNo9eopELmIjIpsr8jf1oHi5k RBNUjRH7K67xQK6k+5QnVIMTLU3TepGmDrlDf4M1UMgsMEkDAl4I4RsGfJUEBnJVeep9 AVgA== X-Gm-Message-State: APjAAAXIp0euEeTtQBgAWl+7Ds5pGAgdcOjuF8NsgCnovoAvvD00RAvn t23CyhcTIG2zUcZSTYHa/m0/fMuB6JE= X-Google-Smtp-Source: APXvYqxtyFwjOY5I01pBJZAv+B9mZHK4d2ylpN6Zi2l7xDBssF1MraLy9/tG+x5NvERAmxS8NEJ2Sg== X-Received: by 2002:a1c:a6d3:: with SMTP id p202mr14558665wme.26.1564931424930; Sun, 04 Aug 2019 08:10:24 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:24 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 01/10] net: tc_act: add skbedit_ptype helper functions Date: Sun, 4 Aug 2019 16:09:03 +0100 Message-Id: <1564931351-1036-2-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The tc_act header file contains an inline function that checks if an action is changing the skb mark of a packet and a further function to extract the mark. Add similar functions to check for and get skbedit actions that modify the packet type of the skb. Signed-off-by: John Hurley Reviewed-by: Simon Horman Reviewed-by: Jakub Kicinski --- include/net/tc_act/tc_skbedit.h | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/include/net/tc_act/tc_skbedit.h b/include/net/tc_act/tc_skbedit.h index 4c04e29..b22a1f6 100644 --- a/include/net/tc_act/tc_skbedit.h +++ b/include/net/tc_act/tc_skbedit.h @@ -54,4 +54,31 @@ static inline u32 tcf_skbedit_mark(const struct tc_action *a) return mark; } +/* Return true iff action is ptype */ +static inline bool is_tcf_skbedit_ptype(const struct tc_action *a) +{ +#ifdef CONFIG_NET_CLS_ACT + u32 flags; + + if (a->ops && a->ops->id == TCA_ID_SKBEDIT) { + rcu_read_lock(); + flags = rcu_dereference(to_skbedit(a)->params)->flags; + rcu_read_unlock(); + return flags == SKBEDIT_F_PTYPE; + } +#endif + return false; +} + +static inline u32 tcf_skbedit_ptype(const struct tc_action *a) +{ + u16 ptype; + + rcu_read_lock(); + ptype = rcu_dereference(to_skbedit(a)->params)->ptype; + rcu_read_unlock(); + + return ptype; +} + #endif /* __NET_TC_SKBEDIT_H */ From patchwork Sun Aug 4 15:09:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141765 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="K667K8pJ"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqL3KY9z9sNy for ; Mon, 5 Aug 2019 01:10:38 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726530AbfHDPKa (ORCPT ); Sun, 4 Aug 2019 11:10:30 -0400 Received: from mail-wm1-f65.google.com ([209.85.128.65]:35529 "EHLO mail-wm1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726474AbfHDPK1 (ORCPT ); Sun, 4 Aug 2019 11:10:27 -0400 Received: by mail-wm1-f65.google.com with SMTP id l2so70694175wmg.0 for ; Sun, 04 Aug 2019 08:10:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=GIK3vLRJwz2VMoF4+r1s0h38UAW4YbVeLg7YVAMmYKw=; b=K667K8pJtqNghyF+Tj40CxvuTIMaiUqUqe8GNzgc9gCLDP3O9UEL2UQP1tA5WQNsz2 s4xo1opK4dfx2ptLUpwYykRpAXfOXseWLwOaB4QkMPP2dIeenrAReJbxGaBlL6plEpNC 1Wa+FHC81XhiNB3VUXZ44Od+GXsw3PTplRT7tLbtmODpFnBvF8d1KtpQEoGtN7ZO0XDs x5Ygb0K8GUVP6H4hbmYNLq6uxpg6oYbEYmOy4wuWWq7nV4xONxsSnU3HG/IFmvzZqnZk e3Dz1n5LUjTbUWflvdwt17YrEeAK/5ZjtVl/iOL7d82cSjxWsc4iKRHziuPQXvLT9S+7 HC0g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=GIK3vLRJwz2VMoF4+r1s0h38UAW4YbVeLg7YVAMmYKw=; b=h2fZjlFrgsgAbtXcldmP33KUX62eSrwlT+DD8sFucUbPy/2r+HVuN7Bn5kQiLmq/1G 7Saex5dYBQgafbqJmiXBBMiFSjZqPHkYUd5KstvcfOfmEb+dlZda3VIWh4wm9/FQp+gL DAtWKTtxoVesYH8jibo87R+zwuaymTrLjiyzN9zffPPPQV4VFDL4xmuCSePtp6r1pWU+ mNDbqtSekaLr3D+pX3DLCXt745n5tp93Cyic08f06u8UZ/H1n7cYRrrVqRQESl1NkAO1 Bt/eZOjNoMeERZ40eqmafIsa37bXPQ+n9sjN/pklwYNq6dr9ODSLMZwdmxq5gmREYVXB bUGw== X-Gm-Message-State: APjAAAUy22duSp4rxc3Us83jLVJ0NnDHngtFDomWJFTkIxpvG9mwxvwJ u4U5kvND6BF/jEjwpxu/+sGFzL339SQ= X-Google-Smtp-Source: APXvYqw6M4lDEFIDDE/Ggl3X7tuYrCcw2WcSx/3czxN9CxpNT8ZFQTrZ8/f0YfcYHIa5YkbsMHIHWw== X-Received: by 2002:a1c:2c41:: with SMTP id s62mr14237536wms.8.1564931425845; Sun, 04 Aug 2019 08:10:25 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:25 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 02/10] net: sched: add skbedit of ptype action to hardware IR Date: Sun, 4 Aug 2019 16:09:04 +0100 Message-Id: <1564931351-1036-3-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org TC rules can impliment skbedit actions. Currently actions that modify the skb mark are passed to offloading drivers via the hardware intermediate representation in the flow_offload API. Extend this to include skbedit actions that modify the packet type of the skb. Such actions may be used to set the ptype to HOST when redirecting a packet to ingress. Signed-off-by: John Hurley Reviewed-by: Simon Horman Reviewed-by: Jakub Kicinski --- include/net/flow_offload.h | 2 ++ net/sched/cls_api.c | 3 +++ 2 files changed, 5 insertions(+) diff --git a/include/net/flow_offload.h b/include/net/flow_offload.h index 00b9aab..04c29f5 100644 --- a/include/net/flow_offload.h +++ b/include/net/flow_offload.h @@ -126,6 +126,7 @@ enum flow_action_id { FLOW_ACTION_ADD, FLOW_ACTION_CSUM, FLOW_ACTION_MARK, + FLOW_ACTION_PTYPE, FLOW_ACTION_WAKE, FLOW_ACTION_QUEUE, FLOW_ACTION_SAMPLE, @@ -168,6 +169,7 @@ struct flow_action_entry { const struct ip_tunnel_info *tunnel; /* FLOW_ACTION_TUNNEL_ENCAP */ u32 csum_flags; /* FLOW_ACTION_CSUM */ u32 mark; /* FLOW_ACTION_MARK */ + u16 ptype; /* FLOW_ACTION_PTYPE */ struct { /* FLOW_ACTION_QUEUE */ u32 ctx; u32 index; diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c index 3565d9a..ae73d37 100644 --- a/net/sched/cls_api.c +++ b/net/sched/cls_api.c @@ -3294,6 +3294,9 @@ int tc_setup_flow_action(struct flow_action *flow_action, default: goto err_out; } + } else if (is_tcf_skbedit_ptype(act)) { + entry->id = FLOW_ACTION_PTYPE; + entry->ptype = tcf_skbedit_ptype(act); } else { goto err_out; } From patchwork Sun Aug 4 15:09:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141772 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="koC4RGQd"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqT0RFqz9sP6 for ; Mon, 5 Aug 2019 01:10:45 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726631AbfHDPKn (ORCPT ); Sun, 4 Aug 2019 11:10:43 -0400 Received: from mail-wr1-f65.google.com ([209.85.221.65]:46027 "EHLO mail-wr1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726190AbfHDPK2 (ORCPT ); Sun, 4 Aug 2019 11:10:28 -0400 Received: by mail-wr1-f65.google.com with SMTP id f9so2981223wre.12 for ; Sun, 04 Aug 2019 08:10:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=TJZCFi6SWGuL941FTbm8PAdV1InyCLO80UmCo8oiYsY=; b=koC4RGQdg5eoK/PpI4npTbdhRC/tL9lb9Ca5Fl3EP5i+PMLTP/3tQ/joBlxno4/Moq TgG2mZDAPcnRXcaHQeG48+0JatO/Z0bFjtx6wTBcinGLMH/a53XrsthpjSYCPD+u2YOS M1P6Jyrcx3zIM/Ey59w37krFnQj+wQ/yAmnP1MyYk+OduBs5Jfwm2ct3AjllU3F15DzP 5kSaTS249nh3nyUEJMDDJeXdxcZqO5sBRLtG9ngJl4SfUInrN/IJJlG6o0yQs2gkBA2/ 2Tli5XSTgvAv/BMN6RMMFX8Kfh2sT992K+dY7KLJA6umqnDftBjlepPSBjvKc0ghlu8w 7MmQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=TJZCFi6SWGuL941FTbm8PAdV1InyCLO80UmCo8oiYsY=; b=Es6uxQVvHz5z6GLSceqGvpR4S80najmSxwaJ3bsYfY2cwtvBAMlBUSt3zCbq337RUE Kd+RIxMEXXiTJMp95Qf6F2soR0KehIM3oAJ8SwU+DppE3YI3beE6cs9HXTYl8gmMhXef +YvBK3FC/aE412wbNjjfbMcfM2fnYsYjo0B2BgRFrd2lk5aydTdYsxvG/j9M3RjjAeSn gvaYZ5KrSOy1J27k3buiWvTf76D+kSaUKeHl/6zNU6d/Iiy/tUljAOqOK6J31hibwlVp 9fbNd4vbuEQMmgRm1v9CEn3w/FoxkcjTvxrQSnQwCxYZVRAITBYn8rciVJ5Xc/LIk/S/ Rw1Q== X-Gm-Message-State: APjAAAW0Jbp06L1uCzp3GQLwOKhgf5kHNUBWyFkjpcPrZWS/eTZSPCIp NiSclqlEhsmIuTYbFCW1fJ7KOM7PB6I= X-Google-Smtp-Source: APXvYqxgAdbVPOVBOEDPJv1FoQRbcUzLeKMu4NRD3BJ+gT6dENdcsHa2odhtexeu4ZN4Q2XqyjLYZQ== X-Received: by 2002:adf:f601:: with SMTP id t1mr61201347wrp.337.1564931426722; Sun, 04 Aug 2019 08:10:26 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.25 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:26 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 03/10] net: tc_act: add helpers to detect ingress mirred actions Date: Sun, 4 Aug 2019 16:09:05 +0100 Message-Id: <1564931351-1036-4-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org TC mirred actions can send to egress or ingress on a given netdev. Helpers exist to detect actions that are mirred to egress. Extend the header file to include helpers to detect ingress mirred actions. Signed-off-by: John Hurley Reviewed-by: Simon Horman Reviewed-by: Jakub Kicinski --- include/net/tc_act/tc_mirred.h | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/include/net/tc_act/tc_mirred.h b/include/net/tc_act/tc_mirred.h index c757585..1cace4c 100644 --- a/include/net/tc_act/tc_mirred.h +++ b/include/net/tc_act/tc_mirred.h @@ -32,6 +32,24 @@ static inline bool is_tcf_mirred_egress_mirror(const struct tc_action *a) return false; } +static inline bool is_tcf_mirred_ingress_redirect(const struct tc_action *a) +{ +#ifdef CONFIG_NET_CLS_ACT + if (a->ops && a->ops->id == TCA_ID_MIRRED) + return to_mirred(a)->tcfm_eaction == TCA_INGRESS_REDIR; +#endif + return false; +} + +static inline bool is_tcf_mirred_ingress_mirror(const struct tc_action *a) +{ +#ifdef CONFIG_NET_CLS_ACT + if (a->ops && a->ops->id == TCA_ID_MIRRED) + return to_mirred(a)->tcfm_eaction == TCA_INGRESS_MIRROR; +#endif + return false; +} + static inline struct net_device *tcf_mirred_dev(const struct tc_action *a) { return rtnl_dereference(to_mirred(a)->tcfm_dev); From patchwork Sun Aug 4 15:09:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141766 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="a8ZW3ali"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqM5fWbz9sP6 for ; Mon, 5 Aug 2019 01:10:39 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726549AbfHDPKb (ORCPT ); Sun, 4 Aug 2019 11:10:31 -0400 Received: from mail-wm1-f67.google.com ([209.85.128.67]:51005 "EHLO mail-wm1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726181AbfHDPKa (ORCPT ); Sun, 4 Aug 2019 11:10:30 -0400 Received: by mail-wm1-f67.google.com with SMTP id v15so72459801wml.0 for ; Sun, 04 Aug 2019 08:10:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=+LaznjCnVsU17aAS+1MsieE+rq+exC7uT/k3Eq1bSsA=; b=a8ZW3ali7hfsTOWYPH/ZIwMgdBsZVNbGBXSw4IdJCnv0Gj1eQIaCdmWUQAOau3YaMD PAbTMjmj2sqzHKxFu4Z3gBpkBUF+6pVywX5FfMfjjvl3LH90MrbK/3hjXy+oyYchKMzD qdtNSSwdTZSLWV/6cm8EEIVahDyhmQUBXnsNb+oN/36s9O9FCy0m0QwHBmffVv8h7wi9 7uNebC6K6IdQ1MUh4mytL5vCi71nziW+xk2NADZ7ayqmCUGMPcis8VoiVBxcYy68cZpv 52Cx11gGusT5HHoU7a6sew+DMvLDLa7deBAsnCVh7szFfficow3fl7UtXIH32iH3a8v/ trLA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=+LaznjCnVsU17aAS+1MsieE+rq+exC7uT/k3Eq1bSsA=; b=UOxPayPLYC1BlIhn3iDC+TDlqOBXz1T4HN6VIgIqP1RYzPe3iMQ7j8EA9LkkXF39jY an/2evkBNFt/t/XgKkTga0WEEGy2Z6CGZJIUSU4sYtZndu2H+B0RuhL1J2p2xETtz3Ge EuiktZAVHovKSoceJxY8xk9o5PnvbbEAa6eCULkv7642+ro8upjy724wyWiajTNeRRpW /fH7xhgiRfeobKwv9JVOPIfCLpc959Pi88XbtZeY7lwQ5CPP4RrMxed+twfpdXlLVFwG bfgMOx6mArGvpQqPfAZ5gF6U+KgjA2HMSw4Jh3SdFZLmKZnVac2GMzCtLjaMtqaFNRDH 7bcg== X-Gm-Message-State: APjAAAXagPakLd2d3o53Kccyca/Y6gutbfkkr1+PQgsaSk+bNrJX8Vmi /YLDpA+soHFdKX7BNoa2bQJboyCoZFE= X-Google-Smtp-Source: APXvYqwpHJJ0ZfSm75Pmh8gTRv4aWDTC/Db3Itl/FOLSEb2P8J3UeuSGXucCeK4/31t4rwsomGYofA== X-Received: by 2002:a1c:a848:: with SMTP id r69mr13764771wme.12.1564931427820; Sun, 04 Aug 2019 08:10:27 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.26 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:27 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 04/10] net: sched: add ingress mirred action to hardware IR Date: Sun, 4 Aug 2019 16:09:06 +0100 Message-Id: <1564931351-1036-5-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org TC mirred actions (redirect and mirred) can send to egress or ingress of a device. Currently only egress is used for hw offload rules. Modify the intermediate representation for hw offload to include mirred actions that go to ingress. This gives drivers access to such rules and can decide whether or not to offload them. Signed-off-by: John Hurley Reviewed-by: Simon Horman Reviewed-by: Jakub Kicinski --- include/net/flow_offload.h | 2 ++ net/sched/cls_api.c | 6 ++++++ 2 files changed, 8 insertions(+) diff --git a/include/net/flow_offload.h b/include/net/flow_offload.h index 04c29f5..d3b12bc 100644 --- a/include/net/flow_offload.h +++ b/include/net/flow_offload.h @@ -117,6 +117,8 @@ enum flow_action_id { FLOW_ACTION_GOTO, FLOW_ACTION_REDIRECT, FLOW_ACTION_MIRRED, + FLOW_ACTION_REDIRECT_INGRESS, + FLOW_ACTION_MIRRED_INGRESS, FLOW_ACTION_VLAN_PUSH, FLOW_ACTION_VLAN_POP, FLOW_ACTION_VLAN_MANGLE, diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c index ae73d37..9d85d32 100644 --- a/net/sched/cls_api.c +++ b/net/sched/cls_api.c @@ -3205,6 +3205,12 @@ int tc_setup_flow_action(struct flow_action *flow_action, } else if (is_tcf_mirred_egress_mirror(act)) { entry->id = FLOW_ACTION_MIRRED; entry->dev = tcf_mirred_dev(act); + } else if (is_tcf_mirred_ingress_redirect(act)) { + entry->id = FLOW_ACTION_REDIRECT_INGRESS; + entry->dev = tcf_mirred_dev(act); + } else if (is_tcf_mirred_ingress_mirror(act)) { + entry->id = FLOW_ACTION_MIRRED_INGRESS; + entry->dev = tcf_mirred_dev(act); } else if (is_tcf_vlan(act)) { switch (tcf_vlan_action(act)) { case TCA_VLAN_ACT_PUSH: From patchwork Sun Aug 4 15:09:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141767 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="IoIw9Stp"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqN58XYz9sP8 for ; Mon, 5 Aug 2019 01:10:40 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726561AbfHDPKd (ORCPT ); Sun, 4 Aug 2019 11:10:33 -0400 Received: from mail-wr1-f65.google.com ([209.85.221.65]:33999 "EHLO mail-wr1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726524AbfHDPKb (ORCPT ); Sun, 4 Aug 2019 11:10:31 -0400 Received: by mail-wr1-f65.google.com with SMTP id 31so81923995wrm.1 for ; Sun, 04 Aug 2019 08:10:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=+Mp0iodaGf4Jj6dRLCOhmM3wMm+C01K11YTDgoRKUrA=; b=IoIw9StpferemXc9ifoVxmN158X3fKhnYdu3tA02cbuHYhcRtrg9pTjFxINY0ZKVeE kgK6v++cO4oIiOBEYRxQLaAPcOSt48aao5HdZNfUy70yRiyZMRoEhPrNPfm4NHXas3Yk ayFEfa7RdsM1K3NO/UGPOpTP/i/LTPgaMiNYjXTTmj9adLzdoQAd/b8DgBs2KwaUcY0Y jMkg3/N1NuIS6QyB966R1Kz7Ckc6nC6wiaIw1kXpiJChlh64RKIfN8HaAw+iK6YSZIn7 P/Jw97MBpVsIaDhw+S9aEZbcbOtNpMgk4EwTwD463ZGQbD0StSqw/GhHBmRtK7HM23f/ bxlw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=+Mp0iodaGf4Jj6dRLCOhmM3wMm+C01K11YTDgoRKUrA=; b=ZLK2dPHUsWb/FPpIilZsxMtcZzVTFQAJcFenUBnC5OlWEIEGgbcUJuCtLd2AkL8jfG y7IXa5g44tsNpOEA5ZFR02sv4FdHgGuehnv7x+tn2k0EYmtoNe6Pz0Vwh73yK93IBdIA DbbgS0Ai7cXjjPv/hTI0J/Ldf8eaSnenPWXAiRaA6i+PxXbvosHgosa7yEs/I+M7ErAH nD/bKPk5Y3WDr/tvJ5yZWnYf1JSCj/pkgeF6i1GPxxTmbfWhGlIMxUdNpGOlVhky9Os/ RuRDL1GQyUwj8beIZKPDrSmAcRUKWHFv5unJV8DQAcySEtB6Ir1K4U0G5qS0n4WTnyo6 S6Fw== X-Gm-Message-State: APjAAAUyCpaF9aRf2brxC/ddKsNpycByJtqXKJ4HKbRDaKxzoFZFGYou 9zonLG5Y/6J4J2E4Hinwk74cNIyRn/M= X-Google-Smtp-Source: APXvYqzpv6wNjyOsaODTCXHx9+aHvaZL74oagDbv0f0KUsQ/TImsFlYBErzrE/DQObbepn3UU2tF4Q== X-Received: by 2002:adf:f005:: with SMTP id j5mr107184793wro.251.1564931428780; Sun, 04 Aug 2019 08:10:28 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.27 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:28 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 05/10] nfp: flower: push vlan after tunnel in merge Date: Sun, 4 Aug 2019 16:09:07 +0100 Message-Id: <1564931351-1036-6-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org NFP allows the merging of 2 flows together into a single offloaded flow. In the kernel datapath the packet must match 1 flow, impliment its actions, recirculate, match the 2nd flow and also impliment its actions. Merging creates a single flow with all actions from the 2 original flows. Firmware impliments a tunnel header push as the packet is about to egress the card. Therefore, if the first merge rule candiate pushes a tunnel, then the second rule can only have an egress action for a valid merge to occur (or else the action ordering will be incorrect). This prevents the pushing of a tunnel header followed by the pushing of a vlan header. In order to support this behaviour, firmware allows VLAN information to be encoded in the tunnel push action. If this is non zero then the fw will push a VLAN after the tunnel header push meaning that 2 such flows with these actions can be merged (with action order being maintained). Support tunnel in VLAN pushes by encoding VLAN information in the tunnel push action of any merge flow requiring this. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/flower/cmsg.h | 3 +- .../net/ethernet/netronome/nfp/flower/offload.c | 60 ++++++++++++++++++++-- 2 files changed, 58 insertions(+), 5 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h index 3324394..caf3029 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h +++ b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h @@ -220,7 +220,8 @@ struct nfp_fl_set_ipv4_tun { __be16 tun_flags; u8 ttl; u8 tos; - __be32 extra; + __be16 outer_vlan_tpid; + __be16 outer_vlan_tci; u8 tun_len; u8 res2; __be16 tun_proto; diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c index e209f15..607426c 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/offload.c +++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c @@ -732,28 +732,62 @@ nfp_flower_copy_pre_actions(char *act_dst, char *act_src, int len, return act_off; } -static int nfp_fl_verify_post_tun_acts(char *acts, int len) +static int +nfp_fl_verify_post_tun_acts(char *acts, int len, struct nfp_fl_push_vlan **vlan) { struct nfp_fl_act_head *a; unsigned int act_off = 0; while (act_off < len) { a = (struct nfp_fl_act_head *)&acts[act_off]; - if (a->jump_id != NFP_FL_ACTION_OPCODE_OUTPUT) + + if (a->jump_id == NFP_FL_ACTION_OPCODE_PUSH_VLAN && !act_off) + *vlan = (struct nfp_fl_push_vlan *)a; + else if (a->jump_id != NFP_FL_ACTION_OPCODE_OUTPUT) return -EOPNOTSUPP; act_off += a->len_lw << NFP_FL_LW_SIZ; } + /* Ensure any VLAN push also has an egress action. */ + if (*vlan && act_off <= sizeof(struct nfp_fl_push_vlan)) + return -EOPNOTSUPP; + return 0; } static int +nfp_fl_push_vlan_after_tun(char *acts, int len, struct nfp_fl_push_vlan *vlan) +{ + struct nfp_fl_set_ipv4_tun *tun; + struct nfp_fl_act_head *a; + unsigned int act_off = 0; + + while (act_off < len) { + a = (struct nfp_fl_act_head *)&acts[act_off]; + + if (a->jump_id == NFP_FL_ACTION_OPCODE_SET_IPV4_TUNNEL) { + tun = (struct nfp_fl_set_ipv4_tun *)a; + tun->outer_vlan_tpid = vlan->vlan_tpid; + tun->outer_vlan_tci = vlan->vlan_tci; + + return 0; + } + + act_off += a->len_lw << NFP_FL_LW_SIZ; + } + + /* Return error if no tunnel action is found. */ + return -EOPNOTSUPP; +} + +static int nfp_flower_merge_action(struct nfp_fl_payload *sub_flow1, struct nfp_fl_payload *sub_flow2, struct nfp_fl_payload *merge_flow) { unsigned int sub1_act_len, sub2_act_len, pre_off1, pre_off2; + struct nfp_fl_push_vlan *post_tun_push_vlan = NULL; bool tunnel_act = false; char *merge_act; int err; @@ -790,18 +824,36 @@ nfp_flower_merge_action(struct nfp_fl_payload *sub_flow1, sub2_act_len -= pre_off2; /* FW does a tunnel push when egressing, therefore, if sub_flow 1 pushes - * a tunnel, sub_flow 2 can only have output actions for a valid merge. + * a tunnel, there are restrictions on what sub_flow 2 actions lead to a + * valid merge. */ if (tunnel_act) { char *post_tun_acts = &sub_flow2->action_data[pre_off2]; - err = nfp_fl_verify_post_tun_acts(post_tun_acts, sub2_act_len); + err = nfp_fl_verify_post_tun_acts(post_tun_acts, sub2_act_len, + &post_tun_push_vlan); if (err) return err; + + if (post_tun_push_vlan) { + pre_off2 += sizeof(*post_tun_push_vlan); + sub2_act_len -= sizeof(*post_tun_push_vlan); + } } /* Copy remaining actions from sub_flows 1 and 2. */ memcpy(merge_act, sub_flow1->action_data + pre_off1, sub1_act_len); + + if (post_tun_push_vlan) { + /* Update tunnel action in merge to include VLAN push. */ + err = nfp_fl_push_vlan_after_tun(merge_act, sub1_act_len, + post_tun_push_vlan); + if (err) + return err; + + merge_flow->meta.act_len -= sizeof(*post_tun_push_vlan); + } + merge_act += sub1_act_len; memcpy(merge_act, sub_flow2->action_data + pre_off2, sub2_act_len); From patchwork Sun Aug 4 15:09:08 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141770 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="0pDgzobe"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqQ6bYgz9sPG for ; Mon, 5 Aug 2019 01:10:42 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726581AbfHDPKf (ORCPT ); Sun, 4 Aug 2019 11:10:35 -0400 Received: from mail-wm1-f66.google.com ([209.85.128.66]:53070 "EHLO mail-wm1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726536AbfHDPKb (ORCPT ); Sun, 4 Aug 2019 11:10:31 -0400 Received: by mail-wm1-f66.google.com with SMTP id s3so72428218wms.2 for ; Sun, 04 Aug 2019 08:10:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=iqTAWKI1TeAWoyJKc/nzvguqrW1cq2SFQUAQM4Dl6A8=; b=0pDgzobeXuaraRyMQLyCfbLgAfNOmOoNrDABJcK9DrpKtwTwmjXmF2lQLW0uvqJt1Z txV5l+2WlKBOn8E6chJxuH3EEUIe2PU4X2OJO6SI4/jSSlllkC5NVwPzNlJbxdl2+63t BQuzu/Aad0whpud+JjEcRGAgO9C24Z0XJ1bcLyYMPdIPpIke2eA16l3YEF4z+xNA9LkK zh6RTRQcnNnCSqAezzuiveJYEXeUPb6GptQ+IQnRTkYJx65MhBnOl95Ico64qKLHf+25 vp5kJ7itUzGreq1U/LCYFZuF2riywLPv9LI95+vBsu5nY/bPrnl3K7YgTi+ER1deVmcj L3Cg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=iqTAWKI1TeAWoyJKc/nzvguqrW1cq2SFQUAQM4Dl6A8=; b=sUm+xggG0JqyoLf2AIqDS6zr2Jzu5qmwJib/zqym//8OEqmCcwy1KMnnwHCjNVroZa KrpxLL3YjjIO5FfYP6A9+k4SqU2YqipxILABx9WcMj9QBLY6MRudrPWUD9+7SE5Ou0PC iilsLOs5FjH9wbuIwUM+f3N8OuTcl8+XBTC+1XXVLinvllYl2aR2ASkIwdlo7nxfk4WT cbc4qfQl891hM8IpJjp9Vc6wu7PzU9RQymo4h9PFkXTyj4UwiF5BBZokW32hJWmt7h9f a1YZYZ6T7G/yc0vsaMFlsvzEgg9uoABkGUrSVB6GnB50qRPT2WH1w+OhrlzfM+x2uvr3 MEtg== X-Gm-Message-State: APjAAAW4tZcQvVYAnKXd7WqXNf7sxehH0nMJViJpdoPUUsElyji/RnfP RnQBu5pUwDr6g4S/g2easAQCBtELfmk= X-Google-Smtp-Source: APXvYqx0zKDIao+OzmqFawUBqJNGjwaV1r2zPGZwV1XYBDOwatr5wxhAVjazna+tf66nIBpgatOJEQ== X-Received: by 2002:a1c:b457:: with SMTP id d84mr15033505wmf.153.1564931429830; Sun, 04 Aug 2019 08:10:29 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.28 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:29 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 06/10] nfp: flower: detect potential pre-tunnel rules Date: Sun, 4 Aug 2019 16:09:08 +0100 Message-Id: <1564931351-1036-7-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Pre-tunnel rules are used when the tunnel end-point is on an 'internal port'. These rules are used to direct the tunnelled packets (based on outer header fields) to the internal port where they can be detunnelled. The rule must send the packet to ingress the internal port at the TC layer. Currently FW does not support an action to send to ingress so cannot offload such rules. However, in preparation for populating the pre-tunnel table to represent such rules, check for rules that send to the ingress of an internal port and mark them as such. Further validation of such rules is left to subsequent patches. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/flower/action.c | 40 ++++++++++++++++++---- drivers/net/ethernet/netronome/nfp/flower/main.h | 4 +++ .../net/ethernet/netronome/nfp/flower/offload.c | 25 ++++++++++++++ 3 files changed, 62 insertions(+), 7 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/flower/action.c b/drivers/net/ethernet/netronome/nfp/flower/action.c index ff2f419..1b019fd 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/action.c +++ b/drivers/net/ethernet/netronome/nfp/flower/action.c @@ -173,7 +173,7 @@ nfp_fl_output(struct nfp_app *app, struct nfp_fl_output *output, struct nfp_fl_payload *nfp_flow, bool last, struct net_device *in_dev, enum nfp_flower_tun_type tun_type, int *tun_out_cnt, - struct netlink_ext_ack *extack) + bool pkt_host, struct netlink_ext_ack *extack) { size_t act_size = sizeof(struct nfp_fl_output); struct nfp_flower_priv *priv = app->priv; @@ -218,6 +218,20 @@ nfp_fl_output(struct nfp_app *app, struct nfp_fl_output *output, return gid; } output->port = cpu_to_be32(NFP_FL_LAG_OUT | gid); + } else if (nfp_flower_internal_port_can_offload(app, out_dev)) { + if (!(priv->flower_ext_feats & NFP_FL_FEATS_PRE_TUN_RULES)) { + NL_SET_ERR_MSG_MOD(extack, "unsupported offload: pre-tunnel rules not supported in loaded firmware"); + return -EOPNOTSUPP; + } + + if (nfp_flow->pre_tun_rule.dev || !pkt_host) { + NL_SET_ERR_MSG_MOD(extack, "unsupported offload: pre-tunnel rules require single egress dev and ptype HOST action"); + return -EOPNOTSUPP; + } + + nfp_flow->pre_tun_rule.dev = out_dev; + + return 0; } else { /* Set action output parameters. */ output->flags = cpu_to_be16(tmp_flags); @@ -885,7 +899,7 @@ nfp_flower_output_action(struct nfp_app *app, struct nfp_fl_payload *nfp_fl, int *a_len, struct net_device *netdev, bool last, enum nfp_flower_tun_type *tun_type, int *tun_out_cnt, - int *out_cnt, u32 *csum_updated, + int *out_cnt, u32 *csum_updated, bool pkt_host, struct netlink_ext_ack *extack) { struct nfp_flower_priv *priv = app->priv; @@ -907,7 +921,7 @@ nfp_flower_output_action(struct nfp_app *app, output = (struct nfp_fl_output *)&nfp_fl->action_data[*a_len]; err = nfp_fl_output(app, output, act, nfp_fl, last, netdev, *tun_type, - tun_out_cnt, extack); + tun_out_cnt, pkt_host, extack); if (err) return err; @@ -939,7 +953,7 @@ nfp_flower_loop_action(struct nfp_app *app, const struct flow_action_entry *act, struct net_device *netdev, enum nfp_flower_tun_type *tun_type, int *tun_out_cnt, int *out_cnt, u32 *csum_updated, - struct nfp_flower_pedit_acts *set_act, + struct nfp_flower_pedit_acts *set_act, bool *pkt_host, struct netlink_ext_ack *extack, int act_idx) { struct nfp_fl_set_ipv4_tun *set_tun; @@ -955,17 +969,21 @@ nfp_flower_loop_action(struct nfp_app *app, const struct flow_action_entry *act, case FLOW_ACTION_DROP: nfp_fl->meta.shortcut = cpu_to_be32(NFP_FL_SC_ACT_DROP); break; + case FLOW_ACTION_REDIRECT_INGRESS: case FLOW_ACTION_REDIRECT: err = nfp_flower_output_action(app, act, nfp_fl, a_len, netdev, true, tun_type, tun_out_cnt, - out_cnt, csum_updated, extack); + out_cnt, csum_updated, *pkt_host, + extack); if (err) return err; break; + case FLOW_ACTION_MIRRED_INGRESS: case FLOW_ACTION_MIRRED: err = nfp_flower_output_action(app, act, nfp_fl, a_len, netdev, false, tun_type, tun_out_cnt, - out_cnt, csum_updated, extack); + out_cnt, csum_updated, *pkt_host, + extack); if (err) return err; break; @@ -1095,6 +1113,13 @@ nfp_flower_loop_action(struct nfp_app *app, const struct flow_action_entry *act, nfp_fl_set_mpls(set_m, act); *a_len += sizeof(struct nfp_fl_set_mpls); break; + case FLOW_ACTION_PTYPE: + /* TC ptype skbedit sets PACKET_HOST for ingress redirect. */ + if (act->ptype != PACKET_HOST) + return -EOPNOTSUPP; + + *pkt_host = true; + break; default: /* Currently we do not handle any other actions. */ NL_SET_ERR_MSG_MOD(extack, "unsupported offload: unsupported action in action list"); @@ -1150,6 +1175,7 @@ int nfp_flower_compile_action(struct nfp_app *app, struct nfp_flower_pedit_acts set_act; enum nfp_flower_tun_type tun_type; struct flow_action_entry *act; + bool pkt_host = false; u32 csum_updated = 0; memset(nfp_flow->action_data, 0, NFP_FL_MAX_A_SIZ); @@ -1166,7 +1192,7 @@ int nfp_flower_compile_action(struct nfp_app *app, err = nfp_flower_loop_action(app, act, flow, nfp_flow, &act_len, netdev, &tun_type, &tun_out_cnt, &out_cnt, &csum_updated, - &set_act, extack, i); + &set_act, &pkt_host, extack, i); if (err) return err; act_cnt++; diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.h b/drivers/net/ethernet/netronome/nfp/flower/main.h index af9441d..6e9de4e 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/main.h +++ b/drivers/net/ethernet/netronome/nfp/flower/main.h @@ -42,6 +42,7 @@ struct nfp_app; #define NFP_FL_FEATS_VLAN_PCP BIT(3) #define NFP_FL_FEATS_VF_RLIM BIT(4) #define NFP_FL_FEATS_FLOW_MOD BIT(5) +#define NFP_FL_FEATS_PRE_TUN_RULES BIT(6) #define NFP_FL_FEATS_FLOW_MERGE BIT(30) #define NFP_FL_FEATS_LAG BIT(31) @@ -280,6 +281,9 @@ struct nfp_fl_payload { char *action_data; struct list_head linked_flows; bool in_hw; + struct { + struct net_device *dev; + } pre_tun_rule; }; struct nfp_fl_payload_link { diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c index 607426c..fba802a 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/offload.c +++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c @@ -489,6 +489,7 @@ nfp_flower_allocate_new(struct nfp_fl_key_ls *key_layer) flow_pay->meta.flags = 0; INIT_LIST_HEAD(&flow_pay->linked_flows); flow_pay->in_hw = false; + flow_pay->pre_tun_rule.dev = NULL; return flow_pay; @@ -997,6 +998,24 @@ int nfp_flower_merge_offloaded_flows(struct nfp_app *app, } /** + * nfp_flower_validate_pre_tun_rule() + * @app: Pointer to the APP handle + * @flow: Pointer to NFP flow representation of rule + * @extack: Netlink extended ACK report + * + * Verifies the flow as a pre-tunnel rule. + * + * Return: negative value on error, 0 if verified. + */ +static int +nfp_flower_validate_pre_tun_rule(struct nfp_app *app, + struct nfp_fl_payload *flow, + struct netlink_ext_ack *extack) +{ + return -EOPNOTSUPP; +} + +/** * nfp_flower_add_offload() - Adds a new flow to hardware. * @app: Pointer to the APP handle * @netdev: netdev structure. @@ -1046,6 +1065,12 @@ nfp_flower_add_offload(struct nfp_app *app, struct net_device *netdev, if (err) goto err_destroy_flow; + if (flow_pay->pre_tun_rule.dev) { + err = nfp_flower_validate_pre_tun_rule(app, flow_pay, extack); + if (err) + goto err_destroy_flow; + } + err = nfp_compile_flow_metadata(app, flow, flow_pay, netdev, extack); if (err) goto err_destroy_flow; From patchwork Sun Aug 4 15:09:09 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141769 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="qoW7rmtg"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqP5RRFz9sNy for ; Mon, 5 Aug 2019 01:10:41 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726605AbfHDPKg (ORCPT ); Sun, 4 Aug 2019 11:10:36 -0400 Received: from mail-wr1-f68.google.com ([209.85.221.68]:38538 "EHLO mail-wr1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726543AbfHDPKd (ORCPT ); Sun, 4 Aug 2019 11:10:33 -0400 Received: by mail-wr1-f68.google.com with SMTP id g17so81900922wrr.5 for ; Sun, 04 Aug 2019 08:10:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=6WfVzvr+z1cFmG2/oKx8s520jC63LbTyVpNuLYSU9f0=; b=qoW7rmtg7KoUDFeo2NioujCfPTOFWkeYAr96fW2nRZtnlGo4JpEZdyEc12+Ao0EH6U P6bboKfwHkGvlHdEnmOfOOVXpB5WWgYYn3cX8FTbOjYHavmlxCZDktD0BEOvGs/zsT5N D7p9BQ+1BQSLknFuiB0WLEd6clWrSvOBKtU0nrhrb1Blk4bqm/eUOA5ROimd6iixmeHl jaJfE8TfixArWAN+53zt/kCp1OLInZRvFaP/PkQBlB4+I7o8WU6uoosWG955oroLpFGp 7sIEJTc5ghzf2Gpg7+Ml8Hq/x7ggJU/rq3JuOUonbEoUlveYtksN2pi1a2epiTEba8qM Cd/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=6WfVzvr+z1cFmG2/oKx8s520jC63LbTyVpNuLYSU9f0=; b=dCrrM196r5PR1HORca4nffkFj1j1Mom0uMLTSiHaAuyMzs5nSwnUvr6sh2jTzUlzcE tfVQkGqqni6UBRSLDvejSYsxCuMmhpx3uTfA7yxNgajRfrLFPwAn1Pe/F1yC72wHAvrf De7Bpn9W9bE34QMe3aH1fZdGHlMjenp9eFZ3kGo/KOS+QFr5Qif0D7GzygeGtlnntDMF gn2l7VN+RQs8xm6hy8I3j483MR5KSgLdUAMxAUbncedtB8LCnaa0D1o+09O1bo06vBsk 99bDKxSHwfq/wGpE0QPR3Ceo+LEHYQNST46I2cpbu4xHgK2X4sYfYhed27CyDTzfQqyQ Cc8Q== X-Gm-Message-State: APjAAAV4q6YUBxvlm/YUBEjPeYMBSjj+6FmmBT5T4v4KLzmahYGk0Dd9 BCCgoojGRZmUV4X8f6XX+wd+kFSU9lQ= X-Google-Smtp-Source: APXvYqyvglc1qPvtJn29l6zVlnwYgfC+qFzqXt9FgpG7t7vBTsth5Sn/W3AUg5s3B/EEDqDDZMKMLQ== X-Received: by 2002:adf:fc52:: with SMTP id e18mr35095280wrs.14.1564931430757; Sun, 04 Aug 2019 08:10:30 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.29 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:30 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 07/10] nfp: flower: verify pre-tunnel rules Date: Sun, 4 Aug 2019 16:09:09 +0100 Message-Id: <1564931351-1036-8-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Pre-tunnel rules must direct packets to an internal port based on L2 information. Rules that egress to an internal port are already indicated by a non-NULL device in its nfp_fl_payload struct. Verfiy the rest of the match fields indicate that the rule is a pre-tunnel rule. This requires a full match on the destination MAC address, an option VLAN field, and no specific matches on other lower layer fields (with the exception of L4 proto and flags). If a rule is identified as a pre-tunnel rule then mark it for offload to the pre-tunnel table. Similarly, remove it from the pre-tunnel table on rule deletion. The actual offloading of these commands is left to a following patch. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/flower/main.h | 5 + .../net/ethernet/netronome/nfp/flower/offload.c | 103 ++++++++++++++++++++- .../ethernet/netronome/nfp/flower/tunnel_conf.c | 12 +++ 3 files changed, 115 insertions(+), 5 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.h b/drivers/net/ethernet/netronome/nfp/flower/main.h index 6e9de4e..c3aa415 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/main.h +++ b/drivers/net/ethernet/netronome/nfp/flower/main.h @@ -283,6 +283,7 @@ struct nfp_fl_payload { bool in_hw; struct { struct net_device *dev; + __be16 vlan_tci; } pre_tun_rule; }; @@ -419,4 +420,8 @@ void nfp_flower_non_repr_priv_put(struct nfp_app *app, struct net_device *netdev); u32 nfp_flower_get_port_id_from_netdev(struct nfp_app *app, struct net_device *netdev); +int nfp_flower_xmit_pre_tun_flow(struct nfp_app *app, + struct nfp_fl_payload *flow); +int nfp_flower_xmit_pre_tun_del_flow(struct nfp_app *app, + struct nfp_fl_payload *flow); #endif diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c index fba802a..ff8a9f1 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/offload.c +++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c @@ -61,6 +61,11 @@ NFP_FLOWER_LAYER_IPV4 | \ NFP_FLOWER_LAYER_IPV6) +#define NFP_FLOWER_PRE_TUN_RULE_FIELDS \ + (NFP_FLOWER_LAYER_PORT | \ + NFP_FLOWER_LAYER_MAC | \ + NFP_FLOWER_LAYER_IPV4) + struct nfp_flower_merge_check { union { struct { @@ -1012,7 +1017,89 @@ nfp_flower_validate_pre_tun_rule(struct nfp_app *app, struct nfp_fl_payload *flow, struct netlink_ext_ack *extack) { - return -EOPNOTSUPP; + struct nfp_flower_meta_tci *meta_tci; + struct nfp_flower_mac_mpls *mac; + struct nfp_fl_act_head *act; + u8 *mask = flow->mask_data; + bool vlan = false; + int act_offset; + u8 key_layer; + + meta_tci = (struct nfp_flower_meta_tci *)flow->unmasked_data; + if (meta_tci->tci & cpu_to_be16(NFP_FLOWER_MASK_VLAN_PRESENT)) { + u16 vlan_tci = be16_to_cpu(meta_tci->tci); + + vlan_tci &= ~NFP_FLOWER_MASK_VLAN_PRESENT; + flow->pre_tun_rule.vlan_tci = cpu_to_be16(vlan_tci); + vlan = true; + } else { + flow->pre_tun_rule.vlan_tci = cpu_to_be16(0xffff); + } + + key_layer = meta_tci->nfp_flow_key_layer; + if (key_layer & ~NFP_FLOWER_PRE_TUN_RULE_FIELDS) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: too many match fields"); + return -EOPNOTSUPP; + } + + if (!(key_layer & NFP_FLOWER_LAYER_MAC)) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: MAC fields match required"); + return -EOPNOTSUPP; + } + + /* Skip fields known to exist. */ + mask += sizeof(struct nfp_flower_meta_tci); + mask += sizeof(struct nfp_flower_in_port); + + /* Ensure destination MAC address is fully matched. */ + mac = (struct nfp_flower_mac_mpls *)mask; + if (!is_broadcast_ether_addr(&mac->mac_dst[0])) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: dest MAC field must not be masked"); + return -EOPNOTSUPP; + } + + if (key_layer & NFP_FLOWER_LAYER_IPV4) { + int ip_flags = offsetof(struct nfp_flower_ipv4, ip_ext.flags); + int ip_proto = offsetof(struct nfp_flower_ipv4, ip_ext.proto); + int i; + + mask += sizeof(struct nfp_flower_mac_mpls); + + /* Ensure proto and flags are the only IP layer fields. */ + for (i = 0; i < sizeof(struct nfp_flower_ipv4); i++) + if (mask[i] && i != ip_flags && i != ip_proto) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: only flags and proto can be matched in ip header"); + return -EOPNOTSUPP; + } + } + + /* Action must be a single egress or pop_vlan and egress. */ + act_offset = 0; + act = (struct nfp_fl_act_head *)&flow->action_data[act_offset]; + if (vlan) { + if (act->jump_id != NFP_FL_ACTION_OPCODE_POP_VLAN) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: match on VLAN must have VLAN pop as first action"); + return -EOPNOTSUPP; + } + + act_offset += act->len_lw << NFP_FL_LW_SIZ; + act = (struct nfp_fl_act_head *)&flow->action_data[act_offset]; + } + + if (act->jump_id != NFP_FL_ACTION_OPCODE_OUTPUT) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: non egress action detected where egress was expected"); + return -EOPNOTSUPP; + } + + act_offset += act->len_lw << NFP_FL_LW_SIZ; + + /* Ensure there are no more actions after egress. */ + if (act_offset != flow->meta.act_len) { + NL_SET_ERR_MSG_MOD(extack, "unsupported pre-tunnel rule: egress is not the last action"); + return -EOPNOTSUPP; + } + + return 0; } /** @@ -1083,8 +1170,11 @@ nfp_flower_add_offload(struct nfp_app *app, struct net_device *netdev, goto err_release_metadata; } - err = nfp_flower_xmit_flow(app, flow_pay, - NFP_FLOWER_CMSG_TYPE_FLOW_ADD); + if (flow_pay->pre_tun_rule.dev) + err = nfp_flower_xmit_pre_tun_flow(app, flow_pay); + else + err = nfp_flower_xmit_flow(app, flow_pay, + NFP_FLOWER_CMSG_TYPE_FLOW_ADD); if (err) goto err_remove_rhash; @@ -1226,8 +1316,11 @@ nfp_flower_del_offload(struct nfp_app *app, struct net_device *netdev, goto err_free_merge_flow; } - err = nfp_flower_xmit_flow(app, nfp_flow, - NFP_FLOWER_CMSG_TYPE_FLOW_DEL); + if (nfp_flow->pre_tun_rule.dev) + err = nfp_flower_xmit_pre_tun_del_flow(app, nfp_flow); + else + err = nfp_flower_xmit_flow(app, nfp_flow, + NFP_FLOWER_CMSG_TYPE_FLOW_DEL); /* Fall through on error. */ err_free_merge_flow: diff --git a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c index a7a80f4..ef59481 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c +++ b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c @@ -832,6 +832,18 @@ int nfp_tunnel_mac_event_handler(struct nfp_app *app, return NOTIFY_OK; } +int nfp_flower_xmit_pre_tun_flow(struct nfp_app *app, + struct nfp_fl_payload *flow) +{ + return -EOPNOTSUPP; +} + +int nfp_flower_xmit_pre_tun_del_flow(struct nfp_app *app, + struct nfp_fl_payload *flow) +{ + return -EOPNOTSUPP; +} + int nfp_tunnel_config_start(struct nfp_app *app) { struct nfp_flower_priv *priv = app->priv; From patchwork Sun Aug 4 15:09:10 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141768 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="FQ0z6GMf"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqP1nd4z9sN4 for ; Mon, 5 Aug 2019 01:10:41 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726595AbfHDPKf (ORCPT ); Sun, 4 Aug 2019 11:10:35 -0400 Received: from mail-wm1-f67.google.com ([209.85.128.67]:35535 "EHLO mail-wm1-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726181AbfHDPKd (ORCPT ); Sun, 4 Aug 2019 11:10:33 -0400 Received: by mail-wm1-f67.google.com with SMTP id l2so70694272wmg.0 for ; Sun, 04 Aug 2019 08:10:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=Jg2wyoo3g25hCeZErv+8EFH5iIbv9sukQwz3mMdTMsg=; b=FQ0z6GMfVyam+INAAiuoI5obtMXqUDMEb59Jm03s0MQrHLQfqFz025YcAXMmBXCpSo h6PQfvCx3+lj38PwmP/ct7hB3xg2/3PE5OUZvyHvNQU8sLbWJDh3OZ8tu5nneqwCmwFd gJv4BKI+YrYvNkqeuLUBECsGhXsmB4W90eG7sBrZ9BT4P8w/Y+WxiE7X2ccLWCR3yH4R gvhY1jdyms8t4Bj49yhkcAqC7f9NrUobFTGgZTh778uuYtR96T0u3jkYr4tc6n/ZculE GVyhepwP3Vh9mpyTXGDAN0T7sA+r/7c+10iil+a+QTuHuJsBZzRii6dDHc1oe75FA7Vm LDYA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=Jg2wyoo3g25hCeZErv+8EFH5iIbv9sukQwz3mMdTMsg=; b=fBFMsNYktdlG9OcKa0A99tLEMHUHBbeEH8pE18tFIqqRWm3H8zLCQabSgWdbVezjfi 6tnalqWZUMDd+OYP4YKH2mxdcnn92bh/PC5GwKVIf3gLELUz5WYmK3hOz111teo2NXcb gGEzlA1QhPS3g/G3t3thZMovDjCaWvmdM0IX7XTaRJOuaIFztkyFcKHKS2vxwxqn4LkB hJo1lmCrx6TpMBbukgcBqc23OGeK2cCYEcyfSZLRet4GWDBOOzjMWHpu5O5hcpiyBMy4 MytUd26rCSnbu9Pd/aSw2E4Z4Zf+aAkJgimoMMGjOl1yBrf0ZGe2exPa5+pLJ5L2x1zt yUTg== X-Gm-Message-State: APjAAAWEeCsxBDpnRBQJEtAPiAk9MkBzZFAI81ftrC9Y4pMDssOIPlfd XO2MuP4C7UGjgqRH/qDrjKyroefcek8= X-Google-Smtp-Source: APXvYqz9ueY7TLvUShNkAQVjoRnwSD5fq0TTO7d7mQWeSy4Amg7k7AAFizslmKBxj86d4CLRpzLkgA== X-Received: by 2002:a7b:c206:: with SMTP id x6mr14106741wmi.156.1564931431701; Sun, 04 Aug 2019 08:10:31 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.30 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:31 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 08/10] nfp: flower: offload pre-tunnel rules Date: Sun, 4 Aug 2019 16:09:10 +0100 Message-Id: <1564931351-1036-9-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Pre-tunnel rules are TC flower and OvS rules that forward a packet to the tunnel end point where it can then pass through the network stack and be decapsulated. These are required if the tunnel end point is, say, an OvS internal port. Currently, firmware determines that a packet is in a tunnel and decaps it if it has a known destination IP and MAC address. However, this bypasses the flower pre-tunnel rule and so does not update the stats. Further to this it ignores VLANs that may exist outside of the tunnel header. Offload pre-tunnel rules to the NFP. This embeds the pre-tunnel rule into the tunnel decap process based on (firmware) mac index and VLAN. This means that decap can be carried out correctly with VLANs and that stats can be updated for all kernel rules correctly. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/flower/cmsg.h | 1 + drivers/net/ethernet/netronome/nfp/flower/main.c | 1 + drivers/net/ethernet/netronome/nfp/flower/main.h | 3 + .../ethernet/netronome/nfp/flower/tunnel_conf.c | 79 +++++++++++++++++++++- 4 files changed, 82 insertions(+), 2 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h index caf3029..7eb2ec8 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h +++ b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h @@ -484,6 +484,7 @@ enum nfp_flower_cmsg_type_port { NFP_FLOWER_CMSG_TYPE_QOS_MOD = 18, NFP_FLOWER_CMSG_TYPE_QOS_DEL = 19, NFP_FLOWER_CMSG_TYPE_QOS_STATS = 20, + NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE = 21, NFP_FLOWER_CMSG_TYPE_MAX = 32, }; diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.c b/drivers/net/ethernet/netronome/nfp/flower/main.c index eb84613..7a20447 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/main.c +++ b/drivers/net/ethernet/netronome/nfp/flower/main.c @@ -781,6 +781,7 @@ static int nfp_flower_init(struct nfp_app *app) INIT_LIST_HEAD(&app_priv->indr_block_cb_priv); INIT_LIST_HEAD(&app_priv->non_repr_priv); + app_priv->pre_tun_rule_cnt = 0; return 0; diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.h b/drivers/net/ethernet/netronome/nfp/flower/main.h index c3aa415..5d302d7 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/main.h +++ b/drivers/net/ethernet/netronome/nfp/flower/main.h @@ -163,6 +163,7 @@ struct nfp_fl_internal_ports { * @qos_stats_work: Workqueue for qos stats processing * @qos_rate_limiters: Current active qos rate limiters * @qos_stats_lock: Lock on qos stats updates + * @pre_tun_rule_cnt: Number of pre-tunnel rules offloaded */ struct nfp_flower_priv { struct nfp_app *app; @@ -194,6 +195,7 @@ struct nfp_flower_priv { struct delayed_work qos_stats_work; unsigned int qos_rate_limiters; spinlock_t qos_stats_lock; /* Protect the qos stats */ + int pre_tun_rule_cnt; }; /** @@ -284,6 +286,7 @@ struct nfp_fl_payload { struct { struct net_device *dev; __be16 vlan_tci; + __be16 port_idx; } pre_tun_rule; }; diff --git a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c index ef59481..b9dbfb7 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c +++ b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c @@ -15,6 +15,23 @@ #define NFP_FL_MAX_ROUTES 32 +#define NFP_TUN_PRE_TUN_RULE_LIMIT 32 +#define NFP_TUN_PRE_TUN_RULE_DEL 0x1 + +/** + * struct nfp_tun_pre_run_rule - rule matched before decap + * @flags: options for the rule offset + * @port_idx: index of destination MAC address for the rule + * @vlan_tci: VLAN info associated with MAC + * @host_ctx_id: stats context of rule to update + */ +struct nfp_tun_pre_tun_rule { + __be32 flags; + __be16 port_idx; + __be16 vlan_tci; + __be32 host_ctx_id; +}; + /** * struct nfp_tun_active_tuns - periodic message of active tunnels * @seq: sequence number of the message @@ -835,13 +852,71 @@ int nfp_tunnel_mac_event_handler(struct nfp_app *app, int nfp_flower_xmit_pre_tun_flow(struct nfp_app *app, struct nfp_fl_payload *flow) { - return -EOPNOTSUPP; + struct nfp_flower_priv *app_priv = app->priv; + struct nfp_tun_offloaded_mac *mac_entry; + struct nfp_tun_pre_tun_rule payload; + struct net_device *internal_dev; + int err; + + if (app_priv->pre_tun_rule_cnt == NFP_TUN_PRE_TUN_RULE_LIMIT) + return -ENOSPC; + + memset(&payload, 0, sizeof(struct nfp_tun_pre_tun_rule)); + + internal_dev = flow->pre_tun_rule.dev; + payload.vlan_tci = flow->pre_tun_rule.vlan_tci; + payload.host_ctx_id = flow->meta.host_ctx_id; + + /* Lookup MAC index for the pre-tunnel rule egress device. + * Note that because the device is always an internal port, it will + * have a constant global index so does not need to be tracked. + */ + mac_entry = nfp_tunnel_lookup_offloaded_macs(app, + internal_dev->dev_addr); + if (!mac_entry) + return -ENOENT; + + payload.port_idx = cpu_to_be16(mac_entry->index); + + /* Copy mac id and vlan to flow - dev may not exist at delete time. */ + flow->pre_tun_rule.vlan_tci = payload.vlan_tci; + flow->pre_tun_rule.port_idx = payload.port_idx; + + err = nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE, + sizeof(struct nfp_tun_pre_tun_rule), + (unsigned char *)&payload, GFP_KERNEL); + if (err) + return err; + + app_priv->pre_tun_rule_cnt++; + + return 0; } int nfp_flower_xmit_pre_tun_del_flow(struct nfp_app *app, struct nfp_fl_payload *flow) { - return -EOPNOTSUPP; + struct nfp_flower_priv *app_priv = app->priv; + struct nfp_tun_pre_tun_rule payload; + u32 tmp_flags = 0; + int err; + + memset(&payload, 0, sizeof(struct nfp_tun_pre_tun_rule)); + + tmp_flags |= NFP_TUN_PRE_TUN_RULE_DEL; + payload.flags = cpu_to_be32(tmp_flags); + payload.vlan_tci = flow->pre_tun_rule.vlan_tci; + payload.port_idx = flow->pre_tun_rule.port_idx; + + err = nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE, + sizeof(struct nfp_tun_pre_tun_rule), + (unsigned char *)&payload, GFP_KERNEL); + if (err) + return err; + + app_priv->pre_tun_rule_cnt--; + + return 0; } int nfp_tunnel_config_start(struct nfp_app *app) From patchwork Sun Aug 4 15:09:11 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141771 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="kgJ5LHe9"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqR6kc2z9sN6 for ; Mon, 5 Aug 2019 01:10:43 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726621AbfHDPKk (ORCPT ); Sun, 4 Aug 2019 11:10:40 -0400 Received: from mail-wr1-f66.google.com ([209.85.221.66]:37323 "EHLO mail-wr1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726524AbfHDPKf (ORCPT ); Sun, 4 Aug 2019 11:10:35 -0400 Received: by mail-wr1-f66.google.com with SMTP id n9so56825489wrr.4 for ; Sun, 04 Aug 2019 08:10:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=bGr223WMRrbUFbfPwA0NQPu1Jr1GMcU7LLzKSfcbQ1o=; b=kgJ5LHe96h2/hKmYsaqzfXm9ug0/P1PoaDhKdFbQnZyGJeyHf5vFTGBkKFPpT10qZZ 0OeLWrXyjI2MyMlv7XESuMbwODFtzLHeJ1qWYs+VSGvz6rvXNJw5pp/w2ihhWrDNukRM bH4bwrVrJOB1ubDaJxm3FzeriVrZ7ar22DwT4uKDm9SgKoiWZJTdxiAyd7r9uK7a3+aV Jb82TfmTXMw0qETkpu2VHwOuscxFzAPiMWZCzJrXl4WvSrHl0UDdZJG2WNbGez/iCbwt zH3/WYHHKoackmlbaZ4Ds5M7FfbM6SGM+vD+HJPh3fEaxlR65L6XbuE/eU6sStDhWJ+K j5UQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=bGr223WMRrbUFbfPwA0NQPu1Jr1GMcU7LLzKSfcbQ1o=; b=YqeR2M2Bhioc8hNNzvQ3+0E4hnwukQlPFwU4QJuYd3lHS2JnFMdCaGawmubr5Lu6Hm NVLZNcTuRfb+QFMYkJj5jYDlLFyHopXEdoRxYdbzqvJRbqevTdCVCuQ5aKb74FpkOqJi YNoGsxrITF8oA6n5SReYiZOYvROGqumQ1JLlBGNxunGfssH+oPQ+Yi6nHMVl0XkvtrLN VmAR3xuCKITdFXbEff+9P7KYYucWEoSrbXkmun07cNbdo5mKISy4YX75DueEg5QZllQm sQCdFeFQ1RhBr/gIBtWz5DjGWQ1qrIS4QXnw9sslPPr839LM3xGUVHbbCqhxBsblssoz KKqg== X-Gm-Message-State: APjAAAVr0vpmPNiPbPut8ZeoShXS9Fw74YOwAsdxBmrc0ZT5OLEcGzyQ An8bja+cVb+ESLzb4EkzpJKLgPasVRM= X-Google-Smtp-Source: APXvYqx36oFJSlGIX60fJtH2JeP+2of+YSi0h/7pJiaebFQoR8WmUtG6iqQVjb1n7fqlqi5g5f6dOw== X-Received: by 2002:adf:e941:: with SMTP id m1mr6664505wrn.279.1564931432828; Sun, 04 Aug 2019 08:10:32 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id l9sm63769441wmh.36.2019.08.04.08.10.31 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:32 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 09/10] nfp: flower: remove offloaded MACs when reprs are applied to OvS bridges Date: Sun, 4 Aug 2019 16:09:11 +0100 Message-Id: <1564931351-1036-10-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> References: <1564931351-1036-1-git-send-email-john.hurley@netronome.com> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org MAC addresses along with an identifying index are offloaded to firmware to allow tunnel decapsulation. If a tunnel packet arrives with a matching destination MAC address and a verified index, it can continue on the decapsulation process. This replicates the MAC verifications carried out in the kernel network stack. When a netdev is added to a bridge (e.g. OvS) then packets arriving on that dev are directed through the bridge datapath instead of passing through the network stack. Therefore, tunnelled packets matching the MAC of that dev will not be decapped here. Replicate this behaviour on firmware by removing offloaded MAC addresses when a MAC representer is added to an OvS bridge. This can prevent any false positive tunnel decaps. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/flower/main.h | 7 ++++ .../ethernet/netronome/nfp/flower/tunnel_conf.c | 42 ++++++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.h b/drivers/net/ethernet/netronome/nfp/flower/main.h index 5d302d7..31d9459 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/main.h +++ b/drivers/net/ethernet/netronome/nfp/flower/main.h @@ -221,6 +221,7 @@ struct nfp_fl_qos { * @block_shared: Flag indicating if offload applies to shared blocks * @mac_list: List entry of reprs that share the same offloaded MAC * @qos_table: Stored info on filters implementing qos + * @on_bridge: Indicates if the repr is attached to a bridge */ struct nfp_flower_repr_priv { struct nfp_repr *nfp_repr; @@ -230,6 +231,7 @@ struct nfp_flower_repr_priv { bool block_shared; struct list_head mac_list; struct nfp_fl_qos qos_table; + bool on_bridge; }; /** @@ -341,6 +343,11 @@ static inline bool nfp_flower_is_merge_flow(struct nfp_fl_payload *flow_pay) return flow_pay->tc_flower_cookie == (unsigned long)flow_pay; } +static inline bool nfp_flower_is_supported_bridge(struct net_device *netdev) +{ + return netif_is_ovs_master(netdev); +} + int nfp_flower_metadata_init(struct nfp_app *app, u64 host_ctx_count, unsigned int host_ctx_split); void nfp_flower_metadata_cleanup(struct nfp_app *app); diff --git a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c index b9dbfb7..a61e7f2 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c +++ b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c @@ -730,6 +730,9 @@ nfp_tunnel_offload_mac(struct nfp_app *app, struct net_device *netdev, return 0; repr_priv = repr->app_priv; + if (repr_priv->on_bridge) + return 0; + mac_offloaded = &repr_priv->mac_offloaded; off_mac = &repr_priv->offloaded_mac_addr[0]; port = nfp_repr_get_port_id(netdev); @@ -845,6 +848,45 @@ int nfp_tunnel_mac_event_handler(struct nfp_app *app, if (err) nfp_flower_cmsg_warn(app, "Failed to offload MAC change on %s.\n", netdev_name(netdev)); + } else if (event == NETDEV_CHANGEUPPER) { + /* If a repr is attached to a bridge then tunnel packets + * entering the physical port are directed through the bridge + * datapath and cannot be directly detunneled. Therefore, + * associated offloaded MACs and indexes should not be used + * by fw for detunneling. + */ + struct netdev_notifier_changeupper_info *info = ptr; + struct net_device *upper = info->upper_dev; + struct nfp_flower_repr_priv *repr_priv; + struct nfp_repr *repr; + + if (!nfp_netdev_is_nfp_repr(netdev) || + !nfp_flower_is_supported_bridge(upper)) + return NOTIFY_OK; + + repr = netdev_priv(netdev); + if (repr->app != app) + return NOTIFY_OK; + + repr_priv = repr->app_priv; + + if (info->linking) { + if (nfp_tunnel_offload_mac(app, netdev, + NFP_TUNNEL_MAC_OFFLOAD_DEL)) + nfp_flower_cmsg_warn(app, "Failed to delete offloaded MAC on %s.\n", + netdev_name(netdev)); + repr_priv->on_bridge = true; + } else { + repr_priv->on_bridge = false; + + if (!(netdev->flags & IFF_UP)) + return NOTIFY_OK; + + if (nfp_tunnel_offload_mac(app, netdev, + NFP_TUNNEL_MAC_OFFLOAD_ADD)) + nfp_flower_cmsg_warn(app, "Failed to offload MAC on %s.\n", + netdev_name(netdev)); + } } return NOTIFY_OK; } From patchwork Sun Aug 4 15:10:49 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Hurley X-Patchwork-Id: 1141773 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="vaqMpBjt"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 461kqp3m7Kz9sDB for ; Mon, 5 Aug 2019 01:11:02 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726659AbfHDPLB (ORCPT ); Sun, 4 Aug 2019 11:11:01 -0400 Received: from mail-wm1-f68.google.com ([209.85.128.68]:40158 "EHLO mail-wm1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726190AbfHDPLB (ORCPT ); Sun, 4 Aug 2019 11:11:01 -0400 Received: by mail-wm1-f68.google.com with SMTP id v19so70754529wmj.5 for ; Sun, 04 Aug 2019 08:10:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id; bh=xPBgLlcvH5hwo9tAoKvRN7BFd4s2xUaRMMATVlCRpaA=; b=vaqMpBjtOO89g98bBUEtFPka+lg3JOr5ObJDZnJHT2eSmRBgWdoXts4rQV+p1mB07k uRqC6QdHR7v7Cd1zK5IH8isr4U3PU58LzGExcexUEW2m7uHrzkAc/EGFlRrIGlWVvz2m +r/+o3xn/hXgPd4hfSDW1FAhAl540bUvS+mi0fVxb/GDlm2NeZB1Npy4PpcHhY6cAn5r QRhC3CQU8/2zj4AvRB7q9qkiJgS9umOUtkx65DusNanAUZQ7HMdH0Wa5BhBqJZFiTxsX 7p6KYoa3htGydaEzdrk4reR/DHNN15xW4IbRGa/BN1wqh/66/tDJPCnJugULDybpf4Mn mkjQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=xPBgLlcvH5hwo9tAoKvRN7BFd4s2xUaRMMATVlCRpaA=; b=aiTYdZBj/X1ZkyM0X2LuLX4GwxpBrHpqF5MHp3OjH3vrSYMyt8U5KkwW0o1Rkxum+8 1mS8mUuzW3BChldMsSP3efD8vh1TtST0Qa9YO3aV//f3jXLQ0AoRnyeUCeQaEaE6/BT/ wnIhgrSTo83GFfbmHw5CSMV/B/zCMUR1KhJEf3tzriPh5wT0x94ZbdMzxR6MVPzUHKQM VkS/bXUHiDj9/OVUGGd00o4v1ExVuMxQKWWVUVY5YXz4caHpaaWha5DD3jNGAnxkh9Eh qMti+20QYneaATCoSdn4bqiOEgEvJ8NjQFzGzpX+0ipxB+o57s4nA+x14zSNEKVSepP8 dE3g== X-Gm-Message-State: APjAAAXZnIPXoxcj88T0ZvmB0bgJHSPR09N/6EtInHs5t+73SA3gZ2AH qVvYOddRRxSy0Gi9vyH9wRpShcsIVX0= X-Google-Smtp-Source: APXvYqyGD7lPz51op+gjn2d8apB2hy06w74POaP90Q6qxUCQZcGFH7dJvHzNKVIv26rOCBGBTgiZ5Q== X-Received: by 2002:a1c:3b02:: with SMTP id i2mr13545523wma.23.1564931458626; Sun, 04 Aug 2019 08:10:58 -0700 (PDT) Received: from jhurley-Precision-Tower-3420.netronome.com ([80.76.204.157]) by smtp.gmail.com with ESMTPSA id z1sm103728510wrv.90.2019.08.04.08.10.57 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sun, 04 Aug 2019 08:10:58 -0700 (PDT) From: John Hurley To: netdev@vger.kernel.org Cc: davem@davemloft.net, simon.horman@netronome.com, jakub.kicinski@netronome.com, oss-drivers@netronome.com, John Hurley Subject: [PATCH net-next 10/10] nfp: flower: encode mac indexes with pre-tunnel rule check Date: Sun, 4 Aug 2019 16:10:49 +0100 Message-Id: <1564931449-1225-1-git-send-email-john.hurley@netronome.com> X-Mailer: git-send-email 2.7.4 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org When a tunnel packet arrives on the NFP card, its destination MAC is looked up and MAC index returned for it. This index can help verify the tunnel by, for example, ensuring that the packet arrived on the expected port. If the packet is destined for a known MAC that is not connected to a given physical port then the mac index can have a global value (e.g. when a series of bonded ports shared the same MAC). If the packet is to be detunneled at a bridge device or internal port like an Open vSwitch VLAN port, then it should first match a 'pre-tunnel' rule to direct it to that internal port. Use the MAC index to indicate if a packet should match a pre-tunnel rule before decap is allowed. Do this by tracking the number of internal ports associated with a MAC address and, if the number if >0, set a bit in the mac_index to forward the packet to the pre-tunnel table before continuing with decap. Signed-off-by: John Hurley Reviewed-by: Simon Horman Acked-by: Jakub Kicinski --- .../ethernet/netronome/nfp/flower/tunnel_conf.c | 71 +++++++++++++++++----- 1 file changed, 55 insertions(+), 16 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c index a61e7f2..def8c19 100644 --- a/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c +++ b/drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c @@ -17,6 +17,7 @@ #define NFP_TUN_PRE_TUN_RULE_LIMIT 32 #define NFP_TUN_PRE_TUN_RULE_DEL 0x1 +#define NFP_TUN_PRE_TUN_IDX_BIT 0x8 /** * struct nfp_tun_pre_run_rule - rule matched before decap @@ -141,11 +142,12 @@ enum nfp_flower_mac_offload_cmd { /** * struct nfp_tun_offloaded_mac - hashtable entry for an offloaded MAC - * @ht_node: Hashtable entry - * @addr: Offloaded MAC address - * @index: Offloaded index for given MAC address - * @ref_count: Number of devs using this MAC address - * @repr_list: List of reprs sharing this MAC address + * @ht_node: Hashtable entry + * @addr: Offloaded MAC address + * @index: Offloaded index for given MAC address + * @ref_count: Number of devs using this MAC address + * @repr_list: List of reprs sharing this MAC address + * @bridge_count: Number of bridge/internal devs with MAC */ struct nfp_tun_offloaded_mac { struct rhash_head ht_node; @@ -153,6 +155,7 @@ struct nfp_tun_offloaded_mac { u16 index; int ref_count; struct list_head repr_list; + int bridge_count; }; static const struct rhashtable_params offloaded_macs_params = { @@ -573,6 +576,8 @@ nfp_tunnel_offloaded_macs_inc_ref_and_link(struct nfp_tun_offloaded_mac *entry, list_del(&repr_priv->mac_list); list_add_tail(&repr_priv->mac_list, &entry->repr_list); + } else if (nfp_flower_is_supported_bridge(netdev)) { + entry->bridge_count++; } entry->ref_count++; @@ -589,20 +594,35 @@ nfp_tunnel_add_shared_mac(struct nfp_app *app, struct net_device *netdev, entry = nfp_tunnel_lookup_offloaded_macs(app, netdev->dev_addr); if (entry && nfp_tunnel_is_mac_idx_global(entry->index)) { - nfp_tunnel_offloaded_macs_inc_ref_and_link(entry, netdev, mod); - return 0; + if (entry->bridge_count || + !nfp_flower_is_supported_bridge(netdev)) { + nfp_tunnel_offloaded_macs_inc_ref_and_link(entry, + netdev, mod); + return 0; + } + + /* MAC is global but matches need to go to pre_tun table. */ + nfp_mac_idx = entry->index | NFP_TUN_PRE_TUN_IDX_BIT; } - /* Assign a global index if non-repr or MAC address is now shared. */ - if (entry || !port) { - ida_idx = ida_simple_get(&priv->tun.mac_off_ids, 0, - NFP_MAX_MAC_INDEX, GFP_KERNEL); - if (ida_idx < 0) - return ida_idx; + if (!nfp_mac_idx) { + /* Assign a global index if non-repr or MAC is now shared. */ + if (entry || !port) { + ida_idx = ida_simple_get(&priv->tun.mac_off_ids, 0, + NFP_MAX_MAC_INDEX, GFP_KERNEL); + if (ida_idx < 0) + return ida_idx; - nfp_mac_idx = nfp_tunnel_get_global_mac_idx_from_ida(ida_idx); - } else { - nfp_mac_idx = nfp_tunnel_get_mac_idx_from_phy_port_id(port); + nfp_mac_idx = + nfp_tunnel_get_global_mac_idx_from_ida(ida_idx); + + if (nfp_flower_is_supported_bridge(netdev)) + nfp_mac_idx |= NFP_TUN_PRE_TUN_IDX_BIT; + + } else { + nfp_mac_idx = + nfp_tunnel_get_mac_idx_from_phy_port_id(port); + } } if (!entry) { @@ -671,6 +691,25 @@ nfp_tunnel_del_shared_mac(struct nfp_app *app, struct net_device *netdev, list_del(&repr_priv->mac_list); } + if (nfp_flower_is_supported_bridge(netdev)) { + entry->bridge_count--; + + if (!entry->bridge_count && entry->ref_count) { + u16 nfp_mac_idx; + + nfp_mac_idx = entry->index & ~NFP_TUN_PRE_TUN_IDX_BIT; + if (__nfp_tunnel_offload_mac(app, mac, nfp_mac_idx, + false)) { + nfp_flower_cmsg_warn(app, "MAC offload index revert failed on %s.\n", + netdev_name(netdev)); + return 0; + } + + entry->index = nfp_mac_idx; + return 0; + } + } + /* If MAC is now used by 1 repr set the offloaded MAC index to port. */ if (entry->ref_count == 1 && list_is_singular(&entry->repr_list)) { u16 nfp_mac_idx;