selftests/bpf: Add libbpf's log fixup logic selftests

Add tests validating that libbpf is indeed patching up BPF verifier log
with CO-RE relocation details. Also test partial and full truncation
scenarios.

This test might be a bit fragile due to changing BPF verifier log
format. If that proves to be frequently breaking, we can simplify tests
or remove the truncation subtests. But for now it seems useful to test
it in those conditions that are otherwise rarely occuring in practice.

Also test CO-RE relo failure in a subprog as that excercises subprogram CO-RE
relocation mapping logic which doesn't work out of the box without extra
relo storage previously done only for gen_loader case.

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220426004511.2691730-11-andrii@kernel.org

diff --git a/tools/testing/selftests/bpf/prog_tests/log_fixup.c b/tools/testing/selftests/bpf/prog_tests/log_fixup.c
new file mode 100644 (file)
index 0000000..be3a956
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/log_fixup.c
@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
+#include <test_progs.h>
+#include <bpf/btf.h>
+
+#include "test_log_fixup.skel.h"
+
+enum trunc_type {
+       TRUNC_NONE,
+       TRUNC_PARTIAL,
+       TRUNC_FULL,
+};
+
+static void bad_core_relo(size_t log_buf_size, enum trunc_type trunc_type)
+{
+       char log_buf[8 * 1024];
+       struct test_log_fixup* skel;
+       int err;
+
+       skel = test_log_fixup__open();
+       if (!ASSERT_OK_PTR(skel, "skel_open"))
+               return;
+
+       bpf_program__set_autoload(skel->progs.bad_relo, true);
+       memset(log_buf, 0, sizeof(log_buf));
+       bpf_program__set_log_buf(skel->progs.bad_relo, log_buf, log_buf_size ?: sizeof(log_buf));
+
+       err = test_log_fixup__load(skel);
+       if (!ASSERT_ERR(err, "load_fail"))
+               goto cleanup;
+
+       ASSERT_HAS_SUBSTR(log_buf,
+                         "0: <invalid CO-RE relocation>\n"
+                         "failed to resolve CO-RE relocation <byte_sz> ",
+                         "log_buf_part1");
+
+       switch (trunc_type) {
+       case TRUNC_NONE:
+               ASSERT_HAS_SUBSTR(log_buf,
+                                 "struct task_struct___bad.fake_field (0:1 @ offset 4)\n",
+                                 "log_buf_part2");
+               ASSERT_HAS_SUBSTR(log_buf,
+                                 "max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0\n",
+                                 "log_buf_end");
+               break;
+       case TRUNC_PARTIAL:
+               /* we should get full libbpf message patch */
+               ASSERT_HAS_SUBSTR(log_buf,
+                                 "struct task_struct___bad.fake_field (0:1 @ offset 4)\n",
+                                 "log_buf_part2");
+               /* we shouldn't get full end of BPF verifier log */
+               ASSERT_NULL(strstr(log_buf, "max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0\n"),
+                           "log_buf_end");
+               break;
+       case TRUNC_FULL:
+               /* we shouldn't get second part of libbpf message patch */
+               ASSERT_NULL(strstr(log_buf, "struct task_struct___bad.fake_field (0:1 @ offset 4)\n"),
+                           "log_buf_part2");
+               /* we shouldn't get full end of BPF verifier log */
+               ASSERT_NULL(strstr(log_buf, "max_states_per_insn 0 total_states 0 peak_states 0 mark_read 0\n"),
+                           "log_buf_end");
+               break;
+       }
+
+       if (env.verbosity > VERBOSE_NONE)
+               printf("LOG:   \n=================\n%s=================\n", log_buf);
+cleanup:
+       test_log_fixup__destroy(skel);
+}
+
+static void bad_core_relo_subprog(void)
+{
+       char log_buf[8 * 1024];
+       struct test_log_fixup* skel;
+       int err;
+
+       skel = test_log_fixup__open();
+       if (!ASSERT_OK_PTR(skel, "skel_open"))
+               return;
+
+       bpf_program__set_autoload(skel->progs.bad_relo_subprog, true);
+       bpf_program__set_log_buf(skel->progs.bad_relo_subprog, log_buf, sizeof(log_buf));
+
+       err = test_log_fixup__load(skel);
+       if (!ASSERT_ERR(err, "load_fail"))
+               goto cleanup;
+
+       /* there should be no prog loading log because we specified per-prog log buf */
+       ASSERT_HAS_SUBSTR(log_buf,
+                         ": <invalid CO-RE relocation>\n"
+                         "failed to resolve CO-RE relocation <byte_off> ",
+                         "log_buf");
+       ASSERT_HAS_SUBSTR(log_buf,
+                         "struct task_struct___bad.fake_field_subprog (0:2 @ offset 8)\n",
+                         "log_buf");
+
+       if (env.verbosity > VERBOSE_NONE)
+               printf("LOG:   \n=================\n%s=================\n", log_buf);
+
+cleanup:
+       test_log_fixup__destroy(skel);
+}
+
+void test_log_fixup(void)
+{
+       if (test__start_subtest("bad_core_relo_trunc_none"))
+               bad_core_relo(0, TRUNC_NONE /* full buf */);
+       if (test__start_subtest("bad_core_relo_trunc_partial"))
+               bad_core_relo(300, TRUNC_PARTIAL /* truncate original log a bit */);
+       if (test__start_subtest("bad_core_relo_trunc_full"))
+               bad_core_relo(250, TRUNC_FULL  /* truncate also libbpf's message patch */);
+       if (test__start_subtest("bad_core_relo_subprog"))
+               bad_core_relo_subprog();
+}

