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

diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index 5588c622d266a53d94c7681e469b7673ccf06d61..2016c583ed201fb579012538d46a5d33f30f6095 100644 (file)
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -24,7 +24,6 @@ SAN_CFLAGS    ?=
 CFLAGS += -g -O0 -rdynamic -Wall $(GENFLAGS) $(SAN_CFLAGS)             \
          -I$(CURDIR) -I$(INCLUDE_DIR) -I$(GENDIR) -I$(LIBDIR)          \
          -I$(TOOLSINCDIR) -I$(APIDIR) -I$(OUTPUT)                      \
-         -Dbpf_prog_load_deprecated=bpf_prog_test_load                 \
          -Dbpf_load_program=bpf_test_load_program
 LDLIBS += -lcap -lelf -lz -lrt -lpthread
 
@@ -207,6 +206,7 @@ $(OUTPUT)/test_lirc_mode2_user: testing_helpers.o
 $(OUTPUT)/xdping: testing_helpers.o
 $(OUTPUT)/flow_dissector_load: testing_helpers.o
 $(OUTPUT)/test_maps: testing_helpers.o
+$(OUTPUT)/test_verifier: testing_helpers.o
 
 BPFTOOL ?= $(DEFAULT_BPFTOOL)
 $(DEFAULT_BPFTOOL): $(wildcard $(BPFTOOLDIR)/*.[ch] $(BPFTOOLDIR)/Makefile)    \

diff --git a/tools/testing/selftests/bpf/flow_dissector_load.h b/tools/testing/selftests/bpf/flow_dissector_load.h
index 9d0acc2fc6cc0f02a5351712033042b71f19e9de..f40b585f4e7e1030bff6babea3440f169b9d3c6f 100644 (file)
--- a/tools/testing/selftests/bpf/flow_dissector_load.h
+++ b/tools/testing/selftests/bpf/flow_dissector_load.h
@@ -4,6 +4,7 @@
 
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
+#include "testing_helpers.h"
 
 static inline int bpf_flow_load(struct bpf_object **obj,
                                const char *path,
@@ -18,7 +19,7 @@ static inline int bpf_flow_load(struct bpf_object **obj,
        int prog_array_fd;
        int ret, fd, i;
 
-       ret = bpf_prog_load(path, BPF_PROG_TYPE_FLOW_DISSECTOR, obj,
+       ret = bpf_prog_test_load(path, BPF_PROG_TYPE_FLOW_DISSECTOR, obj,
                            prog_fd);
        if (ret)
                return ret;

diff --git a/tools/testing/selftests/bpf/get_cgroup_id_user.c b/tools/testing/selftests/bpf/get_cgroup_id_user.c
index 99628e1a1e58411ea502ed0e5098f386b06f4cc0..3a7b82bd9e941610808c9ce13362ebd1deb7d515 100644 (file)
--- a/tools/testing/selftests/bpf/get_cgroup_id_user.c
+++ b/tools/testing/selftests/bpf/get_cgroup_id_user.c
@@ -19,6 +19,7 @@
 #include <bpf/libbpf.h>
 
 #include "cgroup_helpers.h"
+#include "testing_helpers.h"
 #include "bpf_rlimit.h"
 
 #define CHECK(condition, tag, format...) ({            \
@@ -66,8 +67,8 @@ int main(int argc, char **argv)
        if (CHECK(cgroup_fd < 0, "cgroup_setup_and_join", "err %d errno %d\n", cgroup_fd, errno))
                return 1;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
-       if (CHECK(err, "bpf_prog_load", "err %d errno %d\n", err, errno))
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
+       if (CHECK(err, "bpf_prog_test_load", "err %d errno %d\n", err, errno))
                goto cleanup_cgroup_env;
 
        cgidmap_fd = bpf_find_map(__func__, obj, "cg_ids");

diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c b/tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
index eb8eeebe69359eca6c983c63b48ac8cb84f49c24..0a6c5f00abd40b8c2a34fc810e91c78b95e92612 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c
@@ -48,7 +48,7 @@ void serial_test_bpf_obj_id(void)
        bzero(zeros, sizeof(zeros));
        for (i = 0; i < nr_iters; i++) {
                now = time(NULL);
-               err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT,
+               err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT,
                                    &objs[i], &prog_fds[i]);
                /* test_obj_id.o is a dumb prog. It should never fail
                 * to load.

diff --git a/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c b/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
index 9cff14a23bb7209ab70d26bff6be99a7811ffc65..fdd603ebda28de10ca8747fdfb22663836f3db26 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
+++ b/tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c
@@ -65,7 +65,7 @@ static void test_fexit_bpf2bpf_common(const char *obj_file,
        int err, tgt_fd, i;
        struct btf *btf;
 
-       err = bpf_prog_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
+       err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
                            &tgt_obj, &tgt_fd);
        if (!ASSERT_OK(err, "tgt_prog_load"))
                return;
@@ -224,7 +224,7 @@ static int test_second_attach(struct bpf_object *obj)
        if (CHECK(!prog, "find_prog", "prog %s not found\n", prog_name))
                return -ENOENT;
 
-       err = bpf_prog_load(tgt_obj_file, BPF_PROG_TYPE_UNSPEC,
+       err = bpf_prog_test_load(tgt_obj_file, BPF_PROG_TYPE_UNSPEC,
                            &tgt_obj, &tgt_fd);
        if (CHECK(err, "second_prog_load", "file %s err %d errno %d\n",
                  tgt_obj_file, err, errno))
@@ -274,7 +274,7 @@ static void test_fmod_ret_freplace(void)
        __u32 duration = 0;
        int err, pkt_fd, attach_prog_fd;
 
-       err = bpf_prog_load(tgt_name, BPF_PROG_TYPE_UNSPEC,
+       err = bpf_prog_test_load(tgt_name, BPF_PROG_TYPE_UNSPEC,
                            &pkt_obj, &pkt_fd);
        /* the target prog should load fine */
        if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
@@ -341,7 +341,7 @@ static void test_obj_load_failure_common(const char *obj_file,
        int err, pkt_fd;
        __u32 duration = 0;
 
-       err = bpf_prog_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
+       err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
                            &pkt_obj, &pkt_fd);
        /* the target prog should load fine */
        if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",

diff --git a/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c b/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
index 522237aa4470f5972a88edf170749c83f0e5f7f4..569fcc6ed660995255ec2f06b741bfb2ec48323f 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
+++ b/tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c
@@ -94,11 +94,11 @@ void test_get_stack_raw_tp(void)
        struct bpf_map *map;
        cpu_set_t cpu_set;
 
-       err = bpf_prog_load(file_err, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file_err, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
        if (CHECK(err >= 0, "prog_load raw tp", "err %d errno %d\n", err, errno))
                return;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
        if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/global_data.c b/tools/testing/selftests/bpf/prog_tests/global_data.c
index afd8639f9a947d5d746d85084cc970339ba50b68..9da131b32e13e328bb7db93d52f961a36e37520a 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/global_data.c
+++ b/tools/testing/selftests/bpf/prog_tests/global_data.c
@@ -136,7 +136,7 @@ void test_global_data(void)
        struct bpf_object *obj;
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
        if (CHECK(err, "load program", "error %d loading %s\n", err, file))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/global_func_args.c b/tools/testing/selftests/bpf/prog_tests/global_func_args.c
index 8bcc2869102fd3e3840b3a82e8c0d8cf302b5875..93a2439237b05ee1083dcb2704055be6d6fb12dd 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/global_func_args.c
+++ b/tools/testing/selftests/bpf/prog_tests/global_func_args.c
@@ -44,7 +44,7 @@ void test_global_func_args(void)
        struct bpf_object *obj;
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
        if (CHECK(err, "load program", "error %d loading %s\n", err, file))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/kfree_skb.c b/tools/testing/selftests/bpf/prog_tests/kfree_skb.c
index 01e51d16c8b8d144e8d9aef93956286de44bbf22..885413ed5c969465ff03e0ff83dc1adb351c3e73 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/kfree_skb.c
+++ b/tools/testing/selftests/bpf/prog_tests/kfree_skb.c
@@ -74,7 +74,7 @@ void serial_test_kfree_skb(void)
        const int zero = 0;
        bool test_ok[2];
 
-       err = bpf_prog_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
+       err = bpf_prog_test_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
                            &obj, &tattr.prog_fd);
        if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))
                return;

