Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
selftests/bpf: Store BPF object files with .bpf.o extension
BPF object files are, in a way, the final artifact produced as part of
the ahead-of-time compilation process. That makes them somewhat special
compared to "regular" object files, which are a intermediate build
artifacts that can typically be removed safely. As such, it can make
sense to name them differently to make it easier to spot this difference
at a glance.
Among others, libbpf-bootstrap [0] has established the extension .bpf.o
for BPF object files. It seems reasonable to follow this example and
establish the same denomination for selftest build artifacts. To that
end, this change adjusts the corresponding part of the build system and
the test programs loading BPF object files to work with .bpf.o files.
[0] https://github.com/libbpf/libbpf-bootstrap
Suggested-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Daniel Müller <deso@posteo.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20220901222253.1199242-1-deso@posteo.net
authored by
Daniel Müller
and committed by
Daniel Borkmann
afef88e6
fe2ad08e
+250
-250
+18
-18
tools/testing/selftests/bpf/Makefile
+18
-18
tools/testing/selftests/bpf/Makefile
···
45
45
TEST_GEN_PROGS += test_progs-bpf_gcc
46
46
endif
47
47
48
-
TEST_GEN_FILES = test_lwt_ip_encap.o test_tc_edt.o
48
+
TEST_GEN_FILES = test_lwt_ip_encap.bpf.o test_tc_edt.bpf.o
49
49
TEST_FILES = xsk_prereqs.sh $(wildcard progs/btf_dump_test_case_*.c)
50
50
51
51
# Order correspond to 'make run_tests' order
···
358
358
LSKELS_EXTRA := test_ksyms_module.c test_ksyms_weak.c kfunc_call_test_subprog.c
359
359
SKEL_BLACKLIST += $$(LSKELS)
360
360
361
-
test_static_linked.skel.h-deps := test_static_linked1.o test_static_linked2.o
362
-
linked_funcs.skel.h-deps := linked_funcs1.o linked_funcs2.o
363
-
linked_vars.skel.h-deps := linked_vars1.o linked_vars2.o
364
-
linked_maps.skel.h-deps := linked_maps1.o linked_maps2.o
361
+
test_static_linked.skel.h-deps := test_static_linked1.bpf.o test_static_linked2.bpf.o
362
+
linked_funcs.skel.h-deps := linked_funcs1.bpf.o linked_funcs2.bpf.o
363
+
linked_vars.skel.h-deps := linked_vars1.bpf.o linked_vars2.bpf.o
364
+
linked_maps.skel.h-deps := linked_maps1.bpf.o linked_maps2.bpf.o
365
365
# In the subskeleton case, we want the test_subskeleton_lib.subskel.h file
366
366
# but that's created as a side-effect of the skel.h generation.
367
-
test_subskeleton.skel.h-deps := test_subskeleton_lib2.o test_subskeleton_lib.o test_subskeleton.o
368
-
test_subskeleton_lib.skel.h-deps := test_subskeleton_lib2.o test_subskeleton_lib.o
369
-
test_usdt.skel.h-deps := test_usdt.o test_usdt_multispec.o
367
+
test_subskeleton.skel.h-deps := test_subskeleton_lib2.bpf.o test_subskeleton_lib.bpf.o test_subskeleton.bpf.o
368
+
test_subskeleton_lib.skel.h-deps := test_subskeleton_lib2.bpf.o test_subskeleton_lib.bpf.o
369
+
test_usdt.skel.h-deps := test_usdt.bpf.o test_usdt_multispec.bpf.o
370
370
371
-
LINKED_BPF_SRCS := $(patsubst %.o,%.c,$(foreach skel,$(LINKED_SKELS),$($(skel)-deps)))
371
+
LINKED_BPF_SRCS := $(patsubst %.bpf.o,%.c,$(foreach skel,$(LINKED_SKELS),$($(skel)-deps)))
372
372
373
373
# Set up extra TRUNNER_XXX "temporary" variables in the environment (relies on
374
374
# $eval()) and pass control to DEFINE_TEST_RUNNER_RULES.
···
386
386
TRUNNER_EXTRA_HDRS := $$(filter %.h,$(TRUNNER_EXTRA_SOURCES))
387
387
TRUNNER_TESTS_HDR := $(TRUNNER_TESTS_DIR)/tests.h
388
388
TRUNNER_BPF_SRCS := $$(notdir $$(wildcard $(TRUNNER_BPF_PROGS_DIR)/*.c))
389
-
TRUNNER_BPF_OBJS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.o, $$(TRUNNER_BPF_SRCS))
389
+
TRUNNER_BPF_OBJS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.bpf.o, $$(TRUNNER_BPF_SRCS))
390
390
TRUNNER_BPF_SKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.skel.h, \
391
391
$$(filter-out $(SKEL_BLACKLIST) $(LINKED_BPF_SRCS),\
392
392
$$(TRUNNER_BPF_SRCS)))
···
416
416
# input/output directory combination
417
417
ifeq ($($(TRUNNER_BPF_PROGS_DIR)$(if $2,-)$2-bpfobjs),)
418
418
$(TRUNNER_BPF_PROGS_DIR)$(if $2,-)$2-bpfobjs := y
419
-
$(TRUNNER_BPF_OBJS): $(TRUNNER_OUTPUT)/%.o: \
419
+
$(TRUNNER_BPF_OBJS): $(TRUNNER_OUTPUT)/%.bpf.o: \
420
420
$(TRUNNER_BPF_PROGS_DIR)/%.c \
421
421
$(TRUNNER_BPF_PROGS_DIR)/*.h \
422
422
$$(INCLUDE_DIR)/vmlinux.h \
···
426
426
$$(call $(TRUNNER_BPF_BUILD_RULE),$$<,$$@, \
427
427
$(TRUNNER_BPF_CFLAGS))
428
428
429
-
$(TRUNNER_BPF_SKELS): %.skel.h: %.o $(BPFTOOL) | $(TRUNNER_OUTPUT)
429
+
$(TRUNNER_BPF_SKELS): %.skel.h: %.bpf.o $(BPFTOOL) | $(TRUNNER_OUTPUT)
430
430
$$(call msg,GEN-SKEL,$(TRUNNER_BINARY),$$@)
431
431
$(Q)$$(BPFTOOL) gen object $$(<:.o=.linked1.o) $$<
432
432
$(Q)$$(BPFTOOL) gen object $$(<:.o=.linked2.o) $$(<:.o=.linked1.o)
433
433
$(Q)$$(BPFTOOL) gen object $$(<:.o=.linked3.o) $$(<:.o=.linked2.o)
434
434
$(Q)diff $$(<:.o=.linked2.o) $$(<:.o=.linked3.o)
435
-
$(Q)$$(BPFTOOL) gen skeleton $$(<:.o=.linked3.o) name $$(notdir $$(<:.o=)) > $$@
436
-
$(Q)$$(BPFTOOL) gen subskeleton $$(<:.o=.linked3.o) name $$(notdir $$(<:.o=)) > $$(@:.skel.h=.subskel.h)
435
+
$(Q)$$(BPFTOOL) gen skeleton $$(<:.o=.linked3.o) name $$(notdir $$(<:.bpf.o=)) > $$@
436
+
$(Q)$$(BPFTOOL) gen subskeleton $$(<:.o=.linked3.o) name $$(notdir $$(<:.bpf.o=)) > $$(@:.skel.h=.subskel.h)
437
437
438
-
$(TRUNNER_BPF_LSKELS): %.lskel.h: %.o $(BPFTOOL) | $(TRUNNER_OUTPUT)
438
+
$(TRUNNER_BPF_LSKELS): %.lskel.h: %.bpf.o $(BPFTOOL) | $(TRUNNER_OUTPUT)
439
439
$$(call msg,GEN-SKEL,$(TRUNNER_BINARY),$$@)
440
440
$(Q)$$(BPFTOOL) gen object $$(<:.o=.llinked1.o) $$<
441
441
$(Q)$$(BPFTOOL) gen object $$(<:.o=.llinked2.o) $$(<:.o=.llinked1.o)
442
442
$(Q)$$(BPFTOOL) gen object $$(<:.o=.llinked3.o) $$(<:.o=.llinked2.o)
443
443
$(Q)diff $$(<:.o=.llinked2.o) $$(<:.o=.llinked3.o)
444
-
$(Q)$$(BPFTOOL) gen skeleton -L $$(<:.o=.llinked3.o) name $$(notdir $$(<:.o=_lskel)) > $$@
444
+
$(Q)$$(BPFTOOL) gen skeleton -L $$(<:.o=.llinked3.o) name $$(notdir $$(<:.bpf.o=_lskel)) > $$@
445
445
446
446
$(TRUNNER_BPF_SKELS_LINKED): $(TRUNNER_BPF_OBJS) $(BPFTOOL) | $(TRUNNER_OUTPUT)
447
-
$$(call msg,LINK-BPF,$(TRUNNER_BINARY),$$(@:.skel.h=.o))
447
+
$$(call msg,LINK-BPF,$(TRUNNER_BINARY),$$(@:.skel.h=.bpf.o))
448
448
$(Q)$$(BPFTOOL) gen object $$(@:.skel.h=.linked1.o) $$(addprefix $(TRUNNER_OUTPUT)/,$$($$(@F)-deps))
449
449
$(Q)$$(BPFTOOL) gen object $$(@:.skel.h=.linked2.o) $$(@:.skel.h=.linked1.o)
450
450
$(Q)$$(BPFTOOL) gen object $$(@:.skel.h=.linked3.o) $$(@:.skel.h=.linked2.o)
···
500
500
| $(TRUNNER_BINARY)-extras
501
501
$$(call msg,BINARY,,$$@)
502
502
$(Q)$$(CC) $$(CFLAGS) $$(filter %.a %.o,$$^) $$(LDLIBS) -o $$@
503
-
$(Q)$(RESOLVE_BTFIDS) --btf $(TRUNNER_OUTPUT)/btf_data.o $$@
503
+
$(Q)$(RESOLVE_BTFIDS) --btf $(TRUNNER_OUTPUT)/btf_data.bpf.o $$@
504
504
$(Q)ln -sf $(if $2,..,.)/tools/build/bpftool/bootstrap/bpftool $(if $2,$2/)bpftool
505
505
506
506
endef
+4
-4
tools/testing/selftests/bpf/README.rst
+4
-4
tools/testing/selftests/bpf/README.rst
···
126
126
127
127
__ https://reviews.llvm.org/D78466
128
128
129
-
bpf_verif_scale/loop6.o test failure with Clang 12
130
-
==================================================
129
+
bpf_verif_scale/loop6.bpf.o test failure with Clang 12
130
+
======================================================
131
131
132
132
With Clang 12, the following bpf_verif_scale test failed:
133
-
* ``bpf_verif_scale/loop6.o``
133
+
* ``bpf_verif_scale/loop6.bpf.o``
134
134
135
135
The verifier output looks like
136
136
···
245
245
Using clang 13 to compile old libbpf which has static linker support,
246
246
there will be a compilation failure::
247
247
248
-
libbpf: ELF relo #0 in section #6 has unexpected type 2 in .../bpf_tcp_nogpl.o
248
+
libbpf: ELF relo #0 in section #6 has unexpected type 2 in .../bpf_tcp_nogpl.bpf.o
249
249
250
250
Here, ``type 2`` refers to new relocation type ``R_BPF_64_ABS64``.
251
251
To fix this issue, user newer libbpf.
+1
-1
tools/testing/selftests/bpf/get_cgroup_id_user.c
+1
-1
tools/testing/selftests/bpf/get_cgroup_id_user.c
···
48
48
int main(int argc, char **argv)
49
49
{
50
50
const char *probe_name = "syscalls/sys_enter_nanosleep";
51
-
const char *file = "get_cgroup_id_kern.o";
51
+
const char *file = "get_cgroup_id_kern.bpf.o";
52
52
int err, bytes, efd, prog_fd, pmu_fd;
53
53
int cgroup_fd, cgidmap_fd, pidmap_fd;
54
54
struct perf_event_attr attr = {};
+1
-1
tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
+1
-1
tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
···
7
7
{
8
8
const __u64 array_magic_value = 0xfaceb00c;
9
9
const __u32 array_key = 0;
10
-
const char *file = "./test_obj_id.o";
10
+
const char *file = "./test_obj_id.bpf.o";
11
11
const char *expected_prog_name = "test_obj_id";
12
12
const char *expected_map_name = "test_map_id";
13
13
const __u64 nsec_per_sec = 1000000000;
+27
-27
tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
+27
-27
tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
···
75
75
76
76
void test_verif_scale1()
77
77
{
78
-
scale_test("test_verif_scale1.o", BPF_PROG_TYPE_SCHED_CLS, false);
78
+
scale_test("test_verif_scale1.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false);
79
79
}
80
80
81
81
void test_verif_scale2()
82
82
{
83
-
scale_test("test_verif_scale2.o", BPF_PROG_TYPE_SCHED_CLS, false);
83
+
scale_test("test_verif_scale2.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false);
84
84
}
85
85
86
86
void test_verif_scale3()
87
87
{
88
-
scale_test("test_verif_scale3.o", BPF_PROG_TYPE_SCHED_CLS, false);
88
+
scale_test("test_verif_scale3.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false);
89
89
}
90
90
91
91
void test_verif_scale_pyperf_global()
92
92
{
93
-
scale_test("pyperf_global.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
93
+
scale_test("pyperf_global.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
94
94
}
95
95
96
96
void test_verif_scale_pyperf_subprogs()
97
97
{
98
-
scale_test("pyperf_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
98
+
scale_test("pyperf_subprogs.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
99
99
}
100
100
101
101
void test_verif_scale_pyperf50()
102
102
{
103
103
/* full unroll by llvm */
104
-
scale_test("pyperf50.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
104
+
scale_test("pyperf50.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
105
105
}
106
106
107
107
void test_verif_scale_pyperf100()
108
108
{
109
109
/* full unroll by llvm */
110
-
scale_test("pyperf100.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
110
+
scale_test("pyperf100.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
111
111
}
112
112
113
113
void test_verif_scale_pyperf180()
114
114
{
115
115
/* full unroll by llvm */
116
-
scale_test("pyperf180.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
116
+
scale_test("pyperf180.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
117
117
}
118
118
119
119
void test_verif_scale_pyperf600()
···
124
124
* 16k insns in loop body.
125
125
* Total of 5 such loops. Total program size ~82k insns.
126
126
*/
127
-
scale_test("pyperf600.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
127
+
scale_test("pyperf600.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
128
128
}
129
129
130
130
void test_verif_scale_pyperf600_bpf_loop(void)
131
131
{
132
132
/* use the bpf_loop helper*/
133
-
scale_test("pyperf600_bpf_loop.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
133
+
scale_test("pyperf600_bpf_loop.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
134
134
}
135
135
136
136
void test_verif_scale_pyperf600_nounroll()
···
141
141
* ~110 insns in loop body.
142
142
* Total of 5 such loops. Total program size ~1500 insns.
143
143
*/
144
-
scale_test("pyperf600_nounroll.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
144
+
scale_test("pyperf600_nounroll.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
145
145
}
146
146
147
147
void test_verif_scale_loop1()
148
148
{
149
-
scale_test("loop1.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
149
+
scale_test("loop1.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
150
150
}
151
151
152
152
void test_verif_scale_loop2()
153
153
{
154
-
scale_test("loop2.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
154
+
scale_test("loop2.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
155
155
}
156
156
157
157
void test_verif_scale_loop3_fail()
158
158
{
159
-
scale_test("loop3.o", BPF_PROG_TYPE_RAW_TRACEPOINT, true /* fails */);
159
+
scale_test("loop3.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, true /* fails */);
160
160
}
161
161
162
162
void test_verif_scale_loop4()
163
163
{
164
-
scale_test("loop4.o", BPF_PROG_TYPE_SCHED_CLS, false);
164
+
scale_test("loop4.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false);
165
165
}
166
166
167
167
void test_verif_scale_loop5()
168
168
{
169
-
scale_test("loop5.o", BPF_PROG_TYPE_SCHED_CLS, false);
169
+
scale_test("loop5.bpf.o", BPF_PROG_TYPE_SCHED_CLS, false);
170
170
}
171
171
172
172
void test_verif_scale_loop6()
173
173
{
174
-
scale_test("loop6.o", BPF_PROG_TYPE_KPROBE, false);
174
+
scale_test("loop6.bpf.o", BPF_PROG_TYPE_KPROBE, false);
175
175
}
176
176
177
177
void test_verif_scale_strobemeta()
···
180
180
* Total program size 20.8k insn.
181
181
* ~350k processed_insns
182
182
*/
183
-
scale_test("strobemeta.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
183
+
scale_test("strobemeta.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
184
184
}
185
185
186
186
void test_verif_scale_strobemeta_bpf_loop(void)
187
187
{
188
188
/* use the bpf_loop helper*/
189
-
scale_test("strobemeta_bpf_loop.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
189
+
scale_test("strobemeta_bpf_loop.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
190
190
}
191
191
192
192
void test_verif_scale_strobemeta_nounroll1()
193
193
{
194
194
/* no unroll, tiny loops */
195
-
scale_test("strobemeta_nounroll1.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
195
+
scale_test("strobemeta_nounroll1.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
196
196
}
197
197
198
198
void test_verif_scale_strobemeta_nounroll2()
199
199
{
200
200
/* no unroll, tiny loops */
201
-
scale_test("strobemeta_nounroll2.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
201
+
scale_test("strobemeta_nounroll2.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
202
202
}
203
203
204
204
void test_verif_scale_strobemeta_subprogs()
205
205
{
206
206
/* non-inlined subprogs */
207
-
scale_test("strobemeta_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
207
+
scale_test("strobemeta_subprogs.bpf.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
208
208
}
209
209
210
210
void test_verif_scale_sysctl_loop1()
211
211
{
212
-
scale_test("test_sysctl_loop1.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
212
+
scale_test("test_sysctl_loop1.bpf.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
213
213
}
214
214
215
215
void test_verif_scale_sysctl_loop2()
216
216
{
217
-
scale_test("test_sysctl_loop2.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
217
+
scale_test("test_sysctl_loop2.bpf.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
218
218
}
219
219
220
220
void test_verif_scale_xdp_loop()
221
221
{
222
-
scale_test("test_xdp_loop.o", BPF_PROG_TYPE_XDP, false);
222
+
scale_test("test_xdp_loop.bpf.o", BPF_PROG_TYPE_XDP, false);
223
223
}
224
224
225
225
void test_verif_scale_seg6_loop()
226
226
{
227
-
scale_test("test_seg6_loop.o", BPF_PROG_TYPE_LWT_SEG6LOCAL, false);
227
+
scale_test("test_seg6_loop.bpf.o", BPF_PROG_TYPE_LWT_SEG6LOCAL, false);
228
228
}
229
229
230
230
void test_verif_twfw()
231
231
{
232
-
scale_test("twfw.o", BPF_PROG_TYPE_CGROUP_SKB, false);
232
+
scale_test("twfw.bpf.o", BPF_PROG_TYPE_CGROUP_SKB, false);
233
233
}
+2
-2
tools/testing/selftests/bpf/prog_tests/btf.c
+2
-2
tools/testing/selftests/bpf/prog_tests/btf.c
···
4651
4651
};
4652
4652
4653
4653
static struct btf_file_test file_tests[] = {
4654
-
{ .file = "test_btf_newkv.o", },
4655
-
{ .file = "test_btf_nokv.o", .btf_kv_notfound = true, },
4654
+
{ .file = "test_btf_newkv.bpf.o", },
4655
+
{ .file = "test_btf_nokv.bpf.o", .btf_kv_notfound = true, },
4656
4656
};
4657
4657
4658
4658
static void do_test_file(unsigned int test_num)
+3
-3
tools/testing/selftests/bpf/prog_tests/btf_dump.c
+3
-3
tools/testing/selftests/bpf/prog_tests/btf_dump.c
···
52
52
int err = 0, fd = -1;
53
53
FILE *f = NULL;
54
54
55
-
snprintf(test_file, sizeof(test_file), "%s.o", t->file);
55
+
snprintf(test_file, sizeof(test_file), "%s.bpf.o", t->file);
56
56
57
57
btf = btf__parse_elf(test_file, NULL);
58
58
if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {
···
841
841
char license[4] = "GPL";
842
842
struct btf_dump *d;
843
843
844
-
btf = btf__parse("xdping_kern.o", NULL);
845
-
if (!ASSERT_OK_PTR(btf, "xdping_kern.o BTF not found"))
844
+
btf = btf__parse("xdping_kern.bpf.o", NULL);
845
+
if (!ASSERT_OK_PTR(btf, "xdping_kern.bpf.o BTF not found"))
846
846
return;
847
847
848
848
d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);
+1
-1
tools/testing/selftests/bpf/prog_tests/btf_endian.c
+1
-1
tools/testing/selftests/bpf/prog_tests/btf_endian.c
+1
-1
tools/testing/selftests/bpf/prog_tests/connect_force_port.c
+1
-1
tools/testing/selftests/bpf/prog_tests/connect_force_port.c
···
53
53
__u16 expected_peer_port = 60000;
54
54
struct bpf_program *prog;
55
55
struct bpf_object *obj;
56
-
const char *obj_file = v4 ? "connect_force_port4.o" : "connect_force_port6.o";
56
+
const char *obj_file = v4 ? "connect_force_port4.bpf.o" : "connect_force_port6.bpf.o";
57
57
int fd, err;
58
58
__u32 duration = 0;
59
59
+37
-37
tools/testing/selftests/bpf/prog_tests/core_reloc.c
+37
-37
tools/testing/selftests/bpf/prog_tests/core_reloc.c
···
13
13
14
14
#define MODULES_CASE(name, pg_name, tp_name) { \
15
15
.case_name = name, \
16
-
.bpf_obj_file = "test_core_reloc_module.o", \
16
+
.bpf_obj_file = "test_core_reloc_module.bpf.o", \
17
17
.btf_src_file = NULL, /* find in kernel module BTFs */ \
18
18
.input = "", \
19
19
.input_len = 0, \
···
43
43
44
44
#define FLAVORS_CASE_COMMON(name) \
45
45
.case_name = #name, \
46
-
.bpf_obj_file = "test_core_reloc_flavors.o", \
47
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
46
+
.bpf_obj_file = "test_core_reloc_flavors.bpf.o", \
47
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
48
48
.raw_tp_name = "sys_enter", \
49
49
.prog_name = "test_core_flavors" \
50
50
···
68
68
69
69
#define NESTING_CASE_COMMON(name) \
70
70
.case_name = #name, \
71
-
.bpf_obj_file = "test_core_reloc_nesting.o", \
72
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
71
+
.bpf_obj_file = "test_core_reloc_nesting.bpf.o", \
72
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
73
73
.raw_tp_name = "sys_enter", \
74
74
.prog_name = "test_core_nesting" \
75
75
···
96
96
97
97
#define ARRAYS_CASE_COMMON(name) \
98
98
.case_name = #name, \
99
-
.bpf_obj_file = "test_core_reloc_arrays.o", \
100
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
99
+
.bpf_obj_file = "test_core_reloc_arrays.bpf.o", \
100
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
101
101
.raw_tp_name = "sys_enter", \
102
102
.prog_name = "test_core_arrays" \
103
103
···
130
130
131
131
#define PRIMITIVES_CASE_COMMON(name) \
132
132
.case_name = #name, \
133
-
.bpf_obj_file = "test_core_reloc_primitives.o", \
134
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
133
+
.bpf_obj_file = "test_core_reloc_primitives.bpf.o", \
134
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
135
135
.raw_tp_name = "sys_enter", \
136
136
.prog_name = "test_core_primitives" \
137
137
···
150
150
151
151
#define MODS_CASE(name) { \
152
152
.case_name = #name, \
153
-
.bpf_obj_file = "test_core_reloc_mods.o", \
154
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
153
+
.bpf_obj_file = "test_core_reloc_mods.bpf.o", \
154
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
155
155
.input = STRUCT_TO_CHAR_PTR(core_reloc_##name) { \
156
156
.a = 1, \
157
157
.b = 2, \
···
174
174
175
175
#define PTR_AS_ARR_CASE(name) { \
176
176
.case_name = #name, \
177
-
.bpf_obj_file = "test_core_reloc_ptr_as_arr.o", \
178
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
177
+
.bpf_obj_file = "test_core_reloc_ptr_as_arr.bpf.o", \
178
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
179
179
.input = (const char *)&(struct core_reloc_##name []){ \
180
180
{ .a = 1 }, \
181
181
{ .a = 2 }, \
···
203
203
204
204
#define INTS_CASE_COMMON(name) \
205
205
.case_name = #name, \
206
-
.bpf_obj_file = "test_core_reloc_ints.o", \
207
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
206
+
.bpf_obj_file = "test_core_reloc_ints.bpf.o", \
207
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
208
208
.raw_tp_name = "sys_enter", \
209
209
.prog_name = "test_core_ints"
210
210
···
223
223
224
224
#define FIELD_EXISTS_CASE_COMMON(name) \
225
225
.case_name = #name, \
226
-
.bpf_obj_file = "test_core_reloc_existence.o", \
227
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
226
+
.bpf_obj_file = "test_core_reloc_existence.bpf.o", \
227
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
228
228
.raw_tp_name = "sys_enter", \
229
229
.prog_name = "test_core_existence"
230
230
231
231
#define BITFIELDS_CASE_COMMON(objfile, test_name_prefix, name) \
232
232
.case_name = test_name_prefix#name, \
233
233
.bpf_obj_file = objfile, \
234
-
.btf_src_file = "btf__core_reloc_" #name ".o"
234
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o"
235
235
236
236
#define BITFIELDS_CASE(name, ...) { \
237
-
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.o", \
237
+
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.bpf.o", \
238
238
"probed:", name), \
239
239
.input = STRUCT_TO_CHAR_PTR(core_reloc_##name) __VA_ARGS__, \
240
240
.input_len = sizeof(struct core_reloc_##name), \
···
244
244
.raw_tp_name = "sys_enter", \
245
245
.prog_name = "test_core_bitfields", \
246
246
}, { \
247
-
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o", \
247
+
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.bpf.o", \
248
248
"direct:", name), \
249
249
.input = STRUCT_TO_CHAR_PTR(core_reloc_##name) __VA_ARGS__, \
250
250
.input_len = sizeof(struct core_reloc_##name), \
···
256
256
257
257
258
258
#define BITFIELDS_ERR_CASE(name) { \
259
-
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.o", \
259
+
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.bpf.o", \
260
260
"probed:", name), \
261
261
.fails = true, \
262
-
.run_btfgen_fails = true, \
262
+
.run_btfgen_fails = true, \
263
263
.raw_tp_name = "sys_enter", \
264
264
.prog_name = "test_core_bitfields", \
265
265
}, { \
266
-
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o", \
266
+
BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.bpf.o", \
267
267
"direct:", name), \
268
268
.fails = true, \
269
269
.run_btfgen_fails = true, \
···
272
272
273
273
#define SIZE_CASE_COMMON(name) \
274
274
.case_name = #name, \
275
-
.bpf_obj_file = "test_core_reloc_size.o", \
276
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
275
+
.bpf_obj_file = "test_core_reloc_size.bpf.o", \
276
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
277
277
.raw_tp_name = "sys_enter", \
278
278
.prog_name = "test_core_size"
279
279
···
307
307
#define SIZE_ERR_CASE(name) { \
308
308
SIZE_CASE_COMMON(name), \
309
309
.fails = true, \
310
-
.run_btfgen_fails = true, \
310
+
.run_btfgen_fails = true, \
311
311
}
312
312
313
313
#define TYPE_BASED_CASE_COMMON(name) \
314
314
.case_name = #name, \
315
-
.bpf_obj_file = "test_core_reloc_type_based.o", \
316
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
315
+
.bpf_obj_file = "test_core_reloc_type_based.bpf.o", \
316
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
317
317
.raw_tp_name = "sys_enter", \
318
318
.prog_name = "test_core_type_based"
319
319
···
331
331
332
332
#define TYPE_ID_CASE_COMMON(name) \
333
333
.case_name = #name, \
334
-
.bpf_obj_file = "test_core_reloc_type_id.o", \
335
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
334
+
.bpf_obj_file = "test_core_reloc_type_id.bpf.o", \
335
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
336
336
.raw_tp_name = "sys_enter", \
337
337
.prog_name = "test_core_type_id"
338
338
···
350
350
351
351
#define ENUMVAL_CASE_COMMON(name) \
352
352
.case_name = #name, \
353
-
.bpf_obj_file = "test_core_reloc_enumval.o", \
354
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
353
+
.bpf_obj_file = "test_core_reloc_enumval.bpf.o", \
354
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
355
355
.raw_tp_name = "sys_enter", \
356
356
.prog_name = "test_core_enumval"
357
357
···
369
369
370
370
#define ENUM64VAL_CASE_COMMON(name) \
371
371
.case_name = #name, \
372
-
.bpf_obj_file = "test_core_reloc_enum64val.o", \
373
-
.btf_src_file = "btf__core_reloc_" #name ".o", \
372
+
.bpf_obj_file = "test_core_reloc_enum64val.bpf.o", \
373
+
.btf_src_file = "btf__core_reloc_" #name ".bpf.o", \
374
374
.raw_tp_name = "sys_enter", \
375
375
.prog_name = "test_core_enum64val"
376
376
···
547
547
/* validate we can find kernel image and use its BTF for relocs */
548
548
{
549
549
.case_name = "kernel",
550
-
.bpf_obj_file = "test_core_reloc_kernel.o",
550
+
.bpf_obj_file = "test_core_reloc_kernel.bpf.o",
551
551
.btf_src_file = NULL, /* load from /lib/modules/$(uname -r) */
552
552
.input = "",
553
553
.input_len = 0,
···
629
629
/* validate edge cases of capturing relocations */
630
630
{
631
631
.case_name = "misc",
632
-
.bpf_obj_file = "test_core_reloc_misc.o",
633
-
.btf_src_file = "btf__core_reloc_misc.o",
632
+
.bpf_obj_file = "test_core_reloc_misc.bpf.o",
633
+
.btf_src_file = "btf__core_reloc_misc.bpf.o",
634
634
.input = (const char *)&(struct core_reloc_misc_extensible[]){
635
635
{ .a = 1 },
636
636
{ .a = 2 }, /* not read */
+22
-22
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
+22
-22
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
···
174
174
const char *prog_name[] = {
175
175
"fexit/test_pkt_md_access",
176
176
};
177
-
test_fexit_bpf2bpf_common("./fexit_bpf2bpf_simple.o",
178
-
"./test_pkt_md_access.o",
177
+
test_fexit_bpf2bpf_common("./fexit_bpf2bpf_simple.bpf.o",
178
+
"./test_pkt_md_access.bpf.o",
179
179
ARRAY_SIZE(prog_name),
180
180
prog_name, true, NULL);
181
181
}
···
188
188
"fexit/test_pkt_access_subprog2",
189
189
"fexit/test_pkt_access_subprog3",
190
190
};
191
-
test_fexit_bpf2bpf_common("./fexit_bpf2bpf.o",
192
-
"./test_pkt_access.o",
191
+
test_fexit_bpf2bpf_common("./fexit_bpf2bpf.bpf.o",
192
+
"./test_pkt_access.bpf.o",
193
193
ARRAY_SIZE(prog_name),
194
194
prog_name, true, NULL);
195
195
}
···
206
206
"freplace/get_constant",
207
207
"freplace/test_pkt_write_access_subprog",
208
208
};
209
-
test_fexit_bpf2bpf_common("./fexit_bpf2bpf.o",
210
-
"./test_pkt_access.o",
209
+
test_fexit_bpf2bpf_common("./fexit_bpf2bpf.bpf.o",
210
+
"./test_pkt_access.bpf.o",
211
211
ARRAY_SIZE(prog_name),
212
212
prog_name, true, NULL);
213
213
}
···
217
217
const char *prog_name[] = {
218
218
"freplace/do_bind",
219
219
};
220
-
test_fexit_bpf2bpf_common("./freplace_connect4.o",
221
-
"./connect4_prog.o",
220
+
test_fexit_bpf2bpf_common("./freplace_connect4.bpf.o",
221
+
"./connect4_prog.bpf.o",
222
222
ARRAY_SIZE(prog_name),
223
223
prog_name, false, NULL);
224
224
}
···
227
227
{
228
228
const char *prog_name = "security_new_get_constant";
229
229
const char *tgt_name = "get_constant";
230
-
const char *tgt_obj_file = "./test_pkt_access.o";
230
+
const char *tgt_obj_file = "./test_pkt_access.bpf.o";
231
231
struct bpf_program *prog = NULL;
232
232
struct bpf_object *tgt_obj;
233
233
struct bpf_link *link;
···
272
272
const char *prog_name[] = {
273
273
"freplace/get_constant",
274
274
};
275
-
test_fexit_bpf2bpf_common("./freplace_get_constant.o",
276
-
"./test_pkt_access.o",
275
+
test_fexit_bpf2bpf_common("./freplace_get_constant.bpf.o",
276
+
"./test_pkt_access.bpf.o",
277
277
ARRAY_SIZE(prog_name),
278
278
prog_name, true, test_second_attach);
279
279
}
···
281
281
static void test_fmod_ret_freplace(void)
282
282
{
283
283
struct bpf_object *freplace_obj = NULL, *pkt_obj, *fmod_obj = NULL;
284
-
const char *freplace_name = "./freplace_get_constant.o";
285
-
const char *fmod_ret_name = "./fmod_ret_freplace.o";
284
+
const char *freplace_name = "./freplace_get_constant.bpf.o";
285
+
const char *fmod_ret_name = "./fmod_ret_freplace.bpf.o";
286
286
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
287
-
const char *tgt_name = "./test_pkt_access.o";
287
+
const char *tgt_name = "./test_pkt_access.bpf.o";
288
288
struct bpf_link *freplace_link = NULL;
289
289
struct bpf_program *prog;
290
290
__u32 duration = 0;
···
339
339
const char *prog_name[] = {
340
340
"freplace/cls_redirect",
341
341
};
342
-
test_fexit_bpf2bpf_common("./freplace_cls_redirect.o",
343
-
"./test_cls_redirect.o",
342
+
test_fexit_bpf2bpf_common("./freplace_cls_redirect.bpf.o",
343
+
"./test_cls_redirect.bpf.o",
344
344
ARRAY_SIZE(prog_name),
345
345
prog_name, false, NULL);
346
346
}
···
385
385
static void test_func_replace_return_code(void)
386
386
{
387
387
/* test invalid return code in the replaced program */
388
-
test_obj_load_failure_common("./freplace_connect_v4_prog.o",
389
-
"./connect4_prog.o");
388
+
test_obj_load_failure_common("./freplace_connect_v4_prog.bpf.o",
389
+
"./connect4_prog.bpf.o");
390
390
}
391
391
392
392
static void test_func_map_prog_compatibility(void)
393
393
{
394
394
/* test with spin lock map value in the replaced program */
395
-
test_obj_load_failure_common("./freplace_attach_probe.o",
396
-
"./test_attach_probe.o");
395
+
test_obj_load_failure_common("./freplace_attach_probe.bpf.o",
396
+
"./test_attach_probe.bpf.o");
397
397
}
398
398
399
399
static void test_func_replace_global_func(void)
···
402
402
"freplace/test_pkt_access",
403
403
};
404
404
405
-
test_fexit_bpf2bpf_common("./freplace_global_func.o",
406
-
"./test_pkt_access.o",
405
+
test_fexit_bpf2bpf_common("./freplace_global_func.bpf.o",
406
+
"./test_pkt_access.bpf.o",
407
407
ARRAY_SIZE(prog_name),
408
408
prog_name, false, NULL);
409
409
}
+2
-2
tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
+2
-2
tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
···
84
84
85
85
void test_get_stack_raw_tp(void)
86
86
{
87
-
const char *file = "./test_get_stack_rawtp.o";
88
-
const char *file_err = "./test_get_stack_rawtp_err.o";
87
+
const char *file = "./test_get_stack_rawtp.bpf.o";
88
+
const char *file_err = "./test_get_stack_rawtp_err.bpf.o";
89
89
const char *prog_name = "bpf_prog1";
90
90
int i, err, prog_fd, exp_cnt = MAX_CNT_RAWTP;
91
91
struct perf_buffer *pb = NULL;
+1
-1
tools/testing/selftests/bpf/prog_tests/global_data.c
+1
-1
tools/testing/selftests/bpf/prog_tests/global_data.c
+1
-1
tools/testing/selftests/bpf/prog_tests/global_data_init.c
+1
-1
tools/testing/selftests/bpf/prog_tests/global_data_init.c
+1
-1
tools/testing/selftests/bpf/prog_tests/global_func_args.c
+1
-1
tools/testing/selftests/bpf/prog_tests/global_func_args.c
+1
-1
tools/testing/selftests/bpf/prog_tests/kfree_skb.c
+1
-1
tools/testing/selftests/bpf/prog_tests/kfree_skb.c
···
69
69
const int zero = 0;
70
70
bool test_ok[2];
71
71
72
-
err = bpf_prog_test_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
72
+
err = bpf_prog_test_load("./test_pkt_access.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
73
73
&obj, &prog_fd);
74
74
if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))
75
75
return;
+2
-2
tools/testing/selftests/bpf/prog_tests/l4lb_all.c
+2
-2
tools/testing/selftests/bpf/prog_tests/l4lb_all.c
+2
-2
tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c
+2
-2
tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c
···
27
27
if (CHECK_FAIL(server_fd < 0))
28
28
goto close_cgroup_fd;
29
29
30
-
err = bpf_prog_test_load("./load_bytes_relative.o", BPF_PROG_TYPE_CGROUP_SKB,
31
-
&obj, &prog_fd);
30
+
err = bpf_prog_test_load("./load_bytes_relative.bpf.o", BPF_PROG_TYPE_CGROUP_SKB,
31
+
&obj, &prog_fd);
32
32
if (CHECK_FAIL(err))
33
33
goto close_server_fd;
34
34
+1
-1
tools/testing/selftests/bpf/prog_tests/map_lock.c
+1
-1
tools/testing/selftests/bpf/prog_tests/map_lock.c
+2
-2
tools/testing/selftests/bpf/prog_tests/pinning.c
+2
-2
tools/testing/selftests/bpf/prog_tests/pinning.c
···
26
26
27
27
void test_pinning(void)
28
28
{
29
-
const char *file_invalid = "./test_pinning_invalid.o";
29
+
const char *file_invalid = "./test_pinning_invalid.bpf.o";
30
30
const char *custpinpath = "/sys/fs/bpf/custom/pinmap";
31
31
const char *nopinpath = "/sys/fs/bpf/nopinmap";
32
32
const char *nopinpath2 = "/sys/fs/bpf/nopinmap2";
33
33
const char *custpath = "/sys/fs/bpf/custom";
34
34
const char *pinpath = "/sys/fs/bpf/pinmap";
35
-
const char *file = "./test_pinning.o";
35
+
const char *file = "./test_pinning.bpf.o";
36
36
__u32 map_id, map_id2, duration = 0;
37
37
struct stat statbuf = {};
38
38
struct bpf_object *obj;
+1
-1
tools/testing/selftests/bpf/prog_tests/pkt_access.c
+1
-1
tools/testing/selftests/bpf/prog_tests/pkt_access.c
+1
-1
tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
+1
-1
tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
+1
-1
tools/testing/selftests/bpf/prog_tests/probe_user.c
+1
-1
tools/testing/selftests/bpf/prog_tests/probe_user.c
···
11
11
#endif
12
12
};
13
13
enum { prog_count = ARRAY_SIZE(prog_names) };
14
-
const char *obj_file = "./test_probe_user.o";
14
+
const char *obj_file = "./test_probe_user.bpf.o";
15
15
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts, );
16
16
int err, results_map_fd, sock_fd, duration = 0;
17
17
struct sockaddr curr, orig, tmp;
+2
-2
tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
+2
-2
tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
···
28
28
vals[i] = rand();
29
29
30
30
if (type == QUEUE)
31
-
strncpy(file, "./test_queue_map.o", sizeof(file));
31
+
strncpy(file, "./test_queue_map.bpf.o", sizeof(file));
32
32
else if (type == STACK)
33
-
strncpy(file, "./test_stack_map.o", sizeof(file));
33
+
strncpy(file, "./test_stack_map.bpf.o", sizeof(file));
34
34
else
35
35
return;
36
36
+1
-1
tools/testing/selftests/bpf/prog_tests/rdonly_maps.c
+1
-1
tools/testing/selftests/bpf/prog_tests/rdonly_maps.c
+1
-1
tools/testing/selftests/bpf/prog_tests/reference_tracking.c
+1
-1
tools/testing/selftests/bpf/prog_tests/reference_tracking.c
+1
-1
tools/testing/selftests/bpf/prog_tests/resolve_btfids.c
+1
-1
tools/testing/selftests/bpf/prog_tests/resolve_btfids.c
+2
-2
tools/testing/selftests/bpf/prog_tests/select_reuseport.c
+2
-2
tools/testing/selftests/bpf/prog_tests/select_reuseport.c
···
91
91
struct bpf_map *map;
92
92
int err;
93
93
94
-
obj = bpf_object__open("test_select_reuseport_kern.o");
94
+
obj = bpf_object__open("test_select_reuseport_kern.bpf.o");
95
95
err = libbpf_get_error(obj);
96
-
RET_ERR(err, "open test_select_reuseport_kern.o",
96
+
RET_ERR(err, "open test_select_reuseport_kern.bpf.o",
97
97
"obj:%p PTR_ERR(obj):%d\n", obj, err);
98
98
99
99
map = bpf_object__find_map_by_name(obj, "outer_map");
+1
-1
tools/testing/selftests/bpf/prog_tests/sk_assign.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sk_assign.c
···
47
47
if (CHECK_FAIL(system("tc qdisc add dev lo clsact")))
48
48
return false;
49
49
sprintf(tc_cmd, "%s %s %s %s", "tc filter add dev lo ingress bpf",
50
-
"direct-action object-file ./test_sk_assign.o",
50
+
"direct-action object-file ./test_sk_assign.bpf.o",
51
51
"section tc",
52
52
(env.verbosity < VERBOSE_VERY) ? " 2>/dev/null" : "verbose");
53
53
if (CHECK(system(tc_cmd), "BPF load failed;",
+1
-1
tools/testing/selftests/bpf/prog_tests/skb_ctx.c
+1
-1
tools/testing/selftests/bpf/prog_tests/skb_ctx.c
+1
-1
tools/testing/selftests/bpf/prog_tests/skb_helpers.c
+1
-1
tools/testing/selftests/bpf/prog_tests/skb_helpers.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sockopt_inherit.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sockopt_inherit.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sockopt_multi.c
+1
-1
tools/testing/selftests/bpf/prog_tests/sockopt_multi.c
+1
-1
tools/testing/selftests/bpf/prog_tests/spinlock.c
+1
-1
tools/testing/selftests/bpf/prog_tests/spinlock.c
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
···
6
6
int control_map_fd, stackid_hmap_fd, stackmap_fd, stack_amap_fd;
7
7
const char *prog_name = "oncpu";
8
8
int err, prog_fd, stack_trace_len;
9
-
const char *file = "./test_stacktrace_map.o";
9
+
const char *file = "./test_stacktrace_map.bpf.o";
10
10
__u32 key, val, duration = 0;
11
11
struct bpf_program *prog;
12
12
struct bpf_object *obj;
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
+1
-1
tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
+18
-18
tools/testing/selftests/bpf/prog_tests/tailcalls.c
+18
-18
tools/testing/selftests/bpf/prog_tests/tailcalls.c
···
20
20
.repeat = 1,
21
21
);
22
22
23
-
err = bpf_prog_test_load("tailcall1.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
24
-
&prog_fd);
23
+
err = bpf_prog_test_load("tailcall1.bpf.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
24
+
&prog_fd);
25
25
if (CHECK_FAIL(err))
26
26
return;
27
27
···
156
156
.repeat = 1,
157
157
);
158
158
159
-
err = bpf_prog_test_load("tailcall2.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
160
-
&prog_fd);
159
+
err = bpf_prog_test_load("tailcall2.bpf.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
160
+
&prog_fd);
161
161
if (CHECK_FAIL(err))
162
162
return;
163
163
···
299
299
*/
300
300
static void test_tailcall_3(void)
301
301
{
302
-
test_tailcall_count("tailcall3.o");
302
+
test_tailcall_count("tailcall3.bpf.o");
303
303
}
304
304
305
305
/* test_tailcall_6 checks that the count value of the tail call limit
···
307
307
*/
308
308
static void test_tailcall_6(void)
309
309
{
310
-
test_tailcall_count("tailcall6.o");
310
+
test_tailcall_count("tailcall6.bpf.o");
311
311
}
312
312
313
313
/* test_tailcall_4 checks that the kernel properly selects indirect jump
···
329
329
.repeat = 1,
330
330
);
331
331
332
-
err = bpf_prog_test_load("tailcall4.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
333
-
&prog_fd);
332
+
err = bpf_prog_test_load("tailcall4.bpf.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
333
+
&prog_fd);
334
334
if (CHECK_FAIL(err))
335
335
return;
336
336
···
419
419
.repeat = 1,
420
420
);
421
421
422
-
err = bpf_prog_test_load("tailcall5.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
423
-
&prog_fd);
422
+
err = bpf_prog_test_load("tailcall5.bpf.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
423
+
&prog_fd);
424
424
if (CHECK_FAIL(err))
425
425
return;
426
426
···
507
507
.repeat = 1,
508
508
);
509
509
510
-
err = bpf_prog_test_load("tailcall_bpf2bpf1.o", BPF_PROG_TYPE_SCHED_CLS,
511
-
&obj, &prog_fd);
510
+
err = bpf_prog_test_load("tailcall_bpf2bpf1.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
511
+
&obj, &prog_fd);
512
512
if (CHECK_FAIL(err))
513
513
return;
514
514
···
591
591
.repeat = 1,
592
592
);
593
593
594
-
err = bpf_prog_test_load("tailcall_bpf2bpf2.o", BPF_PROG_TYPE_SCHED_CLS,
595
-
&obj, &prog_fd);
594
+
err = bpf_prog_test_load("tailcall_bpf2bpf2.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
595
+
&obj, &prog_fd);
596
596
if (CHECK_FAIL(err))
597
597
return;
598
598
···
671
671
.repeat = 1,
672
672
);
673
673
674
-
err = bpf_prog_test_load("tailcall_bpf2bpf3.o", BPF_PROG_TYPE_SCHED_CLS,
675
-
&obj, &prog_fd);
674
+
err = bpf_prog_test_load("tailcall_bpf2bpf3.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
675
+
&obj, &prog_fd);
676
676
if (CHECK_FAIL(err))
677
677
return;
678
678
···
766
766
.repeat = 1,
767
767
);
768
768
769
-
err = bpf_prog_test_load("tailcall_bpf2bpf4.o", BPF_PROG_TYPE_SCHED_CLS,
770
-
&obj, &prog_fd);
769
+
err = bpf_prog_test_load("tailcall_bpf2bpf4.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
770
+
&obj, &prog_fd);
771
771
if (CHECK_FAIL(err))
772
772
return;
773
773
+1
-1
tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
+1
-1
tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
+1
-1
tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
+1
-1
tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
···
4
4
static void test_task_fd_query_tp_core(const char *probe_name,
5
5
const char *tp_name)
6
6
{
7
-
const char *file = "./test_tracepoint.o";
7
+
const char *file = "./test_tracepoint.bpf.o";
8
8
int err, bytes, efd, prog_fd, pmu_fd;
9
9
struct perf_event_attr attr = {};
10
10
__u64 probe_offset, probe_addr;
+1
-1
tools/testing/selftests/bpf/prog_tests/tcp_estats.c
+1
-1
tools/testing/selftests/bpf/prog_tests/tcp_estats.c
+17
-17
tools/testing/selftests/bpf/prog_tests/test_global_funcs.c
+17
-17
tools/testing/selftests/bpf/prog_tests/test_global_funcs.c
···
65
65
void test_test_global_funcs(void)
66
66
{
67
67
struct test_def tests[] = {
68
-
{ "test_global_func1.o", "combined stack size of 4 calls is 544" },
69
-
{ "test_global_func2.o" },
70
-
{ "test_global_func3.o" , "the call stack of 8 frames" },
71
-
{ "test_global_func4.o" },
72
-
{ "test_global_func5.o" , "expected pointer to ctx, but got PTR" },
73
-
{ "test_global_func6.o" , "modified ctx ptr R2" },
74
-
{ "test_global_func7.o" , "foo() doesn't return scalar" },
75
-
{ "test_global_func8.o" },
76
-
{ "test_global_func9.o" },
77
-
{ "test_global_func10.o", "invalid indirect read from stack" },
78
-
{ "test_global_func11.o", "Caller passes invalid args into func#1" },
79
-
{ "test_global_func12.o", "invalid mem access 'mem_or_null'" },
80
-
{ "test_global_func13.o", "Caller passes invalid args into func#1" },
81
-
{ "test_global_func14.o", "reference type('FWD S') size cannot be determined" },
82
-
{ "test_global_func15.o", "At program exit the register R0 has value" },
83
-
{ "test_global_func16.o", "invalid indirect read from stack" },
84
-
{ "test_global_func17.o", "Caller passes invalid args into func#1" },
68
+
{ "test_global_func1.bpf.o", "combined stack size of 4 calls is 544" },
69
+
{ "test_global_func2.bpf.o" },
70
+
{ "test_global_func3.bpf.o", "the call stack of 8 frames" },
71
+
{ "test_global_func4.bpf.o" },
72
+
{ "test_global_func5.bpf.o", "expected pointer to ctx, but got PTR" },
73
+
{ "test_global_func6.bpf.o", "modified ctx ptr R2" },
74
+
{ "test_global_func7.bpf.o", "foo() doesn't return scalar" },
75
+
{ "test_global_func8.bpf.o" },
76
+
{ "test_global_func9.bpf.o" },
77
+
{ "test_global_func10.bpf.o", "invalid indirect read from stack" },
78
+
{ "test_global_func11.bpf.o", "Caller passes invalid args into func#1" },
79
+
{ "test_global_func12.bpf.o", "invalid mem access 'mem_or_null'" },
80
+
{ "test_global_func13.bpf.o", "Caller passes invalid args into func#1" },
81
+
{ "test_global_func14.bpf.o", "reference type('FWD S') size cannot be determined" },
82
+
{ "test_global_func15.bpf.o", "At program exit the register R0 has value" },
83
+
{ "test_global_func16.bpf.o", "invalid indirect read from stack" },
84
+
{ "test_global_func17.bpf.o", "Caller passes invalid args into func#1" },
85
85
};
86
86
libbpf_print_fn_t old_print_fn = NULL;
87
87
int err, i, duration = 0;
+1
-1
tools/testing/selftests/bpf/prog_tests/test_overhead.c
+1
-1
tools/testing/selftests/bpf/prog_tests/test_overhead.c
+1
-1
tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
+1
-1
tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
···
6
6
const int num_progs = 3;
7
7
int i, j, bytes, efd, err, prog_fd[num_progs], pmu_fd[num_progs];
8
8
__u32 duration = 0, info_len, saved_prog_ids[num_progs];
9
-
const char *file = "./test_tracepoint.o";
9
+
const char *file = "./test_tracepoint.bpf.o";
10
10
struct perf_event_query_bpf *query;
11
11
struct perf_event_attr attr = {};
12
12
struct bpf_object *obj[num_progs];
+1
-1
tools/testing/selftests/bpf/prog_tests/trampoline_count.c
+1
-1
tools/testing/selftests/bpf/prog_tests/trampoline_count.c
···
35
35
/* TODO: use different target function to run in concurrent mode */
36
36
void serial_test_trampoline_count(void)
37
37
{
38
-
char *file = "test_trampoline_count.o";
38
+
char *file = "test_trampoline_count.bpf.o";
39
39
char *const progs[] = { "fentry_test", "fmod_ret_test", "fexit_test" };
40
40
struct inst inst[MAX_TRAMP_PROGS + 1] = {};
41
41
struct bpf_program *prog;
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp.c
···
8
8
struct vip key6 = {.protocol = 6, .family = AF_INET6};
9
9
struct iptnl_info value4 = {.family = AF_INET};
10
10
struct iptnl_info value6 = {.family = AF_INET6};
11
-
const char *file = "./test_xdp.o";
11
+
const char *file = "./test_xdp.bpf.o";
12
12
struct bpf_object *obj;
13
13
char buf[128];
14
14
struct ipv6hdr iph6;
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_adjust_frags.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_adjust_frags.c
+5
-5
tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
+5
-5
tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
···
4
4
5
5
static void test_xdp_adjust_tail_shrink(void)
6
6
{
7
-
const char *file = "./test_xdp_adjust_tail_shrink.o";
7
+
const char *file = "./test_xdp_adjust_tail_shrink.bpf.o";
8
8
__u32 expect_sz;
9
9
struct bpf_object *obj;
10
10
int err, prog_fd;
···
39
39
40
40
static void test_xdp_adjust_tail_grow(void)
41
41
{
42
-
const char *file = "./test_xdp_adjust_tail_grow.o";
42
+
const char *file = "./test_xdp_adjust_tail_grow.bpf.o";
43
43
struct bpf_object *obj;
44
44
char buf[4096]; /* avoid segfault: large buf to hold grow results */
45
45
__u32 expect_sz;
···
73
73
74
74
static void test_xdp_adjust_tail_grow2(void)
75
75
{
76
-
const char *file = "./test_xdp_adjust_tail_grow.o";
76
+
const char *file = "./test_xdp_adjust_tail_grow.bpf.o";
77
77
char buf[4096]; /* avoid segfault: large buf to hold grow results */
78
78
int tailroom = 320; /* SKB_DATA_ALIGN(sizeof(struct skb_shared_info))*/;
79
79
struct bpf_object *obj;
···
135
135
136
136
static void test_xdp_adjust_frags_tail_shrink(void)
137
137
{
138
-
const char *file = "./test_xdp_adjust_tail_shrink.o";
138
+
const char *file = "./test_xdp_adjust_tail_shrink.bpf.o";
139
139
__u32 exp_size;
140
140
struct bpf_program *prog;
141
141
struct bpf_object *obj;
···
202
202
203
203
static void test_xdp_adjust_frags_tail_grow(void)
204
204
{
205
-
const char *file = "./test_xdp_adjust_tail_grow.o";
205
+
const char *file = "./test_xdp_adjust_tail_grow.bpf.o";
206
206
__u32 exp_size;
207
207
struct bpf_program *prog;
208
208
struct bpf_object *obj;
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_attach.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_attach.c
···
8
8
{
9
9
__u32 duration = 0, id1, id2, id0 = 0, len;
10
10
struct bpf_object *obj1, *obj2, *obj3;
11
-
const char *file = "./test_xdp.o";
11
+
const char *file = "./test_xdp.bpf.o";
12
12
struct bpf_prog_info info = {};
13
13
int err, fd1, fd2, fd3;
14
14
LIBBPF_OPTS(bpf_xdp_attach_opts, opts);
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_info.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_info.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_perf.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_perf.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_synproxy.c
+1
-1
tools/testing/selftests/bpf/prog_tests/xdp_synproxy.c
···
82
82
SYS("ethtool -K tmp0 tx off");
83
83
if (xdp)
84
84
/* Workaround required for veth. */
85
-
SYS("ip link set tmp0 xdp object xdp_dummy.o section xdp 2> /dev/null");
85
+
SYS("ip link set tmp0 xdp object xdp_dummy.bpf.o section xdp 2> /dev/null");
86
86
87
87
ns = open_netns("synproxy");
88
88
if (!ASSERT_OK_PTR(ns, "setns"))
+4
-4
tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c
+4
-4
tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c
···
73
73
__builtin_preserve_access_index(&skb->len));
74
74
75
75
ret = ctx->ret;
76
-
/* bpf_prog_test_load() loads "test_pkt_access.o" with BPF_F_TEST_RND_HI32
77
-
* which randomizes upper 32 bits after BPF_ALU32 insns.
78
-
* Hence after 'w0 <<= 1' upper bits of $rax are random.
79
-
* That is expected and correct. Trim them.
76
+
/* bpf_prog_test_load() loads "test_pkt_access.bpf.o" with
77
+
* BPF_F_TEST_RND_HI32 which randomizes upper 32 bits after BPF_ALU32
78
+
* insns. Hence after 'w0 <<= 1' upper bits of $rax are random. That is
79
+
* expected and correct. Trim them.
80
80
*/
81
81
ret = (__u32) ret;
82
82
if (len != 74 || ret != 148)
+1
-1
tools/testing/selftests/bpf/test_dev_cgroup.c
+1
-1
tools/testing/selftests/bpf/test_dev_cgroup.c
+1
-1
tools/testing/selftests/bpf/test_lirc_mode2_user.c
+1
-1
tools/testing/selftests/bpf/test_lirc_mode2_user.c
+5
-5
tools/testing/selftests/bpf/test_maps.c
+5
-5
tools/testing/selftests/bpf/test_maps.c
···
651
651
#include <arpa/inet.h>
652
652
#include <sys/select.h>
653
653
#include <linux/err.h>
654
-
#define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.o"
655
-
#define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.o"
656
-
#define SOCKMAP_TCP_MSG_PROG "./sockmap_tcp_msg_prog.o"
654
+
#define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.bpf.o"
655
+
#define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.bpf.o"
656
+
#define SOCKMAP_TCP_MSG_PROG "./sockmap_tcp_msg_prog.bpf.o"
657
657
static void test_sockmap(unsigned int tasks, void *data)
658
658
{
659
659
struct bpf_map *bpf_map_rx, *bpf_map_tx, *bpf_map_msg, *bpf_map_break;
···
1143
1143
exit(1);
1144
1144
}
1145
1145
1146
-
#define MAPINMAP_PROG "./test_map_in_map.o"
1147
-
#define MAPINMAP_INVALID_PROG "./test_map_in_map_invalid.o"
1146
+
#define MAPINMAP_PROG "./test_map_in_map.bpf.o"
1147
+
#define MAPINMAP_INVALID_PROG "./test_map_in_map_invalid.bpf.o"
1148
1148
static void test_map_in_map(void)
1149
1149
{
1150
1150
struct bpf_object *obj;
+11
-11
tools/testing/selftests/bpf/test_offload.py
+11
-11
tools/testing/selftests/bpf/test_offload.py
···
782
782
cmd("mount -t debugfs none /sys/kernel/debug")
783
783
784
784
# Check samples are compiled
785
-
samples = ["sample_ret0.o", "sample_map_ret0.o"]
785
+
samples = ["sample_ret0.bpf.o", "sample_map_ret0.bpf.o"]
786
786
for s in samples:
787
787
ret, out = cmd("ls %s/%s" % (bpf_test_dir, s), fail=False)
788
788
skip(ret != 0, "sample %s/%s not found, please compile it" %
···
803
803
netns = []
804
804
805
805
try:
806
-
obj = bpf_obj("sample_ret0.o")
806
+
obj = bpf_obj("sample_ret0.bpf.o")
807
807
bytecode = bpf_bytecode("1,6 0 0 4294967295,")
808
808
809
809
start_test("Test destruction of generic XDP...")
···
1023
1023
1024
1024
sim.wait_for_flush()
1025
1025
start_test("Test non-offload XDP attaching to HW...")
1026
-
bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/nooffload")
1026
+
bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/nooffload")
1027
1027
nooffload = bpf_pinned("/sys/fs/bpf/nooffload")
1028
1028
ret, _, err = sim.set_xdp(nooffload, "offload",
1029
1029
fail=False, include_stderr=True)
···
1032
1032
rm("/sys/fs/bpf/nooffload")
1033
1033
1034
1034
start_test("Test offload XDP attaching to drv...")
1035
-
bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/offload",
1035
+
bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/offload",
1036
1036
dev=sim['ifname'])
1037
1037
offload = bpf_pinned("/sys/fs/bpf/offload")
1038
1038
ret, _, err = sim.set_xdp(offload, "drv", fail=False, include_stderr=True)
···
1043
1043
1044
1044
start_test("Test XDP load failure...")
1045
1045
sim.dfs["dev/bpf_bind_verifier_accept"] = 0
1046
-
ret, _, err = bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/offload",
1046
+
ret, _, err = bpftool_prog_load("sample_ret0.bpf.o", "/sys/fs/bpf/offload",
1047
1047
dev=sim['ifname'], fail=False, include_stderr=True)
1048
1048
fail(ret == 0, "verifier should fail on load")
1049
1049
check_verifier_log(err, "[netdevsim] Hello from netdevsim!")
···
1169
1169
1170
1170
simdev = NetdevSimDev()
1171
1171
sim, = simdev.nsims
1172
-
map_obj = bpf_obj("sample_map_ret0.o")
1172
+
map_obj = bpf_obj("sample_map_ret0.bpf.o")
1173
1173
start_test("Test loading program with maps...")
1174
1174
sim.set_xdp(map_obj, "offload", JSON=False) # map fixup msg breaks JSON
1175
1175
···
1307
1307
sims = (simA, simB1, simB2, simB3)
1308
1308
simB = (simB1, simB2, simB3)
1309
1309
1310
-
bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA",
1310
+
bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimA",
1311
1311
dev=simA['ifname'])
1312
1312
progA = bpf_pinned("/sys/fs/bpf/nsimA")
1313
-
bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB",
1313
+
bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB",
1314
1314
dev=simB1['ifname'])
1315
1315
progB = bpf_pinned("/sys/fs/bpf/nsimB")
1316
1316
···
1344
1344
mapA = bpftool("prog show %s" % (progA))[1]["map_ids"][0]
1345
1345
mapB = bpftool("prog show %s" % (progB))[1]["map_ids"][0]
1346
1346
1347
-
ret, _ = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
1347
+
ret, _ = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB_",
1348
1348
dev=simB3['ifname'],
1349
1349
maps=["idx 0 id %d" % (mapB)],
1350
1350
fail=False)
1351
1351
fail(ret != 0, "couldn't reuse a map on the same ASIC")
1352
1352
rm("/sys/fs/bpf/nsimB_")
1353
1353
1354
-
ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA_",
1354
+
ret, _, err = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimA_",
1355
1355
dev=simA['ifname'],
1356
1356
maps=["idx 0 id %d" % (mapB)],
1357
1357
fail=False, include_stderr=True)
···
1359
1359
fail(err.count("offload device mismatch between prog and map") == 0,
1360
1360
"error message missing for cross-ASIC map")
1361
1361
1362
-
ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
1362
+
ret, _, err = bpftool_prog_load("sample_map_ret0.bpf.o", "/sys/fs/bpf/nsimB_",
1363
1363
dev=simB1['ifname'],
1364
1364
maps=["idx 0 id %d" % (mapA)],
1365
1365
fail=False, include_stderr=True)
+1
-1
tools/testing/selftests/bpf/test_skb_cgroup_id.sh
+1
-1
tools/testing/selftests/bpf/test_skb_cgroup_id.sh
···
54
54
TEST_IF="test_cgid_1"
55
55
TEST_IF_PEER="test_cgid_2"
56
56
MAX_PING_TRIES=5
57
-
BPF_PROG_OBJ="${DIR}/test_skb_cgroup_id_kern.o"
57
+
BPF_PROG_OBJ="${DIR}/test_skb_cgroup_id_kern.bpf.o"
58
58
BPF_PROG_SECTION="cgroup_id_logger"
59
59
BPF_PROG_ID=0
60
60
PROG="${DIR}/test_skb_cgroup_id_user"
+8
-8
tools/testing/selftests/bpf/test_sock_addr.c
+8
-8
tools/testing/selftests/bpf/test_sock_addr.c
···
26
26
#endif
27
27
28
28
#define CG_PATH "/foo"
29
-
#define CONNECT4_PROG_PATH "./connect4_prog.o"
30
-
#define CONNECT6_PROG_PATH "./connect6_prog.o"
31
-
#define SENDMSG4_PROG_PATH "./sendmsg4_prog.o"
32
-
#define SENDMSG6_PROG_PATH "./sendmsg6_prog.o"
33
-
#define RECVMSG4_PROG_PATH "./recvmsg4_prog.o"
34
-
#define RECVMSG6_PROG_PATH "./recvmsg6_prog.o"
35
-
#define BIND4_PROG_PATH "./bind4_prog.o"
36
-
#define BIND6_PROG_PATH "./bind6_prog.o"
29
+
#define CONNECT4_PROG_PATH "./connect4_prog.bpf.o"
30
+
#define CONNECT6_PROG_PATH "./connect6_prog.bpf.o"
31
+
#define SENDMSG4_PROG_PATH "./sendmsg4_prog.bpf.o"
32
+
#define SENDMSG6_PROG_PATH "./sendmsg6_prog.bpf.o"
33
+
#define RECVMSG4_PROG_PATH "./recvmsg4_prog.bpf.o"
34
+
#define RECVMSG6_PROG_PATH "./recvmsg6_prog.bpf.o"
35
+
#define BIND4_PROG_PATH "./bind4_prog.bpf.o"
36
+
#define BIND6_PROG_PATH "./bind6_prog.bpf.o"
37
37
38
38
#define SERV4_IP "192.168.1.254"
39
39
#define SERV4_REWRITE_IP "127.0.0.1"
+2
-2
tools/testing/selftests/bpf/test_sockmap.c
+2
-2
tools/testing/selftests/bpf/test_sockmap.c
···
52
52
#define S1_PORT 10000
53
53
#define S2_PORT 10001
54
54
55
-
#define BPF_SOCKMAP_FILENAME "test_sockmap_kern.o"
56
-
#define BPF_SOCKHASH_FILENAME "test_sockhash_kern.o"
55
+
#define BPF_SOCKMAP_FILENAME "test_sockmap_kern.bpf.o"
56
+
#define BPF_SOCKHASH_FILENAME "test_sockhash_kern.bpf.o"
57
57
#define CG_PATH "/sockmap"
58
58
59
59
/* global sockets */
+3
-3
tools/testing/selftests/bpf/test_sysctl.c
+3
-3
tools/testing/selftests/bpf/test_sysctl.c
···
1372
1372
},
1373
1373
{
1374
1374
"C prog: deny all writes",
1375
-
.prog_file = "./test_sysctl_prog.o",
1375
+
.prog_file = "./test_sysctl_prog.bpf.o",
1376
1376
.attach_type = BPF_CGROUP_SYSCTL,
1377
1377
.sysctl = "net/ipv4/tcp_mem",
1378
1378
.open_flags = O_WRONLY,
···
1381
1381
},
1382
1382
{
1383
1383
"C prog: deny access by name",
1384
-
.prog_file = "./test_sysctl_prog.o",
1384
+
.prog_file = "./test_sysctl_prog.bpf.o",
1385
1385
.attach_type = BPF_CGROUP_SYSCTL,
1386
1386
.sysctl = "net/ipv4/route/mtu_expires",
1387
1387
.open_flags = O_RDONLY,
···
1389
1389
},
1390
1390
{
1391
1391
"C prog: read tcp_mem",
1392
-
.prog_file = "./test_sysctl_prog.o",
1392
+
.prog_file = "./test_sysctl_prog.bpf.o",
1393
1393
.attach_type = BPF_CGROUP_SYSCTL,
1394
1394
.sysctl = "net/ipv4/tcp_mem",
1395
1395
.open_flags = O_RDONLY,
+1
-1
tools/testing/selftests/bpf/test_tcpnotify_user.c
+1
-1
tools/testing/selftests/bpf/test_tcpnotify_user.c
+4
-4
tools/testing/selftests/bpf/test_xdp_redirect.sh
+4
-4
tools/testing/selftests/bpf/test_xdp_redirect.sh
···
54
54
return 0
55
55
fi
56
56
57
-
ip -n ${NS1} link set veth11 $xdpmode obj xdp_dummy.o sec xdp &> /dev/null
58
-
ip -n ${NS2} link set veth22 $xdpmode obj xdp_dummy.o sec xdp &> /dev/null
59
-
ip link set dev veth1 $xdpmode obj test_xdp_redirect.o sec redirect_to_222 &> /dev/null
60
-
ip link set dev veth2 $xdpmode obj test_xdp_redirect.o sec redirect_to_111 &> /dev/null
57
+
ip -n ${NS1} link set veth11 $xdpmode obj xdp_dummy.bpf.o sec xdp &> /dev/null
58
+
ip -n ${NS2} link set veth22 $xdpmode obj xdp_dummy.bpf.o sec xdp &> /dev/null
59
+
ip link set dev veth1 $xdpmode obj test_xdp_redirect.bpf.o sec redirect_to_222 &> /dev/null
60
+
ip link set dev veth2 $xdpmode obj test_xdp_redirect.bpf.o sec redirect_to_111 &> /dev/null
61
61
62
62
if ip netns exec ${NS1} ping -c 1 10.1.1.22 &> /dev/null &&
63
63
ip netns exec ${NS2} ping -c 1 10.1.1.11 &> /dev/null; then
+1
-1
tools/testing/selftests/bpf/test_xdp_redirect_multi.sh
+1
-1
tools/testing/selftests/bpf/test_xdp_redirect_multi.sh
···
94
94
# Add a neigh entry for IPv4 ping test
95
95
ip -n ${NS[$i]} neigh add 192.0.2.253 lladdr 00:00:00:00:00:01 dev veth0
96
96
ip -n ${NS[$i]} link set veth0 $mode obj \
97
-
xdp_dummy.o sec xdp &> /dev/null || \
97
+
xdp_dummy.bpf.o sec xdp &> /dev/null || \
98
98
{ test_fail "Unable to load dummy xdp" && exit 1; }
99
99
IFACES="$IFACES veth$i"
100
100
veth_mac[$i]=$(ip -n ${NS[0]} link show veth$i | awk '/link\/ether/ {print $2}')
+4
-4
tools/testing/selftests/bpf/test_xdp_veth.sh
+4
-4
tools/testing/selftests/bpf/test_xdp_veth.sh
···
101
101
102
102
mkdir $BPF_DIR
103
103
bpftool prog loadall \
104
-
xdp_redirect_map.o $BPF_DIR/progs type xdp \
104
+
xdp_redirect_map.bpf.o $BPF_DIR/progs type xdp \
105
105
pinmaps $BPF_DIR/maps
106
106
bpftool map update pinned $BPF_DIR/maps/tx_port key 0 0 0 0 value 122 0 0 0
107
107
bpftool map update pinned $BPF_DIR/maps/tx_port key 1 0 0 0 value 133 0 0 0
···
110
110
ip link set dev veth2 xdp pinned $BPF_DIR/progs/xdp_redirect_map_1
111
111
ip link set dev veth3 xdp pinned $BPF_DIR/progs/xdp_redirect_map_2
112
112
113
-
ip -n ${NS1} link set dev veth11 xdp obj xdp_dummy.o sec xdp
114
-
ip -n ${NS2} link set dev veth22 xdp obj xdp_tx.o sec xdp
115
-
ip -n ${NS3} link set dev veth33 xdp obj xdp_dummy.o sec xdp
113
+
ip -n ${NS1} link set dev veth11 xdp obj xdp_dummy.bpf.o sec xdp
114
+
ip -n ${NS2} link set dev veth22 xdp obj xdp_tx.bpf.o sec xdp
115
+
ip -n ${NS3} link set dev veth33 xdp obj xdp_dummy.bpf.o sec xdp
116
116
117
117
trap cleanup EXIT
118
118
+1
-1
tools/testing/selftests/bpf/xdp_redirect_multi.c
+1
-1
tools/testing/selftests/bpf/xdp_redirect_multi.c
+1
-1
tools/testing/selftests/bpf/xdp_synproxy.c
+1
-1
tools/testing/selftests/bpf/xdp_synproxy.c
···
193
193
int prog_fd;
194
194
int err;
195
195
196
-
snprintf(xdp_filename, sizeof(xdp_filename), "%s_kern.o", argv0);
196
+
snprintf(xdp_filename, sizeof(xdp_filename), "%s_kern.bpf.o", argv0);
197
197
obj = bpf_object__open_file(xdp_filename, NULL);
198
198
err = libbpf_get_error(obj);
199
199
if (err < 0) {
+1
-1
tools/testing/selftests/bpf/xdping.c
+1
-1
tools/testing/selftests/bpf/xdping.c
···
168
168
/* Use libbpf 1.0 API mode */
169
169
libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
170
170
171
-
snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
171
+
snprintf(filename, sizeof(filename), "%s_kern.bpf.o", argv[0]);
172
172
173
173
if (bpf_prog_test_load(filename, BPF_PROG_TYPE_XDP, &obj, &prog_fd)) {
174
174
fprintf(stderr, "load of %s failed\n", filename);