selftests/bpf: Cover tracing implicit kfunc args

KF_IMPLICIT_ARGS kfuncs have a BPF-call prototype and a real kernel
target prototype. Add a tracing selftest that attaches fentry and fexit
programs to bpf_kfunc_implicit_arg(), runs a syscall BPF program that
calls it, and checks that the tracing context exposes both the explicit
argument and the implicit prog aux pointer.

Co-developed-by: Ihor Solodrai <ihor.solodrai@linux.dev>
Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: Ihor Solodrai <ihor.solodrai@linux.dev>
Link: https://patch.msgid.link/20260713235223.1639022-3-ihor.solodrai@linux.dev
Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>

diff --git a/tools/testing/selftests/bpf/prog_tests/kfunc_implicit_args_tracing.c b/tools/testing/selftests/bpf/prog_tests/kfunc_implicit_args_tracing.c
new file mode 100644 (file)
index 0000000..61cc5aa
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/kfunc_implicit_args_tracing.c
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
+
+#include <test_progs.h>
+#include "kfunc_implicit_args_tracing.skel.h"
+
+void test_kfunc_implicit_args_tracing(void)
+{
+       struct kfunc_implicit_args_tracing *skel;
+       LIBBPF_OPTS(bpf_test_run_opts, topts);
+       int err, fd;
+
+       skel = kfunc_implicit_args_tracing__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "open_and_load"))
+               return;
+
+       err = kfunc_implicit_args_tracing__attach(skel);
+       if (!ASSERT_OK(err, "attach"))
+               goto cleanup;
+
+       fd = bpf_program__fd(skel->progs.trigger_implicit_arg);
+       err = bpf_prog_test_run_opts(fd, &topts);
+       if (!ASSERT_OK(err, "test_run"))
+               goto cleanup;
+
+       ASSERT_EQ(topts.retval, 5, "kfunc_retval");
+       ASSERT_EQ(skel->bss->fentry_arg_cnt, 2, "fentry_arg_cnt");
+       ASSERT_NEQ(skel->bss->fentry_aux_arg, 0, "fentry_aux_arg");
+       ASSERT_EQ(skel->bss->fentry_result, 1, "fentry_result");
+       ASSERT_EQ(skel->bss->fexit_arg_cnt, 2, "fexit_arg_cnt");
+       ASSERT_NEQ(skel->bss->fexit_aux_arg, 0, "fexit_aux_arg");
+       ASSERT_EQ(skel->bss->fexit_result, 1, "fexit_result");
+
+cleanup:
+       kfunc_implicit_args_tracing__destroy(skel);
+}

diff --git a/tools/testing/selftests/bpf/progs/kfunc_implicit_args_tracing.c b/tools/testing/selftests/bpf/progs/kfunc_implicit_args_tracing.c
new file mode 100644 (file)
index 0000000..995f8b8
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/kfunc_implicit_args_tracing.c
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
+
+#include <vmlinux.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+#include <errno.h>
+
+extern int bpf_kfunc_implicit_arg(int a) __weak __ksym;
+
+char _license[] SEC("license") = "GPL";
+
+/* Shared arg checks; reports arg count and aux, returns 1 on success. */
+static __always_inline __u64
+check_implicit_args(void *ctx, __u64 *arg_cnt, __u64 *aux_arg)
+{
+       __u64 a = 0, aux = 0, z = 0;
+       __u64 result;
+       __s64 err;
+
+       *arg_cnt = bpf_get_func_arg_cnt(ctx);
+       result = *arg_cnt == 2;
+
+       err = bpf_get_func_arg(ctx, 0, &a);
+       result &= err == 0 && (int)a == 5;
+
+       err = bpf_get_func_arg(ctx, 1, &aux);
+       *aux_arg = aux;
+       result &= err == 0 && aux != 0;
+
+       err = bpf_get_func_arg(ctx, 2, &z);
+       result &= err == -EINVAL;
+
+       return result;
+}
+
+__u64 fentry_result;
+__u64 fentry_arg_cnt;
+__u64 fentry_aux_arg;
+
+SEC("fentry/bpf_kfunc_implicit_arg")
+int BPF_PROG(trace_implicit_arg_fentry)
+{
+       __u64 ret = 0;
+       __s64 err;
+
+       fentry_result = check_implicit_args(ctx, &fentry_arg_cnt, &fentry_aux_arg);
+
+       err = bpf_get_func_ret(ctx, &ret);
+       fentry_result &= err == -EOPNOTSUPP;
+
+       return 0;
+}
+
+__u64 fexit_result;
+__u64 fexit_arg_cnt;
+__u64 fexit_aux_arg;
+
+SEC("fexit/bpf_kfunc_implicit_arg")
+int BPF_PROG(trace_implicit_arg_fexit)
+{
+       __u64 ret = 0;
+       __s64 err;
+
+       fexit_result = check_implicit_args(ctx, &fexit_arg_cnt, &fexit_aux_arg);
+
+       err = bpf_get_func_ret(ctx, &ret);
+       fexit_result &= err == 0 && ret == 5;
+
+       return 0;
+}
+
+SEC("syscall")
+int trigger_implicit_arg(void *ctx)
+{
+       return bpf_kfunc_implicit_arg(5);
+}