diff --git a/tools/testing/selftests/bpf/prog_tests/l4lb_all.c b/tools/testing/selftests/bpf/prog_tests/l4lb_all.c
index 8073105548ff44380d157296c9035bd1555d883c..540ef28fabff8a69cacb76afaf55ebd91a9718d8 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/l4lb_all.c
+++ b/tools/testing/selftests/bpf/prog_tests/l4lb_all.c
@@ -30,7 +30,7 @@ static void test_l4lb(const char *file)
        char buf[128];
        u32 *magic = (u32 *)buf;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c b/tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c
index 5a2a689dbb683f50e24cb69c86d2e49386e9f36b..4e0b2ec057aad9f68c0b5cdd4cf4e8471e577896 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c
+++ b/tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c
@@ -27,7 +27,7 @@ void test_load_bytes_relative(void)
        if (CHECK_FAIL(server_fd < 0))
                goto close_cgroup_fd;
 
-       err = bpf_prog_load("./load_bytes_relative.o", BPF_PROG_TYPE_CGROUP_SKB,
+       err = bpf_prog_test_load("./load_bytes_relative.o", BPF_PROG_TYPE_CGROUP_SKB,
                            &obj, &prog_fd);
        if (CHECK_FAIL(err))
                goto close_server_fd;

diff --git a/tools/testing/selftests/bpf/prog_tests/map_lock.c b/tools/testing/selftests/bpf/prog_tests/map_lock.c
index ce17b1ed8709f8f4ade0482aaa6ab577daad7e44..23d19e9cf26a8bfbd2b600a22f9dd090b156b39c 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/map_lock.c
+++ b/tools/testing/selftests/bpf/prog_tests/map_lock.c
@@ -53,9 +53,9 @@ void test_map_lock(void)
        int err = 0, key = 0, i;
        void *ret;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
        if (CHECK_FAIL(err)) {
-               printf("test_map_lock:bpf_prog_load errno %d\n", errno);
+               printf("test_map_lock:bpf_prog_test_load errno %d\n", errno);
                goto close_prog;
        }
        map_fd[0] = bpf_find_map(__func__, obj, "hash_map");

diff --git a/tools/testing/selftests/bpf/prog_tests/pkt_access.c b/tools/testing/selftests/bpf/prog_tests/pkt_access.c
index 44b514fabccd844d74b61da956fd595c60fecd82..6628710ec3c68f6704c7bd4b7c42d427cf17c0dc 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/pkt_access.c
+++ b/tools/testing/selftests/bpf/prog_tests/pkt_access.c
@@ -9,7 +9,7 @@ void test_pkt_access(void)
        __u32 duration, retval;
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/pkt_md_access.c b/tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
index 939015cd6dbae3c781c7f10cd09d13d057e4d858..c9d2d6a1bfcc3dfe1530b95ed1177520b2900c5d 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
+++ b/tools/testing/selftests/bpf/prog_tests/pkt_md_access.c
@@ -9,7 +9,7 @@ void test_pkt_md_access(void)
        __u32 duration, retval;
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/queue_stack_map.c b/tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
index f47e7b1cb32cc781fd4190d0fa7c904a4362929a..8ccba3ab70eeac3c7f29631f8629f4b8aec2a0ff 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
+++ b/tools/testing/selftests/bpf/prog_tests/queue_stack_map.c
@@ -27,7 +27,7 @@ static void test_queue_stack_map_by_type(int type)
        else
                return;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/skb_ctx.c b/tools/testing/selftests/bpf/prog_tests/skb_ctx.c
index c437e6ba8fe202c8455644ca02b0e3daacc3be54..d3106078838c4275ffff6ec52518946c4cfd15cf 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/skb_ctx.c
+++ b/tools/testing/selftests/bpf/prog_tests/skb_ctx.c
@@ -32,7 +32,7 @@ void test_skb_ctx(void)
        int err;
        int i;
 
-       err = bpf_prog_load("./test_skb_ctx.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("./test_skb_ctx.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &tattr.prog_fd);
        if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno))
                return;

