This source file includes following definitions.
- test_core_reloc
1
2 #include <test_progs.h>
3 #include "progs/core_reloc_types.h"
4
5 #define STRUCT_TO_CHAR_PTR(struct_name) (const char *)&(struct struct_name)
6
7 #define FLAVORS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
8 .a = 42, \
9 .b = 0xc001, \
10 .c = 0xbeef, \
11 }
12
13 #define FLAVORS_CASE_COMMON(name) \
14 .case_name = #name, \
15 .bpf_obj_file = "test_core_reloc_flavors.o", \
16 .btf_src_file = "btf__core_reloc_" #name ".o" \
17
18 #define FLAVORS_CASE(name) { \
19 FLAVORS_CASE_COMMON(name), \
20 .input = FLAVORS_DATA(core_reloc_##name), \
21 .input_len = sizeof(struct core_reloc_##name), \
22 .output = FLAVORS_DATA(core_reloc_flavors), \
23 .output_len = sizeof(struct core_reloc_flavors), \
24 }
25
26 #define FLAVORS_ERR_CASE(name) { \
27 FLAVORS_CASE_COMMON(name), \
28 .fails = true, \
29 }
30
31 #define NESTING_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
32 .a = { .a = { .a = 42 } }, \
33 .b = { .b = { .b = 0xc001 } }, \
34 }
35
36 #define NESTING_CASE_COMMON(name) \
37 .case_name = #name, \
38 .bpf_obj_file = "test_core_reloc_nesting.o", \
39 .btf_src_file = "btf__core_reloc_" #name ".o"
40
41 #define NESTING_CASE(name) { \
42 NESTING_CASE_COMMON(name), \
43 .input = NESTING_DATA(core_reloc_##name), \
44 .input_len = sizeof(struct core_reloc_##name), \
45 .output = NESTING_DATA(core_reloc_nesting), \
46 .output_len = sizeof(struct core_reloc_nesting) \
47 }
48
49 #define NESTING_ERR_CASE(name) { \
50 NESTING_CASE_COMMON(name), \
51 .fails = true, \
52 }
53
54 #define ARRAYS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
55 .a = { [2] = 1 }, \
56 .b = { [1] = { [2] = { [3] = 2 } } }, \
57 .c = { [1] = { .c = 3 } }, \
58 .d = { [0] = { [0] = { .d = 4 } } }, \
59 }
60
61 #define ARRAYS_CASE_COMMON(name) \
62 .case_name = #name, \
63 .bpf_obj_file = "test_core_reloc_arrays.o", \
64 .btf_src_file = "btf__core_reloc_" #name ".o"
65
66 #define ARRAYS_CASE(name) { \
67 ARRAYS_CASE_COMMON(name), \
68 .input = ARRAYS_DATA(core_reloc_##name), \
69 .input_len = sizeof(struct core_reloc_##name), \
70 .output = STRUCT_TO_CHAR_PTR(core_reloc_arrays_output) { \
71 .a2 = 1, \
72 .b123 = 2, \
73 .c1c = 3, \
74 .d00d = 4, \
75 }, \
76 .output_len = sizeof(struct core_reloc_arrays_output) \
77 }
78
79 #define ARRAYS_ERR_CASE(name) { \
80 ARRAYS_CASE_COMMON(name), \
81 .fails = true, \
82 }
83
84 #define PRIMITIVES_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
85 .a = 1, \
86 .b = 2, \
87 .c = 3, \
88 .d = (void *)4, \
89 .f = (void *)5, \
90 }
91
92 #define PRIMITIVES_CASE_COMMON(name) \
93 .case_name = #name, \
94 .bpf_obj_file = "test_core_reloc_primitives.o", \
95 .btf_src_file = "btf__core_reloc_" #name ".o"
96
97 #define PRIMITIVES_CASE(name) { \
98 PRIMITIVES_CASE_COMMON(name), \
99 .input = PRIMITIVES_DATA(core_reloc_##name), \
100 .input_len = sizeof(struct core_reloc_##name), \
101 .output = PRIMITIVES_DATA(core_reloc_primitives), \
102 .output_len = sizeof(struct core_reloc_primitives), \
103 }
104
105 #define PRIMITIVES_ERR_CASE(name) { \
106 PRIMITIVES_CASE_COMMON(name), \
107 .fails = true, \
108 }
109
110 #define MODS_CASE(name) { \
111 .case_name = #name, \
112 .bpf_obj_file = "test_core_reloc_mods.o", \
113 .btf_src_file = "btf__core_reloc_" #name ".o", \
114 .input = STRUCT_TO_CHAR_PTR(core_reloc_##name) { \
115 .a = 1, \
116 .b = 2, \
117 .c = (void *)3, \
118 .d = (void *)4, \
119 .e = { [2] = 5 }, \
120 .f = { [1] = 6 }, \
121 .g = { .x = 7 }, \
122 .h = { .y = 8 }, \
123 }, \
124 .input_len = sizeof(struct core_reloc_##name), \
125 .output = STRUCT_TO_CHAR_PTR(core_reloc_mods_output) { \
126 .a = 1, .b = 2, .c = 3, .d = 4, \
127 .e = 5, .f = 6, .g = 7, .h = 8, \
128 }, \
129 .output_len = sizeof(struct core_reloc_mods_output), \
130 }
131
132 #define PTR_AS_ARR_CASE(name) { \
133 .case_name = #name, \
134 .bpf_obj_file = "test_core_reloc_ptr_as_arr.o", \
135 .btf_src_file = "btf__core_reloc_" #name ".o", \
136 .input = (const char *)&(struct core_reloc_##name []){ \
137 { .a = 1 }, \
138 { .a = 2 }, \
139 { .a = 3 }, \
140 }, \
141 .input_len = 3 * sizeof(struct core_reloc_##name), \
142 .output = STRUCT_TO_CHAR_PTR(core_reloc_ptr_as_arr) { \
143 .a = 3, \
144 }, \
145 .output_len = sizeof(struct core_reloc_ptr_as_arr), \
146 }
147
148 #define INTS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) { \
149 .u8_field = 1, \
150 .s8_field = 2, \
151 .u16_field = 3, \
152 .s16_field = 4, \
153 .u32_field = 5, \
154 .s32_field = 6, \
155 .u64_field = 7, \
156 .s64_field = 8, \
157 }
158
159 #define INTS_CASE_COMMON(name) \
160 .case_name = #name, \
161 .bpf_obj_file = "test_core_reloc_ints.o", \
162 .btf_src_file = "btf__core_reloc_" #name ".o"
163
164 #define INTS_CASE(name) { \
165 INTS_CASE_COMMON(name), \
166 .input = INTS_DATA(core_reloc_##name), \
167 .input_len = sizeof(struct core_reloc_##name), \
168 .output = INTS_DATA(core_reloc_ints), \
169 .output_len = sizeof(struct core_reloc_ints), \
170 }
171
172 #define INTS_ERR_CASE(name) { \
173 INTS_CASE_COMMON(name), \
174 .fails = true, \
175 }
176
177 struct core_reloc_test_case {
178 const char *case_name;
179 const char *bpf_obj_file;
180 const char *btf_src_file;
181 const char *input;
182 int input_len;
183 const char *output;
184 int output_len;
185 bool fails;
186 };
187
188 static struct core_reloc_test_case test_cases[] = {
189
190 {
191 .case_name = "kernel",
192 .bpf_obj_file = "test_core_reloc_kernel.o",
193 .btf_src_file = NULL,
194 .input = "",
195 .input_len = 0,
196 .output = "\1",
197 .output_len = 1,
198 },
199
200
201
202
203 FLAVORS_CASE(flavors),
204
205 FLAVORS_ERR_CASE(flavors__err_wrong_name),
206
207
208 NESTING_CASE(nesting),
209 NESTING_CASE(nesting___anon_embed),
210 NESTING_CASE(nesting___struct_union_mixup),
211 NESTING_CASE(nesting___extra_nesting),
212 NESTING_CASE(nesting___dup_compat_types),
213
214 NESTING_ERR_CASE(nesting___err_missing_field),
215 NESTING_ERR_CASE(nesting___err_array_field),
216 NESTING_ERR_CASE(nesting___err_missing_container),
217 NESTING_ERR_CASE(nesting___err_nonstruct_container),
218 NESTING_ERR_CASE(nesting___err_array_container),
219 NESTING_ERR_CASE(nesting___err_dup_incompat_types),
220 NESTING_ERR_CASE(nesting___err_partial_match_dups),
221 NESTING_ERR_CASE(nesting___err_too_deep),
222
223
224 ARRAYS_CASE(arrays),
225 ARRAYS_CASE(arrays___diff_arr_dim),
226 ARRAYS_CASE(arrays___diff_arr_val_sz),
227
228 ARRAYS_ERR_CASE(arrays___err_too_small),
229 ARRAYS_ERR_CASE(arrays___err_too_shallow),
230 ARRAYS_ERR_CASE(arrays___err_non_array),
231 ARRAYS_ERR_CASE(arrays___err_wrong_val_type1),
232 ARRAYS_ERR_CASE(arrays___err_wrong_val_type2),
233
234
235 PRIMITIVES_CASE(primitives),
236 PRIMITIVES_CASE(primitives___diff_enum_def),
237 PRIMITIVES_CASE(primitives___diff_func_proto),
238 PRIMITIVES_CASE(primitives___diff_ptr_type),
239
240 PRIMITIVES_ERR_CASE(primitives___err_non_enum),
241 PRIMITIVES_ERR_CASE(primitives___err_non_int),
242 PRIMITIVES_ERR_CASE(primitives___err_non_ptr),
243
244
245 MODS_CASE(mods),
246 MODS_CASE(mods___mod_swap),
247 MODS_CASE(mods___typedefs),
248
249
250 PTR_AS_ARR_CASE(ptr_as_arr),
251 PTR_AS_ARR_CASE(ptr_as_arr___diff_sz),
252
253
254 INTS_CASE(ints),
255 INTS_CASE(ints___bool),
256 INTS_CASE(ints___reverse_sign),
257
258 INTS_ERR_CASE(ints___err_bitfield),
259 INTS_ERR_CASE(ints___err_wrong_sz_8),
260 INTS_ERR_CASE(ints___err_wrong_sz_16),
261 INTS_ERR_CASE(ints___err_wrong_sz_32),
262 INTS_ERR_CASE(ints___err_wrong_sz_64),
263
264
265 {
266 .case_name = "misc",
267 .bpf_obj_file = "test_core_reloc_misc.o",
268 .btf_src_file = "btf__core_reloc_misc.o",
269 .input = (const char *)&(struct core_reloc_misc_extensible[]){
270 { .a = 1 },
271 { .a = 2 },
272 { .a = 3 },
273 },
274 .input_len = 4 * sizeof(int),
275 .output = STRUCT_TO_CHAR_PTR(core_reloc_misc_output) {
276 .a = 1,
277 .b = 1,
278 .c = 0,
279 },
280 .output_len = sizeof(struct core_reloc_misc_output),
281 },
282 };
283
284 struct data {
285 char in[256];
286 char out[256];
287 };
288
289 void test_core_reloc(void)
290 {
291 const char *probe_name = "raw_tracepoint/sys_enter";
292 struct bpf_object_load_attr load_attr = {};
293 struct core_reloc_test_case *test_case;
294 int err, duration = 0, i, equal;
295 struct bpf_link *link = NULL;
296 struct bpf_map *data_map;
297 struct bpf_program *prog;
298 struct bpf_object *obj;
299 const int zero = 0;
300 struct data data;
301
302 for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
303 test_case = &test_cases[i];
304
305 if (!test__start_subtest(test_case->case_name))
306 continue;
307
308 obj = bpf_object__open(test_case->bpf_obj_file);
309 if (CHECK(IS_ERR_OR_NULL(obj), "obj_open",
310 "failed to open '%s': %ld\n",
311 test_case->bpf_obj_file, PTR_ERR(obj)))
312 continue;
313
314 prog = bpf_object__find_program_by_title(obj, probe_name);
315 if (CHECK(!prog, "find_probe",
316 "prog '%s' not found\n", probe_name))
317 goto cleanup;
318 bpf_program__set_type(prog, BPF_PROG_TYPE_RAW_TRACEPOINT);
319
320 load_attr.obj = obj;
321 load_attr.log_level = 0;
322 load_attr.target_btf_path = test_case->btf_src_file;
323 err = bpf_object__load_xattr(&load_attr);
324 if (test_case->fails) {
325 CHECK(!err, "obj_load_fail",
326 "should fail to load prog '%s'\n", probe_name);
327 goto cleanup;
328 } else {
329 if (CHECK(err, "obj_load",
330 "failed to load prog '%s': %d\n",
331 probe_name, err))
332 goto cleanup;
333 }
334
335 link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");
336 if (CHECK(IS_ERR(link), "attach_raw_tp", "err %ld\n",
337 PTR_ERR(link)))
338 goto cleanup;
339
340 data_map = bpf_object__find_map_by_name(obj, "test_cor.bss");
341 if (CHECK(!data_map, "find_data_map", "data map not found\n"))
342 goto cleanup;
343
344 memset(&data, 0, sizeof(data));
345 memcpy(data.in, test_case->input, test_case->input_len);
346
347 err = bpf_map_update_elem(bpf_map__fd(data_map),
348 &zero, &data, 0);
349 if (CHECK(err, "update_data_map",
350 "failed to update .data map: %d\n", err))
351 goto cleanup;
352
353
354 usleep(1);
355
356 err = bpf_map_lookup_elem(bpf_map__fd(data_map), &zero, &data);
357 if (CHECK(err, "get_result",
358 "failed to get output data: %d\n", err))
359 goto cleanup;
360
361 equal = memcmp(data.out, test_case->output,
362 test_case->output_len) == 0;
363 if (CHECK(!equal, "check_result",
364 "input/output data don't match\n")) {
365 int j;
366
367 for (j = 0; j < test_case->input_len; j++) {
368 printf("input byte #%d: 0x%02hhx\n",
369 j, test_case->input[j]);
370 }
371 for (j = 0; j < test_case->output_len; j++) {
372 printf("output byte #%d: EXP 0x%02hhx GOT 0x%02hhx\n",
373 j, test_case->output[j], data.out[j]);
374 }
375 goto cleanup;
376 }
377
378 cleanup:
379 if (!IS_ERR_OR_NULL(link)) {
380 bpf_link__destroy(link);
381 link = NULL;
382 }
383 bpf_object__close(obj);
384 }
385 }