From patchwork Thu Sep 5 11:51:21 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiri Olsa X-Patchwork-Id: 13792207 X-Patchwork-Delegate: bpf@iogearbox.net Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D98781991DD; Thu, 5 Sep 2024 11:51:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537101; cv=none; b=kRWvF8w7zEyCh4xcaLQxPaL/2EYBukYVkE7b9ayy2LXzL1TtwXh3IXzBfdE5mzB/2tCXZr+F0fuUwDqonx0A3tlwT3dDlQgQWuOBrPQb0hfM+O8lnqN8nGdWy4yfKsLZaYZPwFtW8au4mkZmSPJn71M+E/4WEAjb5zml0G+MwJo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537101; c=relaxed/simple; bh=3GHkxBiuhbvmrdo2hRad8iYorzmZ7YUX8YGFybxOZFQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=bW7nkf87iutIhWhsWLfSAoEwptXmxRJhUAwqZio3ndUNqPit9rG6YMCxpcKq0mj8nmbbJgBomwg6idB/WpeIIXWiZ4h2JuX4Z10WmscwUiSs+i2N+Rj4MlpeiPfWVhvkZ8+w98m7GV+y7++QE6Ujwv5y0wqoefCpi6LkK4knAqU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=XOBn3XMN; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="XOBn3XMN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 67C74C4CEC4; Thu, 5 Sep 2024 11:51:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725537100; bh=3GHkxBiuhbvmrdo2hRad8iYorzmZ7YUX8YGFybxOZFQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=XOBn3XMNzUbeLjXbSesPxgzz/yBpjJcQyFrMYFJhaM4Pe2bbm8PSezJ6P6kgJqEBu 9Cys3l7bSFRCIqphDc5fYvRLmdZyWomb8ZsK4+Nygys21j2IVcQAFoZN+x1S7GT3yS 22E/x9nk6veK77lFV1R0NORYlFccRvWnpYDBYPYXm05GH04/TObk9kBZcQ9jZcLIQw xTUvIixy/AL8j4EnMbUlFDdRetES3UtlPiRBsV+jrPe+oGeKGUqQ/+uNqc8TDanJB1 7k9+wBeNsD3wMaEA3dNyv3EpiZzivdz/dSGtX0y8zI+SoZwXJRjZ6HaQjpMe4JC2vr 6HxNPsqSyF5WQ== From: Jiri Olsa To: Oleg Nesterov , Peter Zijlstra , Andrii Nakryiko , Tianyi Liu , Masami Hiramatsu Cc: bpf@vger.kernel.org, Steven Rostedt , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCHv2 bpf-next 1/4] bpf: Fix uprobe multi pid filter check Date: Thu, 5 Sep 2024 14:51:21 +0300 Message-ID: <20240905115124.1503998-2-jolsa@kernel.org> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20240905115124.1503998-1-jolsa@kernel.org> References: <20240905115124.1503998-1-jolsa@kernel.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net Uprobe multi link does its own process (thread leader) filtering before running the bpf program by comparing task's vm pointers. But as Oleg pointed out there can be processes sharing the vm (CLONE_VM), so we can't just compare task->vm pointers, but instead we need to use same_thread_group call. Suggested-by: Oleg Nesterov Signed-off-by: Jiri Olsa Acked-by: Oleg Nesterov --- kernel/trace/bpf_trace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index b69a39316c0c..98e395f1baae 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -3207,7 +3207,7 @@ static int uprobe_prog_run(struct bpf_uprobe *uprobe, struct bpf_run_ctx *old_run_ctx; int err = 0; - if (link->task && current->mm != link->task->mm) + if (link->task && !same_thread_group(current, link->task)) return 0; if (sleepable) From patchwork Thu Sep 5 11:51:22 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiri Olsa X-Patchwork-Id: 13792208 X-Patchwork-Delegate: bpf@iogearbox.net Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7026619922E; Thu, 5 Sep 2024 11:51:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537111; cv=none; b=LCrKJAyZ8JjWk4nJAy+8YVJwgWouxFqaiqOO81RuRzftXAqxLZDyN+R7Q4G2BtxCiITsDqho3P5y56dZOE4XC+1PrJIp/h8ILUu8PYxweSGvX3iec16aMCP26D6S+fncLRew04u3s0LkaGWXh0TsHTUZhz6vEke16K/hdEaFCzA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537111; c=relaxed/simple; bh=BJ0uQV1Yd2KsDe/PvMljMfOBKIPbpYo8HoBH6L01n7o=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Wicis4P4Dcd8h2JAek/+l4sDgV/ZXiZNqtJO0SBGPnyrS8sZ+4TIh2qipP9XtAmQ7aIY9Q1UN2t3cf8BdO83NlyKzBuQYKuoSQpqgLFbyRqLTtck+1LBJNkhFnJdFBgGQOi3KonIQ8yBnOuqobVTL8mXX8bSVhqZQUBayxxTFXs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Cg2g9Lu5; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Cg2g9Lu5" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0ADBBC4CEC3; Thu, 5 Sep 2024 11:51:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725537111; bh=BJ0uQV1Yd2KsDe/PvMljMfOBKIPbpYo8HoBH6L01n7o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Cg2g9Lu5G6blBhY6q1FI28/WtbOjRWo+v3Ega4jpFvtP0W0byE0XF8qBHrDYl5byn 4NmTUlJkyYYu7PvCX24aYxE2/64CS21Dw4kaTzWC86yXqHzOdAbsgNJpkJNnRYAYe/ iudtTSoMoqRFy3eGC14Cvz20tZ6RogP+QXg7ZYFzPzW6CWH9ojRzGt4oZE42HoWTt2 dwoaLAMkOkmHB+ZlAkkdAxA3vXZ8nbywz9PXVdTInBDpWDJM/qVRO4WG/nIW/00irx LVSse9mdYZAx11yA46aNqixmMtfcU3lm7zU9Pm3MOuHjQPBXQ8dZYlW3u/0WZXlSZ/ ophbMkKS93g8A== From: Jiri Olsa To: Oleg Nesterov , Peter Zijlstra , Andrii Nakryiko , Tianyi Liu , Masami Hiramatsu Cc: bpf@vger.kernel.org, Steven Rostedt , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCHv2 bpf-next 2/4] selftests/bpf: Add child argument to spawn_child function Date: Thu, 5 Sep 2024 14:51:22 +0300 Message-ID: <20240905115124.1503998-3-jolsa@kernel.org> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20240905115124.1503998-1-jolsa@kernel.org> References: <20240905115124.1503998-1-jolsa@kernel.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net Adding child argument to spawn_child function to allow to create multiple children in following change. Signed-off-by: Jiri Olsa --- .../bpf/prog_tests/uprobe_multi_test.c | 85 +++++++++---------- 1 file changed, 39 insertions(+), 46 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c index acb62675ff65..250eb47c68f9 100644 --- a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c +++ b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c @@ -68,29 +68,27 @@ static void kick_child(struct child *child) fflush(NULL); } -static struct child *spawn_child(void) +static int spawn_child(struct child *child) { - static struct child child; - int err; - int c; + int err, c; /* pipe to notify child to execute the trigger functions */ - if (pipe(child.go)) - return NULL; + if (pipe(child->go)) + return -1; - child.pid = child.tid = fork(); - if (child.pid < 0) { - release_child(&child); + child->pid = child->tid = fork(); + if (child->pid < 0) { + release_child(child); errno = EINVAL; - return NULL; + return -1; } /* child */ - if (child.pid == 0) { - close(child.go[1]); + if (child->pid == 0) { + close(child->go[1]); /* wait for parent's kick */ - err = read(child.go[0], &c, 1); + err = read(child->go[0], &c, 1); if (err != 1) exit(err); @@ -102,7 +100,7 @@ static struct child *spawn_child(void) exit(errno); } - return &child; + return 0; } static void *child_thread(void *ctx) @@ -131,39 +129,38 @@ static void *child_thread(void *ctx) pthread_exit(&err); } -static struct child *spawn_thread(void) +static int spawn_thread(struct child *child) { - static struct child child; int c, err; /* pipe to notify child to execute the trigger functions */ - if (pipe(child.go)) - return NULL; + if (pipe(child->go)) + return -1; /* pipe to notify parent that child thread is ready */ - if (pipe(child.c2p)) { - close(child.go[0]); - close(child.go[1]); - return NULL; + if (pipe(child->c2p)) { + close(child->go[0]); + close(child->go[1]); + return -1; } - child.pid = getpid(); + child->pid = getpid(); - err = pthread_create(&child.thread, NULL, child_thread, &child); + err = pthread_create(&child->thread, NULL, child_thread, child); if (err) { err = -errno; - close(child.go[0]); - close(child.go[1]); - close(child.c2p[0]); - close(child.c2p[1]); + close(child->go[0]); + close(child->go[1]); + close(child->c2p[0]); + close(child->c2p[1]); errno = -err; - return NULL; + return -1; } - err = read(child.c2p[0], &c, 1); + err = read(child->c2p[0], &c, 1); if (!ASSERT_EQ(err, 1, "child_thread_ready")) - return NULL; + return -1; - return &child; + return 0; } static void uprobe_multi_test_run(struct uprobe_multi *skel, struct child *child) @@ -304,24 +301,22 @@ __test_attach_api(const char *binary, const char *pattern, struct bpf_uprobe_mul static void test_attach_api(const char *binary, const char *pattern, struct bpf_uprobe_multi_opts *opts) { - struct child *child; + static struct child child; /* no pid filter */ __test_attach_api(binary, pattern, opts, NULL); /* pid filter */ - child = spawn_child(); - if (!ASSERT_OK_PTR(child, "spawn_child")) + if (!ASSERT_OK(spawn_child(&child), "spawn_child")) return; - __test_attach_api(binary, pattern, opts, child); + __test_attach_api(binary, pattern, opts, &child); /* pid filter (thread) */ - child = spawn_thread(); - if (!ASSERT_OK_PTR(child, "spawn_thread")) + if (!ASSERT_OK(spawn_thread(&child), "spawn_thread")) return; - __test_attach_api(binary, pattern, opts, child); + __test_attach_api(binary, pattern, opts, &child); } static void test_attach_api_pattern(void) @@ -712,24 +707,22 @@ static void __test_link_api(struct child *child) static void test_link_api(void) { - struct child *child; + static struct child child; /* no pid filter */ __test_link_api(NULL); /* pid filter */ - child = spawn_child(); - if (!ASSERT_OK_PTR(child, "spawn_child")) + if (!ASSERT_OK(spawn_child(&child), "spawn_child")) return; - __test_link_api(child); + __test_link_api(&child); /* pid filter (thread) */ - child = spawn_thread(); - if (!ASSERT_OK_PTR(child, "spawn_thread")) + if (!ASSERT_OK(spawn_thread(&child), "spawn_thread")) return; - __test_link_api(child); + __test_link_api(&child); } static struct bpf_program * From patchwork Thu Sep 5 11:51:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiri Olsa X-Patchwork-Id: 13792209 X-Patchwork-Delegate: bpf@iogearbox.net Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 22BF719415D; Thu, 5 Sep 2024 11:52:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537122; cv=none; b=WJFpBBjUS5x5lAo9B/brGY5whFX1pzpF6BixZd8mOv5e6bka+XxrD8eRtTcquRJ9vyFuJmPjGWKl89Q3SUaxHkbvgHJ7YfhWHL4Qa2ZaTgnKxGd3f/Z+4gJkQHStXDNUF9Psup7QgbAv9TnMkTxwaZtEw9YLjmrgMsNt4Q4A2eY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537122; c=relaxed/simple; bh=9iP/a/0C/4mf7TSl4LPVhAesSJyyFh+wAjB+jhDjfNc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=FkEcOnYDuuOCKoSQ8epjeSY1kLp8pqWfIPq/XWlouAFaDamAo9sf3jBkXofc62JeFJUV/MfsahUFoTW8SVOFueN1J0uBvjcHRT5UkaybFQqYSgTfX2dU3f8jJfnqwNxT0is1VbxEdO4mtm0K2ridDsF4Q8wrIZaCNki6zmrO9f8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=HQavZxQd; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="HQavZxQd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DE630C4CEC3; Thu, 5 Sep 2024 11:51:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725537122; bh=9iP/a/0C/4mf7TSl4LPVhAesSJyyFh+wAjB+jhDjfNc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HQavZxQdr0wBbbeK6n45c7TtfLHJySh2+Qh593SbgFv3CnG7vX5g0lxe7jJ/q2pn8 AJ/6r7WF7R2q2eJR0twp0zfcTQDaoZlP90FpCEbTaJgSP0TSedUqH+KFXYygEuH9Pe 65JczbNylMVX/GvNleEOMmhwmXk0JgdsIdzbh1p5LDTHCTF2MkNSBD868VmT/UOLWa gJ0aziz7DRv1qHo0eIcGGeXEaB2UpUn2ueLH2oGYvd3nfSm5EPVbkqnlP0sq/K0aXl TdwSkOxV9IWRyrBDf/8o0xrXjeycH7Ccl+XQqfL+EHifHm8BQxZheSpy4fZnzH2jiN xXXi4hpiqUF5Q== From: Jiri Olsa To: Oleg Nesterov , Peter Zijlstra , Andrii Nakryiko , Tianyi Liu , Masami Hiramatsu Cc: bpf@vger.kernel.org, Steven Rostedt , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCHv2 bpf-next 3/4] selftests/bpf: Add uprobe multi pid filter test for fork-ed processes Date: Thu, 5 Sep 2024 14:51:23 +0300 Message-ID: <20240905115124.1503998-4-jolsa@kernel.org> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20240905115124.1503998-1-jolsa@kernel.org> References: <20240905115124.1503998-1-jolsa@kernel.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net The idea is to create and monitor 3 uprobes, each trigered in separate process and make sure the bpf program gets executed just for the proper PID specified via pid filter. Signed-off-by: Jiri Olsa --- .../bpf/prog_tests/uprobe_multi_test.c | 67 +++++++++++++++++++ .../bpf/progs/uprobe_multi_pid_filter.c | 40 +++++++++++ 2 files changed, 107 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/uprobe_multi_pid_filter.c diff --git a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c index 250eb47c68f9..9c2f99233304 100644 --- a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c +++ b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c @@ -7,6 +7,7 @@ #include "uprobe_multi_bench.skel.h" #include "uprobe_multi_usdt.skel.h" #include "uprobe_multi_consumers.skel.h" +#include "uprobe_multi_pid_filter.skel.h" #include "bpf/libbpf_internal.h" #include "testing_helpers.h" #include "../sdt.h" @@ -935,6 +936,70 @@ static void test_consumers(void) uprobe_multi_consumers__destroy(skel); } +static struct bpf_program *uprobe_multi_program(struct uprobe_multi_pid_filter *skel, int idx) +{ + switch (idx) { + case 0: return skel->progs.uprobe_multi_0; + case 1: return skel->progs.uprobe_multi_1; + case 2: return skel->progs.uprobe_multi_2; + } + return NULL; +} + +#define TASKS 3 + +static void run_pid_filter(struct uprobe_multi_pid_filter *skel, bool retprobe) +{ + LIBBPF_OPTS(bpf_uprobe_multi_opts, opts, .retprobe = retprobe); + struct bpf_link *link[TASKS] = {}; + struct child child[TASKS] = {}; + int i; + + memset(skel->bss->test, 0, sizeof(skel->bss->test)); + + for (i = 0; i < TASKS; i++) { + if (!ASSERT_OK(spawn_child(&child[i]), "spawn_child")) + goto cleanup; + skel->bss->pids[i] = child[i].pid; + } + + for (i = 0; i < TASKS; i++) { + link[i] = bpf_program__attach_uprobe_multi(uprobe_multi_program(skel, i), + child[i].pid, "/proc/self/exe", + "uprobe_multi_func_1", &opts); + if (!ASSERT_OK_PTR(link[i], "bpf_program__attach_uprobe_multi")) + goto cleanup; + } + + for (i = 0; i < TASKS; i++) + kick_child(&child[i]); + + for (i = 0; i < TASKS; i++) { + ASSERT_EQ(skel->bss->test[i][0], 1, "pid"); + ASSERT_EQ(skel->bss->test[i][1], 0, "unknown"); + } + +cleanup: + for (i = 0; i < TASKS; i++) + bpf_link__destroy(link[i]); + for (i = 0; i < TASKS; i++) + release_child(&child[i]); +} + +static void test_pid_filter_process(void) +{ + struct uprobe_multi_pid_filter *skel; + + skel = uprobe_multi_pid_filter__open_and_load(); + if (!ASSERT_OK_PTR(skel, "uprobe_multi_pid_filter__open_and_load")) + return; + + run_pid_filter(skel, false); + run_pid_filter(skel, true); + + uprobe_multi_pid_filter__destroy(skel); +} + static void test_bench_attach_uprobe(void) { long attach_start_ns = 0, attach_end_ns = 0; @@ -1027,4 +1092,6 @@ void test_uprobe_multi_test(void) test_attach_uprobe_fails(); if (test__start_subtest("consumers")) test_consumers(); + if (test__start_subtest("filter_fork")) + test_pid_filter_process(); } diff --git a/tools/testing/selftests/bpf/progs/uprobe_multi_pid_filter.c b/tools/testing/selftests/bpf/progs/uprobe_multi_pid_filter.c new file mode 100644 index 000000000000..67fcbad36661 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/uprobe_multi_pid_filter.c @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "vmlinux.h" +#include +#include + +char _license[] SEC("license") = "GPL"; + +__u32 pids[3]; +__u32 test[3][2]; + +static void update_pid(int idx) +{ + __u32 pid = bpf_get_current_pid_tgid() >> 32; + + if (pid == pids[idx]) + test[idx][0]++; + else + test[idx][1]++; +} + +SEC("uprobe.multi") +int uprobe_multi_0(struct pt_regs *ctx) +{ + update_pid(0); + return 0; +} + +SEC("uprobe.multi") +int uprobe_multi_1(struct pt_regs *ctx) +{ + update_pid(1); + return 0; +} + +SEC("uprobe.multi") +int uprobe_multi_2(struct pt_regs *ctx) +{ + update_pid(2); + return 0; +} From patchwork Thu Sep 5 11:51:24 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jiri Olsa X-Patchwork-Id: 13792210 X-Patchwork-Delegate: bpf@iogearbox.net Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4651618732F; Thu, 5 Sep 2024 11:52:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537134; cv=none; b=Oe/bOq6wVjCZRtCYQxqS1k1hDJ3RjsA6ZSrVVR/S3IqRWCNEKLNua6+8lMThhgPELpE1rhQATxcyILCY1/7DnIatuF2+PqnKBVqvlzYpUBokCxWZhl7+IKSdCkBj//RSR+yw7I7KkDtmXF6YyM+VAs4bp2vmQs4R0JSs1mjtexM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725537134; c=relaxed/simple; bh=D5S920V3t6cXwRIkyEPu6OV9wD5N2mHt4dpwnePX+aI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TSq/46Q7A2Y74DkL9abPUcoQbnnk0UGqgCfLAEa7l771/oLgHsKFG5jfYi5A5wDSiFQc5aWcMWfwYiZIMfCnOFwSrncnOUeiYg4Zidl5mgg+QWnD/Nntx+6A/uLjdf3kdc2g6hTwgMmprc4QTHY/HlMlY0rkLxwWUEurZmHmroE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hgjmS8j7; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hgjmS8j7" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E3103C4CEC4; Thu, 5 Sep 2024 11:52:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725537134; bh=D5S920V3t6cXwRIkyEPu6OV9wD5N2mHt4dpwnePX+aI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hgjmS8j7f+2G5g08iLPE+6/5N61nvXDi/4X1dchOBd1qnu4eei6hT+g1ATi3qkNwm QiSAR+T5IggyBLNT8GXMzSqSWi6Dvw6H0ARZHoth2oYg7TvlTSUj2FQMi2CArlD/Cf XYXFm08EBVvyj2PteHQYzhdibBUmwpmlsi/oVpVcYONUCRCBGeivzKNg6VY8pHuDLe GZDBpje/ylDxOSZ9SVIKh9zQgjxN6TStSGNIwxXCAfXmTD4efb6Xf+jcIAjeeCpj7q DOQBzEj1UGvHcGJJ9aWlZnq0LhtaZJN1AJVzx7axYaB7GzAuonPsAU5672SjqU+Huq 2rNtUSVbowrJA== From: Jiri Olsa To: Oleg Nesterov , Peter Zijlstra , Andrii Nakryiko , Tianyi Liu , Masami Hiramatsu Cc: bpf@vger.kernel.org, Steven Rostedt , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCHv2 bpf-next 4/4] selftests/bpf: Add uprobe multi pid filter test for clone-ed processes Date: Thu, 5 Sep 2024 14:51:24 +0300 Message-ID: <20240905115124.1503998-5-jolsa@kernel.org> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20240905115124.1503998-1-jolsa@kernel.org> References: <20240905115124.1503998-1-jolsa@kernel.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Patchwork-Delegate: bpf@iogearbox.net The idea is to run same test as for test_pid_filter_process, but instead of standard fork-ed process we create the process with clone(CLONE_VM..) to make sure the thread leader process filter works properly in this case. Signed-off-by: Jiri Olsa --- .../bpf/prog_tests/uprobe_multi_test.c | 66 ++++++++++++------- 1 file changed, 42 insertions(+), 24 deletions(-) diff --git a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c index 9c2f99233304..f160d01ba5da 100644 --- a/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c +++ b/tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c @@ -40,6 +40,7 @@ struct child { int pid; int tid; pthread_t thread; + char stack[65536]; }; static void release_child(struct child *child) @@ -69,41 +70,56 @@ static void kick_child(struct child *child) fflush(NULL); } -static int spawn_child(struct child *child) +static int child_func(void *arg) { + struct child *child = arg; int err, c; + close(child->go[1]); + + /* wait for parent's kick */ + err = read(child->go[0], &c, 1); + if (err != 1) + exit(err); + + uprobe_multi_func_1(); + uprobe_multi_func_2(); + uprobe_multi_func_3(); + usdt_trigger(); + + exit(errno); +} + +static int spawn_child_flag(struct child *child, bool clone_vm) +{ /* pipe to notify child to execute the trigger functions */ if (pipe(child->go)) return -1; - child->pid = child->tid = fork(); + if (clone_vm) { + child->pid = child->tid = clone(child_func, child->stack + sizeof(child->stack)/2, + CLONE_VM|SIGCHLD, child); + } else { + child->pid = child->tid = fork(); + } if (child->pid < 0) { release_child(child); errno = EINVAL; return -1; } - /* child */ - if (child->pid == 0) { - close(child->go[1]); - - /* wait for parent's kick */ - err = read(child->go[0], &c, 1); - if (err != 1) - exit(err); - - uprobe_multi_func_1(); - uprobe_multi_func_2(); - uprobe_multi_func_3(); - usdt_trigger(); - - exit(errno); - } + /* fork-ed child */ + if (!clone_vm && child->pid == 0) + child_func(child); return 0; } +static int spawn_child(struct child *child) +{ + return spawn_child_flag(child, false); +} + static void *child_thread(void *ctx) { struct child *child = ctx; @@ -948,7 +964,7 @@ static struct bpf_program *uprobe_multi_program(struct uprobe_multi_pid_filter * #define TASKS 3 -static void run_pid_filter(struct uprobe_multi_pid_filter *skel, bool retprobe) +static void run_pid_filter(struct uprobe_multi_pid_filter *skel, bool clone_vm, bool retprobe) { LIBBPF_OPTS(bpf_uprobe_multi_opts, opts, .retprobe = retprobe); struct bpf_link *link[TASKS] = {}; @@ -958,7 +974,7 @@ static void run_pid_filter(struct uprobe_multi_pid_filter *skel, bool retprobe) memset(skel->bss->test, 0, sizeof(skel->bss->test)); for (i = 0; i < TASKS; i++) { - if (!ASSERT_OK(spawn_child(&child[i]), "spawn_child")) + if (!ASSERT_OK(spawn_child_flag(&child[i], clone_vm), "spawn_child")) goto cleanup; skel->bss->pids[i] = child[i].pid; } @@ -986,7 +1002,7 @@ static void run_pid_filter(struct uprobe_multi_pid_filter *skel, bool retprobe) release_child(&child[i]); } -static void test_pid_filter_process(void) +static void test_pid_filter_process(bool clone_vm) { struct uprobe_multi_pid_filter *skel; @@ -994,8 +1010,8 @@ static void test_pid_filter_process(void) if (!ASSERT_OK_PTR(skel, "uprobe_multi_pid_filter__open_and_load")) return; - run_pid_filter(skel, false); - run_pid_filter(skel, true); + run_pid_filter(skel, clone_vm, false); + run_pid_filter(skel, clone_vm, true); uprobe_multi_pid_filter__destroy(skel); } @@ -1093,5 +1109,7 @@ void test_uprobe_multi_test(void) if (test__start_subtest("consumers")) test_consumers(); if (test__start_subtest("filter_fork")) - test_pid_filter_process(); + test_pid_filter_process(false); + if (test__start_subtest("filter_clone_vm")) + test_pid_filter_process(true); }