diff --git a/tools/testing/selftests/bpf/prog_tests/skb_helpers.c b/tools/testing/selftests/bpf/prog_tests/skb_helpers.c
index f302ad84a2983744fb956730ce247c0675c86dd4..6f802a1c080023ea85175962b03479e80e67f561 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/skb_helpers.c
+++ b/tools/testing/selftests/bpf/prog_tests/skb_helpers.c
@@ -20,7 +20,7 @@ void test_skb_helpers(void)
        struct bpf_object *obj;
        int err;
 
-       err = bpf_prog_load("./test_skb_helpers.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("./test_skb_helpers.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &tattr.prog_fd);
        if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno))
                return;

diff --git a/tools/testing/selftests/bpf/prog_tests/spinlock.c b/tools/testing/selftests/bpf/prog_tests/spinlock.c
index 7577a77a4c4c57b64a0e750c97eee73d5f2f4278..6307f5d2b4174616ddec92d414d45b632c186262 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/spinlock.c
+++ b/tools/testing/selftests/bpf/prog_tests/spinlock.c
@@ -24,9 +24,9 @@ void test_spinlock(void)
        int err = 0, i;
        void *ret;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
        if (CHECK_FAIL(err)) {
-               printf("test_spin_lock:bpf_prog_load errno %d\n", errno);
+               printf("test_spin_lock:bpf_prog_test_load errno %d\n", errno);
                goto close_prog;
        }
        for (i = 0; i < 4; i++)

