1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2023 Yafang Shao <laoar.shao@gmail.com> */
3
4 #include <string.h>
5 #include <linux/bpf.h>
6 #include <linux/limits.h>
7 #include <test_progs.h>
8 #include "trace_helpers.h"
9 #include "test_fill_link_info.skel.h"
10
11 #define TP_CAT "sched"
12 #define TP_NAME "sched_switch"
13
14 static const char *kmulti_syms[] = {
15 "bpf_fentry_test2",
16 "bpf_fentry_test1",
17 "bpf_fentry_test3",
18 };
19 #define KMULTI_CNT ARRAY_SIZE(kmulti_syms)
20 static __u64 kmulti_addrs[KMULTI_CNT];
21
22 #define KPROBE_FUNC "bpf_fentry_test1"
23 static __u64 kprobe_addr;
24
25 #define UPROBE_FILE "/proc/self/exe"
26 static ssize_t uprobe_offset;
27 /* uprobe attach point */
uprobe_func(void)28 static noinline void uprobe_func(void)
29 {
30 asm volatile ("");
31 }
32
33 #define PERF_EVENT_COOKIE 0xdeadbeef
34
verify_perf_link_info(int fd,enum bpf_perf_event_type type,long addr,ssize_t offset,ssize_t entry_offset)35 static int verify_perf_link_info(int fd, enum bpf_perf_event_type type, long addr,
36 ssize_t offset, ssize_t entry_offset)
37 {
38 struct bpf_link_info info;
39 __u32 len = sizeof(info);
40 char buf[PATH_MAX];
41 int err;
42
43 memset(&info, 0, sizeof(info));
44 buf[0] = '\0';
45
46 again:
47 err = bpf_link_get_info_by_fd(fd, &info, &len);
48 if (!ASSERT_OK(err, "get_link_info"))
49 return -1;
50
51 if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_PERF_EVENT, "link_type"))
52 return -1;
53 if (!ASSERT_EQ(info.perf_event.type, type, "perf_type_match"))
54 return -1;
55
56 switch (info.perf_event.type) {
57 case BPF_PERF_EVENT_KPROBE:
58 case BPF_PERF_EVENT_KRETPROBE:
59 ASSERT_EQ(info.perf_event.kprobe.offset, offset, "kprobe_offset");
60
61 /* In case kernel.kptr_restrict is not permitted or MAX_SYMS is reached */
62 if (addr)
63 ASSERT_EQ(info.perf_event.kprobe.addr, addr + entry_offset,
64 "kprobe_addr");
65
66 ASSERT_EQ(info.perf_event.kprobe.cookie, PERF_EVENT_COOKIE, "kprobe_cookie");
67
68 ASSERT_EQ(info.perf_event.kprobe.name_len, strlen(KPROBE_FUNC) + 1,
69 "name_len");
70 if (!info.perf_event.kprobe.func_name) {
71 info.perf_event.kprobe.func_name = ptr_to_u64(&buf);
72 info.perf_event.kprobe.name_len = sizeof(buf);
73 goto again;
74 }
75
76 err = strncmp(u64_to_ptr(info.perf_event.kprobe.func_name), KPROBE_FUNC,
77 strlen(KPROBE_FUNC));
78 ASSERT_EQ(err, 0, "cmp_kprobe_func_name");
79 break;
80 case BPF_PERF_EVENT_TRACEPOINT:
81 ASSERT_EQ(info.perf_event.tracepoint.name_len, strlen(TP_NAME) + 1,
82 "name_len");
83 if (!info.perf_event.tracepoint.tp_name) {
84 info.perf_event.tracepoint.tp_name = ptr_to_u64(&buf);
85 info.perf_event.tracepoint.name_len = sizeof(buf);
86 goto again;
87 }
88
89 ASSERT_EQ(info.perf_event.tracepoint.cookie, PERF_EVENT_COOKIE, "tracepoint_cookie");
90
91 err = strncmp(u64_to_ptr(info.perf_event.tracepoint.tp_name), TP_NAME,
92 strlen(TP_NAME));
93 ASSERT_EQ(err, 0, "cmp_tp_name");
94 break;
95 case BPF_PERF_EVENT_UPROBE:
96 case BPF_PERF_EVENT_URETPROBE:
97 ASSERT_EQ(info.perf_event.uprobe.offset, offset, "uprobe_offset");
98
99 ASSERT_EQ(info.perf_event.uprobe.name_len, strlen(UPROBE_FILE) + 1,
100 "name_len");
101 if (!info.perf_event.uprobe.file_name) {
102 info.perf_event.uprobe.file_name = ptr_to_u64(&buf);
103 info.perf_event.uprobe.name_len = sizeof(buf);
104 goto again;
105 }
106
107 ASSERT_EQ(info.perf_event.uprobe.cookie, PERF_EVENT_COOKIE, "uprobe_cookie");
108
109 err = strncmp(u64_to_ptr(info.perf_event.uprobe.file_name), UPROBE_FILE,
110 strlen(UPROBE_FILE));
111 ASSERT_EQ(err, 0, "cmp_file_name");
112 break;
113 default:
114 err = -1;
115 break;
116 }
117 return err;
118 }
119
kprobe_fill_invalid_user_buffer(int fd)120 static void kprobe_fill_invalid_user_buffer(int fd)
121 {
122 struct bpf_link_info info;
123 __u32 len = sizeof(info);
124 int err;
125
126 memset(&info, 0, sizeof(info));
127
128 info.perf_event.kprobe.func_name = 0x1; /* invalid address */
129 err = bpf_link_get_info_by_fd(fd, &info, &len);
130 ASSERT_EQ(err, -EINVAL, "invalid_buff_and_len");
131
132 info.perf_event.kprobe.name_len = 64;
133 err = bpf_link_get_info_by_fd(fd, &info, &len);
134 ASSERT_EQ(err, -EFAULT, "invalid_buff");
135
136 info.perf_event.kprobe.func_name = 0;
137 err = bpf_link_get_info_by_fd(fd, &info, &len);
138 ASSERT_EQ(err, -EINVAL, "invalid_len");
139
140 ASSERT_EQ(info.perf_event.kprobe.addr, 0, "func_addr");
141 ASSERT_EQ(info.perf_event.kprobe.offset, 0, "func_offset");
142 ASSERT_EQ(info.perf_event.type, 0, "type");
143 }
144
test_kprobe_fill_link_info(struct test_fill_link_info * skel,enum bpf_perf_event_type type,bool invalid)145 static void test_kprobe_fill_link_info(struct test_fill_link_info *skel,
146 enum bpf_perf_event_type type,
147 bool invalid)
148 {
149 DECLARE_LIBBPF_OPTS(bpf_kprobe_opts, opts,
150 .attach_mode = PROBE_ATTACH_MODE_LINK,
151 .retprobe = type == BPF_PERF_EVENT_KRETPROBE,
152 .bpf_cookie = PERF_EVENT_COOKIE,
153 );
154 ssize_t entry_offset = 0;
155 struct bpf_link *link;
156 int link_fd, err;
157
158 link = bpf_program__attach_kprobe_opts(skel->progs.kprobe_run, KPROBE_FUNC, &opts);
159 if (!ASSERT_OK_PTR(link, "attach_kprobe"))
160 return;
161
162 link_fd = bpf_link__fd(link);
163 if (!invalid) {
164 /* See also arch_adjust_kprobe_addr(). */
165 if (skel->kconfig->CONFIG_X86_KERNEL_IBT)
166 entry_offset = 4;
167 if (skel->kconfig->CONFIG_PPC64 &&
168 skel->kconfig->CONFIG_KPROBES_ON_FTRACE &&
169 !skel->kconfig->CONFIG_PPC_FTRACE_OUT_OF_LINE)
170 entry_offset = 4;
171 err = verify_perf_link_info(link_fd, type, kprobe_addr, 0, entry_offset);
172 ASSERT_OK(err, "verify_perf_link_info");
173 } else {
174 kprobe_fill_invalid_user_buffer(link_fd);
175 }
176 bpf_link__destroy(link);
177 }
178
test_tp_fill_link_info(struct test_fill_link_info * skel)179 static void test_tp_fill_link_info(struct test_fill_link_info *skel)
180 {
181 DECLARE_LIBBPF_OPTS(bpf_tracepoint_opts, opts,
182 .bpf_cookie = PERF_EVENT_COOKIE,
183 );
184 struct bpf_link *link;
185 int link_fd, err;
186
187 link = bpf_program__attach_tracepoint_opts(skel->progs.tp_run, TP_CAT, TP_NAME, &opts);
188 if (!ASSERT_OK_PTR(link, "attach_tp"))
189 return;
190
191 link_fd = bpf_link__fd(link);
192 err = verify_perf_link_info(link_fd, BPF_PERF_EVENT_TRACEPOINT, 0, 0, 0);
193 ASSERT_OK(err, "verify_perf_link_info");
194 bpf_link__destroy(link);
195 }
196
test_uprobe_fill_link_info(struct test_fill_link_info * skel,enum bpf_perf_event_type type)197 static void test_uprobe_fill_link_info(struct test_fill_link_info *skel,
198 enum bpf_perf_event_type type)
199 {
200 DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, opts,
201 .retprobe = type == BPF_PERF_EVENT_URETPROBE,
202 .bpf_cookie = PERF_EVENT_COOKIE,
203 );
204 struct bpf_link *link;
205 int link_fd, err;
206
207 link = bpf_program__attach_uprobe_opts(skel->progs.uprobe_run,
208 0, /* self pid */
209 UPROBE_FILE, uprobe_offset,
210 &opts);
211 if (!ASSERT_OK_PTR(link, "attach_uprobe"))
212 return;
213
214 link_fd = bpf_link__fd(link);
215 err = verify_perf_link_info(link_fd, type, 0, uprobe_offset, 0);
216 ASSERT_OK(err, "verify_perf_link_info");
217 bpf_link__destroy(link);
218 }
219
verify_kmulti_link_info(int fd,bool retprobe)220 static int verify_kmulti_link_info(int fd, bool retprobe)
221 {
222 struct bpf_link_info info;
223 __u32 len = sizeof(info);
224 __u64 addrs[KMULTI_CNT];
225 int flags, i, err;
226
227 memset(&info, 0, sizeof(info));
228
229 again:
230 err = bpf_link_get_info_by_fd(fd, &info, &len);
231 if (!ASSERT_OK(err, "get_link_info"))
232 return -1;
233
234 if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_KPROBE_MULTI, "kmulti_type"))
235 return -1;
236
237 ASSERT_EQ(info.kprobe_multi.count, KMULTI_CNT, "func_cnt");
238 flags = info.kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN;
239 if (!retprobe)
240 ASSERT_EQ(flags, 0, "kmulti_flags");
241 else
242 ASSERT_NEQ(flags, 0, "kretmulti_flags");
243
244 if (!info.kprobe_multi.addrs) {
245 info.kprobe_multi.addrs = ptr_to_u64(addrs);
246 goto again;
247 }
248 for (i = 0; i < KMULTI_CNT; i++)
249 ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
250 return 0;
251 }
252
verify_kmulti_invalid_user_buffer(int fd)253 static void verify_kmulti_invalid_user_buffer(int fd)
254 {
255 struct bpf_link_info info;
256 __u32 len = sizeof(info);
257 __u64 addrs[KMULTI_CNT];
258 int err, i;
259
260 memset(&info, 0, sizeof(info));
261
262 info.kprobe_multi.count = KMULTI_CNT;
263 err = bpf_link_get_info_by_fd(fd, &info, &len);
264 ASSERT_EQ(err, -EINVAL, "no_addr");
265
266 info.kprobe_multi.addrs = ptr_to_u64(addrs);
267 info.kprobe_multi.count = 0;
268 err = bpf_link_get_info_by_fd(fd, &info, &len);
269 ASSERT_EQ(err, -EINVAL, "no_cnt");
270
271 for (i = 0; i < KMULTI_CNT; i++)
272 addrs[i] = 0;
273 info.kprobe_multi.count = KMULTI_CNT - 1;
274 err = bpf_link_get_info_by_fd(fd, &info, &len);
275 ASSERT_EQ(err, -ENOSPC, "smaller_cnt");
276 for (i = 0; i < KMULTI_CNT - 1; i++)
277 ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
278 ASSERT_EQ(addrs[i], 0, "kmulti_addrs");
279
280 for (i = 0; i < KMULTI_CNT; i++)
281 addrs[i] = 0;
282 info.kprobe_multi.count = KMULTI_CNT + 1;
283 err = bpf_link_get_info_by_fd(fd, &info, &len);
284 ASSERT_EQ(err, 0, "bigger_cnt");
285 for (i = 0; i < KMULTI_CNT; i++)
286 ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
287
288 info.kprobe_multi.count = KMULTI_CNT;
289 info.kprobe_multi.addrs = 0x1; /* invalid addr */
290 err = bpf_link_get_info_by_fd(fd, &info, &len);
291 ASSERT_EQ(err, -EFAULT, "invalid_buff");
292 }
293
symbols_cmp_r(const void * a,const void * b)294 static int symbols_cmp_r(const void *a, const void *b)
295 {
296 const char **str_a = (const char **) a;
297 const char **str_b = (const char **) b;
298
299 return strcmp(*str_a, *str_b);
300 }
301
test_kprobe_multi_fill_link_info(struct test_fill_link_info * skel,bool retprobe,bool invalid)302 static void test_kprobe_multi_fill_link_info(struct test_fill_link_info *skel,
303 bool retprobe, bool invalid)
304 {
305 LIBBPF_OPTS(bpf_kprobe_multi_opts, opts);
306 struct bpf_link *link;
307 int link_fd, err;
308
309 opts.syms = kmulti_syms;
310 opts.cnt = KMULTI_CNT;
311 opts.retprobe = retprobe;
312 link = bpf_program__attach_kprobe_multi_opts(skel->progs.kmulti_run, NULL, &opts);
313 if (!ASSERT_OK_PTR(link, "attach_kprobe_multi"))
314 return;
315
316 link_fd = bpf_link__fd(link);
317 if (!invalid) {
318 err = verify_kmulti_link_info(link_fd, retprobe);
319 ASSERT_OK(err, "verify_kmulti_link_info");
320 } else {
321 verify_kmulti_invalid_user_buffer(link_fd);
322 }
323 bpf_link__destroy(link);
324 }
325
test_fill_link_info(void)326 void test_fill_link_info(void)
327 {
328 struct test_fill_link_info *skel;
329 int i;
330
331 skel = test_fill_link_info__open_and_load();
332 if (!ASSERT_OK_PTR(skel, "skel_open"))
333 return;
334
335 /* load kallsyms to compare the addr */
336 if (!ASSERT_OK(load_kallsyms_refresh(), "load_kallsyms_refresh"))
337 goto cleanup;
338
339 kprobe_addr = ksym_get_addr(KPROBE_FUNC);
340 if (test__start_subtest("kprobe_link_info"))
341 test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, false);
342 if (test__start_subtest("kretprobe_link_info"))
343 test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KRETPROBE, false);
344 if (test__start_subtest("kprobe_invalid_ubuff"))
345 test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, true);
346 if (test__start_subtest("tracepoint_link_info"))
347 test_tp_fill_link_info(skel);
348
349 uprobe_offset = get_uprobe_offset(&uprobe_func);
350 if (test__start_subtest("uprobe_link_info"))
351 test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_UPROBE);
352 if (test__start_subtest("uretprobe_link_info"))
353 test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_URETPROBE);
354
355 qsort(kmulti_syms, KMULTI_CNT, sizeof(kmulti_syms[0]), symbols_cmp_r);
356 for (i = 0; i < KMULTI_CNT; i++)
357 kmulti_addrs[i] = ksym_get_addr(kmulti_syms[i]);
358 if (test__start_subtest("kprobe_multi_link_info"))
359 test_kprobe_multi_fill_link_info(skel, false, false);
360 if (test__start_subtest("kretprobe_multi_link_info"))
361 test_kprobe_multi_fill_link_info(skel, true, false);
362 if (test__start_subtest("kprobe_multi_invalid_ubuff"))
363 test_kprobe_multi_fill_link_info(skel, true, true);
364
365 cleanup:
366 test_fill_link_info__destroy(skel);
367 }
368