selftests: bpf: enable hi32 randomization for all tests

The previous libbpf patch allows user to specify "prog_flags" to bpf
program load APIs. To enable high 32-bit randomization for a test, we need
to set BPF_F_TEST_RND_HI32 in "prog_flags".

To enable such randomization for all tests, we need to make sure all places
are passing BPF_F_TEST_RND_HI32. Changing them one by one is not
convenient, also, it would be better if a test could be switched to
"normal" running mode without code change.

Given the program load APIs used across bpf selftests are mostly:
  bpf_prog_load:      load from file
  bpf_load_program:   load from raw insns

A test_stub.c is implemented for bpf seltests, it offers two functions for
testing purpose:

  bpf_prog_test_load
  bpf_test_load_program

The are the same as "bpf_prog_load" and "bpf_load_program", except they
also set BPF_F_TEST_RND_HI32. Given *_xattr functions are the APIs to
customize any "prog_flags", it makes little sense to put these two
functions into libbpf.

Then, the following CFLAGS are passed to compilations for host programs:
  -Dbpf_prog_load=bpf_prog_test_load
  -Dbpf_load_program=bpf_test_load_program

They migrate the used load APIs to the test version, hence enable high
32-bit randomization for these tests without changing source code.

Besides all these, there are several testcases are using
"bpf_prog_load_attr" directly, their call sites are updated to pass
BPF_F_TEST_RND_HI32.

Signed-off-by: Jiong Wang <jiong.wang@netronome.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index cd23758e8b7a70d9ddf6919582cb23be95c47fa2..fa002da36d0d07167f5d90efe141f3f635cc3b9a 100644 (file)
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -15,7 +15,9 @@ LLC           ?= llc
 LLVM_OBJCOPY   ?= llvm-objcopy
 LLVM_READELF   ?= llvm-readelf
 BTF_PAHOLE     ?= pahole
-CFLAGS += -Wall -O2 -I$(APIDIR) -I$(LIBDIR) -I$(BPFDIR) -I$(GENDIR) $(GENFLAGS) -I../../../include
+CFLAGS += -Wall -O2 -I$(APIDIR) -I$(LIBDIR) -I$(BPFDIR) -I$(GENDIR) $(GENFLAGS) -I../../../include \
+         -Dbpf_prog_load=bpf_prog_test_load \
+         -Dbpf_load_program=bpf_test_load_program
 LDLIBS += -lcap -lelf -lrt -lpthread
 
 # Order correspond to 'make run_tests' order
