Re: [RFC PATCH v3 07/13] fork: Support CLONE_INTO_ROOTNS in clone3()

From
sashiko-bot@kernel.org
Date
2026-11-19 19:37:20
Also in
linux-mm
Reply to
Jarkko Sakkinen, 2026-11-18
Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] cred: missing dumpability reset across userns without CLONE_VM
  in copy_creds()
- [Medium] fork: missing CAP_SYS_CHROOT check and umask reset to init_fs
  in copy_fs()
- [Medium] nsproxy: shared mm and timens vvar mismatch in
  copy_namespaces()
- [Low] rootns: wrong errno on external PID 1 race during bootstrap in
  copy_process()
--

commit 9762bc2570e709528c82312b63771aa4f8d6c6d8
Author: Jarkko Sakkinen [off-list ref]

fork: Support CLONE_INTO_ROOTNS in clone3()

This commit adds CLONE_INTO_ROOTNS and struct clone_args.rootns to spawn a
child process directly into a target root namespace via clone3().
quoted hunk ↗ jump to hunk
diff --git a/kernel/cred.c b/kernel/cred.c
index d01df40a9a386..5bc3d455141b5 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
[ ... ]
quoted hunk ↗ jump to hunk
@@ -287,6 +294,28 @@ int copy_creds(struct task_struct *p, u64 clone_flags)
 	if (!new)
 		return -ENOMEM;
 
+	if (rootns) {
+		const struct cred *old = current_cred();
+
+		if (!ns_capable(rootns->user_ns, CAP_SYS_ADMIN)) {
+			ret = -EPERM;
+			goto error_put;
+		}
+		if (new->user_ns != rootns->user_ns) {
+			ret = install_user_ns_cred(new, rootns->user_ns);
+			if (ret < 0)
+				goto error_put;
+		}
+		if (!cred_cap_issubset(old, new) ||
+		    ((clone_flags & CLONE_VM) && old->user_ns != new->user_ns)) {
+			struct task_exec_state *exec_state;
+
+			exec_state = rcu_dereference_protected(p->exec_state, true);
+			if (exec_state != &init_task_exec_state)
+				WRITE_ONCE(exec_state->dumpable, suid_dumpable);
+		}
+	}
[Severity: High]
Should exec_state->dumpable be reset whenever old->user_ns != new->user_ns,
even when CLONE_VM is not set?

When a dumpable daemon (TASK_DUMPABLE_OWNER) creates a rootns and spawns a
child into it without CLONE_VM, old->euid owns rootns->user_ns, so
cred_cap_issubset(old, new) returns true:

kernel/cred.c:cred_cap_issubset() {
    ...
	for (;subset_ns != &init_user_ns; subset_ns = subset_ns->parent) {
		if ((set_ns == subset_ns->parent)  &&
		    uid_eq(subset_ns->owner, set->euid))
			return true;
	}
    ...
}

