From patchwork Thu Jul 25 22:52:25 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137141 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="pAB5K0WP"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnY22N9Tz9s00 for ; Fri, 26 Jul 2019 08:52:38 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726997AbfGYWwi (ORCPT ); Thu, 25 Jul 2019 18:52:38 -0400 Received: from mail-pf1-f202.google.com ([209.85.210.202]:51000 "EHLO mail-pf1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726829AbfGYWwh (ORCPT ); Thu, 25 Jul 2019 18:52:37 -0400 Received: by mail-pf1-f202.google.com with SMTP id h27so31811598pfq.17 for ; Thu, 25 Jul 2019 15:52:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=q2qVpSEjbdKuRWDTXifa9srSYTSuWUhFa7bELs3sAgg=; b=pAB5K0WPtbWnmH0V/wRCJSgo6rxFZ5g829Rc8GCL8bR6p2gXsvvps2+CFdzQcH9MZE wkl6ErbC9Xov1xeVK90oFyG3FZ71pbCHIvwuyrP1NE1kInPOClywmgsuzhR4E/iz6tRu N0ouwT96RsdrJjGslmf7GtuZxIKrFyX6iNs35QDdYwDJfUbCHK7Cd5/4eFGoH8l6ZDmp ywOpu7Vu2xH2ExdcimcDF8IPEVvBfCHha2CSvocPHiLXqMRh4jxqunhKXC+mcOGyEGdl jpE4QeK/af3QTSg0L2F7ttcZoqlKyYggcTKxTiE3D27a4u2SmfcdZiNDsYkO3jHZexwY 0wag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=q2qVpSEjbdKuRWDTXifa9srSYTSuWUhFa7bELs3sAgg=; b=RhUSCwRJ1Q1EkJMVWVsapZmGb7vg9T5dlx+MjTO3BwaDO5yPIoCykiPmgKsYl0W36f c5IF8j/GePfivevQVhxeUee3OI/IMqI6xVsMLLGD3eBgEWu3a8A1wspyhVvT+rq4Iotc rmh+Sb8NM7lEecJ1i+FMTy/rrNZ5mRpP2Q5QAKslN8a8rAc6GfOvA4PRFtSAUCmdAYCQ gB02gg+e5TsOMo+/2s6r3uHxIAmU+wNQU2JSacqKuEegKAcha4wx6zg1AgBaS67z4SIb 8oB+0aP3hgLycSUbfsomrZAS05RfFW2J2DQ+BLRg7UyuQPucPj9CLjEiqWwKM4Ept2Ho NBHw== X-Gm-Message-State: APjAAAXAEB+6iXkuwkeKt0ZGTvQB+O1LNCxUVjE2BgJUVoHoXNetG9Gj nvyMpPtLMR8XM3v0AgvVAILfPDU= X-Google-Smtp-Source: APXvYqyh66ttMnYzT53+vpXKX2Z8k76Z2Ic/SJ1d7nEJ7lGpINOPXP2Qpw09f63G0blvVy74CNTmQD0= X-Received: by 2002:a63:5860:: with SMTP id i32mr60300490pgm.124.1564095156486; Thu, 25 Jul 2019 15:52:36 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:25 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-2-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 1/7] bpf/flow_dissector: pass input flags to BPF flow dissector program From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org C flow dissector supports input flags that tell it to customize parsing by either stopping early or trying to parse as deep as possible. Pass those flags to the BPF flow dissector so it can make the same decisions. In the next commits I'll add support for those flags to our reference bpf_flow.c v3: * Export copy of flow dissector flags instead of moving (Alexei Starovoitov) Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- include/linux/skbuff.h | 2 +- include/uapi/linux/bpf.h | 5 +++++ net/bpf/test_run.c | 2 +- net/core/flow_dissector.c | 12 ++++++++++-- 4 files changed, 17 insertions(+), 4 deletions(-) diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h index 718742b1c505..9b7a8038beec 100644 --- a/include/linux/skbuff.h +++ b/include/linux/skbuff.h @@ -1271,7 +1271,7 @@ static inline int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr) struct bpf_flow_dissector; bool bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx, - __be16 proto, int nhoff, int hlen); + __be16 proto, int nhoff, int hlen, unsigned int flags); bool __skb_flow_dissect(const struct net *net, const struct sk_buff *skb, diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index fa1c753dcdbc..88b9d743036f 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -3507,6 +3507,10 @@ enum bpf_task_fd_type { BPF_FD_TYPE_URETPROBE, /* filename + offset */ }; +#define BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG (1U << 0) +#define BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL (1U << 1) +#define BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP (1U << 2) + struct bpf_flow_keys { __u16 nhoff; __u16 thoff; @@ -3528,6 +3532,7 @@ struct bpf_flow_keys { __u32 ipv6_dst[4]; /* in6_addr; network order */ }; }; + __u32 flags; }; struct bpf_func_info { diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 80e6f3a6864d..4e41d15a1098 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -419,7 +419,7 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, time_start = ktime_get_ns(); for (i = 0; i < repeat; i++) { retval = bpf_flow_dissect(prog, &ctx, eth->h_proto, ETH_HLEN, - size); + size, 0); if (signal_pending(current)) { preempt_enable(); diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index 3e6fedb57bc1..50ed1a688709 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -784,7 +784,7 @@ static void __skb_flow_bpf_to_target(const struct bpf_flow_keys *flow_keys, } bool bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx, - __be16 proto, int nhoff, int hlen) + __be16 proto, int nhoff, int hlen, unsigned int flags) { struct bpf_flow_keys *flow_keys = ctx->flow_keys; u32 result; @@ -795,6 +795,14 @@ bool bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx, flow_keys->nhoff = nhoff; flow_keys->thoff = flow_keys->nhoff; + BUILD_BUG_ON((int)BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG != + (int)FLOW_DISSECTOR_F_PARSE_1ST_FRAG); + BUILD_BUG_ON((int)BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL != + (int)FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL); + BUILD_BUG_ON((int)BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP != + (int)FLOW_DISSECTOR_F_STOP_AT_ENCAP); + flow_keys->flags = flags; + preempt_disable(); result = BPF_PROG_RUN(prog, ctx); preempt_enable(); @@ -914,7 +922,7 @@ bool __skb_flow_dissect(const struct net *net, } ret = bpf_flow_dissect(attached, &ctx, n_proto, nhoff, - hlen); + hlen, flags); __skb_flow_bpf_to_target(&flow_keys, flow_dissector, target_container); rcu_read_unlock(); From patchwork Thu Jul 25 22:52:26 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137143 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="vFWXwEJg"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnY52KZzz9s00 for ; Fri, 26 Jul 2019 08:52:41 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727036AbfGYWwk (ORCPT ); Thu, 25 Jul 2019 18:52:40 -0400 Received: from mail-pg1-f201.google.com ([209.85.215.201]:32980 "EHLO mail-pg1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726846AbfGYWwk (ORCPT ); Thu, 25 Jul 2019 18:52:40 -0400 Received: by mail-pg1-f201.google.com with SMTP id a21so24760676pgv.0 for ; Thu, 25 Jul 2019 15:52:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=yqXwkVRCVEANuJ47HJ+E6Vsq3E4n5B4/T1nK9NocYRQ=; b=vFWXwEJgfcYJW2Z2d2kcb92ptDT613MLhkWQQtVEV9XAcdSJ3qLuFaNrkdDkxNefhj r99ew5Ry+jiNnG0LqYp/+KKu2zOyx9NXSQDgk/hhVnBfhfdgO3cDMlvKsx27Y6vkiAzS jt/kho5moQTYELheBZyBmza7kUOHajk46P1sWGZtij1J2WHZN+ubOzgnoEWVDrZVwXP4 CiSDMhanyKhuTgyv7eBxIxdF57urSItnBrv5JA2BH8VFvoXeiGgtQ5W3ImlaMeCLc+u2 ECuxkL5rzUO+bM+xd08dFWiKMi1kwBsZsh4lbs4E9UAkmM7SnvTzyj2IrEVC6UWLZwWc dyBA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=yqXwkVRCVEANuJ47HJ+E6Vsq3E4n5B4/T1nK9NocYRQ=; b=oPp0VD7VxxWg4qO2/zpZeQ6lao9HdWX4+a9QuQkgBExJ0JG4QsbMxbg6IDua3zyRKz yzaAhgngW/iS+dU7wlegDlZL+mRS8CpyL3ES+JW4xFpZPoxAz8hvaCRI2J99LUQqXWQ4 Pvqi6tNGB8MB6J6ZIfEyR76QtMUVmA3ZkUCK++7Nh0Of4R2W+DqdPgHhhQ0w0fsl4mmt sxghLTkRXaEf9+g+DhR7MNH4W2wbonmS64B6HIb0iWBxHbGpdoHr5O4uxSpMbvLqrwA+ b+/kOQFRylKCIOMfzuviqaVKmYTOl3QJWPQfYbsbgJ9cWenB6qjE3jPD2kQo4c3/LET1 f5OA== X-Gm-Message-State: APjAAAWAmjfbL3CDBSzKey0RCQmCG0wrGL7To9hM+NDYlIo/Wt+M1gZO edFumDASv4Z3k2MKTFpNTonC9Vk= X-Google-Smtp-Source: APXvYqyIZReguwb8LDkNnn2uypGrrLWGu6eLxB+9ZkE346+t3Fny64svX5TyqmErlGRPhuEnCNfIEz8= X-Received: by 2002:a63:505a:: with SMTP id q26mr86045668pgl.18.1564095159124; Thu, 25 Jul 2019 15:52:39 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:26 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-3-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 2/7] bpf/flow_dissector: document flags From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Describe what each input flag does and who uses it. Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- Documentation/bpf/prog_flow_dissector.rst | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/Documentation/bpf/prog_flow_dissector.rst b/Documentation/bpf/prog_flow_dissector.rst index ed343abe541e..a78bf036cadd 100644 --- a/Documentation/bpf/prog_flow_dissector.rst +++ b/Documentation/bpf/prog_flow_dissector.rst @@ -26,6 +26,7 @@ and output arguments. * ``nhoff`` - initial offset of the networking header * ``thoff`` - initial offset of the transport header, initialized to nhoff * ``n_proto`` - L3 protocol type, parsed out of L2 header + * ``flags`` - optional flags Flow dissector BPF program should fill out the rest of the ``struct bpf_flow_keys`` fields. Input arguments ``nhoff/thoff/n_proto`` should be @@ -101,6 +102,23 @@ can be called for both cases and would have to be written carefully to handle both cases. +Flags +===== + +``flow_keys->flags`` might contain optional input flags that work as follows: + +* ``BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG`` - tells BPF flow dissector to + continue parsing first fragment; the default expected behavior is that + flow dissector returns as soon as it finds out that the packet is fragmented; + used by ``eth_get_headlen`` to estimate length of all headers for GRO. +* ``BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL`` - tells BPF flow dissector to + stop parsing as soon as it reaches IPv6 flow label; used by + ``___skb_get_hash`` and ``__skb_get_hash_symmetric`` to get flow hash. +* ``BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP`` - tells BPF flow dissector to stop + parsing as soon as it reaches encapsulated headers; used by routing + infrastructure. + + Reference Implementation ======================== From patchwork Thu Jul 25 22:52:27 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137145 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="VcVMOoIN"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnY75stWz9s00 for ; Fri, 26 Jul 2019 08:52:43 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727055AbfGYWwn (ORCPT ); Thu, 25 Jul 2019 18:52:43 -0400 Received: from mail-pg1-f201.google.com ([209.85.215.201]:55395 "EHLO mail-pg1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726862AbfGYWwm (ORCPT ); Thu, 25 Jul 2019 18:52:42 -0400 Received: by mail-pg1-f201.google.com with SMTP id z14so24621529pgr.22 for ; Thu, 25 Jul 2019 15:52:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=qYiLPfD1jN/p5ufntq2ZDe7HjIN5+8qjpe5If3CnHQU=; b=VcVMOoINi1CEqtFaLn318ESdEI3Z1k05sEzIZ9WwDCEYv17xsC1iGTM+XZ8OOI7EHj Rpg3LlwupLvOz/alzyWlKE7iUgxwxG2+0/aR+lhQVrhA5fj5iJYJ53GcvusSyODLffEO Tm2OvlSAIO5IhlXMRKb2u43JPx2P60w3cASWBjD+6SMUajOZZ/Kkq5XP5K9gb1Wgp03v oINVDoqPxOdUirmW6RZck7pcPI54re6M/KZgJgeU9xEAPT7EHR90VMYEhZGOOPfmI3X2 u5deOYPVG622sDYjwuvGIqeE4zWq4IJVYcOuOXNH1GkB39jWysT9NxOl8OsiXkgyHTQ7 htIg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=qYiLPfD1jN/p5ufntq2ZDe7HjIN5+8qjpe5If3CnHQU=; b=bAi+YF3150//2MEtVtO/WiwAMsdKkFE0bc1UfhQPE3rjqCQZDUVNNuuYsHJlHRQyci FydECCy/BQbUjaKgUzODWI00PT+a3uX9lAgFVeMz179KfmLKi0OH3JcNOj1hnDtEaM7Z TMNmH0YnWOp4cjJUzXGo/cx5+YyUxOhDHxazsc8hLFe/Wume4DC/icO1K/jou1z8VTO6 z5ypICBzSlyRT6o7FnCNHYHGAYV4EGUxZZXZLLdDN5C4imRvynuJHtTlVf+KOr8BOfVs pArpnJKp+H8I/m47i7Z4Cm0YT9hdbKRSHce9E8tc0m6z6d9bFPxXbAz7n7/wvytPHIZ6 +Snw== X-Gm-Message-State: APjAAAWReP29YyWXZX3OCum8b5VZDSkR7JmvVKxTYF8MDM4nC2U7Hdze hFLoswK1LcoKmc+giOHB2QbCmWc= X-Google-Smtp-Source: APXvYqwAChx4jYJmADdPXx1eRfS8HHTSS4iB6rhyvGq2bj+nnCdYN1YJA7tBeF54SjdH4k1bkFHBnIo= X-Received: by 2002:a65:6081:: with SMTP id t1mr89463688pgu.9.1564095161890; Thu, 25 Jul 2019 15:52:41 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:27 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-4-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 3/7] bpf/flow_dissector: support flags in BPF_PROG_TEST_RUN From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org This will allow us to write tests for those flags. v2: * Swap kfree(data) and kfree(user_ctx) (Song Liu) Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- net/bpf/test_run.c | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 4e41d15a1098..1153bbcdff72 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -377,6 +377,22 @@ int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr, return ret; } +static int verify_user_bpf_flow_keys(struct bpf_flow_keys *ctx) +{ + /* make sure the fields we don't use are zeroed */ + if (!range_is_zero(ctx, 0, offsetof(struct bpf_flow_keys, flags))) + return -EINVAL; + + /* flags is allowed */ + + if (!range_is_zero(ctx, offsetof(struct bpf_flow_keys, flags) + + FIELD_SIZEOF(struct bpf_flow_keys, flags), + sizeof(struct bpf_flow_keys))) + return -EINVAL; + + return 0; +} + int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, const union bpf_attr *kattr, union bpf_attr __user *uattr) @@ -384,9 +400,11 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, u32 size = kattr->test.data_size_in; struct bpf_flow_dissector ctx = {}; u32 repeat = kattr->test.repeat; + struct bpf_flow_keys *user_ctx; struct bpf_flow_keys flow_keys; u64 time_start, time_spent = 0; const struct ethhdr *eth; + unsigned int flags = 0; u32 retval, duration; void *data; int ret; @@ -395,9 +413,6 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, if (prog->type != BPF_PROG_TYPE_FLOW_DISSECTOR) return -EINVAL; - if (kattr->test.ctx_in || kattr->test.ctx_out) - return -EINVAL; - if (size < ETH_HLEN) return -EINVAL; @@ -410,6 +425,18 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, if (!repeat) repeat = 1; + user_ctx = bpf_ctx_init(kattr, sizeof(struct bpf_flow_keys)); + if (IS_ERR(user_ctx)) { + kfree(data); + return PTR_ERR(user_ctx); + } + if (user_ctx) { + ret = verify_user_bpf_flow_keys(user_ctx); + if (ret) + goto out; + flags = user_ctx->flags; + } + ctx.flow_keys = &flow_keys; ctx.data = data; ctx.data_end = (__u8 *)data + size; @@ -419,7 +446,7 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, time_start = ktime_get_ns(); for (i = 0; i < repeat; i++) { retval = bpf_flow_dissect(prog, &ctx, eth->h_proto, ETH_HLEN, - size, 0); + size, flags); if (signal_pending(current)) { preempt_enable(); @@ -450,8 +477,12 @@ int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, ret = bpf_test_finish(kattr, uattr, &flow_keys, sizeof(flow_keys), retval, duration); + if (!ret) + ret = bpf_ctx_finish(kattr, uattr, user_ctx, + sizeof(struct bpf_flow_keys)); out: + kfree(user_ctx); kfree(data); return ret; } From patchwork Thu Jul 25 22:52:28 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137147 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="Z+b/bGhR"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnYB68Ryz9s00 for ; Fri, 26 Jul 2019 08:52:46 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727084AbfGYWwp (ORCPT ); Thu, 25 Jul 2019 18:52:45 -0400 Received: from mail-pg1-f201.google.com ([209.85.215.201]:44462 "EHLO mail-pg1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726869AbfGYWwp (ORCPT ); Thu, 25 Jul 2019 18:52:45 -0400 Received: by mail-pg1-f201.google.com with SMTP id a21so31592143pgh.11 for ; Thu, 25 Jul 2019 15:52:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=DgAXQIdA0ZhiJ+xsheYT6VV9/xgThvpc7H+hWpWWals=; b=Z+b/bGhRGPiEr7jhNeoEliqMlHbZtMWeT6oR9aAmNAfg3zihXrHrIG0e2I8bdrRR4z mJughnLma8eXEITUZPgDD4EIF/ZbdBuKQaAWn5HFgjxpVU/WTjI7En3/vqrQ2imEsRzi DYFwCPQXIFD+ltMPHODkscT7xGTqBm1rnInUxOqkmHZSw0/8qXa4DTRz8bAGyTLPgwMW JOCM1/EByu3hI2/Nt+sBN0qX/npziImmxt9H0o+BgPoQqvkfnojUDI8gJWUFsGBWJxVV kTJIqlsqV5UshEzLs9vi8eUSrfl6UiYtuiuPrCQGlUTJw89gNgLTTwtte4x4yjfBqrS3 1z7A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=DgAXQIdA0ZhiJ+xsheYT6VV9/xgThvpc7H+hWpWWals=; b=tB3iF4uA5dchvgxGEq6kd7H19SH7lQc0Eh4ODlLpQfvtCAoobxk+EcvZL6exvU0Ua6 NYe5TEEGMf10EzlkNPsgA0FqCKEQZC1J93Ovqnm0FPZNC3xmCsFWwqQMCA+RiAX5AbQi VGdpfhhoyHlNeYBr8jMC+rhb3GgrxUqKB14xf1em9HERGXXAWzS1SrPFuH8I/zikvnxl QVEt+IMXidr+hwx3XgBcg1nVWK6lANZN9YBH+vg4R8ezWPJkY2pR9X0ZGSKO0kV7ZZ62 ugLueNGIoeuxedUowwb3hgHxTa5Ci6lWFdXaa1I280c7ZFm5MORnF/jVQMBvrl1+cC3f t+MA== X-Gm-Message-State: APjAAAWQSAA1J30aZsDJXUT0qa6PPrscNWMjMMb38C4RKwDzxzN5cjmB /I6LRQGdLSYJmI7eXKj0qxSeJzs= X-Google-Smtp-Source: APXvYqywSlusS3kT7pdugZP6FYyE64YryoLfEc2VX+H5iycxuT1/zBr3TIiXIPi4jVFlf3CLM2yjoEU= X-Received: by 2002:a65:44cb:: with SMTP id g11mr42780890pgs.288.1564095164486; Thu, 25 Jul 2019 15:52:44 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:28 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-5-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 4/7] tools/bpf: sync bpf_flow_keys flags From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Export bpf_flow_keys flags to tools/libbpf/selftests. Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- tools/include/uapi/linux/bpf.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 4e455018da65..2e4b0848d795 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -3504,6 +3504,10 @@ enum bpf_task_fd_type { BPF_FD_TYPE_URETPROBE, /* filename + offset */ }; +#define BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG (1U << 0) +#define BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL (1U << 1) +#define BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP (1U << 2) + struct bpf_flow_keys { __u16 nhoff; __u16 thoff; @@ -3525,6 +3529,7 @@ struct bpf_flow_keys { __u32 ipv6_dst[4]; /* in6_addr; network order */ }; }; + __u32 flags; }; struct bpf_func_info { From patchwork Thu Jul 25 22:52:29 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137149 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="oPIjFvgC"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnYF1SdSz9s00 for ; Fri, 26 Jul 2019 08:52:49 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727101AbfGYWws (ORCPT ); Thu, 25 Jul 2019 18:52:48 -0400 Received: from mail-qt1-f202.google.com ([209.85.160.202]:47191 "EHLO mail-qt1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727081AbfGYWws (ORCPT ); Thu, 25 Jul 2019 18:52:48 -0400 Received: by mail-qt1-f202.google.com with SMTP id s9so45807015qtn.14 for ; Thu, 25 Jul 2019 15:52:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=GqrVqR9W0ahtxEON2ZmXPZWAxl+RiznRPwj8fPkH+U8=; b=oPIjFvgC/dOB+J7XaLcFKMs1QZVuyrrTCrEnuibUcPU25K7vYY8/cFgqcGFQTOv0Z7 1kmgVeface3VX6q8h7rfmI3UTfCgn7qaj2LpI7mwEwzEKtmLlFJ7kxbosfiwRV09ujuf j0B6e2aiZUG8MhpBe/Hj6U17Z/FKP79NFaYfcasDtE0a1GA2oB8QTez0Gcrw7qLI72FH qcSi1NvjBCDslyleYefFLExTVAczu2emweSPnrIsT0nusobqSjrqMiv0kCYm7eoELor5 uhw8dx6fuKBGm+ql+AQDeMiRcx84iWEsAfquFea+rtVvkTp+8L4e18oYfapaiCCYU0Nh JSrg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=GqrVqR9W0ahtxEON2ZmXPZWAxl+RiznRPwj8fPkH+U8=; b=cox2Bl00hgdNsZ0xB1ZJ4sKqSPXhrQY0PyRsWw3wDLzLUQW+7cG9Dg/GKgGxL+9bbb 9xOuvLhWjaLQMakhdub3v3q1Wub7rzFX1ZJVcQOT9Dp89MHOOijPztEkLXuJzD4E8Czi d7CmvSwBETId4csf7Y3eFrSBfjWGyD8BxUey8504OzEV/xMDVZtHBWnf54ATwxPlMn8r Gv820s7RpkdF1DZ5zWd3vQUd6DjbOlngp1GaO1fJ1Iz6UZ/IVj5SvnDh2tiQg6dG2Itr yoQzViHsG82Unkr7s9NBM/T4XNY0GHfQYJjO9oFWWDrLdFUoFJQ7xz5njMZojrQ1qr7D VGcw== X-Gm-Message-State: APjAAAWtLBu+WJMOdTf4bh6W2E4bpL25fSYpwG9Z/qYLRghy7Ijtqnak GiJRTDmDykpRywDdijqgEwT9P6k= X-Google-Smtp-Source: APXvYqz3uli8podc8X2FyZ3k+7ZIgVWJtntSskaydP7RxGfFapfKRruKp29RGgw0gonsNy/HOVyIV1Y= X-Received: by 2002:a37:c81:: with SMTP id 123mr62171006qkm.474.1564095167114; Thu, 25 Jul 2019 15:52:47 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:29 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-6-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 5/7] selftests/bpf: support BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org bpf_flow.c: exit early unless BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG is passed in flags. Also, set ip_proto earlier, this makes sure we have correct value with fragmented packets. Add selftest cases to test ipv4/ipv6 fragments and skip eth_get_headlen tests that don't have BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG flag. eth_get_headlen calls flow dissector with BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG flag so we can't run tests that have different set of input flags against it. v2: * sefltests -> selftests (Willem de Bruijn) * Reword a comment about eth_get_headlen flags (Song Liu) Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- .../selftests/bpf/prog_tests/flow_dissector.c | 133 +++++++++++++++++- tools/testing/selftests/bpf/progs/bpf_flow.c | 29 +++- 2 files changed, 155 insertions(+), 7 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c index c938283ac232..8e8c18aced9b 100644 --- a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c +++ b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c @@ -5,6 +5,10 @@ #include #include +#ifndef IP_MF +#define IP_MF 0x2000 +#endif + #define CHECK_FLOW_KEYS(desc, got, expected) \ CHECK_ATTR(memcmp(&got, &expected, sizeof(got)) != 0, \ desc, \ @@ -49,6 +53,18 @@ struct ipv6_pkt { struct tcphdr tcp; } __packed; +struct ipv6_frag_pkt { + struct ethhdr eth; + struct ipv6hdr iph; + struct frag_hdr { + __u8 nexthdr; + __u8 reserved; + __be16 frag_off; + __be32 identification; + } ipf; + struct tcphdr tcp; +} __packed; + struct dvlan_ipv6_pkt { struct ethhdr eth; __u16 vlan_tci; @@ -65,9 +81,11 @@ struct test { struct ipv4_pkt ipv4; struct svlan_ipv4_pkt svlan_ipv4; struct ipv6_pkt ipv6; + struct ipv6_frag_pkt ipv6_frag; struct dvlan_ipv6_pkt dvlan_ipv6; } pkt; struct bpf_flow_keys keys; + __u32 flags; }; #define VLAN_HLEN 4 @@ -143,6 +161,102 @@ struct test tests[] = { .n_proto = __bpf_constant_htons(ETH_P_IPV6), }, }, + { + .name = "ipv4-frag", + .pkt.ipv4 = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IP), + .iph.ihl = 5, + .iph.protocol = IPPROTO_TCP, + .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), + .iph.frag_off = __bpf_constant_htons(IP_MF), + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .flags = BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG, + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct iphdr), + .addr_proto = ETH_P_IP, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IP), + .is_frag = true, + .is_first_frag = true, + .sport = 80, + .dport = 8080, + }, + .flags = BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG, + }, + { + .name = "ipv4-no-frag", + .pkt.ipv4 = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IP), + .iph.ihl = 5, + .iph.protocol = IPPROTO_TCP, + .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), + .iph.frag_off = __bpf_constant_htons(IP_MF), + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct iphdr), + .addr_proto = ETH_P_IP, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IP), + .is_frag = true, + .is_first_frag = true, + }, + }, + { + .name = "ipv6-frag", + .pkt.ipv6_frag = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), + .iph.nexthdr = IPPROTO_FRAGMENT, + .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), + .ipf.nexthdr = IPPROTO_TCP, + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .flags = BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG, + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct ipv6hdr) + + sizeof(struct frag_hdr), + .addr_proto = ETH_P_IPV6, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IPV6), + .is_frag = true, + .is_first_frag = true, + .sport = 80, + .dport = 8080, + }, + .flags = BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG, + }, + { + .name = "ipv6-no-frag", + .pkt.ipv6_frag = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), + .iph.nexthdr = IPPROTO_FRAGMENT, + .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), + .ipf.nexthdr = IPPROTO_TCP, + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct ipv6hdr) + + sizeof(struct frag_hdr), + .addr_proto = ETH_P_IPV6, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IPV6), + .is_frag = true, + .is_first_frag = true, + }, + }, }; static int create_tap(const char *ifname) @@ -225,6 +339,13 @@ void test_flow_dissector(void) .data_size_in = sizeof(tests[i].pkt), .data_out = &flow_keys, }; + static struct bpf_flow_keys ctx = {}; + + if (tests[i].flags) { + tattr.ctx_in = &ctx; + tattr.ctx_size_in = sizeof(ctx); + ctx.flags = tests[i].flags; + } err = bpf_prog_test_run_xattr(&tattr); CHECK_ATTR(tattr.data_size_out != sizeof(flow_keys) || @@ -251,10 +372,20 @@ void test_flow_dissector(void) CHECK(err, "ifup", "err %d errno %d\n", err, errno); for (i = 0; i < ARRAY_SIZE(tests); i++) { - struct bpf_flow_keys flow_keys = {}; + /* Keep in sync with 'flags' from eth_get_headlen. */ + __u32 eth_get_headlen_flags = + BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG; struct bpf_prog_test_run_attr tattr = {}; + struct bpf_flow_keys flow_keys = {}; __u32 key = 0; + /* For skb-less case we can't pass input flags; run + * only the tests that have a matching set of flags. + */ + + if (tests[i].flags != eth_get_headlen_flags) + continue; + err = tx_tap(tap_fd, &tests[i].pkt, sizeof(tests[i].pkt)); CHECK(err < 0, "tx_tap", "err %d errno %d\n", err, errno); diff --git a/tools/testing/selftests/bpf/progs/bpf_flow.c b/tools/testing/selftests/bpf/progs/bpf_flow.c index 5ae485a6af3f..f931cd3db9d4 100644 --- a/tools/testing/selftests/bpf/progs/bpf_flow.c +++ b/tools/testing/selftests/bpf/progs/bpf_flow.c @@ -153,7 +153,6 @@ static __always_inline int parse_ip_proto(struct __sk_buff *skb, __u8 proto) struct tcphdr *tcp, _tcp; struct udphdr *udp, _udp; - keys->ip_proto = proto; switch (proto) { case IPPROTO_ICMP: icmp = bpf_flow_dissect_get_header(skb, sizeof(*icmp), &_icmp); @@ -231,7 +230,6 @@ static __always_inline int parse_ipv6_proto(struct __sk_buff *skb, __u8 nexthdr) { struct bpf_flow_keys *keys = skb->flow_keys; - keys->ip_proto = nexthdr; switch (nexthdr) { case IPPROTO_HOPOPTS: case IPPROTO_DSTOPTS: @@ -266,6 +264,7 @@ PROG(IP)(struct __sk_buff *skb) keys->addr_proto = ETH_P_IP; keys->ipv4_src = iph->saddr; keys->ipv4_dst = iph->daddr; + keys->ip_proto = iph->protocol; keys->thoff += iph->ihl << 2; if (data + keys->thoff > data_end) @@ -273,13 +272,20 @@ PROG(IP)(struct __sk_buff *skb) if (iph->frag_off & bpf_htons(IP_MF | IP_OFFSET)) { keys->is_frag = true; - if (iph->frag_off & bpf_htons(IP_OFFSET)) + if (iph->frag_off & bpf_htons(IP_OFFSET)) { /* From second fragment on, packets do not have headers * we can parse. */ done = true; - else + } else { keys->is_first_frag = true; + /* No need to parse fragmented packet unless + * explicitly asked for. + */ + if (!(keys->flags & + BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG)) + done = true; + } } if (done) @@ -301,6 +307,7 @@ PROG(IPV6)(struct __sk_buff *skb) memcpy(&keys->ipv6_src, &ip6h->saddr, 2*sizeof(ip6h->saddr)); keys->thoff += sizeof(struct ipv6hdr); + keys->ip_proto = ip6h->nexthdr; return parse_ipv6_proto(skb, ip6h->nexthdr); } @@ -317,7 +324,8 @@ PROG(IPV6OP)(struct __sk_buff *skb) /* hlen is in 8-octets and does not include the first 8 bytes * of the header */ - skb->flow_keys->thoff += (1 + ip6h->hdrlen) << 3; + keys->thoff += (1 + ip6h->hdrlen) << 3; + keys->ip_proto = ip6h->nexthdr; return parse_ipv6_proto(skb, ip6h->nexthdr); } @@ -333,9 +341,18 @@ PROG(IPV6FR)(struct __sk_buff *skb) keys->thoff += sizeof(*fragh); keys->is_frag = true; - if (!(fragh->frag_off & bpf_htons(IP6_OFFSET))) + keys->ip_proto = fragh->nexthdr; + + if (!(fragh->frag_off & bpf_htons(IP6_OFFSET))) { keys->is_first_frag = true; + /* No need to parse fragmented packet unless + * explicitly asked for. + */ + if (!(keys->flags & BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG)) + return export_flow_keys(keys, BPF_OK); + } + return parse_ipv6_proto(skb, fragh->nexthdr); } From patchwork Thu Jul 25 22:52:30 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137151 X-Patchwork-Delegate: bpf@iogearbox.net Return-Path: X-Original-To: incoming-bpf@patchwork.ozlabs.org Delivered-To: patchwork-incoming-bpf@bilbo.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=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="LUMEgD7Z"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnYH51kzz9s00 for ; Fri, 26 Jul 2019 08:52:51 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727119AbfGYWwv (ORCPT ); Thu, 25 Jul 2019 18:52:51 -0400 Received: from mail-pf1-f201.google.com ([209.85.210.201]:48857 "EHLO mail-pf1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727091AbfGYWwu (ORCPT ); Thu, 25 Jul 2019 18:52:50 -0400 Received: by mail-pf1-f201.google.com with SMTP id u21so31858492pfn.15 for ; Thu, 25 Jul 2019 15:52:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=qL7cZRSBHY1VH9elVXnZ18wmVUw/HNyB8hQ7P/vwCwM=; b=LUMEgD7ZpfI47zY302IQcxJZSQCQMctM841QfzJO1gxBPHYqw4YVILoEUie0acRIrw oV0VLr5J118q7rIsxhUZbwzrX4wH84GWexiNg5IB0qV/5zj7UlqhpITce1RP3ZaHY7Nf ltlLHVkoxdGjjjLW7lf1+nDXzoISfV9D/Uke/DvIQGKohZqAqMyivBT8pu5Qzlf6EVtu olopwnG6cZ+cttcj/C7FMI0rvFTRGb5Ahc+1hBsOvPHsQMQIXI/xL4Pfpw6ljFVWo32+ NYWplL4AH5NFIEocgkkZzNCcniWWoGPCfxc8Bpblzqq+qNFw5cVPhoAzYwaiVVJJdNpj TcQg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=qL7cZRSBHY1VH9elVXnZ18wmVUw/HNyB8hQ7P/vwCwM=; b=WW/suOS3+YdQbHWzrVTkBcAOvoDRkzvifIcELKwS4JwcjslKHs7l0vrYODz063pXtV jqeyFLwoLYp0aEtkghC6RhHZy55Aq8rFh32Ljxz7yVvDDmb7mIByxGyYptb/Zk7VoXAi E8CTzdEBDujbXFBjdDwnFzNFXahyLuxXaV6fkMTq59Tw5dFG5pNY68bFZtHKYi8Ejtun +j4YpxylsxvJ0eJ1G5YdH/ZgX0a/p2/wMIKH+PaYLoNmMSD2ngK8q0kVhaEzj0Y0mEHv fYKnoM6KynvyuSEUq5oBR9si7VLhkavGjlHvS2Ru8qNDK9/HLLtszff+l8G0yJGOvixR RTRw== X-Gm-Message-State: APjAAAXjdQ0b4PdaT9rpblvbWlGAmZJCkjrwa/4ipiaRg5fg2D2N4Yez qNJUFvwpPSYFUtDQXkOpg5dB6DM= X-Google-Smtp-Source: APXvYqzCkLsD66O3mUhuFbm+nZa8F/q8RbclzigTlfZ7GGgVjhGoaPlPxhP35dj6As6DswOyn3UeeN8= X-Received: by 2002:a63:b10f:: with SMTP id r15mr18801078pgf.230.1564095169393; Thu, 25 Jul 2019 15:52:49 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:30 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-7-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 6/7] bpf/flow_dissector: support ipv6 flow_label and BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Add support for exporting ipv6 flow label via bpf_flow_keys. Export flow label from bpf_flow.c and also return early when BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL is passed. Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- include/uapi/linux/bpf.h | 1 + net/core/flow_dissector.c | 9 ++++ tools/include/uapi/linux/bpf.h | 1 + .../selftests/bpf/prog_tests/flow_dissector.c | 46 +++++++++++++++++++ tools/testing/selftests/bpf/progs/bpf_flow.c | 10 ++++ 5 files changed, 67 insertions(+) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 88b9d743036f..e985f07a98ed 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -3533,6 +3533,7 @@ struct bpf_flow_keys { }; }; __u32 flags; + __be32 flow_label; }; struct bpf_func_info { diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index 50ed1a688709..9741b593ea53 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -737,6 +737,7 @@ static void __skb_flow_bpf_to_target(const struct bpf_flow_keys *flow_keys, struct flow_dissector_key_basic *key_basic; struct flow_dissector_key_addrs *key_addrs; struct flow_dissector_key_ports *key_ports; + struct flow_dissector_key_tags *key_tags; key_control = skb_flow_dissector_target(flow_dissector, FLOW_DISSECTOR_KEY_CONTROL, @@ -781,6 +782,14 @@ static void __skb_flow_bpf_to_target(const struct bpf_flow_keys *flow_keys, key_ports->src = flow_keys->sport; key_ports->dst = flow_keys->dport; } + + if (dissector_uses_key(flow_dissector, + FLOW_DISSECTOR_KEY_FLOW_LABEL)) { + key_tags = skb_flow_dissector_target(flow_dissector, + FLOW_DISSECTOR_KEY_FLOW_LABEL, + target_container); + key_tags->flow_label = ntohl(flow_keys->flow_label); + } } bool bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx, diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 2e4b0848d795..3d7fc67ec1b8 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -3530,6 +3530,7 @@ struct bpf_flow_keys { }; }; __u32 flags; + __be32 flow_label; }; struct bpf_func_info { diff --git a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c index 8e8c18aced9b..ef83f145a6f1 100644 --- a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c +++ b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c @@ -20,6 +20,7 @@ "is_encap=%u/%u " \ "ip_proto=0x%x/0x%x " \ "n_proto=0x%x/0x%x " \ + "flow_label=0x%x/0x%x " \ "sport=%u/%u " \ "dport=%u/%u\n", \ got.nhoff, expected.nhoff, \ @@ -30,6 +31,7 @@ got.is_encap, expected.is_encap, \ got.ip_proto, expected.ip_proto, \ got.n_proto, expected.n_proto, \ + got.flow_label, expected.flow_label, \ got.sport, expected.sport, \ got.dport, expected.dport) @@ -257,6 +259,50 @@ struct test tests[] = { .is_first_frag = true, }, }, + { + .name = "ipv6-flow-label", + .pkt.ipv6 = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), + .iph.nexthdr = IPPROTO_TCP, + .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), + .iph.flow_lbl = { 0xb, 0xee, 0xef }, + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct ipv6hdr), + .addr_proto = ETH_P_IPV6, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IPV6), + .sport = 80, + .dport = 8080, + .flow_label = __bpf_constant_htonl(0xbeeef), + }, + }, + { + .name = "ipv6-no-flow-label", + .pkt.ipv6 = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), + .iph.nexthdr = IPPROTO_TCP, + .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), + .iph.flow_lbl = { 0xb, 0xee, 0xef }, + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .flags = BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL, + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct ipv6hdr), + .addr_proto = ETH_P_IPV6, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IPV6), + .flow_label = __bpf_constant_htonl(0xbeeef), + }, + .flags = BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL, + }, }; static int create_tap(const char *ifname) diff --git a/tools/testing/selftests/bpf/progs/bpf_flow.c b/tools/testing/selftests/bpf/progs/bpf_flow.c index f931cd3db9d4..7fbfa22f33df 100644 --- a/tools/testing/selftests/bpf/progs/bpf_flow.c +++ b/tools/testing/selftests/bpf/progs/bpf_flow.c @@ -83,6 +83,12 @@ static __always_inline int export_flow_keys(struct bpf_flow_keys *keys, return ret; } +#define IPV6_FLOWLABEL_MASK __bpf_constant_htonl(0x000FFFFF) +static inline __be32 ip6_flowlabel(const struct ipv6hdr *hdr) +{ + return *(__be32 *)hdr & IPV6_FLOWLABEL_MASK; +} + static __always_inline void *bpf_flow_dissect_get_header(struct __sk_buff *skb, __u16 hdr_size, void *buffer) @@ -308,6 +314,10 @@ PROG(IPV6)(struct __sk_buff *skb) keys->thoff += sizeof(struct ipv6hdr); keys->ip_proto = ip6h->nexthdr; + keys->flow_label = ip6_flowlabel(ip6h); + + if (keys->flags & BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL) + return export_flow_keys(keys, BPF_OK); return parse_ipv6_proto(skb, ip6h->nexthdr); } From patchwork Thu Jul 25 22:52:31 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stanislav Fomichev X-Patchwork-Id: 1137153 X-Patchwork-Delegate: bpf@iogearbox.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=pass (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="rNlE+24X"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 45vnYP2HBsz9sBZ for ; Fri, 26 Jul 2019 08:52:57 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727169AbfGYWwy (ORCPT ); Thu, 25 Jul 2019 18:52:54 -0400 Received: from mail-qk1-f202.google.com ([209.85.222.202]:51298 "EHLO mail-qk1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727124AbfGYWwx (ORCPT ); Thu, 25 Jul 2019 18:52:53 -0400 Received: by mail-qk1-f202.google.com with SMTP id s25so43555269qkj.18 for ; Thu, 25 Jul 2019 15:52:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=UlRemZ2kT14YHAylc9y0G5ccVqoKv3zS1dwSBWg5K9Y=; b=rNlE+24Xap0dVvBd7hIA2isBhcX4wir3CZWnhEVDWQlSEx3jMFHg1RKh1QHXVePJVa kw5n0/3EBvn9ivO6q+FlS8CALwKpB2+LwSjc0hIhAKpOpOu+hJaeE8LnZbLdY0tYXfLS dTzNEzhwJ8IP+07ExAwe430IDqv9MCzL3IOOR9hY4LZ8X+HGcPY1yXPMfvEA7GasWkMb xCvzh4sbQ4hxeu/gkDysaQDLPumoUzt4EP4ByG35oxVc2aRFR3AjyZ+JEvThA6lu1gEb xo7dvl9Ctw87F5NfSPpTb7Ny2EC6yGouX+6RmVrkP3TykfVRg1KpRPXpr2D86nuH/0JE IVvg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=UlRemZ2kT14YHAylc9y0G5ccVqoKv3zS1dwSBWg5K9Y=; b=Q5x1zPfxSj6lhAUiB1ZBhf5Arv4SKyYcQQqSvA9HYIwIvgjQkkOuGHOAGsRpOZ2eeM k70w76kbdpzYyI0Kmba46+4x6XRrCGqjJtvaTg18OMtTsgXq5rqy9FO+UbrRyEuaSqJv /lEzWUy0+3/8oEd7bC7iz+wYhRH8dat/DjsOjG9NzKyWtwVq8zt71qTWpHv4GLBCBfwH Z4dugt13nv5htJlTJs6Wc57Ix4LhkRZyDYIOpqQb8f9B9Ngl/3KZ458pr5Qi8AhAoYx4 C5AoHBfHFQaqgXdla6q3ToUgT0bQQTzatBdWoP4zB0IfvQylnfCl4rA2f8JDJIU7KEbz e1xg== X-Gm-Message-State: APjAAAUQrhAPVRLq9BcwWxinjFrzN5p4pOuFV9EYhX5N0GvN0PMXtTYH iig0xpmGtsMUce7bk/1ejqaQgPNHpgkU4pOzSV3vigzMYIcYGywNURrO4EOEZ8DgTyvVRIkbR+f zAkd4mNPAOys8tPui2MPUinFeOKtGcOLtG12GhtoSgemrWNqdPquu/A== X-Google-Smtp-Source: APXvYqypjifXslPHkH9woXWF5vpWpt5hJxon/sboM5/ybdSHyvPXTsMa85cTxqD9jnMwegm5CRdAgqA= X-Received: by 2002:a37:4e8f:: with SMTP id c137mr59090880qkb.127.1564095172242; Thu, 25 Jul 2019 15:52:52 -0700 (PDT) Date: Thu, 25 Jul 2019 15:52:31 -0700 In-Reply-To: <20190725225231.195090-1-sdf@google.com> Message-Id: <20190725225231.195090-8-sdf@google.com> Mime-Version: 1.0 References: <20190725225231.195090-1-sdf@google.com> X-Mailer: git-send-email 2.22.0.709.g102302147b-goog Subject: [PATCH bpf-next v3 7/7] selftests/bpf: support BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP From: Stanislav Fomichev To: netdev@vger.kernel.org, bpf@vger.kernel.org Cc: davem@davemloft.net, ast@kernel.org, daniel@iogearbox.net, Stanislav Fomichev , Petar Penkov , Willem de Bruijn , Song Liu Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Exit as soon as we found that packet is encapped when BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP is passed. Add appropriate selftest cases. v2: * Subtract sizeof(struct iphdr) from .iph_inner.tot_len (Willem de Bruijn) Acked-by: Petar Penkov Acked-by: Willem de Bruijn Acked-by: Song Liu Cc: Song Liu Cc: Willem de Bruijn Cc: Petar Penkov Signed-off-by: Stanislav Fomichev --- .../selftests/bpf/prog_tests/flow_dissector.c | 64 +++++++++++++++++++ tools/testing/selftests/bpf/progs/bpf_flow.c | 8 +++ 2 files changed, 72 insertions(+) diff --git a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c index ef83f145a6f1..700d73d2f22a 100644 --- a/tools/testing/selftests/bpf/prog_tests/flow_dissector.c +++ b/tools/testing/selftests/bpf/prog_tests/flow_dissector.c @@ -41,6 +41,13 @@ struct ipv4_pkt { struct tcphdr tcp; } __packed; +struct ipip_pkt { + struct ethhdr eth; + struct iphdr iph; + struct iphdr iph_inner; + struct tcphdr tcp; +} __packed; + struct svlan_ipv4_pkt { struct ethhdr eth; __u16 vlan_tci; @@ -82,6 +89,7 @@ struct test { union { struct ipv4_pkt ipv4; struct svlan_ipv4_pkt svlan_ipv4; + struct ipip_pkt ipip; struct ipv6_pkt ipv6; struct ipv6_frag_pkt ipv6_frag; struct dvlan_ipv6_pkt dvlan_ipv6; @@ -303,6 +311,62 @@ struct test tests[] = { }, .flags = BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL, }, + { + .name = "ipip-encap", + .pkt.ipip = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IP), + .iph.ihl = 5, + .iph.protocol = IPPROTO_IPIP, + .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), + .iph_inner.ihl = 5, + .iph_inner.protocol = IPPROTO_TCP, + .iph_inner.tot_len = + __bpf_constant_htons(MAGIC_BYTES) - + sizeof(struct iphdr), + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .nhoff = 0, + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct iphdr) + + sizeof(struct iphdr), + .addr_proto = ETH_P_IP, + .ip_proto = IPPROTO_TCP, + .n_proto = __bpf_constant_htons(ETH_P_IP), + .is_encap = true, + .sport = 80, + .dport = 8080, + }, + }, + { + .name = "ipip-no-encap", + .pkt.ipip = { + .eth.h_proto = __bpf_constant_htons(ETH_P_IP), + .iph.ihl = 5, + .iph.protocol = IPPROTO_IPIP, + .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), + .iph_inner.ihl = 5, + .iph_inner.protocol = IPPROTO_TCP, + .iph_inner.tot_len = + __bpf_constant_htons(MAGIC_BYTES) - + sizeof(struct iphdr), + .tcp.doff = 5, + .tcp.source = 80, + .tcp.dest = 8080, + }, + .keys = { + .flags = BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP, + .nhoff = ETH_HLEN, + .thoff = ETH_HLEN + sizeof(struct iphdr), + .addr_proto = ETH_P_IP, + .ip_proto = IPPROTO_IPIP, + .n_proto = __bpf_constant_htons(ETH_P_IP), + .is_encap = true, + }, + .flags = BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP, + }, }; static int create_tap(const char *ifname) diff --git a/tools/testing/selftests/bpf/progs/bpf_flow.c b/tools/testing/selftests/bpf/progs/bpf_flow.c index 7fbfa22f33df..08bd8b9d58d0 100644 --- a/tools/testing/selftests/bpf/progs/bpf_flow.c +++ b/tools/testing/selftests/bpf/progs/bpf_flow.c @@ -167,9 +167,15 @@ static __always_inline int parse_ip_proto(struct __sk_buff *skb, __u8 proto) return export_flow_keys(keys, BPF_OK); case IPPROTO_IPIP: keys->is_encap = true; + if (keys->flags & BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP) + return export_flow_keys(keys, BPF_OK); + return parse_eth_proto(skb, bpf_htons(ETH_P_IP)); case IPPROTO_IPV6: keys->is_encap = true; + if (keys->flags & BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP) + return export_flow_keys(keys, BPF_OK); + return parse_eth_proto(skb, bpf_htons(ETH_P_IPV6)); case IPPROTO_GRE: gre = bpf_flow_dissect_get_header(skb, sizeof(*gre), &_gre); @@ -189,6 +195,8 @@ static __always_inline int parse_ip_proto(struct __sk_buff *skb, __u8 proto) keys->thoff += 4; /* Step over sequence number */ keys->is_encap = true; + if (keys->flags & BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP) + return export_flow_keys(keys, BPF_OK); if (gre->proto == bpf_htons(ETH_P_TEB)) { eth = bpf_flow_dissect_get_header(skb, sizeof(*eth),