selftests/bpf: Add a test for bpf_cgroup_from_id lookup in non-root cgns

Make sure that we only switch the cgroup namespace and enter a new
cgroup in a child process separate from test_progs, to not mess up the
environment for subsequent tests.

To remove this cgroup, we need to wait for the child to exit, and then
rmdir its cgroup. If the read call fails, or waitpid succeeds, we know
the child exited (read call would fail when the last pipe end is closed,
otherwise waitpid waits until exit(2) is called). We then invoke a newly
introduced remove_cgroup_pid() helper, that identifies cgroup path using
the passed in pid of the now dead child, instead of using the current
process pid (getpid()).

Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Link: https://lore.kernel.org/r/20250915032618.1551762-3-memxor@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/tools/testing/selftests/bpf/cgroup_helpers.c b/tools/testing/selftests/bpf/cgroup_helpers.c
index 15f6260..20cede4 100644 (file)
--- a/tools/testing/selftests/bpf/cgroup_helpers.c
+++ b/tools/testing/selftests/bpf/cgroup_helpers.c
@@ -412,6 +412,26 @@ void remove_cgroup(const char *relative_path)
                log_err("rmdiring cgroup %s .. %s", relative_path, cgroup_path);
 }
 
+/*
+ * remove_cgroup_pid() - Remove a cgroup setup by process identified by PID
+ * @relative_path: The cgroup path, relative to the workdir, to remove
+ * @pid: PID to be used to find cgroup_path
+ *
+ * This function expects a cgroup to already be created, relative to the cgroup
+ * work dir. It also expects the cgroup doesn't have any children or live
+ * processes and it removes the cgroup.
+ *
+ * On failure, it will print an error to stderr.
+ */
+void remove_cgroup_pid(const char *relative_path, int pid)
+{
+       char cgroup_path[PATH_MAX + 1];
+
+       format_cgroup_path_pid(cgroup_path, relative_path, pid);
+       if (rmdir(cgroup_path))
+               log_err("rmdiring cgroup %s .. %s", relative_path, cgroup_path);
+}
+
 /**
  * create_and_get_cgroup() - Create a cgroup, relative to workdir, and get the FD
  * @relative_path: The cgroup path, relative to the workdir, to join

diff --git a/tools/testing/selftests/bpf/cgroup_helpers.h b/tools/testing/selftests/bpf/cgroup_helpers.h
index 182e1ac..3857304 100644 (file)
--- a/tools/testing/selftests/bpf/cgroup_helpers.h
+++ b/tools/testing/selftests/bpf/cgroup_helpers.h
@@ -19,6 +19,7 @@ int cgroup_setup_and_join(const char *relative_path);
 int get_root_cgroup(void);
 int create_and_get_cgroup(const char *relative_path);
 void remove_cgroup(const char *relative_path);
+void remove_cgroup_pid(const char *relative_path, int pid);
 unsigned long long get_cgroup_id(const char *relative_path);
 int get_cgroup1_hierarchy_id(const char *subsys_name);
 

diff --git a/tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c b/tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c
index adda85f..4b42fbc 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c
+++ b/tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c
@@ -4,6 +4,8 @@
 #define _GNU_SOURCE
 #include <cgroup_helpers.h>
 #include <test_progs.h>
+#include <sched.h>
+#include <sys/wait.h>
 
 #include "cgrp_kfunc_failure.skel.h"
 #include "cgrp_kfunc_success.skel.h"
@@ -87,6 +89,72 @@ static const char * const success_tests[] = {
        "test_cgrp_from_id",
 };
 
+static void test_cgrp_from_id_ns(void)
+{
+       LIBBPF_OPTS(bpf_test_run_opts, opts);
+       struct cgrp_kfunc_success *skel;
+       struct bpf_program *prog;
+       int pid, pipe_fd[2];
+
+       skel = open_load_cgrp_kfunc_skel();
+       if (!ASSERT_OK_PTR(skel, "open_load_skel"))
+               return;
+
+       if (!ASSERT_OK(skel->bss->err, "pre_mkdir_err"))
+               goto cleanup;
+
+       prog = skel->progs.test_cgrp_from_id_ns;
+
+       if (!ASSERT_OK(pipe(pipe_fd), "pipe"))
+               goto cleanup;
+
+       pid = fork();
+       if (!ASSERT_GE(pid, 0, "fork result")) {
+               close(pipe_fd[0]);
+               close(pipe_fd[1]);
+               goto cleanup;
+       }
+
+       if (pid == 0) {
+               int ret = 0;
+
+               close(pipe_fd[0]);
+
+               if (!ASSERT_GE(cgroup_setup_and_join("cgrp_from_id_ns"), 0, "join cgroup"))
+                       exit(1);
+
+               if (!ASSERT_OK(unshare(CLONE_NEWCGROUP), "unshare cgns"))
+                       exit(1);
+
+               ret = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);
+               if (!ASSERT_OK(ret, "test run ret"))
+                       exit(1);
+
+               if (!ASSERT_OK(opts.retval, "test run retval"))
+                       exit(1);
+
+               if (!ASSERT_EQ(write(pipe_fd[1], &ret, sizeof(ret)), sizeof(ret), "write pipe"))
+                       exit(1);
+
+               exit(0);
+       } else {
+               int res;
+
+               close(pipe_fd[1]);
+
+               ASSERT_EQ(read(pipe_fd[0], &res, sizeof(res)), sizeof(res), "read res");
+               ASSERT_EQ(waitpid(pid, NULL, 0), pid, "wait on child");
+
+               remove_cgroup_pid("cgrp_from_id_ns", pid);
+
+               ASSERT_OK(res, "result from run");
+       }
+
+       close(pipe_fd[0]);
+cleanup:
+       cgrp_kfunc_success__destroy(skel);
+}
+
 void test_cgrp_kfunc(void)
 {
        int i, err;
@@ -102,6 +170,9 @@ void test_cgrp_kfunc(void)
                run_success_test(success_tests[i]);
        }
 
+       if (test__start_subtest("test_cgrp_from_id_ns"))
+               test_cgrp_from_id_ns();
+
        RUN_TESTS(cgrp_kfunc_failure);
 
 cleanup:

diff --git a/tools/testing/selftests/bpf/progs/cgrp_kfunc_success.c b/tools/testing/selftests/bpf/progs/cgrp_kfunc_success.c
index 5354455..02d8f16 100644 (file)
--- a/tools/testing/selftests/bpf/progs/cgrp_kfunc_success.c
+++ b/tools/testing/selftests/bpf/progs/cgrp_kfunc_success.c
@@ -221,3 +221,15 @@ int BPF_PROG(test_cgrp_from_id, struct cgroup *cgrp, const char *path)
 
        return 0;
 }
+
+SEC("syscall")
+int test_cgrp_from_id_ns(void *ctx)
+{
+       struct cgroup *cg;
+
+       cg = bpf_cgroup_from_id(1);
+       if (!cg)
+               return 42;
+       bpf_cgroup_release(cg);
+       return 0;
+}