| // SPDX-License-Identifier: GPL-2.0 | |
| #define _GNU_SOURCE | |
| #include <pthread.h> | |
| #include <sched.h> | |
| #include <sys/socket.h> | |
| #include <test_progs.h> | |
| #include "bpf/libbpf_internal.h" | |
| #include "test_perf_branches.skel.h" | |
| static void check_good_sample(struct test_perf_branches *skel) | |
| { | |
| int written_global = skel->bss->written_global_out; | |
| int required_size = skel->bss->required_size_out; | |
| int written_stack = skel->bss->written_stack_out; | |
| int pbe_size = sizeof(struct perf_branch_entry); | |
| int duration = 0; | |
| if (CHECK(!skel->bss->run_cnt, "invalid run_cnt", | |
| "checked sample validity before prog run")) | |
| return; | |
| if (CHECK(!skel->bss->valid, "output not valid", | |
| "no valid sample from prog")) | |
| return; | |
| /* | |
| * It's hard to validate the contents of the branch entries b/c it | |
| * would require some kind of disassembler and also encoding the | |
| * valid jump instructions for supported architectures. So just check | |
| * the easy stuff for now. | |
| */ | |
| CHECK(required_size <= 0, "read_branches_size", "err %d\n", required_size); | |
| CHECK(written_stack < 0, "read_branches_stack", "err %d\n", written_stack); | |
| CHECK(written_stack % pbe_size != 0, "read_branches_stack", | |
| "stack bytes written=%d not multiple of struct size=%d\n", | |
| written_stack, pbe_size); | |
| CHECK(written_global < 0, "read_branches_global", "err %d\n", written_global); | |
| CHECK(written_global % pbe_size != 0, "read_branches_global", | |
| "global bytes written=%d not multiple of struct size=%d\n", | |
| written_global, pbe_size); | |
| CHECK(written_global < written_stack, "read_branches_size", | |
| "written_global=%d < written_stack=%d\n", written_global, written_stack); | |
| } | |
| static void check_bad_sample(struct test_perf_branches *skel) | |
| { | |
| int written_global = skel->bss->written_global_out; | |
| int required_size = skel->bss->required_size_out; | |
| int written_stack = skel->bss->written_stack_out; | |
| int duration = 0; | |
| if (CHECK(!skel->bss->run_cnt, "invalid run_cnt", | |
| "checked sample validity before prog run")) | |
| return; | |
| if (CHECK(!skel->bss->valid, "output not valid", | |
| "no valid sample from prog")) | |
| return; | |
| CHECK((required_size != -EINVAL && required_size != -ENOENT), | |
| "read_branches_size", "err %d\n", required_size); | |
| CHECK((written_stack != -EINVAL && written_stack != -ENOENT), | |
| "read_branches_stack", "written %d\n", written_stack); | |
| CHECK((written_global != -EINVAL && written_global != -ENOENT), | |
| "read_branches_global", "written %d\n", written_global); | |
| } | |
| static void test_perf_branches_common(int perf_fd, | |
| void (*cb)(struct test_perf_branches *)) | |
| { | |
| struct test_perf_branches *skel; | |
| int err, i, duration = 0; | |
| bool detached = false; | |
| struct bpf_link *link; | |
| volatile int j = 0; | |
| cpu_set_t cpu_set; | |
| skel = test_perf_branches__open_and_load(); | |
| if (CHECK(!skel, "test_perf_branches_load", | |
| "perf_branches skeleton failed\n")) | |
| return; | |
| /* attach perf_event */ | |
| link = bpf_program__attach_perf_event(skel->progs.perf_branches, perf_fd); | |
| if (!ASSERT_OK_PTR(link, "attach_perf_event")) | |
| goto out_destroy_skel; | |
| /* generate some branches on cpu 0 */ | |
| CPU_ZERO(&cpu_set); | |
| CPU_SET(0, &cpu_set); | |
| err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set); | |
| if (CHECK(err, "set_affinity", "cpu #0, err %d\n", err)) | |
| goto out_destroy; | |
| /* Spin the loop for a while by using a high iteration count, and by | |
| * checking whether the specific run count marker has been explicitly | |
| * incremented at least once by the backing perf_event BPF program. | |
| */ | |
| for (i = 0; i < 100000000 && !*(volatile int *)&skel->bss->run_cnt; ++i) | |
| ++j; | |
| test_perf_branches__detach(skel); | |
| detached = true; | |
| cb(skel); | |
| out_destroy: | |
| bpf_link__destroy(link); | |
| out_destroy_skel: | |
| if (!detached) | |
| test_perf_branches__detach(skel); | |
| test_perf_branches__destroy(skel); | |
| } | |
| static void test_perf_branches_hw(void) | |
| { | |
| struct perf_event_attr attr = {0}; | |
| int duration = 0; | |
| int pfd; | |
| /* create perf event */ | |
| attr.size = sizeof(attr); | |
| attr.type = PERF_TYPE_HARDWARE; | |
| attr.config = PERF_COUNT_HW_CPU_CYCLES; | |
| attr.freq = 1; | |
| attr.sample_freq = 1000; | |
| attr.sample_type = PERF_SAMPLE_BRANCH_STACK; | |
| attr.branch_sample_type = PERF_SAMPLE_BRANCH_USER | PERF_SAMPLE_BRANCH_ANY; | |
| pfd = syscall(__NR_perf_event_open, &attr, -1, 0, -1, PERF_FLAG_FD_CLOEXEC); | |
| /* | |
| * Some setups don't support LBR (virtual machines, !x86, AMD Milan Zen | |
| * 3 which only supports BRS), so skip test in this case. | |
| */ | |
| if (pfd < 0) { | |
| if (errno == ENOENT || errno == EOPNOTSUPP || errno == EINVAL) { | |
| printf("%s:SKIP:no PERF_SAMPLE_BRANCH_STACK\n", | |
| __func__); | |
| test__skip(); | |
| return; | |
| } | |
| if (CHECK(pfd < 0, "perf_event_open", "err %d errno %d\n", | |
| pfd, errno)) | |
| return; | |
| } | |
| test_perf_branches_common(pfd, check_good_sample); | |
| close(pfd); | |
| } | |
| /* | |
| * Tests negative case -- run bpf_read_branch_records() on improperly configured | |
| * perf event. | |
| */ | |
| static void test_perf_branches_no_hw(void) | |
| { | |
| struct perf_event_attr attr = {0}; | |
| int duration = 0; | |
| int pfd; | |
| /* create perf event */ | |
| attr.size = sizeof(attr); | |
| attr.type = PERF_TYPE_SOFTWARE; | |
| attr.config = PERF_COUNT_SW_CPU_CLOCK; | |
| attr.freq = 1; | |
| attr.sample_freq = 1000; | |
| pfd = syscall(__NR_perf_event_open, &attr, -1, 0, -1, PERF_FLAG_FD_CLOEXEC); | |
| if (CHECK(pfd < 0, "perf_event_open", "err %d\n", pfd)) | |
| return; | |
| test_perf_branches_common(pfd, check_bad_sample); | |
| close(pfd); | |
| } | |
| void test_perf_branches(void) | |
| { | |
| if (test__start_subtest("perf_branches_hw")) | |
| test_perf_branches_hw(); | |
| if (test__start_subtest("perf_branches_no_hw")) | |
| test_perf_branches_no_hw(); | |
| } |