tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

selftests/bpf: Use explicit bpf_prog_test_load() calls everywhere

-Dbpf_prog_load_deprecated=bpf_prog_test_load trick is both ugly and
breaks when deprecation goes into effect due to macro magic. Convert all
the uses to explicit bpf_prog_test_load() calls which avoid deprecation
errors and makes everything less magical.

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Dave Marchevsky <davemarchevsky@fb.com>
Link: https://lore.kernel.org/bpf/20211103220845.2676888-12-andrii@kernel.org

authored by

Andrii Nakryiko and committed by
Alexei Starovoitov cbdb1461 f87c1930

+68 -59
+1 -1
tools/testing/selftests/bpf/Makefile
··· 24 24 CFLAGS += -g -O0 -rdynamic -Wall $(GENFLAGS) $(SAN_CFLAGS) \ 25 25 -I$(CURDIR) -I$(INCLUDE_DIR) -I$(GENDIR) -I$(LIBDIR) \ 26 26 -I$(TOOLSINCDIR) -I$(APIDIR) -I$(OUTPUT) \ 27 - -Dbpf_prog_load_deprecated=bpf_prog_test_load \ 28 27 -Dbpf_load_program=bpf_test_load_program 29 28 LDLIBS += -lcap -lelf -lz -lrt -lpthread 30 29 ··· 206 207 $(OUTPUT)/xdping: testing_helpers.o 207 208 $(OUTPUT)/flow_dissector_load: testing_helpers.o 208 209 $(OUTPUT)/test_maps: testing_helpers.o 210 + $(OUTPUT)/test_verifier: testing_helpers.o 209 211 210 212 BPFTOOL ?= $(DEFAULT_BPFTOOL) 211 213 $(DEFAULT_BPFTOOL): $(wildcard $(BPFTOOLDIR)/*.[ch] $(BPFTOOLDIR)/Makefile) \
+2 -1
tools/testing/selftests/bpf/flow_dissector_load.h
··· 4 4 5 5 #include <bpf/bpf.h> 6 6 #include <bpf/libbpf.h> 7 + #include "testing_helpers.h" 7 8 8 9 static inline int bpf_flow_load(struct bpf_object **obj, 9 10 const char *path, ··· 19 18 int prog_array_fd; 20 19 int ret, fd, i; 21 20 22 - ret = bpf_prog_load(path, BPF_PROG_TYPE_FLOW_DISSECTOR, obj, 21 + ret = bpf_prog_test_load(path, BPF_PROG_TYPE_FLOW_DISSECTOR, obj, 23 22 prog_fd); 24 23 if (ret) 25 24 return ret;
+3 -2
tools/testing/selftests/bpf/get_cgroup_id_user.c
··· 19 19 #include <bpf/libbpf.h> 20 20 21 21 #include "cgroup_helpers.h" 22 + #include "testing_helpers.h" 22 23 #include "bpf_rlimit.h" 23 24 24 25 #define CHECK(condition, tag, format...) ({ \ ··· 67 66 if (CHECK(cgroup_fd < 0, "cgroup_setup_and_join", "err %d errno %d\n", cgroup_fd, errno)) 68 67 return 1; 69 68 70 - err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 71 - if (CHECK(err, "bpf_prog_load", "err %d errno %d\n", err, errno)) 69 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 70 + if (CHECK(err, "bpf_prog_test_load", "err %d errno %d\n", err, errno)) 72 71 goto cleanup_cgroup_env; 73 72 74 73 cgidmap_fd = bpf_find_map(__func__, obj, "cg_ids");
+1 -1
tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
··· 48 48 bzero(zeros, sizeof(zeros)); 49 49 for (i = 0; i < nr_iters; i++) { 50 50 now = time(NULL); 51 - err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, 51 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, 52 52 &objs[i], &prog_fds[i]); 53 53 /* test_obj_id.o is a dumb prog. It should never fail 54 54 * to load.
+4 -4
tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
··· 65 65 int err, tgt_fd, i; 66 66 struct btf *btf; 67 67 68 - err = bpf_prog_load(target_obj_file, BPF_PROG_TYPE_UNSPEC, 68 + err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC, 69 69 &tgt_obj, &tgt_fd); 70 70 if (!ASSERT_OK(err, "tgt_prog_load")) 71 71 return; ··· 224 224 if (CHECK(!prog, "find_prog", "prog %s not found\n", prog_name)) 225 225 return -ENOENT; 226 226 227 - err = bpf_prog_load(tgt_obj_file, BPF_PROG_TYPE_UNSPEC, 227 + err = bpf_prog_test_load(tgt_obj_file, BPF_PROG_TYPE_UNSPEC, 228 228 &tgt_obj, &tgt_fd); 229 229 if (CHECK(err, "second_prog_load", "file %s err %d errno %d\n", 230 230 tgt_obj_file, err, errno)) ··· 274 274 __u32 duration = 0; 275 275 int err, pkt_fd, attach_prog_fd; 276 276 277 - err = bpf_prog_load(tgt_name, BPF_PROG_TYPE_UNSPEC, 277 + err = bpf_prog_test_load(tgt_name, BPF_PROG_TYPE_UNSPEC, 278 278 &pkt_obj, &pkt_fd); 279 279 /* the target prog should load fine */ 280 280 if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n", ··· 341 341 int err, pkt_fd; 342 342 __u32 duration = 0; 343 343 344 - err = bpf_prog_load(target_obj_file, BPF_PROG_TYPE_UNSPEC, 344 + err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC, 345 345 &pkt_obj, &pkt_fd); 346 346 /* the target prog should load fine */ 347 347 if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
+2 -2
tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
··· 94 94 struct bpf_map *map; 95 95 cpu_set_t cpu_set; 96 96 97 - err = bpf_prog_load(file_err, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 97 + err = bpf_prog_test_load(file_err, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 98 98 if (CHECK(err >= 0, "prog_load raw tp", "err %d errno %d\n", err, errno)) 99 99 return; 100 100 101 - err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 101 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 102 102 if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno)) 103 103 return; 104 104
+1 -1
tools/testing/selftests/bpf/prog_tests/global_data.c
··· 136 136 struct bpf_object *obj; 137 137 int err, prog_fd; 138 138 139 - err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 139 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 140 140 if (CHECK(err, "load program", "error %d loading %s\n", err, file)) 141 141 return; 142 142
+1 -1
tools/testing/selftests/bpf/prog_tests/global_func_args.c
··· 44 44 struct bpf_object *obj; 45 45 int err, prog_fd; 46 46 47 - err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 47 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 48 48 if (CHECK(err, "load program", "error %d loading %s\n", err, file)) 49 49 return; 50 50
+1 -1
tools/testing/selftests/bpf/prog_tests/kfree_skb.c
··· 74 74 const int zero = 0; 75 75 bool test_ok[2]; 76 76 77 - err = bpf_prog_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS, 77 + err = bpf_prog_test_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS, 78 78 &obj, &tattr.prog_fd); 79 79 if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno)) 80 80 return;
+1 -1
tools/testing/selftests/bpf/prog_tests/l4lb_all.c
··· 30 30 char buf[128]; 31 31 u32 *magic = (u32 *)buf; 32 32 33 - err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 33 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 34 34 if (CHECK_FAIL(err)) 35 35 return; 36 36
+1 -1
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_load("./load_bytes_relative.o", BPF_PROG_TYPE_CGROUP_SKB, 30 + err = bpf_prog_test_load("./load_bytes_relative.o", BPF_PROG_TYPE_CGROUP_SKB, 31 31 &obj, &prog_fd); 32 32 if (CHECK_FAIL(err)) 33 33 goto close_server_fd;
+2 -2
tools/testing/selftests/bpf/prog_tests/map_lock.c
··· 53 53 int err = 0, key = 0, i; 54 54 void *ret; 55 55 56 - err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 56 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 57 57 if (CHECK_FAIL(err)) { 58 - printf("test_map_lock:bpf_prog_load errno %d\n", errno); 58 + printf("test_map_lock:bpf_prog_test_load errno %d\n", errno); 59 59 goto close_prog; 60 60 } 61 61 map_fd[0] = bpf_find_map(__func__, obj, "hash_map");
+1 -1
tools/testing/selftests/bpf/prog_tests/pkt_access.c
··· 9 9 __u32 duration, retval; 10 10 int err, prog_fd; 11 11 12 - err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 12 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 13 13 if (CHECK_FAIL(err)) 14 14 return; 15 15
+1 -1
tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
··· 9 9 __u32 duration, retval; 10 10 int err, prog_fd; 11 11 12 - err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 12 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 13 13 if (CHECK_FAIL(err)) 14 14 return; 15 15
+1 -1
tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
··· 27 27 else 28 28 return; 29 29 30 - err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 30 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd); 31 31 if (CHECK_FAIL(err)) 32 32 return; 33 33
+1 -1
tools/testing/selftests/bpf/prog_tests/skb_ctx.c
··· 32 32 int err; 33 33 int i; 34 34 35 - err = bpf_prog_load("./test_skb_ctx.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 35 + err = bpf_prog_test_load("./test_skb_ctx.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 36 36 &tattr.prog_fd); 37 37 if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno)) 38 38 return;
+1 -1
tools/testing/selftests/bpf/prog_tests/skb_helpers.c
··· 20 20 struct bpf_object *obj; 21 21 int err; 22 22 23 - err = bpf_prog_load("./test_skb_helpers.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 23 + err = bpf_prog_test_load("./test_skb_helpers.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 24 24 &tattr.prog_fd); 25 25 if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno)) 26 26 return;
+2 -2
tools/testing/selftests/bpf/prog_tests/spinlock.c
··· 24 24 int err = 0, i; 25 25 void *ret; 26 26 27 - err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 27 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd); 28 28 if (CHECK_FAIL(err)) { 29 - printf("test_spin_lock:bpf_prog_load errno %d\n", errno); 29 + printf("test_spin_lock:bpf_prog_test_load errno %d\n", errno); 30 30 goto close_prog; 31 31 } 32 32 for (i = 0; i < 4; i++)
+1 -1
tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
··· 12 12 struct bpf_object *obj; 13 13 struct bpf_link *link; 14 14 15 - err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 15 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 16 16 if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno)) 17 17 return; 18 18
+1 -1
tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
··· 12 12 struct bpf_object *obj; 13 13 struct bpf_link *link = NULL; 14 14 15 - err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 15 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 16 16 if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno)) 17 17 return; 18 18
+9 -9
tools/testing/selftests/bpf/prog_tests/tailcalls.c
··· 16 16 char prog_name[32]; 17 17 char buff[128] = {}; 18 18 19 - err = bpf_prog_load("tailcall1.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 19 + err = bpf_prog_test_load("tailcall1.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 20 20 &prog_fd); 21 21 if (CHECK_FAIL(err)) 22 22 return; ··· 154 154 char prog_name[32]; 155 155 char buff[128] = {}; 156 156 157 - err = bpf_prog_load("tailcall2.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 157 + err = bpf_prog_test_load("tailcall2.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 158 158 &prog_fd); 159 159 if (CHECK_FAIL(err)) 160 160 return; ··· 228 228 __u32 retval, duration; 229 229 char buff[128] = {}; 230 230 231 - err = bpf_prog_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj, 231 + err = bpf_prog_test_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj, 232 232 &prog_fd); 233 233 if (CHECK_FAIL(err)) 234 234 return; ··· 324 324 char buff[128] = {}; 325 325 char prog_name[32]; 326 326 327 - err = bpf_prog_load("tailcall4.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 327 + err = bpf_prog_test_load("tailcall4.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 328 328 &prog_fd); 329 329 if (CHECK_FAIL(err)) 330 330 return; ··· 412 412 char buff[128] = {}; 413 413 char prog_name[32]; 414 414 415 - err = bpf_prog_load("tailcall5.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 415 + err = bpf_prog_test_load("tailcall5.o", BPF_PROG_TYPE_SCHED_CLS, &obj, 416 416 &prog_fd); 417 417 if (CHECK_FAIL(err)) 418 418 return; ··· 498 498 __u32 retval, duration; 499 499 char prog_name[32]; 500 500 501 - err = bpf_prog_load("tailcall_bpf2bpf1.o", BPF_PROG_TYPE_SCHED_CLS, 501 + err = bpf_prog_test_load("tailcall_bpf2bpf1.o", BPF_PROG_TYPE_SCHED_CLS, 502 502 &obj, &prog_fd); 503 503 if (CHECK_FAIL(err)) 504 504 return; ··· 582 582 __u32 retval, duration; 583 583 char buff[128] = {}; 584 584 585 - err = bpf_prog_load("tailcall_bpf2bpf2.o", BPF_PROG_TYPE_SCHED_CLS, 585 + err = bpf_prog_test_load("tailcall_bpf2bpf2.o", BPF_PROG_TYPE_SCHED_CLS, 586 586 &obj, &prog_fd); 587 587 if (CHECK_FAIL(err)) 588 588 return; ··· 660 660 __u32 retval, duration; 661 661 char prog_name[32]; 662 662 663 - err = bpf_prog_load("tailcall_bpf2bpf3.o", BPF_PROG_TYPE_SCHED_CLS, 663 + err = bpf_prog_test_load("tailcall_bpf2bpf3.o", BPF_PROG_TYPE_SCHED_CLS, 664 664 &obj, &prog_fd); 665 665 if (CHECK_FAIL(err)) 666 666 return; ··· 757 757 __u32 retval, duration; 758 758 char prog_name[32]; 759 759 760 - err = bpf_prog_load("tailcall_bpf2bpf4.o", BPF_PROG_TYPE_SCHED_CLS, 760 + err = bpf_prog_test_load("tailcall_bpf2bpf4.o", BPF_PROG_TYPE_SCHED_CLS, 761 761 &obj, &prog_fd); 762 762 if (CHECK_FAIL(err)) 763 763 return;
+1 -1
tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
··· 11 11 __u32 duration = 0; 12 12 char buf[256]; 13 13 14 - err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 14 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd); 15 15 if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno)) 16 16 return; 17 17
+2 -2
tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
··· 13 13 __u32 duration = 0; 14 14 char buf[256]; 15 15 16 - err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 17 - if (CHECK(err, "bpf_prog_load", "err %d errno %d\n", err, errno)) 16 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 17 + if (CHECK(err, "bpf_prog_test_load", "err %d errno %d\n", err, errno)) 18 18 goto close_prog; 19 19 20 20 snprintf(buf, sizeof(buf),
+1 -1
tools/testing/selftests/bpf/prog_tests/tcp_estats.c
··· 8 8 struct bpf_object *obj; 9 9 __u32 duration = 0; 10 10 11 - err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 11 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd); 12 12 CHECK(err, "", "err %d errno %d\n", err, errno); 13 13 if (err) 14 14 return;
+1 -1
tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
··· 35 35 36 36 query = malloc(sizeof(*query) + sizeof(__u32) * num_progs); 37 37 for (i = 0; i < num_progs; i++) { 38 - err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj[i], 38 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj[i], 39 39 &prog_fd[i]); 40 40 if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno)) 41 41 goto cleanup1;
+1 -1
tools/testing/selftests/bpf/prog_tests/xdp.c
··· 16 16 __u32 duration, retval, size; 17 17 int err, prog_fd, map_fd; 18 18 19 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 19 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 20 20 if (CHECK_FAIL(err)) 21 21 return; 22 22
+3 -3
tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
··· 10 10 int err, prog_fd; 11 11 char buf[128]; 12 12 13 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 13 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 14 14 if (CHECK_FAIL(err)) 15 15 return; 16 16 ··· 38 38 __u32 duration, retval, size, expect_sz; 39 39 int err, prog_fd; 40 40 41 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 41 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 42 42 if (CHECK_FAIL(err)) 43 43 return; 44 44 ··· 75 75 .data_size_out = 0, /* Per test */ 76 76 }; 77 77 78 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &tattr.prog_fd); 78 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &tattr.prog_fd); 79 79 if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno)) 80 80 return; 81 81
+3 -3
tools/testing/selftests/bpf/prog_tests/xdp_attach.c
··· 16 16 17 17 len = sizeof(info); 18 18 19 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj1, &fd1); 19 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj1, &fd1); 20 20 if (CHECK_FAIL(err)) 21 21 return; 22 22 err = bpf_obj_get_info_by_fd(fd1, &info, &len); ··· 24 24 goto out_1; 25 25 id1 = info.id; 26 26 27 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj2, &fd2); 27 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj2, &fd2); 28 28 if (CHECK_FAIL(err)) 29 29 goto out_1; 30 30 ··· 34 34 goto out_2; 35 35 id2 = info.id; 36 36 37 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj3, &fd3); 37 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj3, &fd3); 38 38 if (CHECK_FAIL(err)) 39 39 goto out_2; 40 40
+1 -1
tools/testing/selftests/bpf/prog_tests/xdp_info.c
··· 29 29 30 30 /* Setup prog */ 31 31 32 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 32 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 33 33 if (CHECK_FAIL(err)) 34 34 return; 35 35
+1 -1
tools/testing/selftests/bpf/prog_tests/xdp_perf.c
··· 9 9 char in[128], out[128]; 10 10 int err, prog_fd; 11 11 12 - err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 12 + err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 13 13 if (CHECK_FAIL(err)) 14 14 return; 15 15
+1 -1
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_load() loads "test_pkt_access.o" with BPF_F_TEST_RND_HI32 76 + /* bpf_prog_test_load() loads "test_pkt_access.o" with BPF_F_TEST_RND_HI32 77 77 * which randomizes upper 32 bits after BPF_ALU32 insns. 78 78 * Hence after 'w0 <<= 1' upper bits of $rax are random. 79 79 * That is expected and correct. Trim them.
+2 -1
tools/testing/selftests/bpf/test_dev_cgroup.c
··· 14 14 #include <bpf/libbpf.h> 15 15 16 16 #include "cgroup_helpers.h" 17 + #include "testing_helpers.h" 17 18 #include "bpf_rlimit.h" 18 19 19 20 #define DEV_CGROUP_PROG "./dev_cgroup.o" ··· 28 27 int prog_fd, cgroup_fd; 29 28 __u32 prog_cnt; 30 29 31 - if (bpf_prog_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE, 30 + if (bpf_prog_test_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE, 32 31 &obj, &prog_fd)) { 33 32 printf("Failed to load DEV_CGROUP program\n"); 34 33 goto out;
+4 -2
tools/testing/selftests/bpf/test_lirc_mode2_user.c
··· 45 45 #include <bpf/bpf.h> 46 46 #include <bpf/libbpf.h> 47 47 48 + #include "testing_helpers.h" 49 + 48 50 int main(int argc, char **argv) 49 51 { 50 52 struct bpf_object *obj; ··· 60 58 return 2; 61 59 } 62 60 63 - ret = bpf_prog_load("test_lirc_mode2_kern.o", 64 - BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd); 61 + ret = bpf_prog_test_load("test_lirc_mode2_kern.o", 62 + BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd); 65 63 if (ret) { 66 64 printf("Failed to load bpf program\n"); 67 65 return 1;
+4 -3
tools/testing/selftests/bpf/test_maps.c
··· 25 25 #include "bpf_util.h" 26 26 #include "bpf_rlimit.h" 27 27 #include "test_maps.h" 28 + #include "testing_helpers.h" 28 29 29 30 #ifndef ENOTSUPP 30 31 #define ENOTSUPP 524 ··· 831 830 } 832 831 833 832 /* Load SK_SKB program and Attach */ 834 - err = bpf_prog_load(SOCKMAP_PARSE_PROG, 833 + err = bpf_prog_test_load(SOCKMAP_PARSE_PROG, 835 834 BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog); 836 835 if (err) { 837 836 printf("Failed to load SK_SKB parse prog\n"); 838 837 goto out_sockmap; 839 838 } 840 839 841 - err = bpf_prog_load(SOCKMAP_TCP_MSG_PROG, 840 + err = bpf_prog_test_load(SOCKMAP_TCP_MSG_PROG, 842 841 BPF_PROG_TYPE_SK_MSG, &obj, &msg_prog); 843 842 if (err) { 844 843 printf("Failed to load SK_SKB msg prog\n"); 845 844 goto out_sockmap; 846 845 } 847 846 848 - err = bpf_prog_load(SOCKMAP_VERDICT_PROG, 847 + err = bpf_prog_test_load(SOCKMAP_VERDICT_PROG, 849 848 BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog); 850 849 if (err) { 851 850 printf("Failed to load SK_SKB verdict prog\n");
+1
tools/testing/selftests/bpf/test_sysctl.c
··· 17 17 #include "bpf_rlimit.h" 18 18 #include "bpf_util.h" 19 19 #include "cgroup_helpers.h" 20 + #include "testing_helpers.h" 20 21 21 22 #define CG_PATH "/foo" 22 23 #define MAX_INSNS 512
+2 -1
tools/testing/selftests/bpf/test_tcpnotify_user.c
··· 25 25 26 26 #include "test_tcpnotify.h" 27 27 #include "trace_helpers.h" 28 + #include "testing_helpers.h" 28 29 29 30 #define SOCKET_BUFFER_SIZE (getpagesize() < 8192L ? getpagesize() : 8192L) 30 31 ··· 93 92 if (cg_fd < 0) 94 93 goto err; 95 94 96 - if (bpf_prog_load(file, BPF_PROG_TYPE_SOCK_OPS, &obj, &prog_fd)) { 95 + if (bpf_prog_test_load(file, BPF_PROG_TYPE_SOCK_OPS, &obj, &prog_fd)) { 97 96 printf("FAILED: load_bpf_file failed for: %s\n", file); 98 97 goto err; 99 98 }
+2 -1
tools/testing/selftests/bpf/xdping.c
··· 22 22 #include "bpf/libbpf.h" 23 23 24 24 #include "xdping.h" 25 + #include "testing_helpers.h" 25 26 26 27 static int ifindex; 27 28 static __u32 xdp_flags = XDP_FLAGS_UPDATE_IF_NOEXIST; ··· 174 173 175 174 snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]); 176 175 177 - if (bpf_prog_load(filename, BPF_PROG_TYPE_XDP, &obj, &prog_fd)) { 176 + if (bpf_prog_test_load(filename, BPF_PROG_TYPE_XDP, &obj, &prog_fd)) { 178 177 fprintf(stderr, "load of %s failed\n", filename); 179 178 return 1; 180 179 }