From patchwork Fri May 15 22:05:57 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Fastabend X-Patchwork-Id: 1291682 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=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=rFuERQ4r; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 49P2YK40JQz9sTD for ; Sat, 16 May 2020 08:06:13 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726290AbgEOWGM (ORCPT ); Fri, 15 May 2020 18:06:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49972 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726179AbgEOWGL (ORCPT ); Fri, 15 May 2020 18:06:11 -0400 Received: from mail-il1-x144.google.com (mail-il1-x144.google.com [IPv6:2607:f8b0:4864:20::144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CC0C7C061A0C; Fri, 15 May 2020 15:06:11 -0700 (PDT) Received: by mail-il1-x144.google.com with SMTP id q10so4128367ile.0; Fri, 15 May 2020 15:06:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=c0BG3kaZ50Dcd+OGVnp2ZcPP0p+RiidJl2L8uBk24fI=; b=rFuERQ4rSSIe5IVcO1biP7F/LEcOX76pk/lgNPgSV8FuO9EbHDqFGCCKPhbrIkngVj owlkdupaDkO84Bb9Y3o0KBdh1TYjyR09YFDBNSUXQVIORmv/upmWw7vBS+yhQqEHsl9v cB7F6y5Quq6HrFQLUnRd+F4XHi9PGmAMjyf0ByfjDLlDTLD9aSqrAFM7TpR6BuDIdqAm t3hb2QUT1YVvGhXbV3uEK9QHLOzYZYr79P7rgm1RGJH1mRmFFvGIoeziyUMMwzStlQM8 N+tmKbhhcGjtkSUaH6I8q8hTYwB3eIkWjaUeZ0kmxxbIK//UUn65xMshI0KLPKugLDBo 92Ig== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=c0BG3kaZ50Dcd+OGVnp2ZcPP0p+RiidJl2L8uBk24fI=; b=rz76RBgdCgv2M/9cuWEYqRdtsKAF3CKyCqiVfa7BhCL1JkA6zYMplUq15b7MuSwePB Pz/qgX7mV4icXaixNPYXa60muCSOXS5d77/MmScivxlaE5M1d3ADi4nqJL6sHrHb87qn zKrDERoDdxIqKEKHzDRto/wgL/41A+HYb7m1oCLP6lstAvwQey0Lepu/A71MhgWd6LCR 9KssP37+XPbt9Su8JI7157dEWDoU4VHqeQImISPYq95Ah/sForNqmFDyseb3nuz7RMZQ u1r8Pe+lEHoIq3mTuOv+cujbFLTUolGVDT5lrH72s4OFkR0gg5o00UVpgCVU751aOyj1 2ZnQ== X-Gm-Message-State: AOAM531VSkB9e/foJEq8sFtm7zgPx0cM2DrVepkcGT8R/uiPFYKMWaXN sVhvXPiOo3r/ncKOSGCXM90= X-Google-Smtp-Source: ABdhPJwXBqFJlCMCIWH5MM45uzHva0n0oF5xuuz75wO+Y2DO+QyLry53sNupAjqPWhYiyubuM/AdPA== X-Received: by 2002:a92:40ca:: with SMTP id d71mr5615680ill.200.1589580371196; Fri, 15 May 2020 15:06:11 -0700 (PDT) Received: from [127.0.1.1] ([184.63.162.180]) by smtp.gmail.com with ESMTPSA id u17sm1372861ilb.86.2020.05.15.15.06.03 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 15 May 2020 15:06:10 -0700 (PDT) Subject: [bpf-next PATCH v2 1/5] bpf: sk_msg add some generic helpers that may be useful from sk_msg From: John Fastabend To: yhs@fb.com, ast@kernel.org, daniel@iogearbox.net Cc: lmb@cloudflare.com, bpf@vger.kernel.org, john.fastabend@gmail.com, jakub@cloudflare.com, netdev@vger.kernel.org Date: Fri, 15 May 2020 15:05:57 -0700 Message-ID: <158958035716.12532.11872908481088096292.stgit@john-Precision-5820-Tower> In-Reply-To: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> References: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add these generic helpers that may be useful to use from sk_msg programs. The helpers do not depend on ctx so we can simply add them here, BPF_FUNC_perf_event_output BPF_FUNC_get_current_uid_gid BPF_FUNC_get_current_pid_tgid BPF_FUNC_get_current_comm BPF_FUNC_get_current_cgroup_id BPF_FUNC_get_current_ancestor_cgroup_id BPF_FUNC_get_cgroup_classid Acked-by: Yonghong Song Signed-off-by: John Fastabend --- net/core/filter.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/net/core/filter.c b/net/core/filter.c index f8a3c7e..7dac2b6 100644 --- a/net/core/filter.c +++ b/net/core/filter.c @@ -6443,6 +6443,22 @@ sk_msg_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_msg_push_data_proto; case BPF_FUNC_msg_pop_data: return &bpf_msg_pop_data_proto; + case BPF_FUNC_perf_event_output: + return &bpf_event_output_data_proto; + case BPF_FUNC_get_current_uid_gid: + return &bpf_get_current_uid_gid_proto; + case BPF_FUNC_get_current_pid_tgid: + return &bpf_get_current_pid_tgid_proto; +#ifdef CONFIG_CGROUPS + case BPF_FUNC_get_current_cgroup_id: + return &bpf_get_current_cgroup_id_proto; + case BPF_FUNC_get_current_ancestor_cgroup_id: + return &bpf_get_current_ancestor_cgroup_id_proto; +#endif +#ifdef CONFIG_CGROUP_NET_CLASSID + case BPF_FUNC_get_cgroup_classid: + return &bpf_get_cgroup_classid_curr_proto; +#endif default: return bpf_base_func_proto(func_id); } From patchwork Fri May 15 22:06:17 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Fastabend X-Patchwork-Id: 1291684 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=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=SxzT6nzH; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 49P2Yk0jdzz9sTD for ; Sat, 16 May 2020 08:06:34 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726492AbgEOWGd (ORCPT ); Fri, 15 May 2020 18:06:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726179AbgEOWGd (ORCPT ); Fri, 15 May 2020 18:06:33 -0400 Received: from mail-il1-x143.google.com (mail-il1-x143.google.com [IPv6:2607:f8b0:4864:20::143]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1132DC061A0C; Fri, 15 May 2020 15:06:33 -0700 (PDT) Received: by mail-il1-x143.google.com with SMTP id c20so1925608ilk.6; Fri, 15 May 2020 15:06:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=tERCCKiIKjEOnssno9mpcVZCO2wmElRDazrTiC4NWhc=; b=SxzT6nzH53RfnGEZPsqknVJuHoICyb9rZPzQ7437b1+CiLKdVFzjPL8ecKFhHW/7Y0 hHeki8WSCL9l3GnzlwVYDCLkDKD4M8OTwBAlGt89JFRykzRSn5OFt9VXRO3PfBma+Qje Yexk2vdHU/qBxStUMigyYUKQyDbim7QJ0fyaf7MopdrDN4ZL5w+NuRfyzTB/skcq2KuP nmRz3zDU68HZVsgUCSnq79741d3t+1aE2zkuIo+tLXPjz171+nwNH6k6hMdyCQQwWOKo w3bzGx8xW3YY+b6CmzoN2Du8rQpmn3JxZTzJoVya8uy0qgiKWMJEmhmtYlqD9YANXQci CZuA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=tERCCKiIKjEOnssno9mpcVZCO2wmElRDazrTiC4NWhc=; b=V1wlLaEkzM7AuSz7Lhp85AOXH7xlMNgNt1nkXspcu22flP85F3004Cs17QljYRmd1O KX9wmmp+JbKkwf3qnjSccupw728BoqGjkzRIOHW0qXsxmbW/0supG6HtdcvJQQn/tza/ Z5ALhjCdghAjYOx4u+QVajJM9u/ZrystLuPAQm5w+B4KlnwOYUGmstDo7I77xU8RtoXT +RbksAk6mHURAbvvDVDvwaEBwJpUOA/IR1hbwSguFNCxojA68bQBZ0pfua1nJBT/Dh4l rKBL1t06VniKjkwc2+FuVI5gQimQbYikiYWyldzMeaFg8tYX8r0vnET0JB+BKztxgAan FHHw== X-Gm-Message-State: AOAM531MUO4d7WYgvFWqo/yGO8+O6H+f+/3VNljM2vNzBbFSiuennwUb v3HqRMjbuUB/oCr0ttQQ+fw= X-Google-Smtp-Source: ABdhPJx1zhZSh7bwpqkECWQRvF3kqTYnQ7hkWZA+FrFoOXcDOz5FAIoBQlEOaFNkeWztXGHYV8BhoA== X-Received: by 2002:a92:bb55:: with SMTP id w82mr5558479ili.211.1589580392500; Fri, 15 May 2020 15:06:32 -0700 (PDT) Received: from [127.0.1.1] ([184.63.162.180]) by smtp.gmail.com with ESMTPSA id l7sm1402407ilh.54.2020.05.15.15.06.23 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 15 May 2020 15:06:31 -0700 (PDT) Subject: [bpf-next PATCH v2 2/5] bpf: extend bpf_base_func_proto helpers with probe_* and *current_task* From: John Fastabend To: yhs@fb.com, ast@kernel.org, daniel@iogearbox.net Cc: lmb@cloudflare.com, bpf@vger.kernel.org, john.fastabend@gmail.com, jakub@cloudflare.com, netdev@vger.kernel.org Date: Fri, 15 May 2020 15:06:17 -0700 Message-ID: <158958037715.12532.12473092995203096801.stgit@john-Precision-5820-Tower> In-Reply-To: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> References: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Often it is useful when applying policy to know something about the task. If the administrator has CAP_SYS_ADMIN rights then they can use kprobe + networking hook and link the two programs together to accomplish this. However, this is a bit clunky and also means we have to call both the network program and kprobe program when we could just use a single program and avoid passing metadata through sk_msg/skb->cb, socket, maps, etc. To accomplish this add probe_* helpers to bpf_base_func_proto programs guarded by a perfmon_capable() check. New supported helpers are the following, BPF_FUNC_get_current_task BPF_FUNC_current_task_under_cgroup BPF_FUNC_probe_read_user BPF_FUNC_probe_read_kernel BPF_FUNC_probe_read_user_str BPF_FUNC_probe_read_kernel_str Signed-off-by: John Fastabend Acked-by: Yonghong Song --- kernel/bpf/helpers.c | 27 +++++++++++++++++++++++++++ kernel/trace/bpf_trace.c | 16 ++++++++-------- 2 files changed, 35 insertions(+), 8 deletions(-) diff --git a/kernel/bpf/helpers.c b/kernel/bpf/helpers.c index 886949f..ee992dd 100644 --- a/kernel/bpf/helpers.c +++ b/kernel/bpf/helpers.c @@ -601,6 +601,13 @@ const struct bpf_func_proto bpf_event_output_data_proto = { .arg5_type = ARG_CONST_SIZE_OR_ZERO, }; +const struct bpf_func_proto bpf_current_task_under_cgroup_proto __weak; +const struct bpf_func_proto bpf_get_current_task_proto __weak; +const struct bpf_func_proto bpf_probe_read_user_proto __weak; +const struct bpf_func_proto bpf_probe_read_user_str_proto __weak; +const struct bpf_func_proto bpf_probe_read_kernel_proto __weak; +const struct bpf_func_proto bpf_probe_read_kernel_str_proto __weak; + const struct bpf_func_proto * bpf_base_func_proto(enum bpf_func_id func_id) { @@ -648,6 +655,26 @@ bpf_base_func_proto(enum bpf_func_id func_id) case BPF_FUNC_jiffies64: return &bpf_jiffies64_proto; default: + break; + } + + if (!perfmon_capable()) + return NULL; + + switch (func_id) { + case BPF_FUNC_get_current_task: + return &bpf_get_current_task_proto; + case BPF_FUNC_current_task_under_cgroup: + return &bpf_current_task_under_cgroup_proto; + case BPF_FUNC_probe_read_user: + return &bpf_probe_read_user_proto; + case BPF_FUNC_probe_read_kernel: + return &bpf_probe_read_kernel_proto; + case BPF_FUNC_probe_read_user_str: + return &bpf_probe_read_user_str_proto; + case BPF_FUNC_probe_read_kernel_str: + return &bpf_probe_read_kernel_str_proto; + default: return NULL; } } diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index 9a84d7f..60e54be 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -147,7 +147,7 @@ BPF_CALL_3(bpf_probe_read_user, void *, dst, u32, size, return ret; } -static const struct bpf_func_proto bpf_probe_read_user_proto = { +const struct bpf_func_proto bpf_probe_read_user_proto = { .func = bpf_probe_read_user, .gpl_only = true, .ret_type = RET_INTEGER, @@ -167,7 +167,7 @@ BPF_CALL_3(bpf_probe_read_user_str, void *, dst, u32, size, return ret; } -static const struct bpf_func_proto bpf_probe_read_user_str_proto = { +const struct bpf_func_proto bpf_probe_read_user_str_proto = { .func = bpf_probe_read_user_str, .gpl_only = true, .ret_type = RET_INTEGER, @@ -198,7 +198,7 @@ BPF_CALL_3(bpf_probe_read_kernel, void *, dst, u32, size, return bpf_probe_read_kernel_common(dst, size, unsafe_ptr, false); } -static const struct bpf_func_proto bpf_probe_read_kernel_proto = { +const struct bpf_func_proto bpf_probe_read_kernel_proto = { .func = bpf_probe_read_kernel, .gpl_only = true, .ret_type = RET_INTEGER, @@ -213,7 +213,7 @@ BPF_CALL_3(bpf_probe_read_compat, void *, dst, u32, size, return bpf_probe_read_kernel_common(dst, size, unsafe_ptr, true); } -static const struct bpf_func_proto bpf_probe_read_compat_proto = { +const struct bpf_func_proto bpf_probe_read_compat_proto = { .func = bpf_probe_read_compat, .gpl_only = true, .ret_type = RET_INTEGER, @@ -253,7 +253,7 @@ BPF_CALL_3(bpf_probe_read_kernel_str, void *, dst, u32, size, return bpf_probe_read_kernel_str_common(dst, size, unsafe_ptr, false); } -static const struct bpf_func_proto bpf_probe_read_kernel_str_proto = { +const struct bpf_func_proto bpf_probe_read_kernel_str_proto = { .func = bpf_probe_read_kernel_str, .gpl_only = true, .ret_type = RET_INTEGER, @@ -268,7 +268,7 @@ BPF_CALL_3(bpf_probe_read_compat_str, void *, dst, u32, size, return bpf_probe_read_kernel_str_common(dst, size, unsafe_ptr, true); } -static const struct bpf_func_proto bpf_probe_read_compat_str_proto = { +const struct bpf_func_proto bpf_probe_read_compat_str_proto = { .func = bpf_probe_read_compat_str, .gpl_only = true, .ret_type = RET_INTEGER, @@ -877,7 +877,7 @@ BPF_CALL_0(bpf_get_current_task) return (long) current; } -static const struct bpf_func_proto bpf_get_current_task_proto = { +const struct bpf_func_proto bpf_get_current_task_proto = { .func = bpf_get_current_task, .gpl_only = true, .ret_type = RET_INTEGER, @@ -898,7 +898,7 @@ BPF_CALL_2(bpf_current_task_under_cgroup, struct bpf_map *, map, u32, idx) return task_under_cgroup_hierarchy(current, cgrp); } -static const struct bpf_func_proto bpf_current_task_under_cgroup_proto = { +const struct bpf_func_proto bpf_current_task_under_cgroup_proto = { .func = bpf_current_task_under_cgroup, .gpl_only = false, .ret_type = RET_INTEGER, From patchwork Fri May 15 22:06:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Fastabend X-Patchwork-Id: 1291686 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=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=LxhqcWhP; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 49P2Z72GvCz9sTC for ; Sat, 16 May 2020 08:06:55 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726183AbgEOWGy (ORCPT ); Fri, 15 May 2020 18:06:54 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50078 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726179AbgEOWGy (ORCPT ); Fri, 15 May 2020 18:06:54 -0400 Received: from mail-io1-xd43.google.com (mail-io1-xd43.google.com [IPv6:2607:f8b0:4864:20::d43]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 378BBC061A0C; Fri, 15 May 2020 15:06:53 -0700 (PDT) Received: by mail-io1-xd43.google.com with SMTP id e18so4329221iog.9; Fri, 15 May 2020 15:06:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=l0fi4reCxer9j8s9eFCBgAkvySexoWyfcL59EJukikY=; b=LxhqcWhPLBEftR47C+v6nBU3ILpjsHwv6xxYgpO/OkYWyxQUDrJEfWCjJZd805E3eD 88eWenEKf+nxNimKv9DVrDjnZpAIoVWMJyyAIECOjNr4CKuNgfyUJsbpM0Rfz5DZstMj ogN/M6fi5WV6hBZ3a5KPICK8/Zfs8PsmYwBoOI+jGqvdtfWvXxcPiOwWkDSXeyYB+Ck4 zf1288dBawZ8L905oBwPUyu85akyBfXHUuTpgDEYI+hOJyt3qUTUMYwr/r3ehcI12qyn n8v+4qHLGLCpRcfBxw1met1+ciJ7OWION0HdKjlaM2xNrW/bzqKY1tTS+UqH4aCrG3fN NR+A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=l0fi4reCxer9j8s9eFCBgAkvySexoWyfcL59EJukikY=; b=DiAUELLLhV+8tnU42dkDFj3CL9lavRMTtUU8lNWmuGsxA8JTsmUnxGZhxvBAHML75G geYKlvWpsqE/3a3+/BU4dbj6RM5RX5x0+WIHDFeX+r4MMuQ3jBGAMV88n4tLqWy9Avoj ZAd/HlJ2LvbjpKQyKm2U3P9brwypnqCj9NL/Jd+FVVaZlp+u0wZ+q0Q0GRKXKWkdUMMx wC9DsfTExqFvEMM8c3iBuoPIuIysS6mtW99NnoBlwMZdKLpx+NLccGJV4TCJYUu+u81C ZKhgSzDGiZJMw5YtUQIda81yuQ50jrUvb+NVnMCzYi6QCVdERlq90DWxHsF8a6pPp3bK S1Jw== X-Gm-Message-State: AOAM530ov3whhtDKAAZhYBSvhtPOinVbBcPsOqn3MR7v0Hlt3/EviQso 7aS4Wmqq2ALlKxn7c7aMNfk= X-Google-Smtp-Source: ABdhPJwi6DDOdiXnSQYep45RnkdFsuJQ6R3I2yS02NhcBhJr9wLujcLmJiKoM7ctuzGhAruffSfanw== X-Received: by 2002:a5d:8ad8:: with SMTP id e24mr4797036iot.41.1589580412674; Fri, 15 May 2020 15:06:52 -0700 (PDT) Received: from [127.0.1.1] ([184.63.162.180]) by smtp.gmail.com with ESMTPSA id e19sm1148301iob.1.2020.05.15.15.06.44 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 15 May 2020 15:06:52 -0700 (PDT) Subject: [bpf-next PATCH v2 3/5] bpf: sk_msg add get socket storage helpers From: John Fastabend To: yhs@fb.com, ast@kernel.org, daniel@iogearbox.net Cc: lmb@cloudflare.com, bpf@vger.kernel.org, john.fastabend@gmail.com, jakub@cloudflare.com, netdev@vger.kernel.org Date: Fri, 15 May 2020 15:06:38 -0700 Message-ID: <158958039839.12532.8701091377815048145.stgit@john-Precision-5820-Tower> In-Reply-To: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> References: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Add helpers to use local socket storage. Signed-off-by: John Fastabend Acked-by: Yonghong Song --- include/uapi/linux/bpf.h | 2 ++ net/core/filter.c | 15 +++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index b9b8a0f..d394b09 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -3641,6 +3641,8 @@ struct sk_msg_md { __u32 remote_port; /* Stored in network byte order */ __u32 local_port; /* stored in host byte order */ __u32 size; /* Total size of sk_msg */ + + __bpf_md_ptr(struct bpf_sock *, sk); /* current socket */ }; struct sk_reuseport_md { diff --git a/net/core/filter.c b/net/core/filter.c index 7dac2b6..5769753 100644 --- a/net/core/filter.c +++ b/net/core/filter.c @@ -6449,6 +6449,10 @@ sk_msg_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog) return &bpf_get_current_uid_gid_proto; case BPF_FUNC_get_current_pid_tgid: return &bpf_get_current_pid_tgid_proto; + case BPF_FUNC_sk_storage_get: + return &bpf_sk_storage_get_proto; + case BPF_FUNC_sk_storage_delete: + return &bpf_sk_storage_delete_proto; #ifdef CONFIG_CGROUPS case BPF_FUNC_get_current_cgroup_id: return &bpf_get_current_cgroup_id_proto; @@ -7269,6 +7273,11 @@ static bool sk_msg_is_valid_access(int off, int size, if (size != sizeof(__u64)) return false; break; + case offsetof(struct sk_msg_md, sk): + if (size != sizeof(__u64)) + return false; + info->reg_type = PTR_TO_SOCKET; + break; case bpf_ctx_range(struct sk_msg_md, family): case bpf_ctx_range(struct sk_msg_md, remote_ip4): case bpf_ctx_range(struct sk_msg_md, local_ip4): @@ -8605,6 +8614,12 @@ static u32 sk_msg_convert_ctx_access(enum bpf_access_type type, si->dst_reg, si->src_reg, offsetof(struct sk_msg_sg, size)); break; + + case offsetof(struct sk_msg_md, sk): + *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_msg, sk), + si->dst_reg, si->src_reg, + offsetof(struct sk_msg, sk)); + break; } return insn - insn_buf; From patchwork Fri May 15 22:06:58 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Fastabend X-Patchwork-Id: 1291688 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=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=bpf-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=YBV7DQLW; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 49P2ZV6hpVz9sTC for ; Sat, 16 May 2020 08:07:14 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726290AbgEOWHO (ORCPT ); Fri, 15 May 2020 18:07:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50132 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726226AbgEOWHO (ORCPT ); Fri, 15 May 2020 18:07:14 -0400 Received: from mail-io1-xd42.google.com (mail-io1-xd42.google.com [IPv6:2607:f8b0:4864:20::d42]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 05208C061A0C; Fri, 15 May 2020 15:07:14 -0700 (PDT) Received: by mail-io1-xd42.google.com with SMTP id f3so4406090ioj.1; Fri, 15 May 2020 15:07:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=57P6zNk9VRKEbYCoGncmEzqStuJNuPNTToulDQComAo=; b=YBV7DQLWPq1kGY6bkodhpKjsaUNmMxw0DSLFrdgd+sFphf5WPUWNZXW8dmINzJp+EG 4X1K702cX5c/tqO+PttZQqhk42CYbrGsIe2rQEeiiWufVvLJ+lWrwYidH9t9O5XimD0h X72kTkIq8pKUKb/0ITvDwg8PfChNNF3tb691Wk0OBF06cZP+FunqQFXumA3TcOOx0teI 1e/1233loTB/Efr7c7Lla9XpNEuQb03pqHTq2jYo1eShAqdtDTJhjpINWGIsRFLUKODW tnTvOB3MdSrsE3iCGdINoti0KOxjGTmPcYXM43DMV3WndPZxzwA7LhcS0dQY0M1fJaIF QJcQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=57P6zNk9VRKEbYCoGncmEzqStuJNuPNTToulDQComAo=; b=JW2ITNSwLUOlZq1zt7ZtaUYCMneb8gYcq94eoIYGUp6IyVVobE4h5LjcnuvQ0oAxJA 8om2NVJOCKGQsXXJNDTZZKhIgMzZXxuO/+66MbEnKZDCTg8inty+5MBvNSZWQJ5O6sWg 2lugPgE62OfUsFweG3o1cikCKnis8Ckw6m1w9ol1lQt3T1AI/wg0Lg4reZmRmagwWpb7 FlUpI1c5PRMCrKXjn4hbdISrrxqQDPD1T+6l+/g8PrcqOJClcrdNl45UAX201x/VJl2b WrPkTcHrWFUoZXhw1zsmoRMMN2QHqHHARzFPIIc/Zwng1EM4wfh2DZIIfqZ+jHnJqmEN /7vA== X-Gm-Message-State: AOAM5310+JzQCrk4wZpp/RLPpqEilaCd3fwY5v7jQSpikqWuD518kTsZ LZXVf6+ipgVMzOxsLPWc7yo= X-Google-Smtp-Source: ABdhPJwCmp/M422Dajxxjn5HjCey1xk7T3QYypoec41xnc+VOqeedzBgyuf273Sr+5C21q7zWejUdw== X-Received: by 2002:a05:6602:2dca:: with SMTP id l10mr4839032iow.163.1589580433395; Fri, 15 May 2020 15:07:13 -0700 (PDT) Received: from [127.0.1.1] ([184.63.162.180]) by smtp.gmail.com with ESMTPSA id z24sm757901ioe.18.2020.05.15.15.07.04 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 15 May 2020 15:07:12 -0700 (PDT) Subject: [bpf-next PATCH v2 4/5] bpf: selftests, add sk_msg helpers load and attach test From: John Fastabend To: yhs@fb.com, ast@kernel.org, daniel@iogearbox.net Cc: lmb@cloudflare.com, bpf@vger.kernel.org, john.fastabend@gmail.com, jakub@cloudflare.com, netdev@vger.kernel.org Date: Fri, 15 May 2020 15:06:58 -0700 Message-ID: <158958041855.12532.1433164462914547063.stgit@john-Precision-5820-Tower> In-Reply-To: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> References: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org The test itself is not particularly useful but it encodes a common pattern we have. Namely do a sk storage lookup then depending on data here decide if we need to do more work or alternatively allow packet to PASS. Then if we need to do more work consult task_struct for more information about the running task. Finally based on this additional information drop or pass the data. In this case the suspicious check is not so realisitic but it encodes the general pattern and uses the helpers so we test the workflow. This is a load test to ensure verifier correctly handles this case. Signed-off-by: John Fastabend --- tools/include/uapi/linux/bpf.h | 2 + .../selftests/bpf/prog_tests/sockmap_basic.c | 57 ++++++++++++++++++++ .../selftests/bpf/progs/test_skmsg_load_helpers.c | 48 +++++++++++++++++ 3 files changed, 107 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/test_skmsg_load_helpers.c diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 146c742..b95bb16 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -3641,6 +3641,8 @@ struct sk_msg_md { __u32 remote_port; /* Stored in network byte order */ __u32 local_port; /* stored in host byte order */ __u32 size; /* Total size of sk_msg */ + + __bpf_md_ptr(struct bpf_sock *, sk); /* current socket */ }; struct sk_reuseport_md { diff --git a/tools/testing/selftests/bpf/prog_tests/sockmap_basic.c b/tools/testing/selftests/bpf/prog_tests/sockmap_basic.c index aa43e0b..cacb4ad 100644 --- a/tools/testing/selftests/bpf/prog_tests/sockmap_basic.c +++ b/tools/testing/selftests/bpf/prog_tests/sockmap_basic.c @@ -1,13 +1,46 @@ // SPDX-License-Identifier: GPL-2.0 // Copyright (c) 2020 Cloudflare +#include #include "test_progs.h" +#include "test_skmsg_load_helpers.skel.h" #define TCP_REPAIR 19 /* TCP sock is under repair right now */ #define TCP_REPAIR_ON 1 #define TCP_REPAIR_OFF_NO_WP -1 /* Turn off without window probes */ +#define _FAIL(errnum, fmt...) \ + ({ \ + error_at_line(0, (errnum), __func__, __LINE__, fmt); \ + CHECK_FAIL(true); \ + }) +#define FAIL(fmt...) _FAIL(0, fmt) +#define FAIL_ERRNO(fmt...) _FAIL(errno, fmt) +#define FAIL_LIBBPF(err, msg) \ + ({ \ + char __buf[MAX_STRERR_LEN]; \ + libbpf_strerror((err), __buf, sizeof(__buf)); \ + FAIL("%s: %s", (msg), __buf); \ + }) + +#define xbpf_prog_attach(prog, target, type, flags) \ + ({ \ + int __ret = \ + bpf_prog_attach((prog), (target), (type), (flags)); \ + if (__ret == -1) \ + FAIL_ERRNO("prog_attach(" #type ")"); \ + __ret; \ + }) + +#define xbpf_prog_detach2(prog, target, type) \ + ({ \ + int __ret = bpf_prog_detach2((prog), (target), (type)); \ + if (__ret == -1) \ + FAIL_ERRNO("prog_detach2(" #type ")"); \ + __ret; \ + }) + static int connected_socket_v4(void) { struct sockaddr_in addr = { @@ -70,10 +103,34 @@ static void test_sockmap_create_update_free(enum bpf_map_type map_type) close(s); } +static void test_skmsg_helpers(enum bpf_map_type map_type) +{ + struct test_skmsg_load_helpers *skel; + int err, map, verdict; + + skel = test_skmsg_load_helpers__open_and_load(); + if (!skel) { + FAIL("skeleton open/load failed"); + return; + } + + verdict = bpf_program__fd(skel->progs.prog_msg_verdict); + map = bpf_map__fd(skel->maps.sock_map); + + err = xbpf_prog_attach(verdict, map, BPF_SK_MSG_VERDICT, 0); + if (err) + return; + xbpf_prog_detach2(verdict, map, BPF_SK_MSG_VERDICT); +} + void test_sockmap_basic(void) { if (test__start_subtest("sockmap create_update_free")) test_sockmap_create_update_free(BPF_MAP_TYPE_SOCKMAP); if (test__start_subtest("sockhash create_update_free")) test_sockmap_create_update_free(BPF_MAP_TYPE_SOCKHASH); + if (test__start_subtest("sockmap sk_msg load helpers")) + test_skmsg_helpers(BPF_MAP_TYPE_SOCKMAP); + if (test__start_subtest("sockhash sk_msg load helpers")) + test_skmsg_helpers(BPF_MAP_TYPE_SOCKHASH); } diff --git a/tools/testing/selftests/bpf/progs/test_skmsg_load_helpers.c b/tools/testing/selftests/bpf/progs/test_skmsg_load_helpers.c new file mode 100644 index 0000000..b68eb6c --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_skmsg_load_helpers.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2020 Isovalent, Inc. +#include "vmlinux.h" +#include + +struct { + __uint(type, BPF_MAP_TYPE_SOCKMAP); + __uint(max_entries, 2); + __type(key, __u32); + __type(value, __u64); +} sock_map SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_SOCKHASH); + __uint(max_entries, 2); + __type(key, __u32); + __type(value, __u64); +} sock_hash SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_SK_STORAGE); + __uint(map_flags, BPF_F_NO_PREALLOC); + __type(key, __u32); + __type(value, __u64); +} socket_storage SEC(".maps"); + +SEC("sk_msg") +int prog_msg_verdict(struct sk_msg_md *msg) +{ + struct task_struct *task = (struct task_struct *)bpf_get_current_task(); + int verdict = SK_PASS; + __u32 pid, tpid; + __u64 *sk_stg; + + pid = bpf_get_current_pid_tgid() >> 32; + sk_stg = bpf_sk_storage_get(&socket_storage, msg->sk, 0, BPF_SK_STORAGE_GET_F_CREATE); + if (!sk_stg) + return SK_DROP; + *sk_stg = pid; + bpf_probe_read_kernel(&tpid , sizeof(tpid), &task->tgid); + if (pid != tpid) + verdict = SK_DROP; + bpf_sk_storage_delete(&socket_storage, (void *)msg->sk); + return verdict; +} + +int _version SEC("version") = 1; +char _license[] SEC("license") = "GPL"; From patchwork Fri May 15 22:07:19 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Fastabend X-Patchwork-Id: 1291690 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=pass (sender SPF authorized) smtp.mailfrom=vger.kernel.org (client-ip=23.128.96.18; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=o3Y1DFLr; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by ozlabs.org (Postfix) with ESMTP id 49P2Zv2s8Sz9sTD for ; Sat, 16 May 2020 08:07:35 +1000 (AEST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726694AbgEOWHe (ORCPT ); Fri, 15 May 2020 18:07:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50184 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726179AbgEOWHe (ORCPT ); Fri, 15 May 2020 18:07:34 -0400 Received: from mail-il1-x142.google.com (mail-il1-x142.google.com [IPv6:2607:f8b0:4864:20::142]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3B538C061A0C; Fri, 15 May 2020 15:07:34 -0700 (PDT) Received: by mail-il1-x142.google.com with SMTP id j3so4058273ilk.11; Fri, 15 May 2020 15:07:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:from:to:cc:date:message-id:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=z33mlGjEz4I59W1+QKMq9lrKs++29fGwAD1ltXgXi64=; b=o3Y1DFLrbGYwuOHt8YEkkBXoWsc2pFqIMHo/giphTezCSjQum+r1wJ3z3Tz9wNWQoC yGz5r8EgXKCdxjJZactHz9fVa+3DRFwDpTKVgERzP3MNdRbTitX/BnGBnEYjw4Bmx+hQ tuZn8cL4UqlSN/zz2MyIEaA8gGx1vrYNqwKh0CgtCOmR1Yh3AkPVJqjilTo4OTFl5a18 HAjMm+HQC0yL6GfIAK22cWdMqhfP165XjM5iMhtGVJimYQhJVyJPTSF9V97bITmpwTyb Up/MANjBY0F9B7YTxihJ6YKV5uGELdt9u/GBne/0U6EPdrSzragUJgajJe9HMksh04u7 z+Dw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=z33mlGjEz4I59W1+QKMq9lrKs++29fGwAD1ltXgXi64=; b=HAXNvbjmNKicQj3D4AC2AG4RG1dofnsDLt6DOK3Nsqy4ZNYF3C3KH34FjBnqpKZP4W swLlD94UtfljzjK7w4+7SxBtz47X9j1oTvmig8pSIZ+163bGbuU9W20Kybno21W1EJVz jKAk24EgwhW9mNiqQRQkRCEztaCwKCjSlmGjrbepWlo0YWhkg9/YOL7RU2HLx+3fYebl x95CYdtn2iDK9+NwIfzrAaB5X/HsSL6qk1pLCbZsi9m8vY+M5w48nGlv438WKqtiEHiW Kd7EIcGbftiZqnEQqcpRSMlOTJoJPgSqjTNEZ2BVl32GD6WYW2LXZJWQs5RuKSSO2u2G MUqQ== X-Gm-Message-State: AOAM531t6lJGfWu+hnEXa99F20z13bNBeT5/gUs6uViDtDxjaK9XMNih ROQMw7iWryP9KSEUBMY4En0= X-Google-Smtp-Source: ABdhPJwff0wuXbjRSQh7sZsNfuZE1qnracD7horXU1HxglhUQoND710bAis6R0gsOe/Eai86jaME7A== X-Received: by 2002:a92:4911:: with SMTP id w17mr5574961ila.254.1589580453636; Fri, 15 May 2020 15:07:33 -0700 (PDT) Received: from [127.0.1.1] ([184.63.162.180]) by smtp.gmail.com with ESMTPSA id p7sm1154237iob.7.2020.05.15.15.07.25 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 15 May 2020 15:07:32 -0700 (PDT) Subject: [bpf-next PATCH v2 5/5] bpf: selftests, test probe_* helpers from SCHED_CLS From: John Fastabend To: yhs@fb.com, ast@kernel.org, daniel@iogearbox.net Cc: lmb@cloudflare.com, bpf@vger.kernel.org, john.fastabend@gmail.com, jakub@cloudflare.com, netdev@vger.kernel.org Date: Fri, 15 May 2020 15:07:19 -0700 Message-ID: <158958043927.12532.9117835889381363621.stgit@john-Precision-5820-Tower> In-Reply-To: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> References: <158958022865.12532.5430684453474460041.stgit@john-Precision-5820-Tower> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Lets test using probe* in SCHED_CLS network programs as well just to be sure these keep working. Its cheap to add the extra test and provides a second context to test outside of sk_msg after we generalized probe* helpers to all networking types. Signed-off-by: John Fastabend --- .../testing/selftests/bpf/prog_tests/skb_helpers.c | 30 ++++++++++++++++++ .../testing/selftests/bpf/progs/test_skb_helpers.c | 33 ++++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/skb_helpers.c create mode 100644 tools/testing/selftests/bpf/progs/test_skb_helpers.c diff --git a/tools/testing/selftests/bpf/prog_tests/skb_helpers.c b/tools/testing/selftests/bpf/prog_tests/skb_helpers.c new file mode 100644 index 0000000..5a865c4 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/skb_helpers.c @@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include + +void test_skb_helpers(void) +{ + struct __sk_buff skb = { + .wire_len = 100, + .gso_segs = 8, + .gso_size = 10, + }; + struct bpf_prog_test_run_attr tattr = { + .data_in = &pkt_v4, + .data_size_in = sizeof(pkt_v4), + .ctx_in = &skb, + .ctx_size_in = sizeof(skb), + .ctx_out = &skb, + .ctx_size_out = sizeof(skb), + }; + struct bpf_object *obj; + int err; + + err = bpf_prog_load("./test_skb_helpers.o", BPF_PROG_TYPE_SCHED_CLS, &obj, + &tattr.prog_fd); + if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno)) + return; + + err = bpf_prog_test_run_xattr(&tattr); + CHECK_ATTR(err != 0, "len", "err %d errno %d\n", err, errno); +} diff --git a/tools/testing/selftests/bpf/progs/test_skb_helpers.c b/tools/testing/selftests/bpf/progs/test_skb_helpers.c new file mode 100644 index 0000000..05a1260 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_skb_helpers.c @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include "vmlinux.h" +#include +#include + +int _version SEC("version") = 1; + +#define TEST_COMM_LEN 10 + +struct bpf_map_def SEC("maps") cgroup_map = { + .type = BPF_MAP_TYPE_CGROUP_ARRAY, + .key_size = sizeof(u32), + .value_size = sizeof(u32), + .max_entries = 1, +}; + +char _license[] SEC("license") = "GPL"; + +SEC("classifier/test_skb_helpers") +int test_skb_helpers(struct __sk_buff *skb) +{ + struct task_struct *task; + char *comm[TEST_COMM_LEN]; + __u32 tpid; + int ctask; + + ctask = bpf_current_task_under_cgroup(&cgroup_map, 0); + task = (struct task_struct *)bpf_get_current_task(); + + bpf_probe_read_kernel(&tpid , sizeof(tpid), &task->tgid); + bpf_probe_read_kernel_str(&comm, sizeof(comm), &task->comm); + return 0; +}