From patchwork Thu Sep 28 21:48:16 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819758 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="fzE98R3e"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37c84nd8z9sP1 for ; Fri, 29 Sep 2017 07:48:40 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1750905AbdI1Vsi (ORCPT ); Thu, 28 Sep 2017 17:48:38 -0400 Received: from mail-pg0-f47.google.com ([74.125.83.47]:51875 "EHLO mail-pg0-f47.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750805AbdI1Vsh (ORCPT ); Thu, 28 Sep 2017 17:48:37 -0400 Received: by mail-pg0-f47.google.com with SMTP id k193so1638596pgc.8 for ; Thu, 28 Sep 2017 14:48:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id; bh=AaAztvPItaCFVH9tVzciN3BIK+V8OShKTklRoUhWVWc=; b=fzE98R3eg6r5n6A3gZgy8Iw6NkKRIxZGVYbY9ImKghIrWzKwSpH+9c1Qg1S1D9FU/R twa9jTq6ELHL+DHY5dlrmyAkk2VLuFmKCFls3d6XCJJ98UOaU6Vz2Hwn3aZsW/yhavDj atA5L0DzE7p/inM5JdJtITFEl1BLlQwN9zJI/5Q0If3BSwcLroh7iJopLCOPFz/B7OQh ocIVLEgsphPKYCeyaHT/1FO+q32cfK+/8bAhy1/gYFDd/rmpiM/x6KutfUx1GD1XlpwA wuWYGdl5pixDmJXUp5x3CFRLX2uzCrgdCm0EfzAnQ55vyikr1h2nCLTcNpaQFkCiF3Dr BIHg== 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=AaAztvPItaCFVH9tVzciN3BIK+V8OShKTklRoUhWVWc=; b=WpY2ZNz+PaaXwl1IWMQKpvxnqTUL6AisbSgCXkmQ4esPjk1GoA0qecDziJzeTXggL5 NtnXdDYKdLgGCWh7Px3nolo5LpigjHBD5qs0UcChuuMt4CPeAdMtDviTqvSkGW0e9X1x 5MLyuJhPX60oaCAe0rygl/VCK071dEl0JmajjlPFCL3c+EKcDjPtU84VvkmzB1KtRVOX oM2OPjy2KEHku6OKkl+bPJTVCCzo+CWMcF1E3SEUp4ohXKghAmD+B1KhiiMI9nGpOxAh oZH6atw+BDmWaxBAr1uLepUvPUTKlqLqRE3IsAnZwooMQZ8Y4tUkn2PT4DFVx7FS3l7d In5g== X-Gm-Message-State: AHPjjUjyUOFAItwxcjPTiAEr5A3/MfeWeGB49K1G2Q0yRlDbFqOEeSFx jhc+XAuZn7/OV4kqP8FX7E+KlA== X-Google-Smtp-Source: AOwi7QDqUARju6drfb6pAL2zqQbpiprUvPUYs02sQ1wWYIFQPJRjWlxz0acezCKBMASUpBAgrakPOg== X-Received: by 10.99.114.29 with SMTP id n29mr5241162pgc.26.1506635316998; Thu, 28 Sep 2017 14:48:36 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.35 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:36 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 1/8] flow_dissector: Change skbuf argument to be non const Date: Thu, 28 Sep 2017 14:48:16 -0700 Message-Id: <20170928214823.2426-1-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Change the skbuf argument of __skb_flow_dissect to be non constant so that the function can call functions that take non constant skbuf arguments. This is needed if we are to call socket lookup or BPF in the flow dissector path. The changes include unraveling the call chain into __skb_flow_dissect so that those also use non constant skbufs. Signed-off-by: Tom Herbert --- include/linux/skbuff.h | 12 ++++++------ include/net/ip_fib.h | 4 ++-- include/net/route.h | 4 ++-- net/core/flow_dissector.c | 10 +++++----- net/ipv4/fib_semantics.c | 2 +- net/ipv4/route.c | 6 +++--- net/sched/sch_sfq.c | 2 +- 7 files changed, 20 insertions(+), 20 deletions(-) diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h index 19e64bfb1a66..5a6e765e120f 100644 --- a/include/linux/skbuff.h +++ b/include/linux/skbuff.h @@ -1155,8 +1155,8 @@ __skb_set_sw_hash(struct sk_buff *skb, __u32 hash, bool is_l4) } void __skb_get_hash(struct sk_buff *skb); -u32 __skb_get_hash_symmetric(const struct sk_buff *skb); -u32 skb_get_poff(const struct sk_buff *skb); +u32 __skb_get_hash_symmetric(struct sk_buff *skb); +u32 skb_get_poff(struct sk_buff *skb); u32 __skb_get_poff(const struct sk_buff *skb, void *data, const struct flow_keys *keys, int hlen); __be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto, @@ -1172,13 +1172,13 @@ void skb_flow_dissector_init(struct flow_dissector *flow_dissector, const struct flow_dissector_key *key, unsigned int key_count); -bool __skb_flow_dissect(const struct sk_buff *skb, +bool __skb_flow_dissect(struct sk_buff *skb, struct flow_dissector *flow_dissector, void *target_container, void *data, __be16 proto, int nhoff, int hlen, unsigned int flags); -static inline bool skb_flow_dissect(const struct sk_buff *skb, +static inline bool skb_flow_dissect(struct sk_buff *skb, struct flow_dissector *flow_dissector, void *target_container, unsigned int flags) { @@ -1186,7 +1186,7 @@ static inline bool skb_flow_dissect(const struct sk_buff *skb, NULL, 0, 0, 0, flags); } -static inline bool skb_flow_dissect_flow_keys(const struct sk_buff *skb, +static inline bool skb_flow_dissect_flow_keys(struct sk_buff *skb, struct flow_keys *flow, unsigned int flags) { @@ -1225,7 +1225,7 @@ static inline __u32 skb_get_hash_flowi6(struct sk_buff *skb, const struct flowi6 return skb->hash; } -__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb); +__u32 skb_get_hash_perturb(struct sk_buff *skb, u32 perturb); static inline __u32 skb_get_hash_raw(const struct sk_buff *skb) { diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h index 1a7f7e424320..a376dfe1ad44 100644 --- a/include/net/ip_fib.h +++ b/include/net/ip_fib.h @@ -374,11 +374,11 @@ int fib_sync_up(struct net_device *dev, unsigned int nh_flags); #ifdef CONFIG_IP_ROUTE_MULTIPATH int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4, - const struct sk_buff *skb); + struct sk_buff *skb); #endif void fib_select_multipath(struct fib_result *res, int hash); void fib_select_path(struct net *net, struct fib_result *res, - struct flowi4 *fl4, const struct sk_buff *skb); + struct flowi4 *fl4, struct sk_buff *skb); /* Exported by fib_trie.c */ void fib_trie_init(void); diff --git a/include/net/route.h b/include/net/route.h index 57dfc6850d37..cb95b79f0117 100644 --- a/include/net/route.h +++ b/include/net/route.h @@ -114,10 +114,10 @@ int ip_rt_init(void); void rt_cache_flush(struct net *net); void rt_flush_dev(struct net_device *dev); struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *flp, - const struct sk_buff *skb); + struct sk_buff *skb); struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *flp, struct fib_result *res, - const struct sk_buff *skb); + struct sk_buff *skb); static inline struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *flp) diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index 0a977373d003..76f5e5bc3177 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -424,7 +424,7 @@ static bool skb_flow_dissect_allowed(int *num_hdrs) * * Caller must take care of zeroing target container memory. */ -bool __skb_flow_dissect(const struct sk_buff *skb, +bool __skb_flow_dissect(struct sk_buff *skb, struct flow_dissector *flow_dissector, void *target_container, void *data, __be16 proto, int nhoff, int hlen, @@ -1015,7 +1015,7 @@ u32 flow_hash_from_keys(struct flow_keys *keys) } EXPORT_SYMBOL(flow_hash_from_keys); -static inline u32 ___skb_get_hash(const struct sk_buff *skb, +static inline u32 ___skb_get_hash(struct sk_buff *skb, struct flow_keys *keys, u32 keyval) { skb_flow_dissect_flow_keys(skb, keys, @@ -1053,7 +1053,7 @@ EXPORT_SYMBOL(make_flow_keys_digest); static struct flow_dissector flow_keys_dissector_symmetric __read_mostly; -u32 __skb_get_hash_symmetric(const struct sk_buff *skb) +u32 __skb_get_hash_symmetric(struct sk_buff *skb) { struct flow_keys keys; @@ -1090,7 +1090,7 @@ void __skb_get_hash(struct sk_buff *skb) } EXPORT_SYMBOL(__skb_get_hash); -__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb) +__u32 skb_get_hash_perturb(struct sk_buff *skb, u32 perturb) { struct flow_keys keys; @@ -1158,7 +1158,7 @@ u32 __skb_get_poff(const struct sk_buff *skb, void *data, * truncate packets without needing to push actual payload to the user * space and can analyze headers only, instead. */ -u32 skb_get_poff(const struct sk_buff *skb) +u32 skb_get_poff(struct sk_buff *skb) { struct flow_keys keys; diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c index 57a5d48acee8..dc610646bc4c 100644 --- a/net/ipv4/fib_semantics.c +++ b/net/ipv4/fib_semantics.c @@ -1759,7 +1759,7 @@ void fib_select_multipath(struct fib_result *res, int hash) #endif void fib_select_path(struct net *net, struct fib_result *res, - struct flowi4 *fl4, const struct sk_buff *skb) + struct flowi4 *fl4, struct sk_buff *skb) { bool oif_check; diff --git a/net/ipv4/route.c b/net/ipv4/route.c index 94d4cd2d5ea4..94c5b81d8f2b 100644 --- a/net/ipv4/route.c +++ b/net/ipv4/route.c @@ -1791,7 +1791,7 @@ static void ip_multipath_l3_keys(const struct sk_buff *skb, /* if skb is set it will be used and fl4 can be NULL */ int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4, - const struct sk_buff *skb) + struct sk_buff *skb) { struct net *net = fi->fib_net; struct flow_keys hash_keys; @@ -2270,7 +2270,7 @@ static struct rtable *__mkroute_output(const struct fib_result *res, */ struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4, - const struct sk_buff *skb) + struct sk_buff *skb) { __u8 tos = RT_FL_TOS(fl4); struct fib_result res; @@ -2295,7 +2295,7 @@ EXPORT_SYMBOL_GPL(ip_route_output_key_hash); struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4, struct fib_result *res, - const struct sk_buff *skb) + struct sk_buff *skb) { struct net_device *dev_out = NULL; int orig_oif = fl4->flowi4_oif; diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c index 74ea863b8240..0d2d3a8d03f0 100644 --- a/net/sched/sch_sfq.c +++ b/net/sched/sch_sfq.c @@ -158,7 +158,7 @@ static inline struct sfq_head *sfq_dep_head(struct sfq_sched_data *q, sfq_index } static unsigned int sfq_hash(const struct sfq_sched_data *q, - const struct sk_buff *skb) + struct sk_buff *skb) { return skb_get_hash_perturb(skb, q->perturbation) & (q->divisor - 1); } From patchwork Thu Sep 28 21:48:17 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819759 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="FJYbs3zs"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cF0pX2z9sP1 for ; Fri, 29 Sep 2017 07:48:45 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751548AbdI1Vsn (ORCPT ); Thu, 28 Sep 2017 17:48:43 -0400 Received: from mail-pf0-f176.google.com ([209.85.192.176]:43992 "EHLO mail-pf0-f176.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750977AbdI1Vsm (ORCPT ); Thu, 28 Sep 2017 17:48:42 -0400 Received: by mail-pf0-f176.google.com with SMTP id y29so1509900pff.0 for ; Thu, 28 Sep 2017 14:48:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=r7jsxPT7lfI/P2klXaJnLAkSAYXNGIO/Irljg0FscDY=; b=FJYbs3zskEWe7ZVnIFxKx2yxn9xUEYcJ7jqFwTKIgYuF1ce85XPoCdz783fp3Dq4pW 5T8Up1IpukYRskypE5SA56OaRQDU+2mWrPfRyQGqXaA6MUwnn54aW1Hb8WuPrA98buzi HjAvKCzXnJaaW8IrTCTxKlKy71CJ2RycfkCzOnvi3K232ZD4PQebql7fB0jsxyX0BR4X CmsiXk77tP9LRXQoaO8q2uirC48/99ttWm0Gft+R9QoeLOCQn+apEq4ZopMmtDwiXL5O BZhrxgKthFwjEETZHnu08BOGNBDS9ImZrVLbHQ3OuFV4dVXX8Xh71evECNlVpVGCpXMX 96rQ== 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=r7jsxPT7lfI/P2klXaJnLAkSAYXNGIO/Irljg0FscDY=; b=rEVDXCc5BvhKkxi6idZLiOS5pL8w8rhx5LLM+/PCV+eZlmW9jACQKvlsp+5tTUd5jB O8gqu7gZp036AG2FcYRH5rrR6hsrmYWQ7v/YhZqKCN+YNze3Ydr/umIZaGUnxP9kYS1a Q+yX7DxF5rPxt1ZqH9PykhQ1ijRxXRa+eGrRVtsMHcGd2z5E4q5JBdUEEaB6+XRvvfwM 8B37bXQtf/NUnzP4Pza/wd3p9WOsoLuDY1COVp2u7siUi0QleG2z/66qWjcJMlBhjElO cv6VC1Xk6jp6X3E8SaFB8yrf4tiBZpuTRLyb2LoJiQ5FvH6gvC7f9BD+sYclyTZ7tUzB g1RA== X-Gm-Message-State: AHPjjUh6UIqAMUkbsN/TWi/1p1glsfGWBYYpe2P+GTDA78vIdvWrfT0H 3BhtA60PKh5egN/IrAT4k63fc4rj X-Google-Smtp-Source: AOwi7QCr/2VmFEnAEa0uFCiZiBQYoQeNo0+nID0uUIGztr6i7d2aQUvZnkgUo9JPnDjAa3pcpMHgkQ== X-Received: by 10.101.83.4 with SMTP id m4mr5279271pgq.266.1506635321727; Thu, 28 Sep 2017 14:48:41 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.40 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:40 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 2/8] flow_dissector: Move ETH_P_TEB processing to main switch Date: Thu, 28 Sep 2017 14:48:17 -0700 Message-Id: <20170928214823.2426-2-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Support for processing TEB is currently in GRE flow dissection as a special case. This can be moved to be a case the main proto switch in __skb_flow_dissect. Signed-off-by: Tom Herbert --- net/core/flow_dissector.c | 45 ++++++++++++++++++++++++--------------------- 1 file changed, 24 insertions(+), 21 deletions(-) diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index 76f5e5bc3177..c15b41f96cbe 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -282,27 +282,8 @@ __skb_flow_dissect_gre(const struct sk_buff *skb, if (hdr->flags & GRE_SEQ) offset += sizeof(((struct pptp_gre_header *) 0)->seq); - if (gre_ver == 0) { - if (*p_proto == htons(ETH_P_TEB)) { - const struct ethhdr *eth; - struct ethhdr _eth; - - eth = __skb_header_pointer(skb, *p_nhoff + offset, - sizeof(_eth), - data, *p_hlen, &_eth); - if (!eth) - return FLOW_DISSECT_RET_OUT_BAD; - *p_proto = eth->h_proto; - offset += sizeof(*eth); - - /* Cap headers that we access via pointers at the - * end of the Ethernet header as our maximum alignment - * at that point is only 2 bytes. - */ - if (NET_IP_ALIGN) - *p_hlen = *p_nhoff + offset; - } - } else { /* version 1, must be PPTP */ + /* version 1, must be PPTP */ + if (gre_ver == 1) { u8 _ppp_hdr[PPP_HDRLEN]; u8 *ppp_hdr; @@ -595,6 +576,28 @@ bool __skb_flow_dissect(struct sk_buff *skb, break; } + case htons(ETH_P_TEB): { + const struct ethhdr *eth; + struct ethhdr _eth; + + eth = __skb_header_pointer(skb, nhoff, sizeof(_eth), + data, hlen, &_eth); + if (!eth) + goto out_bad; + + proto = eth->h_proto; + nhoff += sizeof(*eth); + + /* Cap headers that we access via pointers at the + * end of the Ethernet header as our maximum alignment + * at that point is only 2 bytes. + */ + if (NET_IP_ALIGN) + hlen = nhoff; + + fdret = FLOW_DISSECT_RET_PROTO_AGAIN; + break; + } case htons(ETH_P_8021AD): case htons(ETH_P_8021Q): { const struct vlan_hdr *vlan; From patchwork Thu Sep 28 21:48:18 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819760 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="os0CBBb/"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cJ5Mw7z9sP1 for ; Fri, 29 Sep 2017 07:48:48 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751664AbdI1Vsq (ORCPT ); Thu, 28 Sep 2017 17:48:46 -0400 Received: from mail-pf0-f181.google.com ([209.85.192.181]:47874 "EHLO mail-pf0-f181.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751042AbdI1Vsp (ORCPT ); Thu, 28 Sep 2017 17:48:45 -0400 Received: by mail-pf0-f181.google.com with SMTP id u12so1503940pfl.4 for ; Thu, 28 Sep 2017 14:48:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=dnCQPEc4Va+Ld9HDo7UtbyaBBot6cR+4OoJXbeQgXWQ=; b=os0CBBb/8mzPhtJR8i91EV8ebv6eZXkXj/s7cBlIlN7Q1t8u9kQ33RGnQ0SwMbw6qc qc5NYA6aBdW2GwtdbaCK00qfp1Y4MNcIoTXJZQyN2GkEonbD1telVkbiRSrG71PeNlpD fRT1JpqR5pLOqtVZfmgqd2ZRjctpTq1UjDkk8ZR/smIXccCixwEHwIhRRmS40Hv30vVK JzMOY4U4ZgJxoHqri5JFwB3jnUlIR4vYSJNoPNSv1gpwsnVzWhXm33G8dqH3had0vD6J DaxAdPO+QiFIRpV4JcM26z/FLK0BteFjzICxesf+2N2W2uhDijLQHzRPtm6Cv1ae7AUM 6N9Q== 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=dnCQPEc4Va+Ld9HDo7UtbyaBBot6cR+4OoJXbeQgXWQ=; b=sKsbAjDvmKEcY3Tc8Rev2kHLR/73x5t/w+pr5WpqRRFxkYtNehDu+Tw9XvzqzWUQOJ ice02ved9vzyELjmUsxPZNda8zcvhRBy5wLDvy+WCUG2+UTOKgUjXdo9i/Wbox/d6XSq N9shrHgL1ARImzQV81fpi3L7XWkkbsYrGWZ08TyK8KnbyWZmAtSkSxxuK2Cxy8nzocIE TRLDbErTyzGR9PxoBfebfCO+Mo5VcJqYke5wduHV56l0zO01NDYZTWDgT4EN3cKxPZa9 EPPRJrSYWdbB+CJ3D9SXBr3d5Dy+8Z3SzTK/8HfqVDji6krWx8x2I41qzZgPFVP0faBP ZrRA== X-Gm-Message-State: AHPjjUjriTRdzh1VkNUVeUGglC4gIj/VzhRDDWASOBnJsv3r8a56nJM+ vOK/9XI5c4QIIJD3Xv2THiFKMg== X-Google-Smtp-Source: AOwi7QDYOe2na/tN1juBgwqFjZk4Uiqb3fy71U7omjdSEKpY9un5udcMZlgRrHoM70jCIdnHBiLguQ== X-Received: by 10.98.206.194 with SMTP id y185mr5512266pfg.28.1506635324837; Thu, 28 Sep 2017 14:48:44 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:44 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 3/8] udp: Check static key udp_encap_needed in udp_gro_receive Date: Thu, 28 Sep 2017 14:48:18 -0700 Message-Id: <20170928214823.2426-3-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Currently, the only support for udp gro is provided by UDP encapsulation protocols. Since they always set udp_encap_needed we can check that in udp_gro_receive functions before performing a socket lookup. Signed-off-by: Tom Herbert --- include/net/udp.h | 2 ++ net/ipv4/udp.c | 4 +++- net/ipv4/udp_offload.c | 7 +++++++ net/ipv6/udp_offload.c | 7 +++++++ 4 files changed, 19 insertions(+), 1 deletion(-) diff --git a/include/net/udp.h b/include/net/udp.h index 12dfbfe2e2d7..c6b1c5d8d3c9 100644 --- a/include/net/udp.h +++ b/include/net/udp.h @@ -97,6 +97,8 @@ static inline struct udp_hslot *udp_hashslot2(struct udp_table *table, extern struct proto udp_prot; +extern struct static_key udp_encap_needed; + extern atomic_long_t udp_memory_allocated; /* sysctl variables for udp */ diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c index 784ced0b9150..2788843e8eb2 100644 --- a/net/ipv4/udp.c +++ b/net/ipv4/udp.c @@ -1813,7 +1813,9 @@ static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) return 0; } -static struct static_key udp_encap_needed __read_mostly; +struct static_key udp_encap_needed __read_mostly; +EXPORT_SYMBOL(udp_encap_needed); + void udp_encap_enable(void) { static_key_enable(&udp_encap_needed); diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c index 97658bfc1b58..a744bb515455 100644 --- a/net/ipv4/udp_offload.c +++ b/net/ipv4/udp_offload.c @@ -261,6 +261,13 @@ static struct sk_buff **udp4_gro_receive(struct sk_buff **head, { struct udphdr *uh = udp_gro_udphdr(skb); + if (!static_key_false(&udp_encap_needed)) { + /* Currently udp_gro_receive only does something if + * a UDP encapsulation has been set. + */ + goto flush; + } + if (unlikely(!uh)) goto flush; diff --git a/net/ipv6/udp_offload.c b/net/ipv6/udp_offload.c index 455fd4e39333..111b026e4f03 100644 --- a/net/ipv6/udp_offload.c +++ b/net/ipv6/udp_offload.c @@ -34,6 +34,13 @@ static struct sk_buff **udp6_gro_receive(struct sk_buff **head, { struct udphdr *uh = udp_gro_udphdr(skb); + if (!static_key_false(&udp_encap_needed)) { + /* Currently udp_gro_receive only does something if + * a UDP encapsulation has been set. + */ + goto flush; + } + if (unlikely(!uh)) goto flush; From patchwork Thu Sep 28 21:48:19 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819761 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="YrQg2qq7"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cM6XJbz9sP1 for ; Fri, 29 Sep 2017 07:48:51 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751689AbdI1Vsu (ORCPT ); Thu, 28 Sep 2017 17:48:50 -0400 Received: from mail-pg0-f46.google.com ([74.125.83.46]:47535 "EHLO mail-pg0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751042AbdI1Vsr (ORCPT ); Thu, 28 Sep 2017 17:48:47 -0400 Received: by mail-pg0-f46.google.com with SMTP id d8so1642580pgt.4 for ; Thu, 28 Sep 2017 14:48:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=IPBqj8aya8Y8MJ9ptH0B2VemCpMYxC0Av3+lvaEcPHs=; b=YrQg2qq7/FdAaF1o2BilnFBPBnxAmb6dHbGYLeeJCoXhQnOtvv6TKzo6K3rIWTDOBt AG2A2OYqFiBLaEMEXHe5oyey3mfb0zQuIVIpTj3RcL7g9FE3G2Dgvdq2IOaGjeby7Lmf QE3ya14ATELXU2z1I0UQYOXEFXv5dGWfoQbTLqVcUfKgZzvP1r2WIkuWyeetwDUUD0Sq xwUpRE/9nUw8tRB3AH5igcR4HMT0/yHLv8On7LenDGgKMeskrusE0BJtYg24jSfRiLs5 qAxSBy5rCgHps91BbiQdx8ToqUwcwJaUp4cnWZbyYSpqi/kTcj2EI9IxvQtej6l+tR6Y Py2A== 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=IPBqj8aya8Y8MJ9ptH0B2VemCpMYxC0Av3+lvaEcPHs=; b=GgO2dKY+VRd4oi7JzJJ9QA6iKO2bCzb0h2QclFUX9CSbcTSRhjcVjWE4edTDYx7rU7 fo1U2X2tbePXQAi9nD+hfYevq+Pk6SRUfKHV49DWeIsUCLSOG2unQY1DzFMzKv/XDxeR cAiEO0BmRG8hfwOzli7V10epcRZVvYVLpvr7F8AJl2kwoNxNqnHrsJsxH2mO29f1KntC AO/jenIpSVsO/FaVmdjsHfaqbQmC5Yju90V8M+BbscjUzlwiAey80MFUcieAujSsfo9r ufgXER2+XIt2FEC8bSWQsZroXo+hDieYu9wsoQ47ZQDvC2Zil/X8tr+g/vE7vscmZZfT fouA== X-Gm-Message-State: AHPjjUg8PF3tnpP5Lx01EcfExAiMCaP0j2aNKF+89frOuVClvK+bvz9I dlrozH2jba8HRjwpY9Fvm0g9iw== X-Google-Smtp-Source: AOwi7QCondJdJtFM0PhkjKgL01jOdBStwBDhDnSQwA6hYSJ3oxe4ek+z/OkdTUrI4ZxJbeIKfwyZbg== X-Received: by 10.98.202.220 with SMTP id y89mr5462661pfk.57.1506635327110; Thu, 28 Sep 2017 14:48:47 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.45 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:46 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 4/8] flow_dissector: Add protocol specific flow dissection offload Date: Thu, 28 Sep 2017 14:48:19 -0700 Message-Id: <20170928214823.2426-4-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add offload capability for performing protocol specific flow dissection (either by EtherType or IP protocol). Specifically: - Add flow_dissect to offload callbacks - Move flow_dissect_ret enum to flow_dissector.h, cleanup names and add a couple of values - Unify handling of functions that return flow_dissect_ret enum - In __skb_flow_dissect, add default case for switch(proto) as well as switch(ip_proto) that looks up and calls protocol specific flow dissection Signed-off-by: Tom Herbert --- include/linux/netdevice.h | 27 ++++++++++++++++++ include/net/flow_dissector.h | 1 + net/core/dev.c | 65 ++++++++++++++++++++++++++++++++++++++++++++ net/core/flow_dissector.c | 16 +++++++++-- net/ipv4/route.c | 4 ++- 5 files changed, 110 insertions(+), 3 deletions(-) diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index f535779d9dc1..565d7cdfe967 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -2207,12 +2207,25 @@ struct offload_callbacks { struct sk_buff **(*gro_receive)(struct sk_buff **head, struct sk_buff *skb); int (*gro_complete)(struct sk_buff *skb, int nhoff); + enum flow_dissect_ret (*flow_dissect)(struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); }; struct packet_offload { __be16 type; /* This is really htons(ether_type). */ u16 priority; struct offload_callbacks callbacks; + enum flow_dissect_ret (*proto_flow_dissect)(struct sk_buff *skb, + u8 proto, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); struct list_head list; }; @@ -3252,6 +3265,20 @@ struct sk_buff *napi_get_frags(struct napi_struct *napi); gro_result_t napi_gro_frags(struct napi_struct *napi); struct packet_offload *gro_find_receive_by_type(__be16 type); struct packet_offload *gro_find_complete_by_type(__be16 type); +enum flow_dissect_ret flow_dissect_by_type(struct sk_buff *skb, + __be16 type, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); +enum flow_dissect_ret flow_dissect_by_type_proto(struct sk_buff *skb, + __be16 type, u8 proto, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); static inline void napi_free_frags(struct napi_struct *napi) { diff --git a/include/net/flow_dissector.h b/include/net/flow_dissector.h index fc3dce730a6b..ad75bbfd1c9c 100644 --- a/include/net/flow_dissector.h +++ b/include/net/flow_dissector.h @@ -213,6 +213,7 @@ enum flow_dissector_key_id { #define FLOW_DISSECTOR_F_STOP_AT_L3 BIT(1) #define FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL BIT(2) #define FLOW_DISSECTOR_F_STOP_AT_ENCAP BIT(3) +#define FLOW_DISSECTOR_F_STOP_AT_L4 BIT(4) struct flow_dissector_key { enum flow_dissector_key_id key_id; diff --git a/net/core/dev.c b/net/core/dev.c index e350c768d4b5..f3cd884bd04b 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -104,6 +104,7 @@ #include #include #include +#include #include #include #include @@ -4907,6 +4908,70 @@ struct packet_offload *gro_find_complete_by_type(__be16 type) } EXPORT_SYMBOL(gro_find_complete_by_type); +enum flow_dissect_ret flow_dissect_by_type(struct sk_buff *skb, + __be16 type, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + enum flow_dissect_ret ret = FLOW_DISSECT_RET_CONTINUE; + struct list_head *offload_head = &offload_base; + struct packet_offload *ptype; + + rcu_read_lock(); + + list_for_each_entry_rcu(ptype, offload_head, list) { + if (ptype->type != type || !ptype->callbacks.flow_dissect) + continue; + ret = ptype->callbacks.flow_dissect(skb, key_control, + flow_dissector, + target_container, + data, p_proto, + p_ip_proto, p_nhoff, + p_hlen, flags); + break; + } + + rcu_read_unlock(); + + return ret; +} +EXPORT_SYMBOL(flow_dissect_by_type); + +enum flow_dissect_ret flow_dissect_by_type_proto(struct sk_buff *skb, + __be16 type, u8 proto, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + enum flow_dissect_ret ret = FLOW_DISSECT_RET_CONTINUE; + struct list_head *offload_head = &offload_base; + struct packet_offload *ptype; + + rcu_read_lock(); + + list_for_each_entry_rcu(ptype, offload_head, list) { + if (ptype->type != type || !ptype->proto_flow_dissect) + continue; + ret = ptype->proto_flow_dissect(skb, proto, key_control, + flow_dissector, + target_container, + data, p_proto, + p_ip_proto, p_nhoff, + p_hlen, flags); + break; + } + + rcu_read_unlock(); + + return ret; +} +EXPORT_SYMBOL(flow_dissect_by_type_proto); + static void napi_skb_free_stolen_head(struct sk_buff *skb) { skb_dst_drop(skb); diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index c15b41f96cbe..84b8eb1f6664 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -721,7 +722,11 @@ bool __skb_flow_dissect(struct sk_buff *skb, break; default: - fdret = FLOW_DISSECT_RET_OUT_BAD; + fdret = flow_dissect_by_type(skb, proto, key_control, + flow_dissector, + target_container, + data, &proto, &ip_proto, &nhoff, + &hlen, flags); break; } @@ -838,6 +843,12 @@ bool __skb_flow_dissect(struct sk_buff *skb, break; default: + fdret = flow_dissect_by_type_proto(skb, proto, + ip_proto, key_control, + flow_dissector, + target_container, + data, &proto, &ip_proto, &nhoff, + &hlen, flags); break; } @@ -1022,7 +1033,8 @@ static inline u32 ___skb_get_hash(struct sk_buff *skb, struct flow_keys *keys, u32 keyval) { skb_flow_dissect_flow_keys(skb, keys, - FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL); + FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL | + FLOW_DISSECTOR_F_STOP_AT_L4); return __flow_hash_from_keys(keys, keyval); } diff --git a/net/ipv4/route.c b/net/ipv4/route.c index 94c5b81d8f2b..69d6ce7dfa18 100644 --- a/net/ipv4/route.c +++ b/net/ipv4/route.c @@ -1811,7 +1811,9 @@ int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4, case 1: /* skb is currently provided only when forwarding */ if (skb) { - unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP; + unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP | + FLOW_DISSECTOR_F_STOP_AT_L4; +; struct flow_keys keys; /* short-circuit if we already have L4 hash present */ From patchwork Thu Sep 28 21:48:20 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819762 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="fLybAWvB"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cQ29rLz9sP1 for ; Fri, 29 Sep 2017 07:48:54 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751840AbdI1Vsx (ORCPT ); Thu, 28 Sep 2017 17:48:53 -0400 Received: from mail-pf0-f174.google.com ([209.85.192.174]:55069 "EHLO mail-pf0-f174.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751710AbdI1Vst (ORCPT ); Thu, 28 Sep 2017 17:48:49 -0400 Received: by mail-pf0-f174.google.com with SMTP id d187so1498296pfg.11 for ; Thu, 28 Sep 2017 14:48:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=0uhjiVHywnRmL0X2YEO7FxciPaRp6ZvKdyDBZAeROUc=; b=fLybAWvB5xWZzZbvs9nKr41jG3U4QN4LvnKAwoRdrnsFqOrA4n4uzPbMV6UObOCAJB 7odJxFXnTU5bhieF9EaF7p6U6azwgLO0YNgJHKabn5SgaLkHfBJuF8gf7ydU+XiZQ9MN Bnx5T0wlSTY8zuWkhsAwZCt4U0Ejzj7P89cIOH2X859EP1is5BikR7Al7v1x9KfeHwgq 6+drGhgc8hEoJMaaea5sVViyOEYGfGs7CgrKjII5EeW8Vw1Fg4UCQ+Vv+xrX10FuFIw0 kx3REID3L+dm5TIGAvHrrlGtVjmnmQuYC6FgLBZJzRjPWA/+yiAUPKJKBcX6RAo6kFAC 31mQ== 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=0uhjiVHywnRmL0X2YEO7FxciPaRp6ZvKdyDBZAeROUc=; b=cvTijBmgidy3miJ+2XkTk6EHkMIwOBUZD5HuDdgzM17rXoAaPvrI7aaQhTRI89Kx6E IatxZl70rbYwklgVCW3OCgzVKOFzJ9PD3zdtDSxb94Ojuw5jDzRkqa7LWrdUS6vK8oMd i6AOGrS5fO+DDGd+NDZGLQpbfjx0WA6M5/VaXi1pCehrutLDYuRkt8WHO9ZVn7oy6Qa/ UZVzOjNKpb9gnU1i2Eiscv7STeaXU4+8RZW4ekGXla8HCAd7hRc58yVVA2H75YfAlfEM cGh3997lzWOpBluUpCWiP180WD/3Qo1h/+4ufZW7cQR5x/n4UrX/a9vhQEO5qldJwcqB y1Sw== X-Gm-Message-State: AHPjjUhWdqb84aDX1UWpm3SCp1QogCUVSOZuT8JffgiDRZbS99bvFg/H MBlZn6DBqBdwhCaeMZAXP9OcXQ== X-Google-Smtp-Source: AOwi7QBt9JnU0M8yFUFxIxQFyUz6eAbhjDL8XtHwPFjnuihDLDpnJeEhoEFUiX2CLFOENk2YeM1g7w== X-Received: by 10.159.204.139 with SMTP id t11mr5000998plo.359.1506635329112; Thu, 28 Sep 2017 14:48:49 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.47 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:48 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 5/8] ip: Add callbacks to flow dissection by IP protocol Date: Thu, 28 Sep 2017 14:48:20 -0700 Message-Id: <20170928214823.2426-5-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Populate the proto_flow_dissect function for IPv4 and IPv6 packet offloads. This allows the caller to flow dissect a packet starting at the given IP protocol (as parsed to that point by flow dissector for instance). Signed-off-by: Tom Herbert --- net/ipv4/af_inet.c | 27 +++++++++++++++++++++++++++ net/ipv6/ip6_offload.c | 27 +++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index e31108e5ef79..18c1d884999a 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -1440,6 +1440,32 @@ static struct sk_buff **ipip_gro_receive(struct sk_buff **head, return inet_gro_receive(head, skb); } +static enum flow_dissect_ret inet_proto_flow_dissect(struct sk_buff *skb, + u8 proto, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + enum flow_dissect_ret ret = FLOW_DISSECT_RET_CONTINUE; + const struct net_offload *ops; + + rcu_read_lock(); + + ops = rcu_dereference(inet_offloads[proto]); + if (ops && ops->callbacks.flow_dissect) + ret = ops->callbacks.flow_dissect(skb, key_control, + flow_dissector, + target_container, + data, p_proto, p_ip_proto, + p_nhoff, p_hlen, flags); + + rcu_read_unlock(); + + return ret; +} + #define SECONDS_PER_DAY 86400 /* inet_current_timestamp - Return IP network timestamp @@ -1763,6 +1789,7 @@ static int ipv4_proc_init(void); static struct packet_offload ip_packet_offload __read_mostly = { .type = cpu_to_be16(ETH_P_IP), + .proto_flow_dissect = inet_proto_flow_dissect, .callbacks = { .gso_segment = inet_gso_segment, .gro_receive = inet_gro_receive, diff --git a/net/ipv6/ip6_offload.c b/net/ipv6/ip6_offload.c index cdb3728faca7..a33a2b40b3d6 100644 --- a/net/ipv6/ip6_offload.c +++ b/net/ipv6/ip6_offload.c @@ -339,8 +339,35 @@ static int ip4ip6_gro_complete(struct sk_buff *skb, int nhoff) return inet_gro_complete(skb, nhoff); } +static enum flow_dissect_ret inet6_proto_flow_dissect(struct sk_buff *skb, + u8 proto, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + enum flow_dissect_ret ret = FLOW_DISSECT_RET_CONTINUE; + const struct net_offload *ops; + + rcu_read_lock(); + + ops = rcu_dereference(inet6_offloads[proto]); + if (ops && ops->callbacks.flow_dissect) + ret = ops->callbacks.flow_dissect(skb, key_control, + flow_dissector, + target_container, data, + p_proto, p_ip_proto, p_nhoff, + p_hlen, flags); + + rcu_read_unlock(); + + return ret; +} + static struct packet_offload ipv6_packet_offload __read_mostly = { .type = cpu_to_be16(ETH_P_IPV6), + .proto_flow_dissect = inet6_proto_flow_dissect, .callbacks = { .gso_segment = ipv6_gso_segment, .gro_receive = ipv6_gro_receive, From patchwork Thu Sep 28 21:48:21 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819765 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="bX8ThTWO"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cg4fn0z9sP1 for ; Fri, 29 Sep 2017 07:49:07 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751934AbdI1VtF (ORCPT ); Thu, 28 Sep 2017 17:49:05 -0400 Received: from mail-pf0-f179.google.com ([209.85.192.179]:48802 "EHLO mail-pf0-f179.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751805AbdI1Vsw (ORCPT ); Thu, 28 Sep 2017 17:48:52 -0400 Received: by mail-pf0-f179.google.com with SMTP id n24so1502379pfk.5 for ; Thu, 28 Sep 2017 14:48:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=8NHwKis9d93XkuGDUq/eZwt7FAF20Ez2lJ5GlYfl1gg=; b=bX8ThTWO/MSYft5u19nwJibM7shU28ZsqG0m+AOKzkjV6I8eW5AndY66YZicEH8/pP Pmtzk0qpJpcGlHNiSWw84deRD7uTN+NHAMo6wvIBrd/Ja/Rk2Ynmyt+CG4aHNPTAHFru SkvoQf8mGXa4dajU9Rc7RXUXzifienmFwC4b+zXW+/6ZvClyFkMEplOFgdmxO1zsMMFQ W5bePZT+ri6qwPN57Zb2NJt5lNPYOPTp68ILUQBqB16443uH7CHHVDHjanarr3D6mVsx CQiDgd3mbT4Ydzqc7/qtuYJrNls6Qv1KbcNgVKuHDFKWXGIF0eHxxlnP8kkdlrfUFGqH vRig== 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=8NHwKis9d93XkuGDUq/eZwt7FAF20Ez2lJ5GlYfl1gg=; b=Tt1qy4u2P7K9iIu8dfFjh7KMkvpmqNCSISAAirD+wJ20oz1KQqbbpoFKY8NRNL/J8S jP3V4MrK9i2X3ATbMu65No8DE3yE0jmYR/MIxA/oB6gzpkJBJE+i0BPBjoYKru4ABNu9 0iDA78+q2R1Jd4PFa6/cRFoOpiOtBtVQ/sxBh5FTnZEVX1Ve1kMfkjJ0X6xAepeogjvs ewFzwT80GTGZUPwSJlVRv5BMw449MTkq9nPb1CcZ0xCvFaJkhzwLdGcqtb25bOpJna9k 6FCD9MdEkIbh6HfytdkBYsKaqDayIxxynRlMybhM71szVy6+baxLIDO4af3dwSN6H2F7 XY0A== X-Gm-Message-State: AHPjjUhUW7UU0yut3bxhBApOmlnczUeU4uNggw/g9nUZ5ZJYhoKZpqSm cwR0xDpZsH6sEkIMMIGpEVLckoyr X-Google-Smtp-Source: AOwi7QC1IfiBG0CZ9GfiT8Ii0HFeyyj5rrbdn1U9MIUX4DZs+Bh5QNjqOk9U7BcLsyGhKBzrraLk1w== X-Received: by 10.84.235.7 with SMTP id o7mr4869482plk.163.1506635331538; Thu, 28 Sep 2017 14:48:51 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.49 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:50 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 6/8] udp: flow dissector offload Date: Thu, 28 Sep 2017 14:48:21 -0700 Message-Id: <20170928214823.2426-6-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add support to perform UDP specific flow dissection. This is primarily intended for dissecting encapsulated packets in UDP encapsulation. This patch adds a flow_dissect offload for UDP4 and UDP6. The backend function performs a socket lookup and calls the flow_dissect function if a socket is found. Signed-off-by: Tom Herbert --- include/linux/udp.h | 8 ++++++++ include/net/udp.h | 8 ++++++++ include/net/udp_tunnel.h | 8 ++++++++ net/ipv4/udp_offload.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ net/ipv4/udp_tunnel.c | 1 + net/ipv6/udp_offload.c | 16 ++++++++++++++++ 6 files changed, 89 insertions(+) diff --git a/include/linux/udp.h b/include/linux/udp.h index eaea63bc79bb..2e90b189ef6a 100644 --- a/include/linux/udp.h +++ b/include/linux/udp.h @@ -79,6 +79,14 @@ struct udp_sock { int (*gro_complete)(struct sock *sk, struct sk_buff *skb, int nhoff); + /* Flow dissector function for a UDP socket */ + enum flow_dissect_ret (*flow_dissect)(struct sock *sk, + const struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); /* udp_recvmsg try to use this before splicing sk_receive_queue */ struct sk_buff_head reader_queue ____cacheline_aligned_in_smp; diff --git a/include/net/udp.h b/include/net/udp.h index c6b1c5d8d3c9..4867f329538c 100644 --- a/include/net/udp.h +++ b/include/net/udp.h @@ -176,6 +176,14 @@ struct sk_buff **udp_gro_receive(struct sk_buff **head, struct sk_buff *skb, struct udphdr *uh, udp_lookup_t lookup); int udp_gro_complete(struct sk_buff *skb, int nhoff, udp_lookup_t lookup); +enum flow_dissect_ret udp_flow_dissect(struct sk_buff *skb, + udp_lookup_t lookup, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); + static inline struct udphdr *udp_gro_udphdr(struct sk_buff *skb) { struct udphdr *uh; diff --git a/include/net/udp_tunnel.h b/include/net/udp_tunnel.h index 10cce0dd4450..b7102e0f41a9 100644 --- a/include/net/udp_tunnel.h +++ b/include/net/udp_tunnel.h @@ -69,6 +69,13 @@ typedef struct sk_buff **(*udp_tunnel_gro_receive_t)(struct sock *sk, struct sk_buff *skb); typedef int (*udp_tunnel_gro_complete_t)(struct sock *sk, struct sk_buff *skb, int nhoff); +typedef enum flow_dissect_ret (*udp_tunnel_flow_dissect_t)(struct sock *sk, + const struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags); struct udp_tunnel_sock_cfg { void *sk_user_data; /* user data used by encap_rcv call back */ @@ -78,6 +85,7 @@ struct udp_tunnel_sock_cfg { udp_tunnel_encap_destroy_t encap_destroy; udp_tunnel_gro_receive_t gro_receive; udp_tunnel_gro_complete_t gro_complete; + udp_tunnel_flow_dissect_t flow_dissect; }; /* Setup the given (UDP) sock to receive UDP encapsulated packets */ diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c index a744bb515455..fddf923ef433 100644 --- a/net/ipv4/udp_offload.c +++ b/net/ipv4/udp_offload.c @@ -335,11 +335,59 @@ static int udp4_gro_complete(struct sk_buff *skb, int nhoff) return udp_gro_complete(skb, nhoff, udp4_lib_lookup_skb); } +enum flow_dissect_ret udp_flow_dissect(struct sk_buff *skb, + udp_lookup_t lookup, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + enum flow_dissect_ret ret = FLOW_DISSECT_RET_CONTINUE; + struct udphdr *uh, _uh; + struct sock *sk; + + uh = __skb_header_pointer(skb, *p_nhoff, sizeof(_uh), data, + *p_hlen, &_uh); + if (!uh) + return FLOW_DISSECT_RET_OUT_BAD; + + rcu_read_lock(); + + sk = (*lookup)(skb, uh->source, uh->dest); + + if (sk && udp_sk(sk)->flow_dissect) + ret = udp_sk(sk)->flow_dissect(sk, skb, key_control, + flow_dissector, target_container, + data, p_proto, p_ip_proto, + p_nhoff, p_hlen, flags); + rcu_read_unlock(); + + return ret; +} +EXPORT_SYMBOL(udp_flow_dissect); + +static enum flow_dissect_ret udp4_flow_dissect(struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + if (!static_key_false(&udp_encap_needed)) + return FLOW_DISSECT_RET_CONTINUE; + + return udp_flow_dissect(skb, udp4_lib_lookup_skb, key_control, + flow_dissector, target_container, data, + p_proto, p_ip_proto, p_nhoff, p_hlen, flags); +} + static const struct net_offload udpv4_offload = { .callbacks = { .gso_segment = udp4_tunnel_segment, .gro_receive = udp4_gro_receive, .gro_complete = udp4_gro_complete, + .flow_dissect = udp4_flow_dissect, }, }; diff --git a/net/ipv4/udp_tunnel.c b/net/ipv4/udp_tunnel.c index 6539ff15e9a3..a4eec2a044d2 100644 --- a/net/ipv4/udp_tunnel.c +++ b/net/ipv4/udp_tunnel.c @@ -71,6 +71,7 @@ void setup_udp_tunnel_sock(struct net *net, struct socket *sock, udp_sk(sk)->encap_destroy = cfg->encap_destroy; udp_sk(sk)->gro_receive = cfg->gro_receive; udp_sk(sk)->gro_complete = cfg->gro_complete; + udp_sk(sk)->flow_dissect = cfg->flow_dissect; udp_tunnel_encap_enable(sock); } diff --git a/net/ipv6/udp_offload.c b/net/ipv6/udp_offload.c index 111b026e4f03..45b77f92d77d 100644 --- a/net/ipv6/udp_offload.c +++ b/net/ipv6/udp_offload.c @@ -80,11 +80,27 @@ static int udp6_gro_complete(struct sk_buff *skb, int nhoff) return udp_gro_complete(skb, nhoff, udp6_lib_lookup_skb); } +static enum flow_dissect_ret udp6_flow_dissect(struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + if (!static_key_false(&udp_encap_needed)) + return FLOW_DISSECT_RET_CONTINUE; + + return udp_flow_dissect(skb, udp6_lib_lookup_skb, key_control, + flow_dissector, target_container, data, + p_proto, p_ip_proto, p_nhoff, p_hlen, flags); +} + static const struct net_offload udpv6_offload = { .callbacks = { .gso_segment = udp6_tunnel_segment, .gro_receive = udp6_gro_receive, .gro_complete = udp6_gro_complete, + .flow_dissect = udp6_flow_dissect, }, }; From patchwork Thu Sep 28 21:48:22 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819763 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="Jq9HUgI5"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cW2hkdz9sP1 for ; Fri, 29 Sep 2017 07:48:59 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751905AbdI1Vs5 (ORCPT ); Thu, 28 Sep 2017 17:48:57 -0400 Received: from mail-pg0-f42.google.com ([74.125.83.42]:56158 "EHLO mail-pg0-f42.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751770AbdI1Vsy (ORCPT ); Thu, 28 Sep 2017 17:48:54 -0400 Received: by mail-pg0-f42.google.com with SMTP id b11so1633416pgn.12 for ; Thu, 28 Sep 2017 14:48:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=iTpwfmSqYm+U2pPyX4deOP8YcIK636yLP8yOe/K6Rxw=; b=Jq9HUgI5Srkb6BYGr9kwEIze/mzW8enQIhFGvejBU5Ty7uBb143urB1f7dUsINAvI9 HUWiLIFscNMm97gxMkayRgvRj+H263PYZFfytKEvUKAxOyZYZ/V3/02ULYXO4ZeemYMg VTV4H7hs8jl5KaxqSNG5nOtKD3vGlOPpqM1UVoR0G7/HmgRTUcYXY35Zbp1q+fxmr2os ZegQa0UPVayajJNyLysT/yM8RWhy4+qLg8+gEqMlsYpaQ2Aq44vW0YiigXu1p3afaJBU uTJvVIqx/tsGpZaEMf91qapN6nwW7++GaZpsqO28j70pjccIkSF2gfCBPj9PKchhIY4O SSvg== 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=iTpwfmSqYm+U2pPyX4deOP8YcIK636yLP8yOe/K6Rxw=; b=NP1O7lr5PXKReIEGatOCoY0OCvzCJuutF2W+DusM3f07JtWBHFid33idqsEOpU1tdz ZAGtUNnNr4YgUXzSXtkncsF2fuyfCuwUGzzKEbBL4Q91VnKQ3ZbPgTYzG+u2pwxsmOcw N78qSDCzbGif/vmhr+YMqVEnt7WWU7AXPw7xCFsCcfhM58j3DwM9vezh9yKJFjkeoqA2 lLxThi4FxwyLCg9gf8VqzV+g4J5uiuIQiUwqwV0eSz05HaoK3S8Sc/d8bqa0usvHQVUw 0ss+s/ZZHWwrzwTZlJsJlK/8GL+z8MUDmF7UvuikeOlIxfWeeGoQAKW+Ijl7vHqXzGXv 5NAA== X-Gm-Message-State: AHPjjUiuTL+B1rWIRTsBMa2j7No2JtydE9MNJ/B2e15D4y+5U2x+OSw6 BSq5Dt/klHg1iPaC0fabN6T5YQ== X-Google-Smtp-Source: AOwi7QCOGN3vp5VA0wWm3JPPkgiqAvkiUQ+0kKkGG6Wtv6GcO+XDuTLJiFeP9ghzOeGsPWuJhQSr7g== X-Received: by 10.84.216.87 with SMTP id f23mr4961887plj.307.1506635333639; Thu, 28 Sep 2017 14:48:53 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.52 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:52 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 7/8] fou: Support flow dissection Date: Thu, 28 Sep 2017 14:48:22 -0700 Message-Id: <20170928214823.2426-7-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Populate offload flow_dissect callabck appropriately for fou and gue. Signed-off-by: Tom Herbert --- net/ipv4/fou.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/net/ipv4/fou.c b/net/ipv4/fou.c index 1540db65241a..a831dd49fb28 100644 --- a/net/ipv4/fou.c +++ b/net/ipv4/fou.c @@ -282,6 +282,20 @@ static int fou_gro_complete(struct sock *sk, struct sk_buff *skb, return err; } +static enum flow_dissect_ret fou_flow_dissect(struct sock *sk, + const struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + *p_ip_proto = fou_from_sock(sk)->protocol; + *p_nhoff += sizeof(struct udphdr); + + return FLOW_DISSECT_RET_IPPROTO_AGAIN; +} + static struct guehdr *gue_gro_remcsum(struct sk_buff *skb, unsigned int off, struct guehdr *guehdr, void *data, size_t hdrlen, struct gro_remcsum *grc, @@ -500,6 +514,53 @@ static int gue_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff) return err; } +static enum flow_dissect_ret gue_flow_dissect(struct sock *sk, + const struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + struct guehdr *guehdr, _guehdr; + + guehdr = __skb_header_pointer(skb, *p_nhoff + sizeof(struct udphdr), + sizeof(_guehdr), data, *p_hlen, &_guehdr); + if (!guehdr) + return FLOW_DISSECT_RET_OUT_BAD; + + switch (guehdr->version) { + case 0: + if (unlikely(guehdr->control)) + return FLOW_DISSECT_RET_CONTINUE; + + *p_ip_proto = guehdr->proto_ctype; + *p_nhoff += sizeof(struct udphdr) + + sizeof(*guehdr) + (guehdr->hlen << 2); + + break; + case 1: + switch (((struct iphdr *)guehdr)->version) { + case 4: + *p_ip_proto = IPPROTO_IPIP; + break; + case 6: + *p_ip_proto = IPPROTO_IPV6; + break; + default: + return FLOW_DISSECT_RET_CONTINUE; + } + + *p_nhoff += sizeof(struct udphdr); + + break; + default: + return FLOW_DISSECT_RET_CONTINUE; + } + + return FLOW_DISSECT_RET_IPPROTO_AGAIN; +} + static int fou_add_to_port_list(struct net *net, struct fou *fou) { struct fou_net *fn = net_generic(net, fou_net_id); @@ -570,12 +631,14 @@ static int fou_create(struct net *net, struct fou_cfg *cfg, tunnel_cfg.encap_rcv = fou_udp_recv; tunnel_cfg.gro_receive = fou_gro_receive; tunnel_cfg.gro_complete = fou_gro_complete; + tunnel_cfg.flow_dissect = fou_flow_dissect; fou->protocol = cfg->protocol; break; case FOU_ENCAP_GUE: tunnel_cfg.encap_rcv = gue_udp_recv; tunnel_cfg.gro_receive = gue_gro_receive; tunnel_cfg.gro_complete = gue_gro_complete; + tunnel_cfg.flow_dissect = gue_flow_dissect; break; default: err = -EINVAL; From patchwork Thu Sep 28 21:48:23 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Herbert X-Patchwork-Id: 819764 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@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; dkim=pass (2048-bit key; unprotected) header.d=quantonium-net.20150623.gappssmtp.com header.i=@quantonium-net.20150623.gappssmtp.com header.b="IYAiTfDM"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 3y37cY5fpsz9sP1 for ; Fri, 29 Sep 2017 07:49:01 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751917AbdI1Vs7 (ORCPT ); Thu, 28 Sep 2017 17:48:59 -0400 Received: from mail-pf0-f177.google.com ([209.85.192.177]:56296 "EHLO mail-pf0-f177.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751819AbdI1Vs4 (ORCPT ); Thu, 28 Sep 2017 17:48:56 -0400 Received: by mail-pf0-f177.google.com with SMTP id r71so1495538pfe.12 for ; Thu, 28 Sep 2017 14:48:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=quantonium-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=yNwn4H1x9xNz16l0pgj/7MrQtL11truhNgqYO5ISZks=; b=IYAiTfDMy04LaWyS9UGHo+BbZB7S+EFAYXBo+QBJBzulMjY2BM7ws4CfKOuPhGRype aetSfUEr04kaukSWnEOGHXnc+SuYM3/1W5iOr3nTF8yio7HsWMnGwMxLZEtxOxdFnZzk Dz4fFNiF/ayA7hJpe33M6zPN5Pgnvuq8AzI/najnudq2SdIT29OMftEyxklCpFRwXFOy fWfFl9xPFTPPsY6XJFGfGVC2wDcvPUSHUETDUZYqbm2LWFsoGutzE+w82975ojmAJ68l eBN1nUw+rbw/omiuBVSH2s2fODH+sj7rNJQDU9PNKoTYiKmlSFWOORLZWrnMV0xw7M9+ QWSQ== 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=yNwn4H1x9xNz16l0pgj/7MrQtL11truhNgqYO5ISZks=; b=t5W0MJOv+j43WOIBUnL1sFopHjztvrm30abTdKVAx2nA//YrttJ/NeRWYmTuvOvSfT 433hIV0GpqtvYQUKX4X9aVTietcu+3zmztXZhvBRlnJqbJ61Nl0+KfMCwskVhNP/IBuC u+KJKwHIK8VL1Rnp9JPP1XZEjWkgGhdu/5uQRVJtmQOE1WX4I4KwjPTwgsU/U/CLvwuE ZQnnb57vbSMBTZ2AZF48Q3xgLtMdxX/Lz5pawObeUXrRlY/jy4184UgdPBhvtuE/O244 ak71ZyoeJlO0YAr2wgxVzjNJ8yeYUuA/IUeyKT1krflCmUVDs9iLT9MnzPFtynR9e8Xl 6Fpw== X-Gm-Message-State: AHPjjUiDkhyoUqIwj0c4FTXtcCkVgIE0k+wnYqrsyvZFWxvzxYj/+Cm6 XNysf/wUTbXN+tIrCu8roGXPxw== X-Google-Smtp-Source: AOwi7QChHE2pb7foOncXfq04cxIfC0r2LZmdvCpAZzJXAbZT6VAsuD3btSZvnWE7Hi4ZhwWvzsmCIw== X-Received: by 10.84.129.193 with SMTP id b59mr4936381plb.147.1506635335815; Thu, 28 Sep 2017 14:48:55 -0700 (PDT) Received: from localhost.localdomain (67-207-98-108.static.wiline.com. [67.207.98.108]) by smtp.gmail.com with ESMTPSA id f8sm3540310pgs.7.2017.09.28.14.48.54 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 28 Sep 2017 14:48:54 -0700 (PDT) From: Tom Herbert To: davem@davemloft.net Cc: netdev@vger.kernel.org, rohit@quantonium.net, Tom Herbert Subject: [PATCH v3 net-next 8/8] vxlan: support flow dissect Date: Thu, 28 Sep 2017 14:48:23 -0700 Message-Id: <20170928214823.2426-8-tom@quantonium.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170928214823.2426-1-tom@quantonium.net> References: <20170928214823.2426-1-tom@quantonium.net> Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Populate offload flow_dissect callback appropriately for VXLAN and VXLAN-GPE. Signed-off-by: Tom Herbert --- drivers/net/vxlan.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c index d7c49cf1d5e9..80227050b2d4 100644 --- a/drivers/net/vxlan.c +++ b/drivers/net/vxlan.c @@ -1327,6 +1327,45 @@ static bool vxlan_ecn_decapsulate(struct vxlan_sock *vs, void *oiph, return err <= 1; } +static enum flow_dissect_ret vxlan_flow_dissect(struct sock *sk, + const struct sk_buff *skb, + struct flow_dissector_key_control *key_control, + struct flow_dissector *flow_dissector, + void *target_container, void *data, + __be16 *p_proto, u8 *p_ip_proto, int *p_nhoff, + int *p_hlen, unsigned int flags) +{ + __be16 protocol = htons(ETH_P_TEB); + struct vxlanhdr *vhdr, _vhdr; + struct vxlan_sock *vs; + + vhdr = __skb_header_pointer(skb, *p_nhoff + sizeof(struct udphdr), + sizeof(_vhdr), data, *p_hlen, &_vhdr); + if (!vhdr) + return FLOW_DISSECT_RET_OUT_BAD; + + vs = rcu_dereference_sk_user_data(sk); + if (!vs) + return FLOW_DISSECT_RET_OUT_BAD; + + if (vs->flags & VXLAN_F_GPE) { + struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)vhdr; + + /* Need to have Next Protocol set for interfaces in GPE mode. */ + if (gpe->version != 0 || !gpe->np_applied || gpe->oam_flag) + return FLOW_DISSECT_RET_CONTINUE; + + protocol = tun_p_from_eth_p(gpe->next_protocol); + if (!protocol) + return FLOW_DISSECT_RET_CONTINUE; + } + + *p_nhoff += sizeof(struct udphdr) + sizeof(_vhdr); + *p_proto = protocol; + + return FLOW_DISSECT_RET_PROTO_AGAIN; +} + /* Callback from net/ipv4/udp.c to receive packets */ static int vxlan_rcv(struct sock *sk, struct sk_buff *skb) { @@ -2846,6 +2885,7 @@ static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6, tunnel_cfg.encap_destroy = NULL; tunnel_cfg.gro_receive = vxlan_gro_receive; tunnel_cfg.gro_complete = vxlan_gro_complete; + tunnel_cfg.flow_dissect = vxlan_flow_dissect; setup_udp_tunnel_sock(net, sock, &tunnel_cfg);