diff --git a/tools/testing/selftests/bpf/prog_tests/stacktrace_map.c b/tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
index 04b476bd62b9f4ebc7cef865a6e56477b382cbeb..337493d74ec554741fb59c2ad75b4425dd0d03f2 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
+++ b/tools/testing/selftests/bpf/prog_tests/stacktrace_map.c
@@ -12,7 +12,7 @@ void test_stacktrace_map(void)
        struct bpf_object *obj;
        struct bpf_link *link;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
        if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c b/tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
index 4fd30bb651ad75fb18e010703905778326210660..063a14a2060dc941ff2390c79738d982f5819662 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
+++ b/tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c
@@ -12,7 +12,7 @@ void test_stacktrace_map_raw_tp(void)
        struct bpf_object *obj;
        struct bpf_link *link = NULL;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
        if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/tailcalls.c b/tools/testing/selftests/bpf/prog_tests/tailcalls.c
index 9825f1f7bfcc20218320686f54bfd0609976949d..5dc0f425bd11db9aebac13055cdf4b7b15e65d05 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/tailcalls.c
+++ b/tools/testing/selftests/bpf/prog_tests/tailcalls.c
@@ -16,7 +16,7 @@ static void test_tailcall_1(void)
        char prog_name[32];
        char buff[128] = {};
 
