1 // SPDX-License-Identifier: GPL-2.0
2 #include <test_progs.h>
3 #include "progs/core_reloc_types.h"
4 #include <sys/mman.h>
5 #include <sys/syscall.h>
6
7 #define STRUCT_TO_CHAR_PTR(struct_name) (const char *)&(struct struct_name)
8
9 #define FLAVORS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
10 .a = 42, \
11 .b = 0xc001, \
12 .c = 0xbeef, \
13 }
14
15 #define FLAVORS_CASE_COMMON(name) \
16 .case_name = #name, \
17 .bpf_obj_file = "test_core_reloc_flavors.o", \
18 .btf_src_file = "btf__core_reloc_" #name ".o" \
19
20 #define FLAVORS_CASE(name) { \
21 FLAVORS_CASE_COMMON(name), \
22 .input = FLAVORS_DATA(core_reloc_##name), \
23 .input_len = sizeof(struct core_reloc_##name), \
24 .output = FLAVORS_DATA(core_reloc_flavors), \
25 .output_len = sizeof(struct core_reloc_flavors), \
26 }
27
28 #define FLAVORS_ERR_CASE(name) { \
29 FLAVORS_CASE_COMMON(name), \
30 .fails = true, \
31 }
32
33 #define NESTING_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
34 .a = { .a = { .a = 42 } }, \
35 .b = { .b = { .b = 0xc001 } }, \
36 }
37
38 #define NESTING_CASE_COMMON(name) \
39 .case_name = #name, \
40 .bpf_obj_file = "test_core_reloc_nesting.o", \
41 .btf_src_file = "btf__core_reloc_" #name ".o"
42
43 #define NESTING_CASE(name) { \
44 NESTING_CASE_COMMON(name), \
45 .input = NESTING_DATA(core_reloc_##name), \
46 .input_len = sizeof(struct core_reloc_##name), \
47 .output = NESTING_DATA(core_reloc_nesting), \
48 .output_len = sizeof(struct core_reloc_nesting) \
49 }
50
51 #define NESTING_ERR_CASE(name) { \
52 NESTING_CASE_COMMON(name), \
53 .fails = true, \
54 }
55
56 #define ARRAYS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
57 .a = { [2] = 1 }, \
58 .b = { [1] = { [2] = { [3] = 2 } } }, \
59 .c = { [1] = { .c = 3 } }, \
60 .d = { [0] = { [0] = { .d = 4 } } }, \
61 }
62
63 #define ARRAYS_CASE_COMMON(name) \
64 .case_name = #name, \
65 .bpf_obj_file = "test_core_reloc_arrays.o", \
66 .btf_src_file = "btf__core_reloc_" #name ".o"
67
68 #define ARRAYS_CASE(name) { \
69 ARRAYS_CASE_COMMON(name), \
70 .input = ARRAYS_DATA(core_reloc_##name), \
71 .input_len = sizeof(struct core_reloc_##name), \
72 .output = STRUCT_TO_CHAR_PTR(core_reloc_arrays_output) { \
73 .a2 = 1, \
74 .b123 = 2, \
75 .c1c = 3, \
76 .d00d = 4, \
77 }, \
78 .output_len = sizeof(struct core_reloc_arrays_output) \
79 }
80
81 #define ARRAYS_ERR_CASE(name) { \
82 ARRAYS_CASE_COMMON(name), \
83 .fails = true, \
84 }
85
86 #define PRIMITIVES_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
87 .a = 1, \
88 .b = 2, \
89 .c = 3, \
90 .d = (void *)4, \
91 .f = (void *)5, \
92 }
93
94 #define PRIMITIVES_CASE_COMMON(name) \
95 .case_name = #name, \
96 .bpf_obj_file = "test_core_reloc_primitives.o", \
97 .btf_src_file = "btf__core_reloc_" #name ".o"
98
99 #define PRIMITIVES_CASE(name) { \
100 PRIMITIVES_CASE_COMMON(name), \
101 .input = PRIMITIVES_DATA(core_reloc_##name), \
102 .input_len = sizeof(struct core_reloc_##name), \
103 .output = PRIMITIVES_DATA(core_reloc_primitives), \
104 .output_len = sizeof(struct core_reloc_primitives), \
105 }
106
107 #define PRIMITIVES_ERR_CASE(name) { \
108 PRIMITIVES_CASE_COMMON(name), \
109 .fails = true, \
110 }
111
112 #define MODS_CASE(name) { \
113 .case_name = #name, \
114 .bpf_obj_file = "test_core_reloc_mods.o", \
115 .btf_src_file = "btf__core_reloc_" #name ".o", \
116 .input = STRUCT_TO_CHAR_PTR(core_reloc_##name) { \
117 .a = 1, \
118 .b = 2, \
119 .c = (void *)3, \
120 .d = (void *)4, \
121 .e = { [2] = 5 }, \
122 .f = { [1] = 6 }, \
123 .g = { .x = 7 }, \
124 .h = { .y = 8 }, \
125 }, \
126 .input_len = sizeof(struct core_reloc_##name), \
127 .output = STRUCT_TO_CHAR_PTR(core_reloc_mods_output) { \
128 .a = 1, .b = 2, .c = 3, .d = 4, \
129 .e = 5, .f = 6, .g = 7, .h = 8, \
130 }, \
131 .output_len = sizeof(struct core_reloc_mods_output), \
132 }
133
134 #define PTR_AS_ARR_CASE(name) { \
135 .case_name = #name, \
136 .bpf_obj_file = "test_core_reloc_ptr_as_arr.o", \
137 .btf_src_file = "btf__core_reloc_" #name ".o", \
138 .input = (const char *)&(struct core_reloc_##name []){ \
139 { .a = 1 }, \
140 { .a = 2 }, \
141 { .a = 3 }, \
142 }, \
143 .input_len = 3 * sizeof(struct core_reloc_##name), \
144 .output = STRUCT_TO_CHAR_PTR(core_reloc_ptr_as_arr) { \
145 .a = 3, \
146 }, \
147 .output_len = sizeof(struct core_reloc_ptr_as_arr), \
148 }
149
150 #define INTS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
151 .u8_field = 1, \
152 .s8_field = 2, \
153 .u16_field = 3, \
154 .s16_field = 4, \
155 .u32_field = 5, \
156 .s32_field = 6, \
157 .u64_field = 7, \
158 .s64_field = 8, \
159 }
160
161 #define INTS_CASE_COMMON(name) \
162 .case_name = #name, \
163 .bpf_obj_file = "test_core_reloc_ints.o", \
164 .btf_src_file = "btf__core_reloc_" #name ".o"
165
166 #define INTS_CASE(name) { \
167 INTS_CASE_COMMON(name), \
168 .input = INTS_DATA(core_reloc_##name), \
169 .input_len = sizeof(struct core_reloc_##name), \
170 .output = INTS_DATA(core_reloc_ints), \
171 .output_len = sizeof(struct core_reloc_ints), \
172 }
173
174 #define INTS_ERR_CASE(name) { \
175 INTS_CASE_COMMON(name), \
176 .fails = true, \
177 }
178
179 #define EXISTENCE_CASE_COMMON(name) \
180 .case_name = #name, \
181 .bpf_obj_file = "test_core_reloc_existence.o", \
182 .btf_src_file = "btf__core_reloc_" #name ".o", \
183 .relaxed_core_relocs = true
184
185 #define EXISTENCE_ERR_CASE(name) { \
186 EXISTENCE_CASE_COMMON(name), \
187 .fails = true, \
188 }
189
190 #define BITFIELDS_CASE_COMMON(objfile, test_name_prefix, name) \
191 .case_name = test_name_prefix#name, \
192 .bpf_obj_file = objfile, \
193 .btf_src_file = "btf__core_reloc_" #name ".o"
194
195 #define BITFIELDS_CASE(name, ...) { \
196 BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.o", \
197 "direct:", name), \
198 .input = STRUCT_TO_CHAR_PTR(core_reloc_##name) __VA_ARGS__, \
199 .input_len = sizeof(struct core_reloc_##name), \
200 .output = STRUCT_TO_CHAR_PTR(core_reloc_bitfields_output) \
201 __VA_ARGS__, \
202 .output_len = sizeof(struct core_reloc_bitfields_output), \
203 }, { \
204 BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o", \
205 "probed:", name), \
206 .input = STRUCT_TO_CHAR_PTR(core_reloc_##name) __VA_ARGS__, \
207 .input_len = sizeof(struct core_reloc_##name), \
208 .output = STRUCT_TO_CHAR_PTR(core_reloc_bitfields_output) \
209 __VA_ARGS__, \
210 .output_len = sizeof(struct core_reloc_bitfields_output), \
211 .direct_raw_tp = true, \
212 }
213
214
215 #define BITFIELDS_ERR_CASE(name) { \
216 BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.o", \
217 "probed:", name), \
218 .fails = true, \
219 }, { \
220 BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o", \
221 "direct:", name), \
222 .direct_raw_tp = true, \
223 .fails = true, \
224 }
225
226 #define SIZE_CASE_COMMON(name) \
227 .case_name = #name, \
228 .bpf_obj_file = "test_core_reloc_size.o", \
229 .btf_src_file = "btf__core_reloc_" #name ".o", \
230 .relaxed_core_relocs = true
231
232 #define SIZE_OUTPUT_DATA(type) \
233 STRUCT_TO_CHAR_PTR(core_reloc_size_output) { \
234 .int_sz = sizeof(((type *)0)->int_field), \
235 .struct_sz = sizeof(((type *)0)->struct_field), \
236 .union_sz = sizeof(((type *)0)->union_field), \
237 .arr_sz = sizeof(((type *)0)->arr_field), \
238 .arr_elem_sz = sizeof(((type *)0)->arr_field[0]), \
239 .ptr_sz = sizeof(((type *)0)->ptr_field), \
240 .enum_sz = sizeof(((type *)0)->enum_field), \
241 }
242
243 #define SIZE_CASE(name) { \
244 SIZE_CASE_COMMON(name), \
245 .input_len = 0, \
246 .output = SIZE_OUTPUT_DATA(struct core_reloc_##name), \
247 .output_len = sizeof(struct core_reloc_size_output), \
248 }
249
250 #define SIZE_ERR_CASE(name) { \
251 SIZE_CASE_COMMON(name), \
252 .fails = true, \
253 }
254
255 struct core_reloc_test_case {
256 const char *case_name;
257 const char *bpf_obj_file;
258 const char *btf_src_file;
259 const char *input;
260 int input_len;
261 const char *output;
262 int output_len;
263 bool fails;
264 bool relaxed_core_relocs;
265 bool direct_raw_tp;
266 };
267
268 static struct core_reloc_test_case test_cases[] = {
269 /* validate we can find kernel image and use its BTF for relocs */
270 {
271 .case_name = "kernel",
272 .bpf_obj_file = "test_core_reloc_kernel.o",
273 .btf_src_file = NULL, /* load from /lib/modules/$(uname -r) */
274 .input = "",
275 .input_len = 0,
276 .output = STRUCT_TO_CHAR_PTR(core_reloc_kernel_output) {
277 .valid = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, },
278 .comm = "test_progs",
279 .comm_len = sizeof("test_progs"),
280 },
281 .output_len = sizeof(struct core_reloc_kernel_output),
282 },
283
284 /* validate BPF program can use multiple flavors to match against
285 * single target BTF type
286 */
287 FLAVORS_CASE(flavors),
288
289 FLAVORS_ERR_CASE(flavors__err_wrong_name),
290
291 /* various struct/enum nesting and resolution scenarios */
292 NESTING_CASE(nesting),
293 NESTING_CASE(nesting___anon_embed),
294 NESTING_CASE(nesting___struct_union_mixup),
295 NESTING_CASE(nesting___extra_nesting),
296 NESTING_CASE(nesting___dup_compat_types),
297
298 NESTING_ERR_CASE(nesting___err_missing_field),
299 NESTING_ERR_CASE(nesting___err_array_field),
300 NESTING_ERR_CASE(nesting___err_missing_container),
301 NESTING_ERR_CASE(nesting___err_nonstruct_container),
302 NESTING_ERR_CASE(nesting___err_array_container),
303 NESTING_ERR_CASE(nesting___err_dup_incompat_types),
304 NESTING_ERR_CASE(nesting___err_partial_match_dups),
305 NESTING_ERR_CASE(nesting___err_too_deep),
306
307 /* various array access relocation scenarios */
308 ARRAYS_CASE(arrays),
309 ARRAYS_CASE(arrays___diff_arr_dim),
310 ARRAYS_CASE(arrays___diff_arr_val_sz),
311
312 ARRAYS_ERR_CASE(arrays___err_too_small),
313 ARRAYS_ERR_CASE(arrays___err_too_shallow),
314 ARRAYS_ERR_CASE(arrays___err_non_array),
315 ARRAYS_ERR_CASE(arrays___err_wrong_val_type1),
316 ARRAYS_ERR_CASE(arrays___err_wrong_val_type2),
317
318 /* enum/ptr/int handling scenarios */
319 PRIMITIVES_CASE(primitives),
320 PRIMITIVES_CASE(primitives___diff_enum_def),
321 PRIMITIVES_CASE(primitives___diff_func_proto),
322 PRIMITIVES_CASE(primitives___diff_ptr_type),
323
324 PRIMITIVES_ERR_CASE(primitives___err_non_enum),
325 PRIMITIVES_ERR_CASE(primitives___err_non_int),
326 PRIMITIVES_ERR_CASE(primitives___err_non_ptr),
327
328 /* const/volatile/restrict and typedefs scenarios */
329 MODS_CASE(mods),
330 MODS_CASE(mods___mod_swap),
331 MODS_CASE(mods___typedefs),
332
333 /* handling "ptr is an array" semantics */
334 PTR_AS_ARR_CASE(ptr_as_arr),
335 PTR_AS_ARR_CASE(ptr_as_arr___diff_sz),
336
337 /* int signedness/sizing/bitfield handling */
338 INTS_CASE(ints),
339 INTS_CASE(ints___bool),
340 INTS_CASE(ints___reverse_sign),
341
342 /* validate edge cases of capturing relocations */
343 {
344 .case_name = "misc",
345 .bpf_obj_file = "test_core_reloc_misc.o",
346 .btf_src_file = "btf__core_reloc_misc.o",
347 .input = (const char *)&(struct core_reloc_misc_extensible[]){
348 { .a = 1 },
349 { .a = 2 }, /* not read */
350 { .a = 3 },
351 },
352 .input_len = 4 * sizeof(int),
353 .output = STRUCT_TO_CHAR_PTR(core_reloc_misc_output) {
354 .a = 1,
355 .b = 1,
356 .c = 0, /* BUG in clang, should be 3 */
357 },
358 .output_len = sizeof(struct core_reloc_misc_output),
359 },
360
361 /* validate field existence checks */
362 {
363 EXISTENCE_CASE_COMMON(existence),
364 .input = STRUCT_TO_CHAR_PTR(core_reloc_existence) {
365 .a = 1,
366 .b = 2,
367 .c = 3,
368 .arr = { 4 },
369 .s = { .x = 5 },
370 },
371 .input_len = sizeof(struct core_reloc_existence),
372 .output = STRUCT_TO_CHAR_PTR(core_reloc_existence_output) {
373 .a_exists = 1,
374 .b_exists = 1,
375 .c_exists = 1,
376 .arr_exists = 1,
377 .s_exists = 1,
378 .a_value = 1,
379 .b_value = 2,
380 .c_value = 3,
381 .arr_value = 4,
382 .s_value = 5,
383 },
384 .output_len = sizeof(struct core_reloc_existence_output),
385 },
386 {
387 EXISTENCE_CASE_COMMON(existence___minimal),
388 .input = STRUCT_TO_CHAR_PTR(core_reloc_existence___minimal) {
389 .a = 42,
390 },
391 .input_len = sizeof(struct core_reloc_existence),
392 .output = STRUCT_TO_CHAR_PTR(core_reloc_existence_output) {
393 .a_exists = 1,
394 .b_exists = 0,
395 .c_exists = 0,
396 .arr_exists = 0,
397 .s_exists = 0,
398 .a_value = 42,
399 .b_value = 0xff000002u,
400 .c_value = 0xff000003u,
401 .arr_value = 0xff000004u,
402 .s_value = 0xff000005u,
403 },
404 .output_len = sizeof(struct core_reloc_existence_output),
405 },
406
407 EXISTENCE_ERR_CASE(existence__err_int_sz),
408 EXISTENCE_ERR_CASE(existence__err_int_type),
409 EXISTENCE_ERR_CASE(existence__err_int_kind),
410 EXISTENCE_ERR_CASE(existence__err_arr_kind),
411 EXISTENCE_ERR_CASE(existence__err_arr_value_type),
412 EXISTENCE_ERR_CASE(existence__err_struct_type),
413
414 /* bitfield relocation checks */
415 BITFIELDS_CASE(bitfields, {
416 .ub1 = 1,
417 .ub2 = 2,
418 .ub7 = 96,
419 .sb4 = -7,
420 .sb20 = -0x76543,
421 .u32 = 0x80000000,
422 .s32 = -0x76543210,
423 }),
424 BITFIELDS_CASE(bitfields___bit_sz_change, {
425 .ub1 = 6,
426 .ub2 = 0xABCDE,
427 .ub7 = 1,
428 .sb4 = -1,
429 .sb20 = -0x17654321,
430 .u32 = 0xBEEF,
431 .s32 = -0x3FEDCBA987654321,
432 }),
433 BITFIELDS_CASE(bitfields___bitfield_vs_int, {
434 .ub1 = 0xFEDCBA9876543210,
435 .ub2 = 0xA6,
436 .ub7 = -0x7EDCBA987654321,
437 .sb4 = -0x6123456789ABCDE,
438 .sb20 = 0xD00D,
439 .u32 = -0x76543,
440 .s32 = 0x0ADEADBEEFBADB0B,
441 }),
442 BITFIELDS_CASE(bitfields___just_big_enough, {
443 .ub1 = 0xF,
444 .ub2 = 0x0812345678FEDCBA,
445 }),
446 BITFIELDS_ERR_CASE(bitfields___err_too_big_bitfield),
447
448 /* size relocation checks */
449 SIZE_CASE(size),
450 SIZE_CASE(size___diff_sz),
451 };
452
453 struct data {
454 char in[256];
455 char out[256];
456 uint64_t my_pid_tgid;
457 };
458
roundup_page(size_t sz)459 static size_t roundup_page(size_t sz)
460 {
461 long page_size = sysconf(_SC_PAGE_SIZE);
462 return (sz + page_size - 1) / page_size * page_size;
463 }
464
test_core_reloc(void)465 void test_core_reloc(void)
466 {
467 const size_t mmap_sz = roundup_page(sizeof(struct data));
468 struct bpf_object_load_attr load_attr = {};
469 struct core_reloc_test_case *test_case;
470 const char *tp_name, *probe_name;
471 int err, duration = 0, i, equal;
472 struct bpf_link *link = NULL;
473 struct bpf_map *data_map;
474 struct bpf_program *prog;
475 struct bpf_object *obj;
476 uint64_t my_pid_tgid;
477 struct data *data;
478 void *mmap_data = NULL;
479
480 my_pid_tgid = getpid() | ((uint64_t)syscall(SYS_gettid) << 32);
481
482 for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
483 test_case = &test_cases[i];
484 if (!test__start_subtest(test_case->case_name))
485 continue;
486
487 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts,
488 .relaxed_core_relocs = test_case->relaxed_core_relocs,
489 );
490
491 obj = bpf_object__open_file(test_case->bpf_obj_file, &opts);
492 if (CHECK(IS_ERR(obj), "obj_open", "failed to open '%s': %ld\n",
493 test_case->bpf_obj_file, PTR_ERR(obj)))
494 continue;
495
496 /* for typed raw tracepoints, NULL should be specified */
497 if (test_case->direct_raw_tp) {
498 probe_name = "tp_btf/sys_enter";
499 tp_name = NULL;
500 } else {
501 probe_name = "raw_tracepoint/sys_enter";
502 tp_name = "sys_enter";
503 }
504
505 prog = bpf_object__find_program_by_title(obj, probe_name);
506 if (CHECK(!prog, "find_probe",
507 "prog '%s' not found\n", probe_name))
508 goto cleanup;
509
510 load_attr.obj = obj;
511 load_attr.log_level = 0;
512 load_attr.target_btf_path = test_case->btf_src_file;
513 err = bpf_object__load_xattr(&load_attr);
514 if (test_case->fails) {
515 CHECK(!err, "obj_load_fail",
516 "should fail to load prog '%s'\n", probe_name);
517 goto cleanup;
518 } else {
519 if (CHECK(err, "obj_load",
520 "failed to load prog '%s': %d\n",
521 probe_name, err))
522 goto cleanup;
523 }
524
525 data_map = bpf_object__find_map_by_name(obj, "test_cor.bss");
526 if (CHECK(!data_map, "find_data_map", "data map not found\n"))
527 goto cleanup;
528
529 mmap_data = mmap(NULL, mmap_sz, PROT_READ | PROT_WRITE,
530 MAP_SHARED, bpf_map__fd(data_map), 0);
531 if (CHECK(mmap_data == MAP_FAILED, "mmap",
532 ".bss mmap failed: %d", errno)) {
533 mmap_data = NULL;
534 goto cleanup;
535 }
536 data = mmap_data;
537
538 memset(mmap_data, 0, sizeof(*data));
539 memcpy(data->in, test_case->input, test_case->input_len);
540 data->my_pid_tgid = my_pid_tgid;
541
542 link = bpf_program__attach_raw_tracepoint(prog, tp_name);
543 if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n",
544 PTR_ERR(link)))
545 goto cleanup;
546
547 /* trigger test run */
548 usleep(1);
549
550 equal = memcmp(data->out, test_case->output,
551 test_case->output_len) == 0;
552 if (CHECK(!equal, "check_result",
553 "input/output data don't match\n")) {
554 int j;
555
556 for (j = 0; j < test_case->input_len; j++) {
557 printf("input byte #%d: 0x%02hhx\n",
558 j, test_case->input[j]);
559 }
560 for (j = 0; j < test_case->output_len; j++) {
561 printf("output byte #%d: EXP 0x%02hhx GOT 0x%02hhx\n",
562 j, test_case->output[j], data->out[j]);
563 }
564 goto cleanup;
565 }
566
567 cleanup:
568 if (mmap_data) {
569 CHECK_FAIL(munmap(mmap_data, mmap_sz));
570 mmap_data = NULL;
571 }
572 if (!IS_ERR_OR_NULL(link)) {
573 bpf_link__destroy(link);
574 link = NULL;
575 }
576 bpf_object__close(obj);
577 }
578 }
579