diff --git a/tools/testing/selftests/bpf/progs/test_log_fixup.c b/tools/testing/selftests/bpf/progs/test_log_fixup.c
new file mode 100644 (file)
index 0000000..a78980d
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/test_log_fixup.c
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
+
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_core_read.h>
+
+struct task_struct___bad {
+       int pid;
+       int fake_field;
+       void *fake_field_subprog;
+} __attribute__((preserve_access_index));
+
+SEC("?raw_tp/sys_enter")
+int bad_relo(const void *ctx)
+{
+       static struct task_struct___bad *t;
+
+       return bpf_core_field_size(t->fake_field);
+}
+
+static __noinline int bad_subprog(void)
+{
+       static struct task_struct___bad *t;
+
+       /* ugliness below is a field offset relocation */
+       return (void *)&t->fake_field_subprog - (void *)t;
+}
+
+SEC("?raw_tp/sys_enter")
+int bad_relo_subprog(const void *ctx)
+{
+       static struct task_struct___bad *t;
+
+       return bad_subprog() + bpf_core_field_size(t->pid);
+}
+
+char _license[] SEC("license") = "GPL";

diff --git a/tools/testing/selftests/bpf/test_progs.h b/tools/testing/selftests/bpf/test_progs.h
index 0a102ce460d616c1d1945cabb374dc1f211fdd2b..d3fee3b98888093c0873d8270dc26f3b7adc75a1 100644 (file)
--- a/tools/testing/selftests/bpf/test_progs.h
+++ b/tools/testing/selftests/bpf/test_progs.h
@@ -292,6 +292,17 @@ int test__join_cgroup(const char *path);
        ___ok;                                                          \
 })
 
+#define ASSERT_HAS_SUBSTR(str, substr, name) ({                                \
+       static int duration = 0;                                        \
+       const char *___str = str;                                       \
+       const char *___substr = substr;                                 \
+       bool ___ok = strstr(___str, ___substr) != NULL;                 \
+       CHECK(!___ok, (name),                                           \
+             "unexpected %s: '%s' is not a substring of '%s'\n",       \
+             (name), ___substr, ___str);                               \
+       ___ok;                                                          \
+})
+
 #define ASSERT_OK(res, name) ({                                                \
        static int duration = 0;                                        \
        long long ___res = (res);                                       \