From patchwork Thu Dec 7 16:34:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kyle Huey X-Patchwork-Id: 13483641 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kylehuey.com header.i=@kylehuey.com header.b="guqiquCD" Received: from mail-pl1-x62e.google.com (mail-pl1-x62e.google.com [IPv6:2607:f8b0:4864:20::62e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 10DE810F1 for ; Thu, 7 Dec 2023 08:35:22 -0800 (PST) Received: by mail-pl1-x62e.google.com with SMTP id d9443c01a7336-1d06819a9cbso8222115ad.1 for ; Thu, 07 Dec 2023 08:35:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kylehuey.com; s=google; t=1701966921; x=1702571721; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=9osTTHotszQKXwqlQLd/oaMNF9NAZxsSosoDc6zgOuE=; b=guqiquCDDbMLYq3eH2n38T7sPBx426J4mjZcL0wNaAjrTabqZGy+S1ks8lcxs3Xfp1 C36Sj6oXju/pQDECYrk2GH5SpsWqyMLo+gNhg3ypC73rxWjOQiuGv7MENNOWMfXeZAoD eqXPCZuJFwP2l+cyIFu65Rf2pj1pg5YB+RJPDQ4X88rMro10dKJtNjzawZOwkMSsCMNb Pr8Le3ZtQGoNLImBwmSZM8tE8WSa8rPVR9SBOpRQJUdFdgqXd1Q3hwiIZFL1VbYQWetT B4ap62AEHiQ3sp0Ex3zQsgpZcQJJBQyOhwl6suuToU70J1R7hmw0UdJsumPgJXTaWmml ZEAg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1701966921; x=1702571721; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=9osTTHotszQKXwqlQLd/oaMNF9NAZxsSosoDc6zgOuE=; b=jKgpsfHoWZLiUBju4nVYzUPu4jjmqAWlcokd/VJ1FNU+VSMhneNDdaXxiZfjJRwXd4 wNA9Esaw/Gtnrnv8BsJGd9b55rKcDmZuJHVcPicyEvKfehXzFG1yaATAJk0IyyIYcIri xsg0Hjh6/Q+cjGml17Vqk2IiwVVRR1X8Vd9H45cirIJmzcQBH0Qe3R+PXwkieMb7eBa6 4QduoXvbZ8wtwmZF1IdBreeCdGnbWMWIZjHX+4uLHQnafl76GPYQSGtgOV7uWcwoEdKd cQJvs1tSThD1eY1zyqDFrMBotrJpYGTCVeyxsMv7i2fY8p51cu/95SeJga+HAhUmvg6T Dfhg== X-Gm-Message-State: AOJu0Yy8DKoFH/DvYQ6EvYLqquyEYsN1cgnQcx50brFt3jFuhjeVOw39 Z1hFo66SbNHiOkmebLfyzEGILg== X-Google-Smtp-Source: AGHT+IHQ82i1qkEUSYKOoD2RldhRfBPTftGyytSZK7luHgpXPqIt+QmFwGmYYUQwA6B8JMjwTz/AoQ== X-Received: by 2002:a17:902:7c17:b0:1d0:b033:4a98 with SMTP id x23-20020a1709027c1700b001d0b0334a98mr2630388pll.17.1701966921325; Thu, 07 Dec 2023 08:35:21 -0800 (PST) Received: from zhadum.home.kylehuey.com (c-76-126-33-191.hsd1.ca.comcast.net. [76.126.33.191]) by smtp.gmail.com with ESMTPSA id iw15-20020a170903044f00b001d1cd7e4acfsm6143plb.201.2023.12.07.08.35.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 07 Dec 2023 08:35:20 -0800 (PST) From: Kyle Huey X-Google-Original-From: Kyle Huey To: Kyle Huey , linux-kernel@vger.kernel.org, Andrii Nakryiko , Jiri Olsa , Namhyung Kim , Marco Elver , Yonghong Song Cc: Robert O'Callahan , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko , Martin KaFai Lau , Song Liu , John Fastabend , KP Singh , Stanislav Fomichev , Hao Luo , Mykola Lysenko , Shuah Khan , bpf@vger.kernel.org, linux-kselftest@vger.kernel.org Subject: [PATCH v2 3/3] selftest/bpf: Test a perf bpf program that suppresses side effects. Date: Thu, 7 Dec 2023 08:34:58 -0800 Message-Id: <20231207163458.5554-4-khuey@kylehuey.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231207163458.5554-1-khuey@kylehuey.com> References: <20231207163458.5554-1-khuey@kylehuey.com> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 The test sets a hardware breakpoint and uses a bpf program to suppress the side effects of a perf event sample, including I/O availability signals, SIGTRAPs, and decrementing the event counter limit, if the ip matches the expected value. Then the function with the breakpoint is executed multiple times to test that all effects behave as expected. Signed-off-by: Kyle Huey --- .../selftests/bpf/prog_tests/perf_skip.c | 145 ++++++++++++++++++ .../selftests/bpf/progs/test_perf_skip.c | 15 ++ 2 files changed, 160 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/perf_skip.c create mode 100644 tools/testing/selftests/bpf/progs/test_perf_skip.c diff --git a/tools/testing/selftests/bpf/prog_tests/perf_skip.c b/tools/testing/selftests/bpf/prog_tests/perf_skip.c new file mode 100644 index 000000000000..f6fa9bfd9efa --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/perf_skip.c @@ -0,0 +1,145 @@ +// SPDX-License-Identifier: GPL-2.0 +#define _GNU_SOURCE + +/* We need the latest siginfo from the kernel repo. */ +#include +#define __have_siginfo_t 1 +#define __have_sigval_t 1 +#define __have_sigevent_t 1 +#define __siginfo_t_defined +#define __sigval_t_defined +#define __sigevent_t_defined +#define _BITS_SIGINFO_CONSTS_H 1 +#define _BITS_SIGEVENT_CONSTS_H 1 + +#include +#include "test_perf_skip.skel.h" +#include +#include +#include + +int signals_unexpected = 1; +int sigio_count, sigtrap_count; + +static void handle_sigio(int sig __always_unused) +{ + ASSERT_OK(signals_unexpected, "perf event not skipped"); + ++sigio_count; +} + +static void handle_sigtrap(int signum __always_unused, + siginfo_t *info, + void *ucontext __always_unused) +{ + ASSERT_OK(signals_unexpected, "perf event not skipped"); + ASSERT_EQ(info->si_code, TRAP_PERF, "wrong si_code"); + ++sigtrap_count; +} + +static noinline int test_function(void) +{ + asm volatile (""); + return 0; +} + +void serial_test_perf_skip(void) +{ + struct sigaction action = {}; + struct sigaction previous_sigtrap; + sighandler_t previous_sigio; + struct test_perf_skip *skel = NULL; + struct perf_event_attr attr = {}; + int perf_fd = -1; + int err; + struct f_owner_ex owner; + struct bpf_link *prog_link = NULL; + + action.sa_flags = SA_SIGINFO | SA_NODEFER; + action.sa_sigaction = handle_sigtrap; + sigemptyset(&action.sa_mask); + if (!ASSERT_OK(sigaction(SIGTRAP, &action, &previous_sigtrap), "sigaction")) + return; + + previous_sigio = signal(SIGIO, handle_sigio); + + skel = test_perf_skip__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_load")) + goto cleanup; + + attr.type = PERF_TYPE_BREAKPOINT; + attr.size = sizeof(attr); + attr.bp_type = HW_BREAKPOINT_X; + attr.bp_addr = (uintptr_t)test_function; + attr.bp_len = sizeof(long); + attr.sample_period = 1; + attr.sample_type = PERF_SAMPLE_IP; + attr.pinned = 1; + attr.exclude_kernel = 1; + attr.exclude_hv = 1; + attr.precise_ip = 3; + attr.sigtrap = 1; + attr.remove_on_exec = 1; + + perf_fd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0); + if (perf_fd < 0 && (errno == ENOENT || errno == EOPNOTSUPP)) { + printf("SKIP:no PERF_TYPE_BREAKPOINT/HW_BREAKPOINT_X\n"); + test__skip(); + goto cleanup; + } + if (!ASSERT_OK(perf_fd < 0, "perf_event_open")) + goto cleanup; + + // Configure the perf event to signal on sample. + err = fcntl(perf_fd, F_SETFL, O_ASYNC); + if (!ASSERT_OK(err, "fcntl(F_SETFL, O_ASYNC)")) + goto cleanup; + + owner.type = F_OWNER_TID; + owner.pid = syscall(__NR_gettid); + err = fcntl(perf_fd, F_SETOWN_EX, &owner); + if (!ASSERT_OK(err, "fcntl(F_SETOWN_EX)")) + goto cleanup; + + // Allow at most one sample. A sample rejected by bpf should + // not count against this. + err = ioctl(perf_fd, PERF_EVENT_IOC_REFRESH, 1); + if (!ASSERT_OK(err, "ioctl(PERF_EVENT_IOC_REFRESH)")) + goto cleanup; + + prog_link = bpf_program__attach_perf_event(skel->progs.handler, perf_fd); + if (!ASSERT_OK_PTR(prog_link, "bpf_program__attach_perf_event")) + goto cleanup; + + // Configure the bpf program to suppress the sample. + skel->bss->ip = (uintptr_t)test_function; + test_function(); + + ASSERT_EQ(sigio_count, 0, "sigio_count"); + ASSERT_EQ(sigtrap_count, 0, "sigtrap_count"); + + // Configure the bpf program to allow the sample. + skel->bss->ip = 0; + signals_unexpected = 0; + test_function(); + + ASSERT_EQ(sigio_count, 1, "sigio_count"); + ASSERT_EQ(sigtrap_count, 1, "sigtrap_count"); + + // Test that the sample above is the only one allowed (by perf, not + // by bpf) + test_function(); + + ASSERT_EQ(sigio_count, 1, "sigio_count"); + ASSERT_EQ(sigtrap_count, 1, "sigtrap_count"); + +cleanup: + if (prog_link) + bpf_link__destroy(prog_link); + if (perf_fd >= 0) + close(perf_fd); + if (skel) + test_perf_skip__destroy(skel); + + signal(SIGIO, previous_sigio); + sigaction(SIGTRAP, &previous_sigtrap, NULL); +} diff --git a/tools/testing/selftests/bpf/progs/test_perf_skip.c b/tools/testing/selftests/bpf/progs/test_perf_skip.c new file mode 100644 index 000000000000..417a9db3b770 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_perf_skip.c @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "vmlinux.h" +#include +#include + +uintptr_t ip; + +SEC("perf_event") +int handler(struct bpf_perf_event_data *data) +{ + // Skip events that have the correct ip. + return ip != PT_REGS_IP(&data->regs); +} + +char _license[] SEC("license") = "GPL";