@@ -79,9 +81,9 @@ $(OUTPUT)/test_maps: map_tests/*.c
 
 BPFOBJ := $(OUTPUT)/libbpf.a
 
-$(TEST_GEN_PROGS): $(BPFOBJ)
+$(TEST_GEN_PROGS): test_stub.o $(BPFOBJ)
 
-$(TEST_GEN_PROGS_EXTENDED): $(OUTPUT)/libbpf.a
+$(TEST_GEN_PROGS_EXTENDED): test_stub.o $(OUTPUT)/libbpf.a
 
 $(OUTPUT)/test_dev_cgroup: cgroup_helpers.c
 $(OUTPUT)/test_skb_cgroup_id_user: cgroup_helpers.c
@@ -177,7 +179,7 @@ $(ALU32_BUILD_DIR)/test_progs_32: test_progs.c $(OUTPUT)/libbpf.a\
                                                $(ALU32_BUILD_DIR)/urandom_read
        $(CC) $(TEST_PROGS_CFLAGS) $(CFLAGS) \
                -o $(ALU32_BUILD_DIR)/test_progs_32 \
-               test_progs.c trace_helpers.c prog_tests/*.c \
+               test_progs.c test_stub.c trace_helpers.c prog_tests/*.c \
                $(OUTPUT)/libbpf.a $(LDLIBS)
 
 $(ALU32_BUILD_DIR)/test_progs_32: $(PROG_TESTS_H)

diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c b/tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
index ce03289c907754bf061fd6074e3610280d72d3ff..c0091137074be3efad3c499ea579d6480e384f7f 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
+++ b/tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
@@ -22,6 +22,7 @@ static int check_load(const char *file, enum bpf_prog_type type)
        attr.file = file;
        attr.prog_type = type;
        attr.log_level = 4;
+       attr.prog_flags = BPF_F_TEST_RND_HI32;
        err = bpf_prog_load_xattr(&attr, &obj, &prog_fd);
        bpf_object__close(obj);
        if (err)

diff --git a/tools/testing/selftests/bpf/test_sock_addr.c b/tools/testing/selftests/bpf/test_sock_addr.c
index 3f110eaaf29cea214844ff98211697c764b8a870..5d0c4f0baeffcf1c85c68c02a7fa69bb5a928694 100644 (file)
--- a/tools/testing/selftests/bpf/test_sock_addr.c
+++ b/tools/testing/selftests/bpf/test_sock_addr.c
@@ -745,6 +745,7 @@ static int load_path(const struct sock_addr_test *test, const char *path)
        attr.file = path;
        attr.prog_type = BPF_PROG_TYPE_CGROUP_SOCK_ADDR;
        attr.expected_attach_type = test->expected_attach_type;
+       attr.prog_flags = BPF_F_TEST_RND_HI32;
 
        if (bpf_prog_load_xattr(&attr, &obj, &prog_fd)) {
                if (test->expected_result != LOAD_REJECT)

diff --git a/tools/testing/selftests/bpf/test_sock_fields.c b/tools/testing/selftests/bpf/test_sock_fields.c
index e089477fa0a3ec98cdf29450f8d133fe7b492933..f0fc103261a40f52004d8df5bfa7dbbeca44191e 100644 (file)
--- a/tools/testing/selftests/bpf/test_sock_fields.c
+++ b/tools/testing/selftests/bpf/test_sock_fields.c
@@ -414,6 +414,7 @@ int main(int argc, char **argv)
        struct bpf_prog_load_attr attr = {
                .file = "test_sock_fields_kern.o",
                .prog_type = BPF_PROG_TYPE_CGROUP_SKB,
+               .prog_flags = BPF_F_TEST_RND_HI32,
        };
        int cgroup_fd, egress_fd, ingress_fd, err;
        struct bpf_program *ingress_prog;

diff --git a/tools/testing/selftests/bpf/test_socket_cookie.c b/tools/testing/selftests/bpf/test_socket_cookie.c
index e51d63786ff832ed9bb4b1647a98c2c80b9edf63..cac8ee57a013071de6a3c70df5b662e5f62e5422 100644 (file)
--- a/tools/testing/selftests/bpf/test_socket_cookie.c
+++ b/tools/testing/selftests/bpf/test_socket_cookie.c
@@ -148,6 +148,7 @@ static int run_test(int cgfd)
        memset(&attr, 0, sizeof(attr));
        attr.file = SOCKET_COOKIE_PROG;
        attr.prog_type = BPF_PROG_TYPE_UNSPEC;
+       attr.prog_flags = BPF_F_TEST_RND_HI32;
 
        err = bpf_prog_load_xattr(&attr, &pobj, &prog_fd);
        if (err) {

diff --git a/tools/testing/selftests/bpf/test_stub.c b/tools/testing/selftests/bpf/test_stub.c
new file mode 100644 (file)
index 0000000..84e81a8
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_stub.c
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2019 Netronome Systems, Inc. */
+
+#include <bpf/bpf.h>
+#include <bpf/libbpf.h>
+#include <string.h>
+
+int bpf_prog_test_load(const char *file, enum bpf_prog_type type,
+                      struct bpf_object **pobj, int *prog_fd)
+{
+       struct bpf_prog_load_attr attr;
+
+       memset(&attr, 0, sizeof(struct bpf_prog_load_attr));
+       attr.file = file;
+       attr.prog_type = type;
+       attr.expected_attach_type = 0;
+       attr.prog_flags = BPF_F_TEST_RND_HI32;
+
+       return bpf_prog_load_xattr(&attr, pobj, prog_fd);
+}
+
+int bpf_test_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
+                         size_t insns_cnt, const char *license,
+                         __u32 kern_version, char *log_buf,
+                    size_t log_buf_sz)
+{
+       struct bpf_load_program_attr load_attr;
+
+       memset(&load_attr, 0, sizeof(struct bpf_load_program_attr));
+       load_attr.prog_type = type;
+       load_attr.expected_attach_type = 0;
+       load_attr.name = NULL;
+       load_attr.insns = insns;
+       load_attr.insns_cnt = insns_cnt;
+       load_attr.license = license;
+       load_attr.kern_version = kern_version;
+       load_attr.prog_flags = BPF_F_TEST_RND_HI32;
+
+       return bpf_load_program_xattr(&load_attr, log_buf, log_buf_sz);
+}

diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index fa9b5bfe5d9f3f6becb260a11212cc23de2c4518..cd0248c54e251debcd371eba31ec23a6099b1f6d 100644 (file)
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -882,7 +882,7 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
        if (fixup_skips != skips)
                return;
 
-       pflags = 0;
+       pflags = BPF_F_TEST_RND_HI32;
        if (test->flags & F_LOAD_WITH_STRICT_ALIGNMENT)
                pflags |= BPF_F_STRICT_ALIGNMENT;
        if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)