selftests/bpf: Add a test for enum64 value relocations

Add a test for enum64 value relocations.
The test will be skipped if clang version is 14 or lower
since enum64 is only supported from version 15.

Acked-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Yonghong Song <yhs@fb.com>
Link: https://lore.kernel.org/r/20220607062718.3726307-1-yhs@fb.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/prog_tests/core_reloc.c b/tools/testing/selftests/bpf/prog_tests/core_reloc.c
index 3712dfe..47c1ef1 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/core_reloc.c
+++ b/tools/testing/selftests/bpf/prog_tests/core_reloc.c
@@ -363,6 +363,25 @@ static int duration = 0;
        .fails = true,                                                  \
 }
 
+#define ENUM64VAL_CASE_COMMON(name)                                    \
+       .case_name = #name,                                             \
+       .bpf_obj_file = "test_core_reloc_enum64val.o",                  \
+       .btf_src_file = "btf__core_reloc_" #name ".o",                  \
+       .raw_tp_name = "sys_enter",                                     \
+       .prog_name = "test_core_enum64val"
+
+#define ENUM64VAL_CASE(name, ...) {                                    \
+       ENUM64VAL_CASE_COMMON(name),                                    \
+       .output = STRUCT_TO_CHAR_PTR(core_reloc_enum64val_output)       \
+                       __VA_ARGS__,                                    \
+       .output_len = sizeof(struct core_reloc_enum64val_output),       \
+}
+
+#define ENUM64VAL_ERR_CASE(name) {                                     \
+       ENUM64VAL_CASE_COMMON(name),                                    \
+       .fails = true,                                                  \
+}
+
 struct core_reloc_test_case;
 
 typedef int (*setup_test_fn)(struct core_reloc_test_case *test);
@@ -831,6 +850,45 @@ static const struct core_reloc_test_case test_cases[] = {
                .anon_val2 = 0x222,
        }),
        ENUMVAL_ERR_CASE(enumval___err_missing),
