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 15f6260148728dc6a00ca3de54fd81b711051e3f..20cede4db3cee85ce1fd337388cab5c742d58ad4 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 182e1ac36c95dd3f16e4a99fafc366f72310bd6d..3857304be874100a8bb8f7cdcabdca9d3e6b0f69 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 adda85f970589ee06a47a5b3c0c97b912467d0b4..4b42fbc96efc9a3b11f98274112a1644db615bc2 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 5354455a01be8a65828744347089ea59d5626b83..02d8f160ca0e9544ab5291706c25f82b29f16e90 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;
+}