Because CLONE_VM is clear, p->exec_state->dumpable remains
TASK_DUMPABLE_OWNER while p->real_cred->user_ns is switched to
rootns->user_ns.  In __ptrace_may_access(), a process in rootns->user_ns
with CAP_SYS_PTRACE passes ptrace_has_cap(tcred->user_ns, mode), and
task_still_dumpable() returns true on TASK_DUMPABLE_OWNER without checking
ptrace_has_cap(exec_state->user_ns, mode).  Until the child changes UID or
calls execve(), an unprivileged container root process can attach via
ptrace or read /proc/<pid>/mem and /proc/<pid>/fd/* while the child still
holds the parent daemon's forked memory, O_CLOEXEC descriptors, and host
UID.
quoted hunk ↗ jump to hunk
diff --git a/kernel/fork.c b/kernel/fork.c
index 08fc28ad1eedf..f5b98eea9ce92 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
[ ... ]
quoted hunk ↗ jump to hunk
@@ -1649,7 +1672,7 @@ static int copy_fs(u64 clone_flags, struct task_struct *tsk,
 		if (current->nsproxy->mnt_ns != &init_mnt_ns)
 			return -EINVAL;
 		fs = userspace_init_fs;
-	} else if (flags & COPY_FS_IDLE) {
+	} else if (flags & COPY_FS_IDLE || rootns) {
 		fs = &init_fs;
 	} else {
 		fs = current->fs;
@@ -1671,6 +1694,20 @@ static int copy_fs(u64 clone_flags, struct task_struct *tsk,
 	tsk->real_fs = tsk->fs = copy_fs_struct(fs);
 	if (!tsk->fs)
 		return -ENOMEM;
+	if (rootns) {
+		struct path root __free(path_put) = {};
+		int err;
+
+		err = mnt_ns_get_root(rootns->ns->mnt_ns, &root);
+		if (err) {
+			free_fs_struct(tsk->fs);
+			tsk->real_fs = NULL;
+			tsk->fs = NULL;
+			return err;
+		}
+		set_fs_root(tsk->fs, &root);
+		set_fs_pwd(tsk->fs, &root);
+	}
 	return 0;
 }
[Severity: Medium]
Does copying init_fs when rootns is set discard current->fs->umask, and
should changing tsk->fs->root require CAP_SYS_CHROOT in rootns->user_ns?

Selecting init_fs causes copy_fs_struct() to initialize tsk->fs->umask from
init_fs.umask (0022) instead of inheriting the parent's umask.  In
addition, unlike mntns_install() on setns(CLONE_NEWNS), neither
rootns_prepare_fork() nor copy_creds() checks ns_capable(rootns->user_ns,
CAP_SYS_CHROOT).  A chrooted process already running in rootns->user_ns
that has dropped CAP_SYS_CHROOT while retaining CAP_SYS_ADMIN can call
clone3(CLONE_INTO_ROOTNS) to spawn a child with fs->root reset to the mount
namespace root and escape its chroot.

[ ... ]
quoted hunk ↗ jump to hunk
@@ -2510,6 +2548,12 @@ __latent_entropy struct task_struct *copy_process(
 		goto bad_fork_core_free;
 	}
 
+	if (unlikely(clone_args_rootns_bootstrapping(args) &&
+		     !is_child_reaper(pid))) {
+		retval = -EBUSY;
+		goto bad_fork_core_free;
+	}
+
 	/* Let kill terminate clone/fork in the middle */
 	if (fatal_signal_pending(current)) {
 		retval = -EINTR;
diff --git a/kernel/nsproxy.c b/kernel/nsproxy.c
index 8a3c6d4e94e2a..ec8b6fac7fbf1 100644
--- a/kernel/nsproxy.c
+++ b/kernel/nsproxy.c
@@ -166,12 +167,21 @@ struct nsproxy *create_new_namespaces(u64 flags,
  * called from clone.  This now handles copy for nsproxy and all
  * namespaces therein.
  */
-int copy_namespaces(u64 flags, struct task_struct *tsk)
+int copy_namespaces(u64 flags, struct task_struct *tsk,
+		    struct rootns *rootns)
 {
 	struct nsproxy *old_ns = tsk->nsproxy;
 	struct user_namespace *user_ns = task_cred_xxx(tsk, user_ns);
 	struct nsproxy *new_ns;
 
+	if (rootns) {
+		if (old_ns->time_ns != rootns->ns->time_ns)
+			timens_commit_fork(tsk, rootns->ns->time_ns,
+					   flags & CLONE_VM);
+		get_nsproxy(rootns->ns);
+		tsk->nsproxy = rootns->ns;
+		return 0;
+	}
[Severity: Medium]
Can switching tsk->nsproxy->time_ns under CLONE_VM | CLONE_VFORK install the
child time namespace's vvar page into the parent's shared mm_struct?

When clone3() is called with CLONE_INTO_ROOTNS | CLONE_VM | CLONE_VFORK and
rootns has a different time namespace, timens_commit_fork() skips
vdso_join_timens() because shared_vm is true, while tsk->nsproxy is switched
immediately to rootns->ns (where time_ns == time_ns_for_children).  The
parent and the vfork child now share current->mm while having different
nsproxy->time_ns pointers.

If VDSO_TIME_PAGE_OFFSET in the shared mm's [vvar] VMA has not been faulted
in yet and the child calls a VDSO time function before execve(),
vvar_fault() calls find_timens_vvar_page(), which sees vma->vm_mm ==
current->mm and maps rootns->ns->time_ns->vvar_page into the shared page
tables.  Because time_ns already equals time_ns_for_children in rootns->ns,
exec_task_namespaces() on the child's later execve() is a no-op, leaving
the parent's mm permanently mapped to the child time namespace's vvar page.
Conversely, if the parent already faulted [vvar] before clone3(), the child
observes the parent's time namespace through VDSO and rootns->ns->time_ns
through syscalls until execve().

Also, calling timens_set_vvar_page() in copy_namespaces() before fallible
steps in copy_process() (such as alloc_pid() and cgroup_can_fork())
permanently sets rootns->ns->time_ns->frozen_offsets = true even when the
fork fails.
quoted hunk ↗ jump to hunk
diff --git a/kernel/rootns.c b/kernel/rootns.c
index 32bb8ef5ed584..cfc33c243dba4 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
[ ... ]
quoted hunk ↗ jump to hunk
+int rootns_finish_fork(struct kernel_clone_args *args, struct task_struct *p)
+{
+	struct file *file __free(fput) = args->rootns_file;
+	struct rootns *rootns = args->rootns;
+	struct pid_namespace *pid_ns = rootns->ns->pid_ns_for_children;
+	int ret;
+
+	args->rootns_file = NULL;
+	args->rootns = NULL;
+	if (!IS_ERR(p))
+		return 0;
+
+	ret = PTR_ERR(p);
+	if (args->rootns_bootstrapping) {
+		scoped_guard(spinlock, &rootns->lock) {
+			if (rootns->state == ROOTNS_FORKING)
+				WRITE_ONCE(rootns->state, ROOTNS_INIT);
+		}
+		wake_up_all(&rootns->waitq);
+	} else if (ret == -ENOMEM &&
+		   !(READ_ONCE(pid_ns->pid_allocated) & PIDNS_ADDING)) {
+		return -ESRCH;
+	}
+
+	return ret;
+}
[Severity: Low]
Can a bootstrap race with an external fork into pid_ns return -EINVAL or
-ENOMEM instead of the documented -EBUSY or -ESRCH?

If an external process enters pid_ns and allocates PID 1 in alloc_pid()
after rootns_prepare_fork() checks READ_ONCE(pid_ns->child_reaper) but
before setting child_reaper under tasklist_lock, the bootstrapping task's
alloc_pid() allocates nr == 2 while child_reaper is still NULL and fails
with -EINVAL, never reaching the !is_child_reaper(pid) check in
copy_process().  Similarly, if that external PID 1 exits and clears
PIDNS_ADDING before the bootstrapping task finishes copy_process(),
copy_process() returns -ENOMEM, and rootns_finish_fork() only translates
-ENOMEM to -ESRCH in the !args->rootns_bootstrapping branch.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118193539.240065-1-jarkko@kernel.org?part=7
Thread (33 messages) 33 messages, 3 authors, last reply 1d ago
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help