+
+       /* 64bit enumerator value existence and value relocations */
+       ENUM64VAL_CASE(enum64val, {
+               .unsigned_val1_exists = true,
+               .unsigned_val2_exists = true,
+               .unsigned_val3_exists = true,
+               .signed_val1_exists = true,
+               .signed_val2_exists = true,
+               .signed_val3_exists = true,
+               .unsigned_val1 = 0x1ffffffffULL,
+               .unsigned_val2 = 0x2,
+               .signed_val1 = 0x1ffffffffLL,
+               .signed_val2 = -2,
+       }),
+       ENUM64VAL_CASE(enum64val___diff, {
+               .unsigned_val1_exists = true,
+               .unsigned_val2_exists = true,
+               .unsigned_val3_exists = true,
+               .signed_val1_exists = true,
+               .signed_val2_exists = true,
+               .signed_val3_exists = true,
+               .unsigned_val1 = 0x101ffffffffULL,
+               .unsigned_val2 = 0x202ffffffffULL,
+               .signed_val1 = -101,
+               .signed_val2 = -202,
+       }),
+       ENUM64VAL_CASE(enum64val___val3_missing, {
+               .unsigned_val1_exists = true,
+               .unsigned_val2_exists = true,
+               .unsigned_val3_exists = false,
+               .signed_val1_exists = true,
+               .signed_val2_exists = true,
+               .signed_val3_exists = false,
+               .unsigned_val1 = 0x111ffffffffULL,
+               .unsigned_val2 = 0x222,
+               .signed_val1 = 0x111ffffffffLL,
+               .signed_val2 = -222,
+       }),
+       ENUM64VAL_ERR_CASE(enum64val___err_missing),
 };
 
 struct data {

diff --git a/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val.c b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val.c
new file mode 100644 (file)
index 0000000..888e79d
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val.c
@@ -0,0 +1,3 @@
+#include "core_reloc_types.h"
+
+void f(struct core_reloc_enum64val x) {}

diff --git a/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___diff.c b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___diff.c
new file mode 100644 (file)
index 0000000..1947491
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___diff.c
@@ -0,0 +1,3 @@
+#include "core_reloc_types.h"
+
+void f(struct core_reloc_enum64val___diff x) {}

diff --git a/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___err_missing.c b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___err_missing.c
new file mode 100644 (file)
index 0000000..3d732d4
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___err_missing.c
@@ -0,0 +1,3 @@
+#include "core_reloc_types.h"
+
+void f(struct core_reloc_enum64val___err_missing x) {}

diff --git a/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___val3_missing.c b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___val3_missing.c
new file mode 100644 (file)
index 0000000..17cf5d6
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/btf__core_reloc_enum64val___val3_missing.c
@@ -0,0 +1,3 @@
+#include "core_reloc_types.h"
+
+void f(struct core_reloc_enum64val___val3_missing x) {}

diff --git a/tools/testing/selftests/bpf/progs/core_reloc_types.h b/tools/testing/selftests/bpf/progs/core_reloc_types.h
index f9dc976..26e1033 100644 (file)
--- a/tools/testing/selftests/bpf/progs/core_reloc_types.h
+++ b/tools/testing/selftests/bpf/progs/core_reloc_types.h
@@ -1117,6 +1117,20 @@ struct core_reloc_enumval_output {
        int anon_val2;
 };
 
+struct core_reloc_enum64val_output {
+       bool unsigned_val1_exists;
+       bool unsigned_val2_exists;
+       bool unsigned_val3_exists;
+       bool signed_val1_exists;
+       bool signed_val2_exists;
+       bool signed_val3_exists;
+
+       long unsigned_val1;
+       long unsigned_val2;
+       long signed_val1;
+       long signed_val2;
+};
+
 enum named_enum {
        NAMED_ENUM_VAL1 = 1,
        NAMED_ENUM_VAL2 = 2,
@@ -1134,6 +1148,23 @@ struct core_reloc_enumval {
        anon_enum f2;
 };
 
+enum named_unsigned_enum64 {
+       UNSIGNED_ENUM64_VAL1 = 0x1ffffffffULL,
+       UNSIGNED_ENUM64_VAL2 = 0x2,
+       UNSIGNED_ENUM64_VAL3 = 0x3ffffffffULL,
+};
+
+enum named_signed_enum64 {
+       SIGNED_ENUM64_VAL1 = 0x1ffffffffLL,
+       SIGNED_ENUM64_VAL2 = -2,
+       SIGNED_ENUM64_VAL3 = 0x3ffffffffLL,
+};
+
+struct core_reloc_enum64val {
+       enum named_unsigned_enum64 f1;
+       enum named_signed_enum64 f2;
+};
+
 /* differing enumerator values */
 enum named_enum___diff {
        NAMED_ENUM_VAL1___diff = 101,
@@ -1152,6 +1183,23 @@ struct core_reloc_enumval___diff {
        anon_enum___diff f2;
 };
 
+enum named_unsigned_enum64___diff {
+       UNSIGNED_ENUM64_VAL1___diff = 0x101ffffffffULL,
+       UNSIGNED_ENUM64_VAL2___diff = 0x202ffffffffULL,
+       UNSIGNED_ENUM64_VAL3___diff = 0x303ffffffffULL,
+};
+
+enum named_signed_enum64___diff {
+       SIGNED_ENUM64_VAL1___diff = -101,
+       SIGNED_ENUM64_VAL2___diff = -202,
+       SIGNED_ENUM64_VAL3___diff = -303,
+};
+
+struct core_reloc_enum64val___diff {
+       enum named_unsigned_enum64___diff f1;
+       enum named_signed_enum64___diff f2;
+};
+
 /* missing (optional) third enum value */
 enum named_enum___val3_missing {
        NAMED_ENUM_VAL1___val3_missing = 111,
@@ -1168,6 +1216,21 @@ struct core_reloc_enumval___val3_missing {
        anon_enum___val3_missing f2;
 };
 
+enum named_unsigned_enum64___val3_missing {
+       UNSIGNED_ENUM64_VAL1___val3_missing = 0x111ffffffffULL,
+       UNSIGNED_ENUM64_VAL2___val3_missing = 0x222,
+};
+
+enum named_signed_enum64___val3_missing {
+       SIGNED_ENUM64_VAL1___val3_missing = 0x111ffffffffLL,
+       SIGNED_ENUM64_VAL2___val3_missing = -222,
+};
+
+struct core_reloc_enum64val___val3_missing {
+       enum named_unsigned_enum64___val3_missing f1;
+       enum named_signed_enum64___val3_missing f2;
+};
+
 /* missing (mandatory) second enum value, should fail */
 enum named_enum___err_missing {
        NAMED_ENUM_VAL1___err_missing = 1,
@@ -1183,3 +1246,18 @@ struct core_reloc_enumval___err_missing {
        enum named_enum___err_missing f1;
        anon_enum___err_missing f2;
 };
+
+enum named_unsigned_enum64___err_missing {
+       UNSIGNED_ENUM64_VAL1___err_missing = 0x1ffffffffULL,
+       UNSIGNED_ENUM64_VAL3___err_missing = 0x3ffffffffULL,
+};
+
+enum named_signed_enum64___err_missing {
+       SIGNED_ENUM64_VAL1___err_missing = 0x1ffffffffLL,
+       SIGNED_ENUM64_VAL3___err_missing = -3,
+};
+
+struct core_reloc_enum64val___err_missing {
+       enum named_unsigned_enum64___err_missing f1;
+       enum named_signed_enum64___err_missing f2;
+};

diff --git a/tools/testing/selftests/bpf/progs/test_core_reloc_enum64val.c b/tools/testing/selftests/bpf/progs/test_core_reloc_enum64val.c
new file mode 100644 (file)
index 0000000..63147fb
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/test_core_reloc_enum64val.c
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
+
+#include <linux/bpf.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_core_read.h>
+
+char _license[] SEC("license") = "GPL";
+
+struct {
+       char in[256];
+       char out[256];
+       bool skip;
+} data = {};
+
+enum named_unsigned_enum64 {
+       UNSIGNED_ENUM64_VAL1 = 0x1ffffffffULL,
+       UNSIGNED_ENUM64_VAL2 = 0x2ffffffffULL,
+       UNSIGNED_ENUM64_VAL3 = 0x3ffffffffULL,
+};
+
+enum named_signed_enum64 {
+       SIGNED_ENUM64_VAL1 = 0x1ffffffffLL,
+       SIGNED_ENUM64_VAL2 = -2,
+       SIGNED_ENUM64_VAL3 = 0x3ffffffffLL,
+};
+
+struct core_reloc_enum64val_output {
+       bool unsigned_val1_exists;
+       bool unsigned_val2_exists;
+       bool unsigned_val3_exists;
+       bool signed_val1_exists;
+       bool signed_val2_exists;
+       bool signed_val3_exists;
+
+       long unsigned_val1;
+       long unsigned_val2;
+       long signed_val1;
+       long signed_val2;
+};
+
+SEC("raw_tracepoint/sys_enter")
+int test_core_enum64val(void *ctx)
+{
+#if __clang_major__ >= 15
+       struct core_reloc_enum64val_output *out = (void *)&data.out;
+       enum named_unsigned_enum64 named_unsigned = 0;
+       enum named_signed_enum64 named_signed = 0;
+
+       out->unsigned_val1_exists = bpf_core_enum_value_exists(named_unsigned, UNSIGNED_ENUM64_VAL1);
+       out->unsigned_val2_exists = bpf_core_enum_value_exists(enum named_unsigned_enum64, UNSIGNED_ENUM64_VAL2);
+       out->unsigned_val3_exists = bpf_core_enum_value_exists(enum named_unsigned_enum64, UNSIGNED_ENUM64_VAL3);
+       out->signed_val1_exists = bpf_core_enum_value_exists(named_signed, SIGNED_ENUM64_VAL1);
+       out->signed_val2_exists = bpf_core_enum_value_exists(enum named_signed_enum64, SIGNED_ENUM64_VAL2);
+       out->signed_val3_exists = bpf_core_enum_value_exists(enum named_signed_enum64, SIGNED_ENUM64_VAL3);
+
+       out->unsigned_val1 = bpf_core_enum_value(named_unsigned, UNSIGNED_ENUM64_VAL1);
+       out->unsigned_val2 = bpf_core_enum_value(named_unsigned, UNSIGNED_ENUM64_VAL2);
+       out->signed_val1 = bpf_core_enum_value(named_signed, SIGNED_ENUM64_VAL1);
+       out->signed_val2 = bpf_core_enum_value(named_signed, SIGNED_ENUM64_VAL2);
+       /* NAMED_ENUM64_VAL3 value is optional */
+
+#else
+       data.skip = true;
+#endif
+
+       return 0;
+}