1 // SPDX-License-Identifier: GPL-2.0
2 #define _GNU_SOURCE
3 #include <pthread.h>
4 #include <sched.h>
5 #include <sys/socket.h>
6 #include <test_progs.h>
7 #include "bpf/libbpf_internal.h"
8 #include "test_perf_branches.skel.h"
9 
10 static void check_good_sample(struct test_perf_branches *skel)
11 {
12 	int written_global = skel->bss->written_global_out;
13 	int required_size = skel->bss->required_size_out;
14 	int written_stack = skel->bss->written_stack_out;
15 	int pbe_size = sizeof(struct perf_branch_entry);
16 	int duration = 0;
17 
18 	if (CHECK(!skel->bss->valid, "output not valid",
19 		 "no valid sample from prog"))
20 		return;
21 
22 	/*
23 	 * It's hard to validate the contents of the branch entries b/c it
24 	 * would require some kind of disassembler and also encoding the
25 	 * valid jump instructions for supported architectures. So just check
26 	 * the easy stuff for now.
27 	 */
28 	CHECK(required_size <= 0, "read_branches_size", "err %d\n", required_size);
29 	CHECK(written_stack < 0, "read_branches_stack", "err %d\n", written_stack);
30 	CHECK(written_stack % pbe_size != 0, "read_branches_stack",
31 	      "stack bytes written=%d not multiple of struct size=%d\n",
32 	      written_stack, pbe_size);
33 	CHECK(written_global < 0, "read_branches_global", "err %d\n", written_global);
34 	CHECK(written_global % pbe_size != 0, "read_branches_global",
35 	      "global bytes written=%d not multiple of struct size=%d\n",
36 	      written_global, pbe_size);
37 	CHECK(written_global < written_stack, "read_branches_size",
38 	      "written_global=%d < written_stack=%d\n", written_global, written_stack);
39 }
40 
41 static void check_bad_sample(struct test_perf_branches *skel)
42 {
43 	int written_global = skel->bss->written_global_out;
44 	int required_size = skel->bss->required_size_out;
45 	int written_stack = skel->bss->written_stack_out;
46 	int duration = 0;
47 
48 	if (CHECK(!skel->bss->valid, "output not valid",
49 		 "no valid sample from prog"))
50 		return;
51 
52 	CHECK((required_size != -EINVAL && required_size != -ENOENT),
53 	      "read_branches_size", "err %d\n", required_size);
54 	CHECK((written_stack != -EINVAL && written_stack != -ENOENT),
55 	      "read_branches_stack", "written %d\n", written_stack);
56 	CHECK((written_global != -EINVAL && written_global != -ENOENT),
57 	      "read_branches_global", "written %d\n", written_global);
58 }
59 
60 static void test_perf_branches_common(int perf_fd,
61 				      void (*cb)(struct test_perf_branches *))
62 {
63 	struct test_perf_branches *skel;
64 	int err, i, duration = 0;
65 	bool detached = false;
66 	struct bpf_link *link;
67 	volatile int j = 0;
68 	cpu_set_t cpu_set;
69 
70 	skel = test_perf_branches__open_and_load();
71 	if (CHECK(!skel, "test_perf_branches_load",
72 		  "perf_branches skeleton failed\n"))
73 		return;
74 
75 	/* attach perf_event */
76 	link = bpf_program__attach_perf_event(skel->progs.perf_branches, perf_fd);
77 	if (CHECK(IS_ERR(link), "attach_perf_event", "err %ld\n", PTR_ERR(link)))
78 		goto out_destroy_skel;
79 
80 	/* generate some branches on cpu 0 */
81 	CPU_ZERO(&cpu_set);
82 	CPU_SET(0, &cpu_set);
83 	err = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set);
84 	if (CHECK(err, "set_affinity", "cpu #0, err %d\n", err))
85 		goto out_destroy;
86 	/* spin the loop for a while (random high number) */
87 	for (i = 0; i < 1000000; ++i)
88 		++j;
89 
90 	test_perf_branches__detach(skel);
91 	detached = true;
92 
93 	cb(skel);
94 out_destroy:
95 	bpf_link__destroy(link);
96 out_destroy_skel:
97 	if (!detached)
98 		test_perf_branches__detach(skel);
99 	test_perf_branches__destroy(skel);
100 }
101 
102 static void test_perf_branches_hw(void)
103 {
104 	struct perf_event_attr attr = {0};
105 	int duration = 0;
106 	int pfd;
107 
108 	/* create perf event */
109 	attr.size = sizeof(attr);
110 	attr.type = PERF_TYPE_HARDWARE;
111 	attr.config = PERF_COUNT_HW_CPU_CYCLES;
112 	attr.freq = 1;
113 	attr.sample_freq = 4000;
114 	attr.sample_type = PERF_SAMPLE_BRANCH_STACK;
115 	attr.branch_sample_type = PERF_SAMPLE_BRANCH_USER | PERF_SAMPLE_BRANCH_ANY;
116 	pfd = syscall(__NR_perf_event_open, &attr, -1, 0, -1, PERF_FLAG_FD_CLOEXEC);
117 
118 	/*
119 	 * Some setups don't support branch records (virtual machines, !x86),
120 	 * so skip test in this case.
121 	 */
122 	if (pfd == -1) {
123 		if (errno == ENOENT || errno == EOPNOTSUPP) {
124 			printf("%s:SKIP:no PERF_SAMPLE_BRANCH_STACK\n",
125 			       __func__);
126 			test__skip();
127 			return;
128 		}
129 		if (CHECK(pfd < 0, "perf_event_open", "err %d errno %d\n",
130 			  pfd, errno))
131 			return;
132 	}
133 
134 	test_perf_branches_common(pfd, check_good_sample);
135 
136 	close(pfd);
137 }
138 
139 /*
140  * Tests negative case -- run bpf_read_branch_records() on improperly configured
141  * perf event.
142  */
143 static void test_perf_branches_no_hw(void)
144 {
145 	struct perf_event_attr attr = {0};
146 	int duration = 0;
147 	int pfd;
148 
149 	/* create perf event */
150 	attr.size = sizeof(attr);
151 	attr.type = PERF_TYPE_SOFTWARE;
152 	attr.config = PERF_COUNT_SW_CPU_CLOCK;
153 	attr.freq = 1;
154 	attr.sample_freq = 4000;
155 	pfd = syscall(__NR_perf_event_open, &attr, -1, 0, -1, PERF_FLAG_FD_CLOEXEC);
156 	if (CHECK(pfd < 0, "perf_event_open", "err %d\n", pfd))
157 		return;
158 
159 	test_perf_branches_common(pfd, check_bad_sample);
160 
161 	close(pfd);
162 }
163 
164 void test_perf_branches(void)
165 {
166 	if (test__start_subtest("perf_branches_hw"))
167 		test_perf_branches_hw();
168 	if (test__start_subtest("perf_branches_no_hw"))
169 		test_perf_branches_no_hw();
170 }
171