-       err = bpf_prog_load("tailcall1.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("tailcall1.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -154,7 +154,7 @@ static void test_tailcall_2(void)
        char prog_name[32];
        char buff[128] = {};
 
-       err = bpf_prog_load("tailcall2.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("tailcall2.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -228,7 +228,7 @@ static void test_tailcall_count(const char *which)
        __u32 retval, duration;
        char buff[128] = {};
 
-       err = bpf_prog_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -324,7 +324,7 @@ static void test_tailcall_4(void)
        char buff[128] = {};
        char prog_name[32];
 
-       err = bpf_prog_load("tailcall4.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("tailcall4.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -412,7 +412,7 @@ static void test_tailcall_5(void)
        char buff[128] = {};
        char prog_name[32];
 
-       err = bpf_prog_load("tailcall5.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
+       err = bpf_prog_test_load("tailcall5.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
                            &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -498,7 +498,7 @@ static void test_tailcall_bpf2bpf_1(void)
        __u32 retval, duration;
        char prog_name[32];
 
-       err = bpf_prog_load("tailcall_bpf2bpf1.o", BPF_PROG_TYPE_SCHED_CLS,
+       err = bpf_prog_test_load("tailcall_bpf2bpf1.o", BPF_PROG_TYPE_SCHED_CLS,
                            &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -582,7 +582,7 @@ static void test_tailcall_bpf2bpf_2(void)
        __u32 retval, duration;
        char buff[128] = {};
 
-       err = bpf_prog_load("tailcall_bpf2bpf2.o", BPF_PROG_TYPE_SCHED_CLS,
+       err = bpf_prog_test_load("tailcall_bpf2bpf2.o", BPF_PROG_TYPE_SCHED_CLS,
                            &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -660,7 +660,7 @@ static void test_tailcall_bpf2bpf_3(void)
        __u32 retval, duration;
        char prog_name[32];
 
-       err = bpf_prog_load("tailcall_bpf2bpf3.o", BPF_PROG_TYPE_SCHED_CLS,
+       err = bpf_prog_test_load("tailcall_bpf2bpf3.o", BPF_PROG_TYPE_SCHED_CLS,
                            &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
@@ -757,7 +757,7 @@ static void test_tailcall_bpf2bpf_4(bool noise)
        __u32 retval, duration;
        char prog_name[32];
 
-       err = bpf_prog_load("tailcall_bpf2bpf4.o", BPF_PROG_TYPE_SCHED_CLS,
+       err = bpf_prog_test_load("tailcall_bpf2bpf4.o", BPF_PROG_TYPE_SCHED_CLS,
                            &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;

diff --git a/tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c b/tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
index 1bdc1d86a50c85906f771042dae01e1c3621f1c3..17947c9e1d660175736b7a9ea4f010eea53c727d 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
+++ b/tools/testing/selftests/bpf/prog_tests/task_fd_query_rawtp.c
@@ -11,7 +11,7 @@ void test_task_fd_query_rawtp(void)
        __u32 duration = 0;
        char buf[256];
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);
        if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c b/tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
index 3f131b8fe328a7e4e2240ec5f0164ef518b30801..c2a98a7a8dfc523fc6fb78a25eb4816f1768e4b0 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
+++ b/tools/testing/selftests/bpf/prog_tests/task_fd_query_tp.c
@@ -13,8 +13,8 @@ static void test_task_fd_query_tp_core(const char *probe_name,
        __u32 duration = 0;
        char buf[256];
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
-       if (CHECK(err, "bpf_prog_load", "err %d errno %d\n", err, errno))
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
+       if (CHECK(err, "bpf_prog_test_load", "err %d errno %d\n", err, errno))
                goto close_prog;
 
        snprintf(buf, sizeof(buf),

diff --git a/tools/testing/selftests/bpf/prog_tests/tcp_estats.c b/tools/testing/selftests/bpf/prog_tests/tcp_estats.c
index 594307dffd13bc42b66cd3bae370a2ac70806ad6..11bf755be4c99efbb9c1ed0f6140c6786e2c2fa4 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/tcp_estats.c
+++ b/tools/testing/selftests/bpf/prog_tests/tcp_estats.c
@@ -8,7 +8,7 @@ void test_tcp_estats(void)
        struct bpf_object *obj;
        __u32 duration = 0;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
        CHECK(err, "", "err %d errno %d\n", err, errno);
        if (err)
                return;

diff --git a/tools/testing/selftests/bpf/prog_tests/tp_attach_query.c b/tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
index 8652d0a46c87ab6ecce086fa0a7427f042dd9f39..39e79291c82b8767c0506f0663b3f79a7329445a 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
+++ b/tools/testing/selftests/bpf/prog_tests/tp_attach_query.c
@@ -35,7 +35,7 @@ void serial_test_tp_attach_query(void)
 
        query = malloc(sizeof(*query) + sizeof(__u32) * num_progs);
        for (i = 0; i < num_progs; i++) {
-               err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj[i],
+               err = bpf_prog_test_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj[i],
                                    &prog_fd[i]);
                if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno))
                        goto cleanup1;

diff --git a/tools/testing/selftests/bpf/prog_tests/xdp.c b/tools/testing/selftests/bpf/prog_tests/xdp.c
index 48921ff748503a2b27cae4d08bfec33c38300c47..7a7ef9d4e151f20aa5d115ffb573595e78e4b091 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/xdp.c
+++ b/tools/testing/selftests/bpf/prog_tests/xdp.c
@@ -16,7 +16,7 @@ void test_xdp(void)
        __u32 duration, retval, size;
        int err, prog_fd, map_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c b/tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
index f529e3c923ae71bd1190c071d283ac09d91a0a0d..3f5a17c38be596e0f6fb9fa0561e80249460474e 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
+++ b/tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c
@@ -10,7 +10,7 @@ static void test_xdp_adjust_tail_shrink(void)
        int err, prog_fd;
        char buf[128];
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 
@@ -38,7 +38,7 @@ static void test_xdp_adjust_tail_grow(void)
        __u32 duration, retval, size, expect_sz;
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 
@@ -75,7 +75,7 @@ static void test_xdp_adjust_tail_grow2(void)
                .data_size_out  = 0, /* Per test */
        };
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &tattr.prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &tattr.prog_fd);
        if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_attach.c b/tools/testing/selftests/bpf/prog_tests/xdp_attach.c
index 4c4057262cd8db4b457365f254091ee949f26c46..c6fa390e3aa1adbd4721bbb9d469a178324b9c75 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/xdp_attach.c
+++ b/tools/testing/selftests/bpf/prog_tests/xdp_attach.c
@@ -16,7 +16,7 @@ void serial_test_xdp_attach(void)
 
        len = sizeof(info);
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj1, &fd1);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj1, &fd1);
        if (CHECK_FAIL(err))
                return;
        err = bpf_obj_get_info_by_fd(fd1, &info, &len);
@@ -24,7 +24,7 @@ void serial_test_xdp_attach(void)
                goto out_1;
        id1 = info.id;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj2, &fd2);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj2, &fd2);
        if (CHECK_FAIL(err))
                goto out_1;
 
@@ -34,7 +34,7 @@ void serial_test_xdp_attach(void)
                goto out_2;
        id2 = info.id;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj3, &fd3);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj3, &fd3);
        if (CHECK_FAIL(err))
                goto out_2;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_info.c b/tools/testing/selftests/bpf/prog_tests/xdp_info.c
index 4e2a4fd56f675903e8d1d71f2271a37467a1677c..abe48e82e1dcf4c2d8ee5d73f17217454b3ed415 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/xdp_info.c
+++ b/tools/testing/selftests/bpf/prog_tests/xdp_info.c
@@ -29,7 +29,7 @@ void serial_test_xdp_info(void)
 
        /* Setup prog */
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_perf.c b/tools/testing/selftests/bpf/prog_tests/xdp_perf.c
index 7185bee16fe4fbd5f51a8910e3de0d076a02065b..15a3900e4370ae9bc730639b47aaf274003be07f 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/xdp_perf.c
+++ b/tools/testing/selftests/bpf/prog_tests/xdp_perf.c
@@ -9,7 +9,7 @@ void test_xdp_perf(void)
        char in[128], out[128];
        int err, prog_fd;
 
-       err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+       err = bpf_prog_test_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
        if (CHECK_FAIL(err))
                return;
 

diff --git a/tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c b/tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c
index 49a84a3a2306203060fdb3cf0def0fa1177bc1a6..48cd14b437418b4b4a88df77c0846edbe3838299 100644 (file)
--- a/tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c
+++ b/tools/testing/selftests/bpf/progs/fexit_bpf2bpf.c
@@ -73,7 +73,7 @@ int test_subprog2(struct args_subprog2 *ctx)
                              __builtin_preserve_access_index(&skb->len));
 
        ret = ctx->ret;
-       /* bpf_prog_load() loads "test_pkt_access.o" with BPF_F_TEST_RND_HI32
+       /* bpf_prog_test_load() loads "test_pkt_access.o" with BPF_F_TEST_RND_HI32
         * which randomizes upper 32 bits after BPF_ALU32 insns.
         * Hence after 'w0 <<= 1' upper bits of $rax are random.
         * That is expected and correct. Trim them.

diff --git a/tools/testing/selftests/bpf/test_dev_cgroup.c b/tools/testing/selftests/bpf/test_dev_cgroup.c
index 804dddd97d4c5b7a51d85e24a2e6bec11e527149..c299d34526959f2ce00ba9d3ad02a3d2903c6675 100644 (file)
--- a/tools/testing/selftests/bpf/test_dev_cgroup.c
+++ b/tools/testing/selftests/bpf/test_dev_cgroup.c
@@ -14,6 +14,7 @@
 #include <bpf/libbpf.h>
 
 #include "cgroup_helpers.h"
+#include "testing_helpers.h"
 #include "bpf_rlimit.h"
 
 #define DEV_CGROUP_PROG "./dev_cgroup.o"
@@ -27,7 +28,7 @@ int main(int argc, char **argv)
        int prog_fd, cgroup_fd;
        __u32 prog_cnt;
 
-       if (bpf_prog_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE,
+       if (bpf_prog_test_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE,
                          &obj, &prog_fd)) {
                printf("Failed to load DEV_CGROUP program\n");
                goto out;

diff --git a/tools/testing/selftests/bpf/test_lirc_mode2_user.c b/tools/testing/selftests/bpf/test_lirc_mode2_user.c
index fb5fd6841ef3954fba88646d38ed5e7a90a35547..ebf68dce550484294b3544082e489db2c5a1f463 100644 (file)
--- a/tools/testing/selftests/bpf/test_lirc_mode2_user.c
+++ b/tools/testing/selftests/bpf/test_lirc_mode2_user.c
@@ -45,6 +45,8 @@
 #include <bpf/bpf.h>
 #include <bpf/libbpf.h>
 
+#include "testing_helpers.h"
+
 int main(int argc, char **argv)
 {
        struct bpf_object *obj;
@@ -58,8 +60,8 @@ int main(int argc, char **argv)
                return 2;
        }
 
-       ret = bpf_prog_load("test_lirc_mode2_kern.o",
-                           BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd);
+       ret = bpf_prog_test_load("test_lirc_mode2_kern.o",
+                                BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd);
        if (ret) {
                printf("Failed to load bpf program\n");
                return 1;

diff --git a/tools/testing/selftests/bpf/test_maps.c b/tools/testing/selftests/bpf/test_maps.c
index c7a36a9378f8c6d08344d75baebdac6722b9b980..8b31bc1a801db3187633f2ff804a1fe018fb5d29 100644 (file)
--- a/tools/testing/selftests/bpf/test_maps.c
+++ b/tools/testing/selftests/bpf/test_maps.c
@@ -25,6 +25,7 @@
 #include "bpf_util.h"
 #include "bpf_rlimit.h"
 #include "test_maps.h"
+#include "testing_helpers.h"
 
 #ifndef ENOTSUPP
 #define ENOTSUPP 524
@@ -830,21 +831,21 @@ static void test_sockmap(unsigned int tasks, void *data)
        }
 
        /* Load SK_SKB program and Attach */
-       err = bpf_prog_load(SOCKMAP_PARSE_PROG,
+       err = bpf_prog_test_load(SOCKMAP_PARSE_PROG,
                            BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog);
        if (err) {
                printf("Failed to load SK_SKB parse prog\n");
                goto out_sockmap;
        }
 
-       err = bpf_prog_load(SOCKMAP_TCP_MSG_PROG,
+       err = bpf_prog_test_load(SOCKMAP_TCP_MSG_PROG,
                            BPF_PROG_TYPE_SK_MSG, &obj, &msg_prog);
        if (err) {
                printf("Failed to load SK_SKB msg prog\n");
                goto out_sockmap;
        }
 
-       err = bpf_prog_load(SOCKMAP_VERDICT_PROG,
+       err = bpf_prog_test_load(SOCKMAP_VERDICT_PROG,
                            BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog);
        if (err) {
                printf("Failed to load SK_SKB verdict prog\n");

diff --git a/tools/testing/selftests/bpf/test_sysctl.c b/tools/testing/selftests/bpf/test_sysctl.c
index 4a395d7a8ea950a29bccbaba949bf845553d07d8..4f6cf833b52203a47f1940f85544f7dffa056c6a 100644 (file)
--- a/tools/testing/selftests/bpf/test_sysctl.c
+++ b/tools/testing/selftests/bpf/test_sysctl.c
@@ -17,6 +17,7 @@
 #include "bpf_rlimit.h"
 #include "bpf_util.h"
 #include "cgroup_helpers.h"
+#include "testing_helpers.h"
 
 #define CG_PATH                        "/foo"
 #define MAX_INSNS              512

diff --git a/tools/testing/selftests/bpf/test_tcpnotify_user.c b/tools/testing/selftests/bpf/test_tcpnotify_user.c
index 4a39304cc5a62c223714e79af65f131ebb761de6..63111cb082feccf583255779725bfb63a9b20d02 100644 (file)
--- a/tools/testing/selftests/bpf/test_tcpnotify_user.c
+++ b/tools/testing/selftests/bpf/test_tcpnotify_user.c
@@ -25,6 +25,7 @@
 
 #include "test_tcpnotify.h"
 #include "trace_helpers.h"
+#include "testing_helpers.h"
 
 #define SOCKET_BUFFER_SIZE (getpagesize() < 8192L ? getpagesize() : 8192L)
 
@@ -92,7 +93,7 @@ int main(int argc, char **argv)
        if (cg_fd < 0)
                goto err;
 
-       if (bpf_prog_load(file, BPF_PROG_TYPE_SOCK_OPS, &obj, &prog_fd)) {
+       if (bpf_prog_test_load(file, BPF_PROG_TYPE_SOCK_OPS, &obj, &prog_fd)) {
                printf("FAILED: load_bpf_file failed for: %s\n", file);
                goto err;
        }

diff --git a/tools/testing/selftests/bpf/xdping.c b/tools/testing/selftests/bpf/xdping.c
index 30f12637f4e4abd722e3b9fc7b400b24627b2a74..baa870a759a276fd5b7197824fb8fc6cc5547fea 100644 (file)
--- a/tools/testing/selftests/bpf/xdping.c
+++ b/tools/testing/selftests/bpf/xdping.c
@@ -22,6 +22,7 @@
 #include "bpf/libbpf.h"
 
 #include "xdping.h"
+#include "testing_helpers.h"
 
 static int ifindex;
 static __u32 xdp_flags = XDP_FLAGS_UPDATE_IF_NOEXIST;
@@ -173,7 +174,7 @@ int main(int argc, char **argv)
 
        snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
 
-       if (bpf_prog_load(filename, BPF_PROG_TYPE_XDP, &obj, &prog_fd)) {
+       if (bpf_prog_test_load(filename, BPF_PROG_TYPE_XDP, &obj, &prog_fd)) {
                fprintf(stderr, "load of %s failed\n", filename);
                return 1;
        }