From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.6 required=3.0 tests=DKIMWL_WL_MED,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 93822C282C3 for ; Thu, 24 Jan 2019 19:34:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 5663521907 for ; Thu, 24 Jan 2019 19:34:33 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="UWlaEXyy" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732220AbfAXTec (ORCPT ); Thu, 24 Jan 2019 14:34:32 -0500 Received: from mail-pg1-f202.google.com ([209.85.215.202]:42256 "EHLO mail-pg1-f202.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732206AbfAXTea (ORCPT ); Thu, 24 Jan 2019 14:34:30 -0500 Received: by mail-pg1-f202.google.com with SMTP id q62so4617009pgq.9 for ; Thu, 24 Jan 2019 11:34:29 -0800 (PST) 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=6O3PhG/7Ts+975kUUJ7ix1mlG6edJBAmGc0Zd+heBg4=; b=UWlaEXyynpCSEssdnyPKfLENuspyG7QCpz6RDCNv1jsJUi01Ya3MdTZDfxFU1ha3DG uVKvjD4w6Svj83zhEEg31+0443IQQVwFrKveof6JVSGDMaHh9SQfbgJvVBwIrNRW5en3 NGuuf+sSUB2bPBVzFf56b9ExPdKEDiRoo/kIGHLIUXkaHCnRmWTId1AxVd/Hzr5VA8m+ KDQnOX053DPA/ieaFaeu6Kfg3Uf3/xRzGs9xZtsu58DMuqDMlKgaIMy/YqhVwh3MypEv yPT74jDKsBbCCe1ymsi7ekpCGJalUGX/WMnwTj6wzncFgR2fxLZo/s409nmsDAA0l5HC oPxA== 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=6O3PhG/7Ts+975kUUJ7ix1mlG6edJBAmGc0Zd+heBg4=; b=X0/rZ9Whfui+MOww9yrHYdtE/gLKOfcc/cVjSZtghUTzxVonLbQBHSNZWw1tlhv4yb 1bKivnoexDJwcr9Gw4OIlT+PDjsgaCQfRase+WfSDt1CddpBHwMxphUh2oar89NB88S3 FJYqM/hZN9FL2rhvAPKqrEmmhrEIt8465CvhyPg38Twe0Fl5c5i9+963fsfVVrfS7zy1 omCBBqkLp3xDlx4x6Y0yIRE+b4X3EjfEPAAq2YSUMKacHYE+d0EuZ6IoLnTt/duUbxr5 VCGWd5XlPv1I9i7fQqcInEYu+XoikAfEOWX8IBeUMe1dDNXkvYNeakOLe8jy8Hu/unyV C96Q== X-Gm-Message-State: AJcUukcB+P87mVj3kScfGL3JzqOOD3q/+Gf81CgGm7MP2o//GmQPlcqJ w9h6XWM8PkbAEfSYRbzVHrizQ/Ks X-Google-Smtp-Source: ALg8bN5m5zQEJGvzkjmu/Axv/dlQAAt0WZgFFW5AAshYARoZHhziarEgCd3U0f6fbwJk9dlL/8EUlF7w X-Received: by 2002:a17:902:6b0c:: with SMTP id o12mr2742839plk.132.1548358469432; Thu, 24 Jan 2019 11:34:29 -0800 (PST) Date: Thu, 24 Jan 2019 11:34:16 -0800 In-Reply-To: <20190124193418.81674-1-posk@google.com> Message-Id: <20190124193418.81674-2-posk@google.com> Mime-Version: 1.0 References: <20190124193418.81674-1-posk@google.com> X-Mailer: git-send-email 2.20.1.321.g9e740568ce-goog Subject: [PATCH bpf-next v2 1/3] bpf: add plumbing for BPF_LWT_ENCAP_IP in bpf_lwt_push_encap From: Peter Oskolkov To: Alexei Starovoitov , Daniel Borkmann , netdev@vger.kernel.org Cc: Peter Oskolkov , David Ahern , Willem de Bruijn , Peter Oskolkov Content-Type: text/plain; charset="UTF-8" Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org This patch adds all needed plumbing in preparation to allowing bpf programs to do IP encapping via bpf_lwt_push_encap. Actual implementation is added in the next patch in the patchset. Of note: - bpf_lwt_push_encap can now be called from BPF_PROG_TYPE_LWT_XMIT prog types in addition to BPF_PROG_TYPE_LWT_IN; - as route lookups are different for ingress vs egress, the single external bpf_lwt_push_encap BPF helper is routed internally to either bpf_lwt_in_push_encap or bpf_lwt_xmit_push_encap BPF_CALLs, depending on prog type. Signed-off-by: Peter Oskolkov --- include/uapi/linux/bpf.h | 23 ++++++++++++++++++-- net/core/filter.c | 46 +++++++++++++++++++++++++++++++++++----- 2 files changed, 62 insertions(+), 7 deletions(-) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 2940a9854f6d..d4852feb14e4 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -2014,6 +2014,16 @@ union bpf_attr { * Only works if *skb* contains an IPv6 packet. Insert a * Segment Routing Header (**struct ipv6_sr_hdr**) inside * the IPv6 header. + * **BPF_LWT_ENCAP_IP** + * IP encapsulation (GRE/GUE/IPIP/etc). The outer header + * must be IPv4 or IPv6, followed by zero or more + * additional headers, up to LWT_BPF_MAX_HEADROOM total + * bytes in all prepended headers. + * + * BPF_LWT_ENCAP_SEG6*** types can be called by bpf programs of + * type BPF_PROG_TYPE_LWT_IN; BPF_LWT_ENCAP_IP type can be called + * by bpf programs of types BPF_PROG_TYPE_LWT_IN and + * BPF_PROG_TYPE_LWT_XMIT. * * A call to this helper is susceptible to change the underlaying * packet buffer. Therefore, at load time, all checks on pointers @@ -2494,7 +2504,8 @@ enum bpf_hdr_start_off { /* Encapsulation type for BPF_FUNC_lwt_push_encap helper. */ enum bpf_lwt_encap_mode { BPF_LWT_ENCAP_SEG6, - BPF_LWT_ENCAP_SEG6_INLINE + BPF_LWT_ENCAP_SEG6_INLINE, + BPF_LWT_ENCAP_IP, }; #define __bpf_md_ptr(type, name) \ @@ -2582,7 +2593,15 @@ enum bpf_ret_code { BPF_DROP = 2, /* 3-6 reserved */ BPF_REDIRECT = 7, - /* >127 are reserved for prog type specific return codes */ + /* >127 are reserved for prog type specific return codes. + * + * BPF_LWT_REROUTE: used by BPF_PROG_TYPE_LWT_IN and + * BPF_PROG_TYPE_LWT_XMIT to indicate that skb's dst + * has changed and appropriate dst_input() or dst_output() + * action has to be taken (this is an L3 redirect, as + * opposed to L2 redirect represented by BPF_REDIRECT above). + */ + BPF_LWT_REROUTE = 128, }; struct bpf_sock { diff --git a/net/core/filter.c b/net/core/filter.c index 8e587dd1da20..fd3ae092d3d7 100644 --- a/net/core/filter.c +++ b/net/core/filter.c @@ -4793,7 +4793,13 @@ static int bpf_push_seg6_encap(struct sk_buff *skb, u32 type, void *hdr, u32 len } #endif /* CONFIG_IPV6_SEG6_BPF */ -BPF_CALL_4(bpf_lwt_push_encap, struct sk_buff *, skb, u32, type, void *, hdr, +static int bpf_push_ip_encap(struct sk_buff *skb, void *hdr, u32 len, + bool ingress) +{ + return -EINVAL; /* Implemented in the next patch. */ +} + +BPF_CALL_4(bpf_lwt_in_push_encap, struct sk_buff *, skb, u32, type, void *, hdr, u32, len) { switch (type) { @@ -4801,14 +4807,41 @@ BPF_CALL_4(bpf_lwt_push_encap, struct sk_buff *, skb, u32, type, void *, hdr, case BPF_LWT_ENCAP_SEG6: case BPF_LWT_ENCAP_SEG6_INLINE: return bpf_push_seg6_encap(skb, type, hdr, len); +#endif +#if IS_ENABLED(CONFIG_LWTUNNEL_BPF) + case BPF_LWT_ENCAP_IP: + return bpf_push_ip_encap(skb, hdr, len, true /* ingress */); #endif default: return -EINVAL; } } -static const struct bpf_func_proto bpf_lwt_push_encap_proto = { - .func = bpf_lwt_push_encap, +BPF_CALL_4(bpf_lwt_xmit_push_encap, struct sk_buff *, skb, u32, type, + void *, hdr, u32, len) +{ + switch (type) { +#if IS_ENABLED(CONFIG_LWTUNNEL_BPF) + case BPF_LWT_ENCAP_IP: + return bpf_push_ip_encap(skb, hdr, len, false /* egress */); +#endif + default: + return -EINVAL; + } +} + +static const struct bpf_func_proto bpf_lwt_in_push_encap_proto = { + .func = bpf_lwt_in_push_encap, + .gpl_only = false, + .ret_type = RET_INTEGER, + .arg1_type = ARG_PTR_TO_CTX, + .arg2_type = ARG_ANYTHING, + .arg3_type = ARG_PTR_TO_MEM, + .arg4_type = ARG_CONST_SIZE +}; + +static const struct bpf_func_proto bpf_lwt_xmit_push_encap_proto = { + .func = bpf_lwt_xmit_push_encap, .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_PTR_TO_CTX, @@ -5274,7 +5307,8 @@ bool bpf_helper_changes_pkt_data(void *func) func == bpf_lwt_seg6_adjust_srh || func == bpf_lwt_seg6_action || #endif - func == bpf_lwt_push_encap) + func == bpf_lwt_in_push_encap || + func == bpf_lwt_xmit_push_encap) return true; return false; @@ -5652,7 +5686,7 @@ lwt_in_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) { switch (func_id) { case BPF_FUNC_lwt_push_encap: - return &bpf_lwt_push_encap_proto; + return &bpf_lwt_in_push_encap_proto; default: return lwt_out_func_proto(func_id, prog); } @@ -5688,6 +5722,8 @@ lwt_xmit_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_l4_csum_replace_proto; case BPF_FUNC_set_hash_invalid: return &bpf_set_hash_invalid_proto; + case BPF_FUNC_lwt_push_encap: + return &bpf_lwt_xmit_push_encap_proto; default: return lwt_out_func_proto(func_id, prog); } -- 2.20.1.321.g9e740568ce-goog