selftests/namespaces: eleventh active reference count tests

Test that different namespace types with same owner all contribute
active references to the owning user namespace.

Link: https://patch.msgid.link/20251029-work-namespace-nstree-listns-v4-33-2e6f823ebdc0@kernel.org
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/tools/testing/selftests/namespaces/ns_active_ref_test.c b/tools/testing/selftests/namespaces/ns_active_ref_test.c
index a334792da982677721032536ae852a9149cf83b1..885f58c8124719fe22b8c071c254e44453e6723d 100644 (file)
--- a/tools/testing/selftests/namespaces/ns_active_ref_test.c
+++ b/tools/testing/selftests/namespaces/ns_active_ref_test.c
@@ -1276,4 +1276,175 @@ TEST(ns_multiple_children_same_parent)
        ASSERT_LT(p_fd, 0);
 }
 
+/*
+ * Test that different namespace types with same owner all contribute
+ * active references to the owning user namespace.
+ */
+TEST(ns_different_types_same_owner)
+{
+       struct file_handle *u_handle, *n_handle, *ut_handle;
+       int ret, pipefd[2];
+       pid_t pid;
+       int status;
+       __u64 u_id, n_id, ut_id;
+       char u_buf[sizeof(*u_handle) + MAX_HANDLE_SZ];
+       char n_buf[sizeof(*n_handle) + MAX_HANDLE_SZ];
+       char ut_buf[sizeof(*ut_handle) + MAX_HANDLE_SZ];
+
+       ASSERT_EQ(pipe(pipefd), 0);
+       pid = fork();
+       ASSERT_GE(pid, 0);
+
+       if (pid == 0) {
+               close(pipefd[0]);
+
+               /* Create user namespace */
+               if (setup_userns() < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+
+               int u_fd = open("/proc/self/ns/user", O_RDONLY);
+               if (u_fd < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               if (ioctl(u_fd, NS_GET_ID, &u_id) < 0) {
+                       close(u_fd);
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               close(u_fd);
+
+               /* Create network namespace (owned by user namespace) */
+               if (unshare(CLONE_NEWNET) < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+
+               int n_fd = open("/proc/self/ns/net", O_RDONLY);
+               if (n_fd < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               if (ioctl(n_fd, NS_GET_ID, &n_id) < 0) {
+                       close(n_fd);
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               close(n_fd);
+
+               /* Create UTS namespace (also owned by user namespace) */
+               if (unshare(CLONE_NEWUTS) < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+
+               int ut_fd = open("/proc/self/ns/uts", O_RDONLY);
+               if (ut_fd < 0) {
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               if (ioctl(ut_fd, NS_GET_ID, &ut_id) < 0) {
+                       close(ut_fd);
+                       close(pipefd[1]);
+                       exit(1);
+               }
+               close(ut_fd);
+
+               /* Send all namespace IDs */
+               write(pipefd[1], &u_id, sizeof(u_id));
+               write(pipefd[1], &n_id, sizeof(n_id));
+               write(pipefd[1], &ut_id, sizeof(ut_id));
+               close(pipefd[1]);
+               exit(0);
+       }
+
+       close(pipefd[1]);
+
+       /* Read all three namespace IDs - fixed size, no parsing needed */
+       ret = read(pipefd[0], &u_id, sizeof(u_id));
+       if (ret != sizeof(u_id)) {
+               close(pipefd[0]);
+               waitpid(pid, NULL, 0);
+               SKIP(return, "Failed to read user namespace ID");
+       }
+
+       ret = read(pipefd[0], &n_id, sizeof(n_id));
+       if (ret != sizeof(n_id)) {
+               close(pipefd[0]);
+               waitpid(pid, NULL, 0);
+               SKIP(return, "Failed to read network namespace ID");
+       }
+
+       ret = read(pipefd[0], &ut_id, sizeof(ut_id));
+       close(pipefd[0]);
+       if (ret != sizeof(ut_id)) {
+               waitpid(pid, NULL, 0);
+               SKIP(return, "Failed to read UTS namespace ID");
+       }
+
+       /* Construct file handles from namespace IDs */
+       u_handle = (struct file_handle *)u_buf;
+       u_handle->handle_bytes = sizeof(struct nsfs_file_handle);
+       u_handle->handle_type = FILEID_NSFS;
+       struct nsfs_file_handle *u_fh = (struct nsfs_file_handle *)u_handle->f_handle;
+       u_fh->ns_id = u_id;
+       u_fh->ns_type = 0;
+       u_fh->ns_inum = 0;
+
+       n_handle = (struct file_handle *)n_buf;
+       n_handle->handle_bytes = sizeof(struct nsfs_file_handle);
+       n_handle->handle_type = FILEID_NSFS;
+       struct nsfs_file_handle *n_fh = (struct nsfs_file_handle *)n_handle->f_handle;
+       n_fh->ns_id = n_id;
+       n_fh->ns_type = 0;
+       n_fh->ns_inum = 0;
+
+       ut_handle = (struct file_handle *)ut_buf;
+       ut_handle->handle_bytes = sizeof(struct nsfs_file_handle);
+       ut_handle->handle_type = FILEID_NSFS;
+       struct nsfs_file_handle *ut_fh = (struct nsfs_file_handle *)ut_handle->f_handle;
+       ut_fh->ns_id = ut_id;
+       ut_fh->ns_type = 0;
+       ut_fh->ns_inum = 0;
+
+       /* Open both non-user namespaces before process exits */
+       int n_fd = open_by_handle_at(FD_NSFS_ROOT, n_handle, O_RDONLY);
+       int ut_fd = open_by_handle_at(FD_NSFS_ROOT, ut_handle, O_RDONLY);
+
+       if (n_fd < 0 || ut_fd < 0) {
+               if (n_fd >= 0) close(n_fd);
+               if (ut_fd >= 0) close(ut_fd);
+               waitpid(pid, NULL, 0);
+               SKIP(return, "Failed to open namespaces");
+       }
+
+       waitpid(pid, &status, 0);
+       ASSERT_TRUE(WIFEXITED(status));
+       ASSERT_EQ(WEXITSTATUS(status), 0);
+
+       /*
+        * Both network and UTS namespaces are active.
+        * User namespace should be active (gets 2 active refs).
+        */
+       TH_LOG("Both net and uts active - user namespace should be active");
+       int u_fd = open_by_handle_at(FD_NSFS_ROOT, u_handle, O_RDONLY);
+       ASSERT_GE(u_fd, 0);
+       close(u_fd);
+
+       /* Close network namespace - user namespace should STILL be active */
+       TH_LOG("Closing network ns - user ns should still be active (uts still active)");
+       close(n_fd);
+       u_fd = open_by_handle_at(FD_NSFS_ROOT, u_handle, O_RDONLY);
+       ASSERT_GE(u_fd, 0);
+       close(u_fd);
+
+       /* Close UTS namespace - user namespace should become inactive */
+       TH_LOG("Closing uts ns - user ns should become inactive");
+       close(ut_fd);
+       u_fd = open_by_handle_at(FD_NSFS_ROOT, u_handle, O_RDONLY);
+       ASSERT_LT(u_fd, 0);
+}
+
 TEST_HARNESS_MAIN