mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
* [RFC PATCH v3 00/13] Namespace for namespace roots
@ 2026-11-18 19:35 Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 01/13] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
                   ` (13 more replies)
  0 siblings, 14 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

OVERVIEW
========

A root namespace (rootns) is a kernel object backed by a file descriptor
that binds together:

1. A full set of detached namespaces owned by a fresh user namespace.
2. A dedicated PID namespace for spawning processes into, signaling
   members, and polling or waiting on PID 1 exit.
3. An initially empty mount namespace (CLONE_EMPTY_MNTNS) populated
   directly in its target user namespace before going live, without
   inheriting host mounts or cloning staged trees, while still allowing
   new mounts to be attached at runtime.

Work on this feature started in 2025 from David Howells' container object
patch set [1], which I turned into a namespace for namespace roots and
rebuilt around that premise.

While the patch set is manually written, the original motivation came
from isolating LLM agents. Running untrusted agent workloads made it
clear that OCI runtimes need to minimize their live configuration
surface.

Assembling mounts, credentials, and namespaces inside helper processes
with a half-configured container is what I see as the main challenge,
and the existential debate around namespaces and container objects is an
unfocused discussion topic.

[1] https://lore.kernel.org/all/155059610368.17079.2220554006494174417.stgit@warthog.procyon.org.uk/

IMPLEMENTATION
==============

rootns_create() allocates a rootns instance backed by a pollable
anonymous inode fd, creating a fresh owning user namespace and a full set
of detached namespaces: empty mount (CLONE_EMPTY_MNTNS), PID, UTS, IPC,
network, cgroup, and time. ioctl(rootnsfd, ROOTNS_GET_NSFD, nstype)
returns nsfs file descriptors for individual member namespaces when
standalone namespace operations are needed.

Superblocks are configured directly in the target user namespace via
fsopen(), FSCONFIG_SET_ROOTNS, and fsmount(), allowing unprivileged
callers to assemble FS_USERNS_MOUNT filesystems without holding
CAP_SYS_ADMIN in their own user namespace or entering the target user
namespace first. move_mount(..., MOVE_MOUNT_T_MNTNS) operates on any
non-anonymous mount namespace fd: on an empty mount namespace it installs
"/" onto the nullfs root once, and it attaches relative submounts both
before entry and into live mount namespaces.

Once "/" is installed, processes are spawned into the rootns via clone3()
with CLONE_INTO_ROOTNS and struct clone_args.rootns, without mutating the
caller in place. Pairing CLONE_INTO_ROOTNS with CLONE_VM | CLONE_VFORK
and opening the target binary via openat2(..., RESOLVE_IN_ROOT) on the
retained "/" mount fd allows spawning with execveat() without copying
page tables.

The first entrant becomes PID 1; once it exits and
zap_pid_ns_processes() reaps all members, poll() reports EPOLLHUP and
rootns_wait() returns init's exit status and rusage. rootns_kill() walks
pid_ns->idr under tasklist_lock to signal member thread groups.

CHANGES
=======

v3:
- The patch set size increased predominantly because the coverage of
  kselftest had to widened to cover the introduced changes.
- Replace MOVE_MOUNT_T_ROOTNS_ROOT with MOVE_MOUNT_T_MNTNS targeting
  mnt_ns nsfs fds, and add ioctl(ROOTNS_GET_NSFD) to open member
  namespace fds (Andy Lutomirski).
- Allow unprivileged fsopen(), FSCONFIG_SET_ROOTNS, and fsmount() to
  configure and mount FS_USERNS_MOUNT filesystems directly in the target
  user namespace without entering it first (Andy Lutomirski).
- Fix locking, refcounting, credential/dumpability/timens setup,
  pivot_root() lookup, and cross-userns mount checks across copy_rootns(),
  CLONE_INTO_ROOTNS, rootns_kill(), FSCONFIG_SET_ROOTNS, and move_mount()
  (Sashiko).
- Mark PowerPC rootns syscalls nospu (Sashiko).
- Update documentation and kselftests.

v2:
- Drop rootns provenance tracking (rootns_id and rootns_may_setns()) and
  rely on user_namespace ownership for setns() isolation (Andy
  Lutomirski).
- Replace the rootns_enter() system call with clone3(CLONE_INTO_ROOTNS)
  and struct clone_args.rootns (CLONE_ARGS_SIZE_VER3), allowing
  CLONE_VM | CLONE_VFORK and compatible per-child clone3() flags (Andy
  Lutomirski).
- Drop the spurious task_no_new_privs() check in may_enter_rootns_creds()
  (Andy Lutomirski).
- Update documentation, Kconfig, syscall tables, and kselftests for
  CLONE_INTO_ROOTNS.

VERSIONS
========

v2: https://lore.kernel.org/linux-fsdevel/20261117231352.3816603-1-jarkko@kernel.org/
v1: https://lore.kernel.org/linux-fsdevel/20261117050841.3289652-1-jarkko@kernel.org/

Cc: linux-api@vger.kernel.org
Cc: linux-doc@vger.kernel.org
Cc: linux-fsdevel@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-kselftest@vger.kernel.org
Cc: linux-mm@kvack.org
Cc: linux-security-module@vger.kernel.org
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Anna-Maria Behnsen <anna-maria@linutronix.de>
Cc: Ben Segall <bsegall@google.com>
Cc: Christian Brauner <brauner@kernel.org>
Cc: David Hildenbrand <david@kernel.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
Cc: Frederic Weisbecker <frederic@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jarkko Sakkinen <jarkko@kernel.org>
Cc: John Johansen <john.johansen@canonical.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Kees Cook <kees@kernel.org>
Cc: K Prateek Nayak <kprateek.nayak@amd.com>
Cc: "Liam R. Howlett" <liam@infradead.org>
Cc: Lorenzo Stoakes <ljs@kernel.org>
Cc: Manfred Spraul <manfred@colorfullife.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Neal Gompa <neal@gompa.dev>
Cc: Paul Moore <paul@paul-moore.com>
Cc: Pavel Tikhomirov <ptikhomirov@virtuozzo.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Serge Hallyn <sergeh@kernel.org>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Thomas Gleixner <tglx@kernel.org>
Cc: Valentin Schneider <vschneid@redhat.com>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Vincenzo Frascino <vincenzo.frascino@arm.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Cc: Zygmunt Krynicki <zygmunt.krynicki@canonical.com>

Jarkko Sakkinen (13):
  nsproxy: Pass nsproxy to create_new_namespaces()
  rootns: Add core infrastructure for root namespaces
  rootns: Track init lifecycle via copy_process() and pid_namespace
  rootns: Add rootns_create() system call
  rootns: Add rootns_wait() system call
  rootns: Add rootns_kill() system call
  fork: Support CLONE_INTO_ROOTNS in clone3()
  fs: Support FSCONFIG_SET_ROOTNS in fsconfig()
  fs: Support MOVE_MOUNT_T_MNTNS in move_mount()
  arch: Wire up rootns system calls
  docs: Document root namespace uAPI
  selftests/rootns: Add root namespace test suite
  MAINTAINERS: Add entry for ROOT NAMESPACE

 Documentation/userspace-api/index.rst         |    1 +
 .../userspace-api/ioctl/ioctl-number.rst      |    1 +
 Documentation/userspace-api/rootns.rst        |   47 +
 MAINTAINERS                                   |   11 +
 arch/alpha/kernel/syscalls/syscall.tbl        |    3 +
 arch/arm/tools/syscall.tbl                    |    3 +
 arch/arm64/tools/syscall_32.tbl               |    3 +
 arch/m68k/kernel/syscalls/syscall.tbl         |    3 +
 arch/microblaze/kernel/syscalls/syscall.tbl   |    3 +
 arch/mips/kernel/syscalls/syscall_n32.tbl     |    3 +
 arch/mips/kernel/syscalls/syscall_n64.tbl     |    3 +
 arch/mips/kernel/syscalls/syscall_o32.tbl     |    3 +
 arch/parisc/kernel/syscalls/syscall.tbl       |    3 +
 arch/powerpc/kernel/syscalls/syscall.tbl      |    3 +
 arch/s390/kernel/syscalls/syscall.tbl         |    3 +
 arch/sh/kernel/syscalls/syscall.tbl           |    3 +
 arch/sparc/kernel/syscalls/syscall.tbl        |    3 +
 arch/x86/entry/syscalls/syscall_32.tbl        |    3 +
 arch/x86/entry/syscalls/syscall_64.tbl        |    3 +
 arch/xtensa/kernel/syscalls/syscall.tbl       |    3 +
 fs/filesystems.c                              |   15 +
 fs/fs_context.c                               |   20 +-
 fs/fsopen.c                                   |  121 +-
 fs/internal.h                                 |    6 +
 fs/namespace.c                                |  245 ++-
 fs/nsfs.c                                     |   64 +
 fs/proc/root.c                                |   18 +
 include/linux/compat.h                        |    4 +
 include/linux/cred.h                          |    4 +-
 include/linux/fs_context.h                    |    5 +
 include/linux/mnt_namespace.h                 |    2 +
 include/linux/nsfs.h                          |    2 +
 include/linux/nsproxy.h                       |    9 +-
 include/linux/pid_namespace.h                 |    4 +
 include/linux/rootns.h                        |   91 +
 include/linux/sched/task.h                    |    8 +
 include/linux/syscalls.h                      |    4 +
 include/linux/time_namespace.h                |   21 +
 include/linux/user_namespace.h                |    7 +
 include/uapi/asm-generic/unistd.h             |   10 +-
 include/uapi/linux/mount.h                    |    4 +-
 include/uapi/linux/rootns.h                   |   44 +
 include/uapi/linux/sched.h                    |    5 +
 init/Kconfig                                  |    9 +
 ipc/mqueue.c                                  |   13 +
 kernel/Makefile                               |    2 +
 kernel/cred.c                                 |   31 +-
 kernel/fork.c                                 |   97 +-
 kernel/nsproxy.c                              |   44 +-
 kernel/pid_namespace.c                        |    2 +
 kernel/rootns.c                               |  609 ++++++
 kernel/sys_ni.c                               |    6 +
 kernel/time/namespace_vdso.c                  |    8 +
 kernel/user_namespace.c                       |   12 +-
 scripts/syscall.tbl                           |    3 +
 tools/testing/selftests/Makefile              |    1 +
 tools/testing/selftests/rootns/.gitignore     |    2 +
 tools/testing/selftests/rootns/Makefile       |    5 +
 tools/testing/selftests/rootns/config         |   10 +
 tools/testing/selftests/rootns/smoke.c        | 1934 +++++++++++++++++
 60 files changed, 3529 insertions(+), 80 deletions(-)
 create mode 100644 Documentation/userspace-api/rootns.rst
 create mode 100644 include/linux/rootns.h
 create mode 100644 include/uapi/linux/rootns.h
 create mode 100644 kernel/rootns.c
 create mode 100644 tools/testing/selftests/rootns/.gitignore
 create mode 100644 tools/testing/selftests/rootns/Makefile
 create mode 100644 tools/testing/selftests/rootns/config
 create mode 100644 tools/testing/selftests/rootns/smoke.c

--
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 01/13] nsproxy: Pass nsproxy to create_new_namespaces()
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 02/13] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
                   ` (12 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

create_new_namespaces() takes a struct task_struct pointer even though
it only reads tsk->nsproxy, preventing callers outside kernel/nsproxy.c
from constructing a child nsproxy without mutating a task.

Expose create_new_namespaces() and pass the source struct nsproxy
pointer directly so root namespace creation can allocate a detached
namespace set from current->nsproxy.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 include/linux/nsproxy.h |  5 +++++
 kernel/nsproxy.c        | 32 ++++++++++++++++----------------
 2 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index dc2447f5f092..cacbbbe3f1ce 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -12,6 +12,7 @@ struct ipc_namespace;
 struct pid_namespace;
 struct cgroup_namespace;
 struct fs_struct;
+struct user_namespace;
 
 /*
  * A structure to contain pointers to all per-process
@@ -92,6 +93,10 @@ static inline struct cred *nsset_cred(struct nsset *set)
  *
  */
 
+struct nsproxy *create_new_namespaces(u64 flags,
+				      struct nsproxy *ns,
+				      struct user_namespace *user_ns,
+				      struct fs_struct *new_fs);
 int copy_namespaces(u64 flags, struct task_struct *tsk);
 void switch_cred_namespaces(const struct cred *old, const struct cred *new);
 void exit_nsproxy_namespaces(struct task_struct *tsk);
diff --git a/kernel/nsproxy.c b/kernel/nsproxy.c
index 2dcf105e8ee2..8a3c6d4e94e2 100644
--- a/kernel/nsproxy.c
+++ b/kernel/nsproxy.c
@@ -85,9 +85,10 @@ void deactivate_nsproxy(struct nsproxy *ns)
  * Return the newly created nsproxy.  Do not attach this to the task,
  * leave it to the caller to do proper locking and attach it to task.
  */
-static struct nsproxy *create_new_namespaces(u64 flags,
-	struct task_struct *tsk, struct user_namespace *user_ns,
-	struct fs_struct *new_fs)
+struct nsproxy *create_new_namespaces(u64 flags,
+				      struct nsproxy *ns,
+				      struct user_namespace *user_ns,
+				      struct fs_struct *new_fs)
 {
 	struct nsproxy *new_nsp;
 	int err;
@@ -96,52 +97,51 @@ static struct nsproxy *create_new_namespaces(u64 flags,
 	if (!new_nsp)
 		return ERR_PTR(-ENOMEM);
 
-	new_nsp->mnt_ns = copy_mnt_ns(flags, tsk->nsproxy->mnt_ns,
-				      user_ns, new_fs);
+	new_nsp->mnt_ns = copy_mnt_ns(flags, ns->mnt_ns, user_ns, new_fs);
 	if (IS_ERR(new_nsp->mnt_ns)) {
 		err = PTR_ERR(new_nsp->mnt_ns);
 		goto out_ns;
 	}
 
-	new_nsp->uts_ns = copy_utsname(flags, user_ns, tsk->nsproxy->uts_ns);
+	new_nsp->uts_ns = copy_utsname(flags, user_ns, ns->uts_ns);
 	if (IS_ERR(new_nsp->uts_ns)) {
 		err = PTR_ERR(new_nsp->uts_ns);
 		goto out_uts;
 	}
 
-	new_nsp->ipc_ns = copy_ipcs(flags, user_ns, tsk->nsproxy->ipc_ns);
+	new_nsp->ipc_ns = copy_ipcs(flags, user_ns, ns->ipc_ns);
 	if (IS_ERR(new_nsp->ipc_ns)) {
 		err = PTR_ERR(new_nsp->ipc_ns);
 		goto out_ipc;
 	}
 
 	new_nsp->pid_ns_for_children =
-		copy_pid_ns(flags, user_ns, tsk->nsproxy->pid_ns_for_children);
+		copy_pid_ns(flags, user_ns, ns->pid_ns_for_children);
 	if (IS_ERR(new_nsp->pid_ns_for_children)) {
 		err = PTR_ERR(new_nsp->pid_ns_for_children);
 		goto out_pid;
 	}
 
 	new_nsp->cgroup_ns = copy_cgroup_ns(flags, user_ns,
-					    tsk->nsproxy->cgroup_ns);
+					    ns->cgroup_ns);
 	if (IS_ERR(new_nsp->cgroup_ns)) {
 		err = PTR_ERR(new_nsp->cgroup_ns);
 		goto out_cgroup;
 	}
 
-	new_nsp->net_ns = copy_net_ns(flags, user_ns, tsk->nsproxy->net_ns);
+	new_nsp->net_ns = copy_net_ns(flags, user_ns, ns->net_ns);
 	if (IS_ERR(new_nsp->net_ns)) {
 		err = PTR_ERR(new_nsp->net_ns);
 		goto out_net;
 	}
 
 	new_nsp->time_ns_for_children = copy_time_ns(flags, user_ns,
-					tsk->nsproxy->time_ns_for_children);
+					ns->time_ns_for_children);
 	if (IS_ERR(new_nsp->time_ns_for_children)) {
 		err = PTR_ERR(new_nsp->time_ns_for_children);
 		goto out_time;
 	}
-	new_nsp->time_ns = get_time_ns(tsk->nsproxy->time_ns);
+	new_nsp->time_ns = get_time_ns(ns->time_ns);
 
 	return new_nsp;
 
@@ -192,7 +192,7 @@ int copy_namespaces(u64 flags, struct task_struct *tsk)
 		(CLONE_NEWIPC | CLONE_SYSVSEM))
 		return -EINVAL;
 
-	new_ns = create_new_namespaces(flags, tsk, user_ns, tsk->fs);
+	new_ns = create_new_namespaces(flags, tsk->nsproxy, user_ns, tsk->fs);
 	if (IS_ERR(new_ns))
 		return  PTR_ERR(new_ns);
 
@@ -231,7 +231,7 @@ int unshare_nsproxy_namespaces(unsigned long unshare_flags,
 		flags |= CLONE_EMPTY_MNTNS;
 	}
 
-	*new_nsp = create_new_namespaces(flags, current, user_ns,
+	*new_nsp = create_new_namespaces(flags, current->nsproxy, user_ns,
 					 new_fs ? new_fs : current->fs);
 	if (IS_ERR(*new_nsp)) {
 		err = PTR_ERR(*new_nsp);
@@ -289,7 +289,7 @@ int exec_task_namespaces(void)
 	if (tsk->nsproxy->time_ns_for_children == tsk->nsproxy->time_ns)
 		return 0;
 
-	new = create_new_namespaces(0, tsk, current_user_ns(), tsk->fs);
+	new = create_new_namespaces(0, tsk->nsproxy, current_user_ns(), tsk->fs);
 	if (IS_ERR(new))
 		return PTR_ERR(new);
 
@@ -356,7 +356,7 @@ static int prepare_nsset(unsigned flags, struct nsset *nsset)
 	struct task_struct *me = current;
 
 	nsset->flags = flags;
-	nsset->nsproxy = create_new_namespaces(0, me, current_user_ns(), me->fs);
+	nsset->nsproxy = create_new_namespaces(0, me->nsproxy, current_user_ns(), me->fs);
 	if (IS_ERR(nsset->nsproxy))
 		return PTR_ERR(nsset->nsproxy);
 
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 02/13] rootns: Add core infrastructure for root namespaces
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 01/13] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 03/13] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
                   ` (11 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Linux namespaces can be created and entered individually, but userspace
orchestrators lack a single kernel object that binds a full detached
namespace set and an init process behind a pollable file descriptor.

Add struct rootns, its lifecycle states, reference counting, uAPI
creation flags, ROOTNS_GET_NSFD ioctl, and anonymous inode file
operations under CONFIG_ROOTNS. Drop active and passive namespace
references on final release, send SIGKILL to the rootns init thread
group on close when ROOTNS_KILL_ON_CLOSE is set, report EPOLLHUP from
poll() once the rootns reaches ROOTNS_DEAD, and allow holders with
CAP_SYS_ADMIN in the rootns user namespace to open member nsfs fds.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 fs/nsfs.c                   |  64 +++++++++++++++
 include/linux/nsfs.h        |   2 +
 include/linux/rootns.h      |  62 ++++++++++++++
 include/uapi/linux/rootns.h |  44 ++++++++++
 init/Kconfig                |   9 ++
 kernel/Makefile             |   2 +
 kernel/rootns.c             | 160 ++++++++++++++++++++++++++++++++++++
 7 files changed, 343 insertions(+)
 create mode 100644 include/linux/rootns.h
 create mode 100644 include/uapi/linux/rootns.h
 create mode 100644 kernel/rootns.c

diff --git a/fs/nsfs.c b/fs/nsfs.c
index 8179d69da038..1de51cd47508 100644
--- a/fs/nsfs.c
+++ b/fs/nsfs.c
@@ -711,3 +711,67 @@ void nsproxy_ns_active_put(struct nsproxy *ns)
 	ns_ref_active_put(ns->time_ns);
 	ns_ref_active_put(ns->time_ns_for_children);
 }
+
+int nsproxy_open_namespace(struct nsproxy *nsp, struct user_namespace *user_ns,
+			   unsigned long nstype)
+{
+	struct ns_common *ns = NULL;
+
+	switch (nstype) {
+	case CLONE_NEWNS:
+		if (ns_ref_get(nsp->mnt_ns))
+			ns = to_ns_common(nsp->mnt_ns);
+		break;
+#ifdef CONFIG_CGROUPS
+	case CLONE_NEWCGROUP:
+		if (ns_ref_get(nsp->cgroup_ns))
+			ns = to_ns_common(nsp->cgroup_ns);
+		break;
+#endif
+#ifdef CONFIG_UTS_NS
+	case CLONE_NEWUTS:
+		if (ns_ref_get(nsp->uts_ns))
+			ns = to_ns_common(nsp->uts_ns);
+		break;
+#endif
+#ifdef CONFIG_IPC_NS
+	case CLONE_NEWIPC:
+		if (ns_ref_get(nsp->ipc_ns))
+			ns = to_ns_common(nsp->ipc_ns);
+		break;
+#endif
+#ifdef CONFIG_USER_NS
+	case CLONE_NEWUSER:
+		if (ns_ref_get(user_ns))
+			ns = to_ns_common(user_ns);
+		break;
+#endif
+#ifdef CONFIG_PID_NS
+	case CLONE_NEWPID:
+		if (ns_ref_get(nsp->pid_ns_for_children))
+			ns = to_ns_common(nsp->pid_ns_for_children);
+		break;
+#endif
+#ifdef CONFIG_NET_NS
+	case CLONE_NEWNET:
+		if (ns_ref_get(nsp->net_ns))
+			ns = to_ns_common(nsp->net_ns);
+		break;
+#endif
+	case CLONE_NEWTIME:
+#ifdef CONFIG_TIME_NS
+		if (ns_ref_get(nsp->time_ns))
+			ns = to_ns_common(nsp->time_ns);
+		break;
+#else
+		return -EOPNOTSUPP;
+#endif
+	default:
+		return -EINVAL;
+	}
+
+	if (!ns)
+		return -ESRCH;
+
+	return open_namespace(ns);
+}
diff --git a/include/linux/nsfs.h b/include/linux/nsfs.h
index 731b67fc2fec..bfba790ee1a7 100644
--- a/include/linux/nsfs.h
+++ b/include/linux/nsfs.h
@@ -39,5 +39,7 @@ void nsfs_init(void);
 
 void nsproxy_ns_active_get(struct nsproxy *ns);
 void nsproxy_ns_active_put(struct nsproxy *ns);
+int nsproxy_open_namespace(struct nsproxy *nsp, struct user_namespace *user_ns,
+			   unsigned long nstype);
 
 #endif /* _LINUX_NSFS_H */
diff --git a/include/linux/rootns.h b/include/linux/rootns.h
new file mode 100644
index 000000000000..a1b2c3f8958b
--- /dev/null
+++ b/include/linux/rootns.h
@@ -0,0 +1,62 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2017-2019 Red Hat, Inc. All Rights Reserved.
+ */
+
+#ifndef _LINUX_ROOTNS_H
+#define _LINUX_ROOTNS_H
+
+#include <linux/refcount.h>
+#include <linux/resource.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+
+struct file;
+struct nsproxy;
+struct pid;
+struct user_namespace;
+
+enum rootns_state {
+	ROOTNS_INIT	= 0,
+	ROOTNS_FORKING	= 1,
+	ROOTNS_RUNNING	= 2,
+	ROOTNS_DEAD	= 3,
+};
+
+/*
+ * The rootns object.
+ */
+struct rootns {
+	refcount_t		usage;
+	int			exit_code;	/* The exit code of 'init' */
+	struct rusage		rusage;		/* Resource usage of 'init' */
+	struct user_namespace	*user_ns;	/* Owning user namespace */
+	struct nsproxy		*ns;		/* This rootns's namespaces */
+	struct pid		*init_pid;	/* The 'init' task's TGID (pid ref) */
+	spinlock_t		lock;		/* Guards rootns lifecycle state */
+	wait_queue_head_t	waitq;		/* Someone waiting for init to exit waits here */
+	unsigned int		flags;		/* Validated rootns_create() flags */
+	enum rootns_state	state;		/* Root namespace lifecycle state */
+};
+
+#ifdef CONFIG_ROOTNS
+struct rootns *get_rootns(struct rootns *c);
+void put_rootns(struct rootns *c);
+bool is_rootns_file(struct file *file);
+#else
+static inline struct rootns *get_rootns(struct rootns *c)
+{
+	return NULL;
+}
+
+static inline void put_rootns(struct rootns *c)
+{
+}
+
+static inline bool is_rootns_file(struct file *file)
+{
+	return false;
+}
+#endif /* CONFIG_ROOTNS */
+
+#endif /* _LINUX_ROOTNS_H */
diff --git a/include/uapi/linux/rootns.h b/include/uapi/linux/rootns.h
new file mode 100644
index 000000000000..77ebc1dcf489
--- /dev/null
+++ b/include/uapi/linux/rootns.h
@@ -0,0 +1,44 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Copyright (C) 2017-2019 Red Hat, Inc. All Rights Reserved.
+ * Copyright (C) 2026 Opinsys Oy
+ */
+
+#ifndef _UAPI_LINUX_ROOTNS_H
+#define _UAPI_LINUX_ROOTNS_H
+
+#include <linux/ioctl.h>
+
+/**
+ * enum rootns_flags - Flags for rootns_create()
+ * @ROOTNS_KILL_ON_CLOSE: Send %SIGKILL to rootns init on final fd release.
+ * @ROOTNS_CLOSE_ON_EXEC: Set %O_CLOEXEC on the returned control fd.
+ * @ROOTNS_ALL_FLAGS: Mask of all valid flags accepted by rootns_create().
+ *
+ * Every root namespace allocates a full set of detached namespaces owned
+ * by a fresh user namespace.
+ */
+enum rootns_flags {
+	ROOTNS_KILL_ON_CLOSE	= 0x00000001,
+	ROOTNS_CLOSE_ON_EXEC	= 0x00000002,
+	ROOTNS_ALL_FLAGS	= 0x00000003,
+};
+
+#define ROOTNS_IOCTL_MAGIC	0xB9
+
+/**
+ * DOC: ROOTNS_GET_NSFD
+ *
+ * ``ioctl(rootnsfd, ROOTNS_GET_NSFD, nstype)`` opens an ``nsfs`` file
+ * descriptor (with ``O_CLOEXEC``) for the member namespace identified by
+ * ``nstype`` (one of ``CLONE_NEWNS``, ``CLONE_NEWCGROUP``,
+ * ``CLONE_NEWUTS``, ``CLONE_NEWIPC``, ``CLONE_NEWUSER``, ``CLONE_NEWPID``,
+ * ``CLONE_NEWNET``, or ``CLONE_NEWTIME``).
+ *
+ * Requires ``CAP_SYS_ADMIN`` in the ``rootns`` user namespace. Opening
+ * ``CLONE_NEWPID`` additionally requires running in an ancestor active PID
+ * namespace and that ``rootns`` init is running.
+ */
+#define ROOTNS_GET_NSFD		_IO(ROOTNS_IOCTL_MAGIC, 0x01)
+
+#endif /* _UAPI_LINUX_ROOTNS_H */
diff --git a/init/Kconfig b/init/Kconfig
index c8a7cfa60a6e..3b857b105d2c 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1281,6 +1281,15 @@ config NET_NS
 	  Allow user space to create what appear to be multiple instances
 	  of the network stack.
 
+config ROOTNS
+	bool "Root namespace"
+	depends on USER_NS && PID_NS && UTS_NS && IPC_NS && NET_NS && CGROUPS
+	help
+	  Allow user space to create and manage isolated root namespaces
+	  with their own mount tree, user namespace, namespace set, and init
+	  process lifecycle via rootns_create(), rootns_wait(),
+	  rootns_kill(), and clone3() with CLONE_INTO_ROOTNS.
+
 endif # NAMESPACES
 
 config CHECKPOINT_RESTORE
diff --git a/kernel/Makefile b/kernel/Makefile
index 4ff92e24680c..7074d2664ce7 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -152,6 +152,8 @@ KCOV_INSTRUMENT_kstack_erase.o := n
 
 obj-$(CONFIG_SCF_TORTURE_TEST) += scftorture.o
 
+obj-$(CONFIG_ROOTNS) += rootns.o
+
 $(obj)/configs.o: $(obj)/config_data.gz
 
 # .config is small, so it is compressed with gzip rather than the image compressor.
diff --git a/kernel/rootns.c b/kernel/rootns.c
new file mode 100644
index 000000000000..4c08ac575f6c
--- /dev/null
+++ b/kernel/rootns.c
@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2017-2019 Red Hat, Inc. All Rights Reserved.
+ */
+
+/**
+ * DOC: Overview
+ *
+ * A root namespace binds a full set of detached namespaces, an initially empty
+ * mount namespace, an owning user namespace, and an init process behind a
+ * pollable control file descriptor:
+ *
+ * 1. ``rootns_create()`` allocates a detached ``rootns`` with a fresh user
+ *    namespace and dedicated mount (``CLONE_EMPTY_MNTNS``), PID, UTS, IPC,
+ *    network, cgroup, and time namespaces, returning its control fd.
+ *
+ * 2. Userspace configures superblocks via ``FSCONFIG_SET_ROOTNS``, retrieves
+ *    the mount namespace fd via ``ioctl(rootnsfd, ROOTNS_GET_NSFD,
+ *    CLONE_NEWNS)``, and installs ``"/"`` and relative submounts via
+ *    ``MOVE_MOUNT_T_MNTNS``.
+ *
+ * 3. ``clone3()`` with ``CLONE_INTO_ROOTNS`` spawns processes into the
+ *    ``rootns``; the first call commits PID 1 while concurrent bootstrap
+ *    callers wait killably.
+ *
+ * 4. When PID 1 exits, the PID namespace zaps and reaps all remaining tasks,
+ *    ``poll()`` reports ``EPOLLHUP``, and ``rootns_wait()`` returns the exit
+ *    status and ``rusage``.
+ */
+
+#include <linux/poll.h>
+#include <linux/wait.h>
+#include <uapi/linux/wait.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/anon_inodes.h>
+#include <linux/rootns.h>
+#include <linux/sched/signal.h>
+#include <linux/sched/task.h>
+#include <linux/slab.h>
+#include <linux/syscalls.h>
+#include <linux/uaccess.h>
+#include <linux/mnt_namespace.h>
+#include <linux/nsproxy.h>
+#include <linux/ns_common.h>
+#include <linux/nsfs.h>
+#include <linux/pid.h>
+#include <linux/pid_namespace.h>
+#include <linux/time_namespace.h>
+#include <linux/user_namespace.h>
+#include <linux/compat.h>
+#include <linux/idr.h>
+#include <uapi/linux/rootns.h>
+
+/*
+ * Get a reference to a rootns.
+ */
+struct rootns *get_rootns(struct rootns *c)
+{
+	refcount_inc(&c->usage);
+	return c;
+}
+
+/*
+ * Drop a reference on a rootns and clear it if it is no longer in use.
+ */
+void put_rootns(struct rootns *c)
+{
+	if (!c || !refcount_dec_and_test(&c->usage))
+		return;
+
+	if (c->ns)
+		put_nsproxy(c->ns);
+	if (c->init_pid)
+		put_pid(c->init_pid);
+	if (c->user_ns) {
+		ns_ref_active_put(c->user_ns);
+		put_user_ns(c->user_ns);
+	}
+	kfree(c);
+}
+
+/*
+ * Allow the user to poll for the rootns dying.
+ */
+static __poll_t rootns_poll(struct file *file, poll_table *wait)
+{
+	struct rootns *rootns = file->private_data;
+	__poll_t mask = 0;
+
+	poll_wait(file, &rootns->waitq, wait);
+
+	if (READ_ONCE(rootns->state) == ROOTNS_DEAD)
+		mask |= EPOLLHUP;
+
+	return mask;
+}
+
+static long rootns_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	struct rootns *rootns = file->private_data;
+
+	if (cmd != ROOTNS_GET_NSFD)
+		return -ENOIOCTLCMD;
+
+	if (!ns_capable(rootns->user_ns, CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (arg == CLONE_NEWPID) {
+		if (!pidns_is_ancestor(rootns->ns->pid_ns_for_children,
+				       task_active_pid_ns(current)))
+			return -EXDEV;
+		if (READ_ONCE(rootns->state) != ROOTNS_RUNNING)
+			return -ESRCH;
+	}
+
+	return nsproxy_open_namespace(rootns->ns, rootns->user_ns, arg);
+}
+
+static int __rootns_kill(struct rootns *rootns, int sig, bool priv)
+{
+	struct pid *pid = NULL;
+	int ret;
+
+	scoped_guard(spinlock, &rootns->lock) {
+		if (rootns->state == ROOTNS_RUNNING)
+			pid = get_pid(rootns->init_pid);
+	}
+	if (!pid)
+		return -ESRCH;
+
+	ret = kill_pid(pid, sig, priv);
+	put_pid(pid);
+	return ret;
+}
+
+static int rootns_release(struct inode *inode, struct file *file)
+{
+	struct rootns *rootns = file->private_data;
+
+	if (rootns->flags & ROOTNS_KILL_ON_CLOSE)
+		__rootns_kill(rootns, SIGKILL, true);
+	put_rootns(rootns);
+	return 0;
+}
+
+static const struct file_operations rootns_fops = {
+	.poll		= rootns_poll,
+	.unlocked_ioctl	= rootns_ioctl,
+	.compat_ioctl	= rootns_ioctl,
+	.release	= rootns_release,
+};
+
+/*
+ * Returns true if the file is a rootns.
+ */
+bool is_rootns_file(struct file *file)
+{
+	return file->f_op == &rootns_fops;
+}
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 03/13] rootns: Track init lifecycle via copy_process() and pid_namespace
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 01/13] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 02/13] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 04/13] rootns: Add rootns_create() system call Jarkko Sakkinen
                   ` (10 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

A root namespace needs to record its init thread group's PID when
bootstrapped and capture its exit status and resource usage once all
processes in the root namespace have terminated, without serializing
normal fork() and exit() paths inside the container.

Commit the bootstrap child reaper, bind pid_ns->rootns, and wake waiters
in copy_rootns() after attach_pid(PIDTYPE_PID), and invoke exit_rootns()
from zap_pid_ns_processes() after the root namespace's PID namespace has
killed and reaped all member tasks.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 include/linux/pid_namespace.h |  4 ++++
 include/linux/rootns.h        | 15 +++++++++++++
 kernel/fork.c                 |  3 +++
 kernel/pid_namespace.c        |  2 ++
 kernel/rootns.c               | 41 +++++++++++++++++++++++++++++++++++
 5 files changed, 65 insertions(+)

diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index b20baaa7e62b..6fd959f4d0d4 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -15,6 +15,7 @@
 #define MAX_PID_NS_LEVEL 32
 
 struct fs_pin;
+struct rootns;
 
 #if defined(CONFIG_SYSCTL) && defined(CONFIG_MEMFD_CREATE)
 /* modes for vm.memfd_noexec sysctl */
@@ -45,6 +46,9 @@ struct pid_namespace {
 	struct user_namespace *user_ns;
 	struct ucounts *ucounts;
 	int reboot;	/* group exit code if this pidns was rebooted */
+#ifdef CONFIG_ROOTNS
+	struct rootns *rootns;
+#endif
 	struct ns_common ns;
 	struct work_struct	work;
 } __randomize_layout;
diff --git a/include/linux/rootns.h b/include/linux/rootns.h
index a1b2c3f8958b..2c34d6cd211a 100644
--- a/include/linux/rootns.h
+++ b/include/linux/rootns.h
@@ -14,6 +14,8 @@
 struct file;
 struct nsproxy;
 struct pid;
+struct pid_namespace;
+struct task_struct;
 struct user_namespace;
 
 enum rootns_state {
@@ -43,6 +45,9 @@ struct rootns {
 struct rootns *get_rootns(struct rootns *c);
 void put_rootns(struct rootns *c);
 bool is_rootns_file(struct file *file);
+void copy_rootns(struct task_struct *tsk, struct pid *pid,
+		 struct rootns *rootns);
+void exit_rootns(struct pid_namespace *pid_ns, struct task_struct *tsk);
 #else
 static inline struct rootns *get_rootns(struct rootns *c)
 {
@@ -57,6 +62,16 @@ static inline bool is_rootns_file(struct file *file)
 {
 	return false;
 }
+
+static inline void copy_rootns(struct task_struct *tsk, struct pid *pid,
+			       struct rootns *rootns)
+{
+}
+
+static inline void exit_rootns(struct pid_namespace *pid_ns,
+			       struct task_struct *tsk)
+{
+}
 #endif /* CONFIG_ROOTNS */
 
 #endif /* _LINUX_ROOTNS_H */
diff --git a/kernel/fork.c b/kernel/fork.c
index 5efceb8d58a7..08fc28ad1eed 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -83,6 +83,7 @@
 #include <linux/fs_struct.h>
 #include <linux/magic.h>
 #include <linux/perf_event.h>
+#include <linux/rootns.h>
 #include <linux/posix-timers.h>
 #include <linux/user-return-notifier.h>
 #include <linux/oom.h>
@@ -2576,6 +2577,8 @@ __latent_entropy struct task_struct *copy_process(
 					  &p->signal->thread_head);
 		}
 		attach_pid(p, PIDTYPE_PID);
+		if (thread_group_leader(p))
+			copy_rootns(p, pid, NULL);
 		nr_threads++;
 	}
 	total_forks++;
diff --git a/kernel/pid_namespace.c b/kernel/pid_namespace.c
index 127a5fd23e70..081c27aa85bd 100644
--- a/kernel/pid_namespace.c
+++ b/kernel/pid_namespace.c
@@ -24,6 +24,7 @@
 #include <linux/sched/signal.h>
 #include <linux/idr.h>
 #include <linux/nstree.h>
+#include <linux/rootns.h>
 #include <uapi/linux/wait.h>
 #include "pid_sysctl.h"
 
@@ -280,6 +281,7 @@ void zap_pid_ns_processes(struct pid_namespace *pid_ns)
 		current->signal->group_exit_code = pid_ns->reboot;
 
 	acct_exit_ns(pid_ns);
+	exit_rootns(pid_ns, me);
 	return;
 }
 
diff --git a/kernel/rootns.c b/kernel/rootns.c
index 4c08ac575f6c..4f40dac4225f 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
@@ -158,3 +158,44 @@ bool is_rootns_file(struct file *file)
 {
 	return file->f_op == &rootns_fops;
 }
+
+void copy_rootns(struct task_struct *tsk, struct pid *pid, struct rootns *c)
+{
+	if (likely(!c || !is_child_reaper(pid)))
+		return;
+
+	scoped_guard(spinlock, &c->lock) {
+		if (c->state != ROOTNS_FORKING)
+			return;
+		ns_of_pid(pid)->rootns = get_rootns(c);
+		WRITE_ONCE(c->init_pid, get_pid(pid));
+		WRITE_ONCE(c->state, ROOTNS_RUNNING);
+	}
+	wake_up_all(&c->waitq);
+}
+
+void exit_rootns(struct pid_namespace *pid_ns, struct task_struct *tsk)
+{
+	struct rootns *c = pid_ns->rootns;
+	struct task_struct *leader;
+	struct rusage rusage;
+	int status;
+
+	if (!c)
+		return;
+
+	leader = tsk->group_leader;
+	status = (tsk->signal->flags & SIGNAL_GROUP_EXIT) ?
+		 tsk->signal->group_exit_code : leader->exit_code;
+	getrusage(leader, RUSAGE_BOTH, &rusage);
+
+	scoped_guard(spinlock, &c->lock) {
+		c->exit_code = status;
+		c->rusage = rusage;
+		WRITE_ONCE(c->state, ROOTNS_DEAD);
+	}
+
+	pid_ns->rootns = NULL;
+	wake_up_poll(&c->waitq, EPOLLHUP);
+	put_rootns(c);
+}
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 04/13] rootns: Add rootns_create() system call
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (2 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 03/13] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 05/13] rootns: Add rootns_wait() " Jarkko Sakkinen
                   ` (9 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Setting up an isolated namespace environment from a multithreaded
manager process currently requires helper processes to call unshare()
and pass file descriptors back over sockets.

Add the rootns_create() system call to allocate a detached rootns
instance owning a fresh user namespace alongside dedicated empty mount
(CLONE_EMPTY_MNTNS), PID, UTS, IPC, network, cgroup, and time
namespaces, and return its control file descriptor. Finalize the nsproxy
time namespace and pin active references for the lifetime of the rootns.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 include/linux/syscalls.h       |   1 +
 include/linux/time_namespace.h |  13 ++++
 kernel/rootns.c                | 106 +++++++++++++++++++++++++++++++++
 kernel/sys_ni.c                |   3 +
 4 files changed, 123 insertions(+)

diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 552d9710a0d5..272d54bddbe2 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -1006,6 +1006,7 @@ asmlinkage long sys_lsm_get_self_attr(unsigned int attr, struct lsm_ctx __user *
 asmlinkage long sys_lsm_set_self_attr(unsigned int attr, struct lsm_ctx __user *ctx,
 				      u32 size, u32 flags);
 asmlinkage long sys_lsm_list_modules(u64 __user *ids, u32 __user *size, u32 flags);
+asmlinkage long sys_rootns_create(unsigned int flags);
 
 /*
  * Architecture-specific system calls
diff --git a/include/linux/time_namespace.h b/include/linux/time_namespace.h
index 58bd9728df58..bdc185543893 100644
--- a/include/linux/time_namespace.h
+++ b/include/linux/time_namespace.h
@@ -60,6 +60,15 @@ static inline void put_time_ns(struct time_namespace *ns)
 		free_time_ns(ns);
 }
 
+static inline void timens_activate_nsproxy(struct nsproxy *nsproxy)
+{
+	if (nsproxy->time_ns != nsproxy->time_ns_for_children) {
+		get_time_ns(nsproxy->time_ns_for_children);
+		put_time_ns(nsproxy->time_ns);
+		nsproxy->time_ns = nsproxy->time_ns_for_children;
+	}
+}
+
 void proc_timens_show_offsets(struct task_struct *p, struct seq_file *m);
 
 struct proc_timens_offset {
@@ -125,6 +134,10 @@ static inline void put_time_ns(struct time_namespace *ns)
 {
 }
 
+static inline void timens_activate_nsproxy(struct nsproxy *nsproxy)
+{
+}
+
 static inline
 struct time_namespace *copy_time_ns(u64 flags,
 				    struct user_namespace *user_ns,
diff --git a/kernel/rootns.c b/kernel/rootns.c
index 4f40dac4225f..c420e36af603 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
@@ -199,3 +199,109 @@ void exit_rootns(struct pid_namespace *pid_ns, struct task_struct *tsk)
 	wake_up_poll(&c->waitq, EPOLLHUP);
 	put_rootns(c);
 }
+
+static struct user_namespace *create_rootns_user_ns(void)
+{
+	struct user_namespace *user_ns;
+	struct cred *new;
+	int ret;
+
+	new = prepare_creds();
+	if (!new)
+		return ERR_PTR(-ENOMEM);
+
+	ret = create_user_ns(new);
+	if (ret < 0) {
+		abort_creds(new);
+		return ERR_PTR(ret);
+	}
+
+	user_ns = get_user_ns(new->user_ns);
+	abort_creds(new);
+	return user_ns;
+}
+
+/*
+ * Create a new rootns.
+ */
+static struct rootns *create_rootns(unsigned int flags)
+{
+	u64 clone_flags = CLONE_NEWNS | CLONE_EMPTY_MNTNS | CLONE_NEWPID |
+			  CLONE_NEWCGROUP | CLONE_NEWUTS | CLONE_NEWIPC |
+			  CLONE_NEWNET |
+			  (IS_ENABLED(CONFIG_TIME_NS) ? CLONE_NEWTIME : 0);
+	struct user_namespace *user_ns;
+	struct nsproxy *ns;
+	struct rootns *c;
+	int ret;
+
+	c = kzalloc_obj(*c, GFP_KERNEL);
+	if (!c)
+		return ERR_PTR(-ENOMEM);
+
+	init_waitqueue_head(&c->waitq);
+	spin_lock_init(&c->lock);
+	refcount_set(&c->usage, 1);
+	c->flags = flags;
+
+	user_ns = create_rootns_user_ns();
+	if (IS_ERR(user_ns)) {
+		ret = PTR_ERR(user_ns);
+		goto err_put;
+	}
+	c->user_ns = user_ns;
+	ns_ref_active_get(user_ns);
+
+	if (!ns_capable(user_ns, CAP_SYS_ADMIN)) {
+		ret = -EPERM;
+		goto err_put;
+	}
+
+	ns = create_new_namespaces(clone_flags, current->nsproxy, user_ns,
+				   NULL);
+	if (IS_ERR(ns)) {
+		ret = PTR_ERR(ns);
+		goto err_put;
+	}
+
+	timens_activate_nsproxy(ns);
+	c->ns = ns;
+	nsproxy_ns_active_get(ns);
+
+	return c;
+
+err_put:
+	put_rootns(c);
+	return ERR_PTR(ret);
+}
+
+/**
+ * sys_rootns_create - Create a detached root namespace
+ * @flags: Combination of &enum rootns_flags values
+ *
+ * Allocate a detached root namespace owning a fresh user namespace and
+ * dedicated empty mount, PID, UTS, IPC, network, cgroup, and time namespaces.
+ *
+ * Return: Control file descriptor on success, negative error code on failure.
+ */
+SYSCALL_DEFINE1(rootns_create, unsigned int, flags)
+{
+	struct rootns *c;
+	int fd;
+
+	if (flags & ~ROOTNS_ALL_FLAGS)
+		return -EINVAL;
+	if (unlikely(!current->nsproxy))
+		return -EOPNOTSUPP;
+
+	c = create_rootns(flags);
+	if (IS_ERR(c))
+		return PTR_ERR(c);
+
+	fd = anon_inode_getfd("rootns", &rootns_fops, c,
+			      O_RDWR | (flags & ROOTNS_CLOSE_ON_EXEC ? O_CLOEXEC : 0));
+	if (fd < 0)
+		put_rootns(c);
+
+	return fd;
+}
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index c8be0abaa407..4a6c4337cc74 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -398,3 +398,6 @@ COND_SYSCALL(rseq_slice_yield);
 
 COND_SYSCALL(uretprobe);
 COND_SYSCALL(uprobe);
+
+/* kernel/rootns.c */
+COND_SYSCALL(rootns_create);
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 05/13] rootns: Add rootns_wait() system call
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (3 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 04/13] rootns: Add rootns_create() system call Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 06/13] rootns: Add rootns_kill() " Jarkko Sakkinen
                   ` (8 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

wait4() and waitid() only allow a parent or subreaper to collect exit
status, so an external manager holding a rootns file descriptor cannot
wait on a rootns init process forked by another process or observe exit
status multiple times across observers.

Add the rootns_wait() system call and its compat entry point to wait on
a rootns file descriptor until its init thread group exits and report
the recorded wait status and rusage. Return the init TGID translated
into the caller's active PID namespace, 0 for WNOHANG while still
running, or -ECHILD when the PID is not visible to the caller.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 include/linux/compat.h   |   4 ++
 include/linux/syscalls.h |   2 +
 kernel/rootns.c          | 103 +++++++++++++++++++++++++++++++++++++++
 kernel/sys_ni.c          |   2 +
 4 files changed, 111 insertions(+)

diff --git a/include/linux/compat.h b/include/linux/compat.h
index ad37ca617e65..3a9ac9dbb24c 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -779,6 +779,10 @@ asmlinkage long compat_sys_recvmmsg_time32(int fd, struct compat_mmsghdr __user
 asmlinkage long compat_sys_wait4(compat_pid_t pid,
 				 compat_uint_t __user *stat_addr, int options,
 				 struct compat_rusage __user *ru);
+asmlinkage long compat_sys_rootns_wait(int rootnsfd,
+				       compat_int_t __user *status,
+				       unsigned int options,
+				       struct compat_rusage __user *ru);
 asmlinkage long compat_sys_fanotify_mark(int, unsigned int, __u32, __u32,
 					    int, const char __user *);
 asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 272d54bddbe2..60e9c4ff71e7 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -1007,6 +1007,8 @@ asmlinkage long sys_lsm_set_self_attr(unsigned int attr, struct lsm_ctx __user *
 				      u32 size, u32 flags);
 asmlinkage long sys_lsm_list_modules(u64 __user *ids, u32 __user *size, u32 flags);
 asmlinkage long sys_rootns_create(unsigned int flags);
+asmlinkage long sys_rootns_wait(int rootnsfd, int __user *status,
+				unsigned int options, struct rusage __user *ru);
 
 /*
  * Architecture-specific system calls
diff --git a/kernel/rootns.c b/kernel/rootns.c
index c420e36af603..5582ff010ca5 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
@@ -305,3 +305,106 @@ SYSCALL_DEFINE1(rootns_create, unsigned int, flags)
 
 	return fd;
 }
+
+/*
+ * Wait for rootns init to exit and report results for the caller.
+ *
+ * Returns caller-visible init TGID on success, 0 for WNOHANG when still
+ * running, and -ECHILD when init pid is not visible in caller pidns.
+ */
+static long rootns_wait_common(int rootnsfd, unsigned int options,
+			       int *status, struct rusage *ru)
+{
+	CLASS(fd, f)(rootnsfd);
+	struct pid_namespace *pid_ns = task_active_pid_ns(current);
+	struct rootns *rootns;
+	long ret;
+
+	if (fd_empty(f))
+		return -EBADF;
+	if (!is_rootns_file(fd_file(f)) || (options & ~WNOHANG))
+		return -EINVAL;
+
+	rootns = fd_file(f)->private_data;
+	if (!(options & WNOHANG)) {
+		ret = wait_event_killable(rootns->waitq,
+					  READ_ONCE(rootns->state) == ROOTNS_DEAD);
+		if (ret)
+			return ret;
+	}
+
+	scoped_guard(spinlock, &rootns->lock) {
+		if (rootns->state != ROOTNS_DEAD)
+			return 0;
+		if (!rootns->init_pid)
+			return -ECHILD;
+		ret = pid_nr_ns(rootns->init_pid, pid_ns);
+		if (ret <= 0)
+			return -ECHILD;
+		if (status)
+			*status = rootns->exit_code;
+		if (ru)
+			*ru = rootns->rusage;
+	}
+
+	return ret;
+}
+
+/**
+ * sys_rootns_wait - Wait for root namespace termination and collect init status
+ * @rootnsfd: Root namespace control file descriptor
+ * @status: Optional user pointer to receive wait status of init
+ * @options: Wait options (0 or %WNOHANG)
+ * @ru: Optional user pointer to receive resource usage of init
+ *
+ * Wait killably (unless %WNOHANG is set in @options) until @rootnsfd reaches
+ * %ROOTNS_DEAD, then copy out the recorded exit status and resource usage of
+ * the rootns init thread group.
+ *
+ * Return: Caller-visible init TGID on success, 0 if %WNOHANG is set and the
+ * rootns has not terminated, %-ECHILD if init was never started or is not
+ * visible in the caller's active PID namespace, or negative error code.
+ */
+SYSCALL_DEFINE4(rootns_wait, int, rootnsfd, int __user *, status,
+		unsigned int, options, struct rusage __user *, ru)
+{
+	int code;
+	long ret;
+	struct rusage rusage;
+
+	ret = rootns_wait_common(rootnsfd, options,
+				 status ? &code : NULL,
+				 ru ? &rusage : NULL);
+	if (ret <= 0)
+		return ret;
+
+	if (status && put_user(code, status))
+		return -EFAULT;
+	if (ru && copy_to_user(ru, &rusage, sizeof(rusage)))
+		return -EFAULT;
+	return ret;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rootns_wait, int, rootnsfd,
+		       compat_int_t __user *, status,
+		       unsigned int, options,
+		       struct compat_rusage __user *, ru)
+{
+	int code;
+	long ret;
+	struct rusage rusage;
+
+	ret = rootns_wait_common(rootnsfd, options,
+				 status ? &code : NULL,
+				 ru ? &rusage : NULL);
+	if (ret <= 0)
+		return ret;
+
+	if (status && put_user(code, status))
+		return -EFAULT;
+	if (ru && put_compat_rusage(&rusage, ru))
+		return -EFAULT;
+	return ret;
+}
+#endif
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index 4a6c4337cc74..f9918d38107b 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -401,3 +401,5 @@ COND_SYSCALL(uprobe);
 
 /* kernel/rootns.c */
 COND_SYSCALL(rootns_create);
+COND_SYSCALL(rootns_wait);
+COND_SYSCALL_COMPAT(rootns_wait);
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 06/13] rootns: Add rootns_kill() system call
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (4 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 05/13] rootns: Add rootns_wait() " Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 07/13] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
                   ` (7 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Signaling every process inside a container from userspace via /proc is
racy against concurrent fork() calls.

Add the rootns_kill() system call to require an ancestor active PID
namespace, walk the root namespace's PID namespace IDR under
tasklist_lock, and deliver a validated signal once to each thread group
including in-flight forks, aggregating per-process delivery results.

Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 include/linux/syscalls.h |  1 +
 kernel/rootns.c          | 71 ++++++++++++++++++++++++++++++++++++++++
 kernel/sys_ni.c          |  1 +
 3 files changed, 73 insertions(+)

diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 60e9c4ff71e7..a854d248c8a3 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -1009,6 +1009,7 @@ asmlinkage long sys_lsm_list_modules(u64 __user *ids, u32 __user *size, u32 flag
 asmlinkage long sys_rootns_create(unsigned int flags);
 asmlinkage long sys_rootns_wait(int rootnsfd, int __user *status,
 				unsigned int options, struct rusage __user *ru);
+asmlinkage long sys_rootns_kill(int rootnsfd, int sig);
 
 /*
  * Architecture-specific system calls
diff --git a/kernel/rootns.c b/kernel/rootns.c
index 5582ff010ca5..32bb8ef5ed58 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
@@ -408,3 +408,74 @@ COMPAT_SYSCALL_DEFINE4(rootns_wait, int, rootnsfd,
 	return ret;
 }
 #endif
+
+static int rootns_kill_members(struct rootns *rootns, int sig)
+{
+	struct pid_namespace *pid_ns = rootns->ns->pid_ns_for_children;
+	bool any_success = false;
+	bool any_other = false;
+	bool any_perm = false;
+	int other_err = 0;
+	struct pid *pid;
+	int nr;
+
+	if (!pidns_is_ancestor(pid_ns, task_active_pid_ns(current)))
+		return -EXDEV;
+	if (READ_ONCE(rootns->state) != ROOTNS_RUNNING)
+		return -ESRCH;
+
+	scoped_guard(rcu) {
+		read_lock(&tasklist_lock);
+		idr_for_each_entry(&pid_ns->idr, pid, nr) {
+			struct task_struct *task = pid_task(pid, PIDTYPE_TGID);
+			int err;
+
+			if (!task)
+				continue;
+
+			err = group_send_sig_info(sig, SEND_SIG_NOINFO, task,
+						  PIDTYPE_MAX);
+			if (!err) {
+				any_success = true;
+			} else if (err == -EPERM) {
+				any_perm = true;
+			} else if (err != -ESRCH && !any_other) {
+				any_other = true;
+				other_err = err;
+			}
+		}
+		read_unlock(&tasklist_lock);
+	}
+
+	if (any_success)
+		return 0;
+	if (any_other)
+		return other_err;
+	if (any_perm)
+		return -EPERM;
+	return -ESRCH;
+}
+
+/**
+ * sys_rootns_kill - Send a signal to all thread groups in a root namespace
+ * @rootnsfd: Root namespace control file descriptor
+ * @sig: Signal number to deliver (or 0 for permission check)
+ *
+ * Walk the target root namespace's PID namespace IDR under ``tasklist_lock``
+ * and deliver @sig once to each member thread group.
+ *
+ * Return: 0 if at least one thread group was signaled, %-EXDEV if the caller's
+ * active PID namespace is not an ancestor, %-ESRCH if the rootns is not
+ * running or has no members, or negative error code on failure.
+ */
+SYSCALL_DEFINE2(rootns_kill, int, rootnsfd, int, sig)
+{
+	CLASS(fd, f)(rootnsfd);
+
+	if (fd_empty(f))
+		return -EBADF;
+	if (!is_rootns_file(fd_file(f)) || !valid_signal(sig))
+		return -EINVAL;
+
+	return rootns_kill_members(fd_file(f)->private_data, sig);
+}
diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
index f9918d38107b..fba44c49ddbb 100644
--- a/kernel/sys_ni.c
+++ b/kernel/sys_ni.c
@@ -403,3 +403,4 @@ COND_SYSCALL(uprobe);
 COND_SYSCALL(rootns_create);
 COND_SYSCALL(rootns_wait);
 COND_SYSCALL_COMPAT(rootns_wait);
+COND_SYSCALL(rootns_kill);
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 07/13] fork: Support CLONE_INTO_ROOTNS in clone3()
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (5 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 06/13] rootns: Add rootns_kill() " Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 08/13] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
                   ` (6 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Multithreaded userspace daemons cannot call setns(CLONE_NEWUSER) or
safely mutate process-wide filesystem state in place before spawning a
child into a target namespace set.

Add CLONE_INTO_ROOTNS and struct clone_args.rootns (CLONE_ARGS_SIZE_VER3)
to spawn a child process directly into a rootns whose root mount has
been installed. Transition the rootns from ROOTNS_INIT through
ROOTNS_FORKING to ROOTNS_RUNNING for the first process so it becomes
PID 1, serialize concurrent entrants on waitq until bootstrap resolves,
and admit subsequent callers into the running PID namespace until
teardown begins.

Derive child credentials from current, require CAP_SYS_ADMIN in the
target user namespace and an ancestor active PID namespace, update
dumpability across user namespace transitions, commit time namespace
vvar mappings, and look up the live mount namespace root. Restrict
companion flags to CLONE_VFORK, CLONE_VM (with CLONE_VFORK),
CLONE_PIDFD, CLONE_PIDFD_AUTOKILL, CLONE_AUTOREAP, CLONE_CLEAR_SIGHAND,
CLONE_INTO_CGROUP, and CLONE_NNP.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 fs/namespace.c                 |  16 +++++
 include/linux/cred.h           |   4 +-
 include/linux/mnt_namespace.h  |   2 +
 include/linux/nsproxy.h        |   4 +-
 include/linux/rootns.h         |  14 ++++
 include/linux/sched/task.h     |   8 +++
 include/linux/time_namespace.h |   8 +++
 include/linux/user_namespace.h |   7 ++
 include/uapi/linux/sched.h     |   5 ++
 kernel/cred.c                  |  31 +++++++-
 kernel/fork.c                  |  96 ++++++++++++++++++++++---
 kernel/nsproxy.c               |  14 +++-
 kernel/rootns.c                | 128 +++++++++++++++++++++++++++++++++
 kernel/time/namespace_vdso.c   |   8 +++
 kernel/user_namespace.c        |  12 ++--
 15 files changed, 339 insertions(+), 18 deletions(-)

diff --git a/fs/namespace.c b/fs/namespace.c
index aecd05ac0170..781380945d78 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -6708,6 +6708,22 @@ static void mntns_put(struct ns_common *ns)
 	put_mnt_ns(to_mnt_ns(ns));
 }
 
+int mnt_ns_get_root(struct mnt_namespace *mnt_ns, struct path *root)
+{
+	int err;
+
+	err = vfs_path_lookup(mnt_ns->root->mnt.mnt_root, &mnt_ns->root->mnt,
+			      "/", LOOKUP_DOWN, root);
+	if (err)
+		return err;
+	if (root->mnt == &mnt_ns->root->mnt) {
+		path_put(root);
+		*root = (struct path){};
+		return -ENOENT;
+	}
+	return 0;
+}
+
 static int mntns_install(struct nsset *nsset, struct ns_common *ns)
 {
 	struct nsproxy *nsproxy = nsset->nsproxy;
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 49c26af37349..9849366fd44b 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -19,6 +19,7 @@
 
 struct cred;
 struct inode;
+struct rootns;
 
 extern struct task_struct init_task;
 
@@ -152,7 +153,8 @@ struct cred {
 
 extern void __put_cred(struct cred *);
 extern void exit_creds(struct task_struct *);
-extern int copy_creds(struct task_struct *, u64);
+int copy_creds(struct task_struct *tsk, u64 clone_flags,
+	       struct rootns *rootns);
 extern const struct cred *get_task_cred(struct task_struct *);
 extern struct cred *cred_alloc_blank(void);
 extern struct cred *prepare_creds(void);
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 0acd1089d149..98188d1f7428 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -8,6 +8,7 @@
 
 struct mnt_namespace;
 struct fs_struct;
+struct path;
 struct user_namespace;
 struct ns_common;
 
@@ -15,6 +16,7 @@ extern struct mnt_namespace init_mnt_ns;
 
 extern struct mnt_namespace *copy_mnt_ns(u64, struct mnt_namespace *,
 		struct user_namespace *, struct fs_struct *);
+int mnt_ns_get_root(struct mnt_namespace *mnt_ns, struct path *root);
 extern void put_mnt_ns(struct mnt_namespace *ns);
 DEFINE_FREE(put_mnt_ns, struct mnt_namespace *, if (!IS_ERR_OR_NULL(_T)) put_mnt_ns(_T))
 extern struct ns_common *from_mnt_ns(struct mnt_namespace *);
diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index cacbbbe3f1ce..26b3b788cc90 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -12,6 +12,7 @@ struct ipc_namespace;
 struct pid_namespace;
 struct cgroup_namespace;
 struct fs_struct;
+struct rootns;
 struct user_namespace;
 
 /*
@@ -97,7 +98,8 @@ struct nsproxy *create_new_namespaces(u64 flags,
 				      struct nsproxy *ns,
 				      struct user_namespace *user_ns,
 				      struct fs_struct *new_fs);
-int copy_namespaces(u64 flags, struct task_struct *tsk);
+int copy_namespaces(u64 flags, struct task_struct *tsk,
+		    struct rootns *rootns);
 void switch_cred_namespaces(const struct cred *old, const struct cred *new);
 void exit_nsproxy_namespaces(struct task_struct *tsk);
 void get_cred_namespaces(struct task_struct *tsk);
diff --git a/include/linux/rootns.h b/include/linux/rootns.h
index 2c34d6cd211a..265d90c24e3a 100644
--- a/include/linux/rootns.h
+++ b/include/linux/rootns.h
@@ -12,6 +12,7 @@
 #include <linux/wait.h>
 
 struct file;
+struct kernel_clone_args;
 struct nsproxy;
 struct pid;
 struct pid_namespace;
@@ -48,6 +49,8 @@ bool is_rootns_file(struct file *file);
 void copy_rootns(struct task_struct *tsk, struct pid *pid,
 		 struct rootns *rootns);
 void exit_rootns(struct pid_namespace *pid_ns, struct task_struct *tsk);
+int rootns_prepare_fork(struct kernel_clone_args *args);
+int rootns_finish_fork(struct kernel_clone_args *args, struct task_struct *p);
 #else
 static inline struct rootns *get_rootns(struct rootns *c)
 {
@@ -72,6 +75,17 @@ static inline void exit_rootns(struct pid_namespace *pid_ns,
 			       struct task_struct *tsk)
 {
 }
+
+static inline int rootns_prepare_fork(struct kernel_clone_args *args)
+{
+	return -EINVAL;
+}
+
+static inline int rootns_finish_fork(struct kernel_clone_args *args,
+				     struct task_struct *p)
+{
+	return 0;
+}
 #endif /* CONFIG_ROOTNS */
 
 #endif /* _LINUX_ROOTNS_H */
diff --git a/include/linux/sched/task.h b/include/linux/sched/task.h
index 90ed5bc3c7af..e0c4e8ab02f1 100644
--- a/include/linux/sched/task.h
+++ b/include/linux/sched/task.h
@@ -16,6 +16,8 @@ struct task_struct;
 struct rusage;
 union thread_union;
 struct css_set;
+struct file;
+struct rootns;
 
 /* All the bits taken by the old clone syscall. */
 #define CLONE_LEGACY_FLAGS 0xffffffffULL
@@ -39,11 +41,17 @@ struct kernel_clone_args {
 	/* Number of elements in *set_tid */
 	size_t set_tid_size;
 	int cgroup;
+	int rootns_fd;
 	int idle;
 	int (*fn)(void *);
 	void *fn_arg;
 	struct cgroup *cgrp;
 	struct css_set *cset;
+#ifdef CONFIG_ROOTNS
+	struct file *rootns_file;
+	struct rootns *rootns;
+	bool rootns_bootstrapping;
+#endif
 	unsigned int kill_seq;
 };
 
diff --git a/include/linux/time_namespace.h b/include/linux/time_namespace.h
index bdc185543893..2e975a00cfc3 100644
--- a/include/linux/time_namespace.h
+++ b/include/linux/time_namespace.h
@@ -173,12 +173,20 @@ static inline ktime_t timens_ktime_to_host(clockid_t clockid, ktime_t tim)
 
 #ifdef CONFIG_TIME_NS_VDSO
 extern void timens_commit(struct task_struct *tsk, struct time_namespace *ns);
+void timens_commit_fork(struct task_struct *tsk, struct time_namespace *ns,
+			bool shared_vm);
 struct page *find_timens_vvar_page(struct vm_area_struct *vma);
 #else /* !CONFIG_TIME_NS_VDSO */
 static inline void timens_commit(struct task_struct *tsk, struct time_namespace *ns)
 {
 }
 
+static inline void timens_commit_fork(struct task_struct *tsk,
+				      struct time_namespace *ns,
+				      bool shared_vm)
+{
+}
+
 static inline struct page *find_timens_vvar_page(struct vm_area_struct *vma)
 {
 	return NULL;
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
index 91232053775d..3600a903442e 100644
--- a/include/linux/user_namespace.h
+++ b/include/linux/user_namespace.h
@@ -184,6 +184,7 @@ static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
 }
 
 extern int create_user_ns(struct cred *new);
+int install_user_ns_cred(struct cred *cred, struct user_namespace *user_ns);
 extern int unshare_userns(unsigned long unshare_flags, struct cred **new_cred);
 extern void __put_user_ns(struct user_namespace *ns);
 
@@ -226,6 +227,12 @@ static inline int create_user_ns(struct cred *new)
 	return -EINVAL;
 }
 
+static inline int install_user_ns_cred(struct cred *cred,
+				       struct user_namespace *user_ns)
+{
+	return -EINVAL;
+}
+
 static inline int unshare_userns(unsigned long unshare_flags,
 				 struct cred **new_cred)
 {
diff --git a/include/uapi/linux/sched.h b/include/uapi/linux/sched.h
index 19ffeba89428..405cfc954ae1 100644
--- a/include/uapi/linux/sched.h
+++ b/include/uapi/linux/sched.h
@@ -40,6 +40,7 @@
 #define CLONE_NNP		(1ULL << 35) /* Set no_new_privs on child. */
 #define CLONE_PIDFD_AUTOKILL	(1ULL << 36) /* Kill child when clone pidfd closes. */
 #define CLONE_EMPTY_MNTNS	(1ULL << 37) /* Create an empty mount namespace. */
+#define CLONE_INTO_ROOTNS	(1ULL << 38) /* Clone into a specific root namespace. */
 
 /*
  * cloning flags intersect with CSIGNAL so can be used with unshare and clone3
@@ -94,6 +95,8 @@
  *                kernel's limit of nested PID namespaces.
  * @cgroup:       If CLONE_INTO_CGROUP is specified set this to
  *                a file descriptor for the cgroup.
+ * @rootns:       If CLONE_INTO_ROOTNS is specified set this to
+ *                a file descriptor for the root namespace.
  *
  * The structure is versioned by size and thus extensible.
  * New struct members must go at the end of the struct and
@@ -111,12 +114,14 @@ struct clone_args {
 	__aligned_u64 set_tid;
 	__aligned_u64 set_tid_size;
 	__aligned_u64 cgroup;
+	__aligned_u64 rootns;
 };
 #endif
 
 #define CLONE_ARGS_SIZE_VER0 64 /* sizeof first published struct */
 #define CLONE_ARGS_SIZE_VER1 80 /* sizeof second published struct */
 #define CLONE_ARGS_SIZE_VER2 88 /* sizeof third published struct */
+#define CLONE_ARGS_SIZE_VER3 96 /* sizeof fourth published struct */
 
 /*
  * Scheduling policies
diff --git a/kernel/cred.c b/kernel/cred.c
index d01df40a9a38..5bc3d455141b 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -12,13 +12,16 @@
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/sched/coredump.h>
+#include <linux/sched/exec_state.h>
 #include <linux/key.h>
 #include <linux/keyctl.h>
 #include <linux/init_task.h>
+#include <linux/rootns.h>
 #include <linux/security.h>
 #include <linux/binfmts.h>
 #include <linux/cn_proc.h>
 #include <linux/uidgid.h>
+#include <linux/user_namespace.h>
 
 #if 0
 #define kdebug(FMT, ...)						\
@@ -251,6 +254,9 @@ struct cred *prepare_exec_creds(void)
 	return new;
 }
 
+static bool cred_cap_issubset(const struct cred *set,
+			      const struct cred *subset);
+
 /*
  * Copy credentials for the new process created by fork()
  *
@@ -260,7 +266,8 @@ struct cred *prepare_exec_creds(void)
  * The new process gets the current process's subjective credentials as its
  * objective and subjective credentials
  */
-int copy_creds(struct task_struct *p, u64 clone_flags)
+int copy_creds(struct task_struct *p, u64 clone_flags,
+	       struct rootns *rootns)
 {
 	struct cred *new;
 	int ret;
@@ -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);
+		}
+	}
+
 	if (clone_flags & CLONE_NEWUSER) {
 		ret = create_user_ns(new);
 		if (ret < 0)
diff --git a/kernel/fork.c b/kernel/fork.c
index 08fc28ad1eed..f5b98eea9ce9 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -65,6 +65,7 @@
 #include <linux/rcupdate.h>
 #include <linux/ptrace.h>
 #include <linux/mount.h>
+#include <linux/mnt_namespace.h>
 #include <linux/audit.h>
 #include <linux/memcontrol.h>
 #include <linux/ftrace.h>
@@ -1616,7 +1617,7 @@ static int copy_exec_state(u64 clone_flags, struct task_struct *tsk)
 	struct task_exec_state *exec_state;
 
 	/* CLONE_VM siblings refcount-share the parent's exec_state. */
-	if (clone_flags & CLONE_VM) {
+	if ((clone_flags & (CLONE_VM | CLONE_INTO_ROOTNS)) == CLONE_VM) {
 		exec_state = rcu_dereference_protected(current->exec_state, true);
 		refcount_inc(&exec_state->count);
 		rcu_assign_pointer(tsk->exec_state, exec_state);
@@ -1632,8 +1633,30 @@ enum copy_fs_flags_t {
 	COPY_FS_IDLE	= (1 << 1),
 };
 
+#ifdef CONFIG_ROOTNS
+static inline struct rootns *clone_args_rootns(const struct kernel_clone_args *args)
+{
+	return args->rootns;
+}
+
+static inline bool clone_args_rootns_bootstrapping(const struct kernel_clone_args *args)
+{
+	return args->rootns_bootstrapping;
+}
+#else
+static inline struct rootns *clone_args_rootns(const struct kernel_clone_args *args)
+{
+	return NULL;
+}
+
+static inline bool clone_args_rootns_bootstrapping(const struct kernel_clone_args *args)
+{
+	return false;
+}
+#endif
+
 static int copy_fs(u64 clone_flags, struct task_struct *tsk,
-		   enum copy_fs_flags_t flags)
+		   enum copy_fs_flags_t flags, struct rootns *rootns)
 {
 	struct fs_struct *fs;
 
@@ -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;
 }
 
@@ -2186,7 +2223,7 @@ __latent_entropy struct task_struct *copy_process(
 #ifdef CONFIG_PROVE_LOCKING
 	DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
 #endif
-	retval = copy_creds(p, clone_flags);
+	retval = copy_creds(p, clone_flags, clone_args_rootns(args));
 	if (retval < 0)
 		goto bad_fork_free;
 
@@ -2317,7 +2354,8 @@ __latent_entropy struct task_struct *copy_process(
 		goto bad_fork_cleanup_semundo;
 	retval = copy_fs(clone_flags, p,
 			 (args->umh ? COPY_FS_UMH : 0) |
-			 (args->idle ? COPY_FS_IDLE : 0));
+			 (args->idle ? COPY_FS_IDLE : 0),
+			 clone_args_rootns(args));
 	if (retval)
 		goto bad_fork_cleanup_semundo;
 	retval = copy_sighand(clone_flags, p);
@@ -2329,7 +2367,7 @@ __latent_entropy struct task_struct *copy_process(
 	retval = copy_mm(clone_flags, p);
 	if (retval)
 		goto bad_fork_cleanup_signal;
-	retval = copy_namespaces(clone_flags, p);
+	retval = copy_namespaces(clone_flags, p, clone_args_rootns(args));
 	if (retval)
 		goto bad_fork_cleanup_mm;
 	retval = copy_io(clone_flags, p);
@@ -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;
@@ -2578,7 +2622,7 @@ __latent_entropy struct task_struct *copy_process(
 		}
 		attach_pid(p, PIDTYPE_PID);
 		if (thread_group_leader(p))
-			copy_rootns(p, pid, NULL);
+			copy_rootns(p, pid, clone_args_rootns(args));
 		nr_threads++;
 	}
 	total_forks++;
@@ -2780,6 +2824,13 @@ pid_t kernel_clone(struct kernel_clone_args *args)
 	if (!valid_signal(args->exit_signal))
 		return -EINVAL;
 
+	if (unlikely(clone_flags & CLONE_INTO_ROOTNS)) {
+		int err = rootns_prepare_fork(args);
+
+		if (err)
+			return err;
+	}
+
 	/*
 	 * Determine whether and which event to report to ptracer.  When
 	 * called from kernel_thread or CLONE_UNTRACED is explicitly
@@ -2801,6 +2852,13 @@ pid_t kernel_clone(struct kernel_clone_args *args)
 	p = copy_process(NULL, trace, NUMA_NO_NODE, args);
 	add_latent_entropy();
 
+	if (unlikely(clone_flags & CLONE_INTO_ROOTNS)) {
+		int err = rootns_finish_fork(args, p);
+
+		if (err)
+			return err;
+	}
+
 	if (IS_ERR(p))
 		return PTR_ERR(p);
 
@@ -2958,7 +3016,9 @@ static noinline int copy_clone_args_from_user(struct kernel_clone_args *kargs,
 		     CLONE_ARGS_SIZE_VER1);
 	BUILD_BUG_ON(offsetofend(struct clone_args, cgroup) !=
 		     CLONE_ARGS_SIZE_VER2);
-	BUILD_BUG_ON(sizeof(struct clone_args) != CLONE_ARGS_SIZE_VER2);
+	BUILD_BUG_ON(offsetofend(struct clone_args, rootns) !=
+		     CLONE_ARGS_SIZE_VER3);
+	BUILD_BUG_ON(sizeof(struct clone_args) != CLONE_ARGS_SIZE_VER3);
 
 	if (unlikely(usize > PAGE_SIZE))
 		return -E2BIG;
@@ -2988,6 +3048,10 @@ static noinline int copy_clone_args_from_user(struct kernel_clone_args *kargs,
 	    (args.cgroup > INT_MAX || usize < CLONE_ARGS_SIZE_VER2))
 		return -EINVAL;
 
+	if ((args.flags & CLONE_INTO_ROOTNS) &&
+	    (args.rootns > INT_MAX || usize < CLONE_ARGS_SIZE_VER3))
+		return -EINVAL;
+
 	*kargs = (struct kernel_clone_args){
 		.flags		= args.flags,
 		.pidfd		= u64_to_user_ptr(args.pidfd),
@@ -2999,6 +3063,7 @@ static noinline int copy_clone_args_from_user(struct kernel_clone_args *kargs,
 		.tls		= args.tls,
 		.set_tid_size	= args.set_tid_size,
 		.cgroup		= args.cgroup,
+		.rootns_fd	= args.rootns,
 	};
 
 	if (args.set_tid &&
@@ -3039,13 +3104,19 @@ static inline bool clone3_stack_valid(struct kernel_clone_args *kargs)
 	return true;
 }
 
+#define CLONE_INTO_ROOTNS_FLAGS \
+	(CLONE_INTO_ROOTNS | CLONE_VM | CLONE_VFORK | CLONE_PIDFD | \
+	 CLONE_CLEAR_SIGHAND | CLONE_INTO_CGROUP | CLONE_AUTOREAP | \
+	 CLONE_NNP | CLONE_PIDFD_AUTOKILL)
+
 static bool clone3_args_valid(struct kernel_clone_args *kargs)
 {
 	/* Verify that no unknown flags are passed along. */
 	if (kargs->flags &
 	    ~(CLONE_LEGACY_FLAGS | CLONE_CLEAR_SIGHAND |
 	      CLONE_INTO_CGROUP | CLONE_AUTOREAP | CLONE_NNP |
-	      CLONE_PIDFD_AUTOKILL | CLONE_EMPTY_MNTNS))
+	      CLONE_PIDFD_AUTOKILL | CLONE_EMPTY_MNTNS |
+	      CLONE_INTO_ROOTNS))
 		return false;
 
 	/*
@@ -3063,6 +3134,13 @@ static bool clone3_args_valid(struct kernel_clone_args *kargs)
 	    kargs->exit_signal)
 		return false;
 
+	if (kargs->flags & CLONE_INTO_ROOTNS) {
+		if (kargs->flags & ~CLONE_INTO_ROOTNS_FLAGS)
+			return false;
+		if ((kargs->flags & CLONE_VM) && !(kargs->flags & CLONE_VFORK))
+			return false;
+	}
+
 	if (!clone3_stack_valid(kargs))
 		return false;
 
diff --git a/kernel/nsproxy.c b/kernel/nsproxy.c
index 8a3c6d4e94e2..ec8b6fac7fbf 100644
--- a/kernel/nsproxy.c
+++ b/kernel/nsproxy.c
@@ -13,6 +13,7 @@
 #include <linux/export.h>
 #include <linux/nsproxy.h>
 #include <linux/ns/ns_common_types.h>
+#include <linux/rootns.h>
 #include <linux/init_task.h>
 #include <linux/mnt_namespace.h>
 #include <linux/utsname.h>
@@ -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;
+	}
 	if (likely(!(flags & (CLONE_NS_ALL & ~CLONE_NEWUSER)))) {
 		if ((flags & CLONE_VM) ||
 		    likely(old_ns->time_ns_for_children == old_ns->time_ns)) {
@@ -192,7 +202,7 @@ int copy_namespaces(u64 flags, struct task_struct *tsk)
 		(CLONE_NEWIPC | CLONE_SYSVSEM))
 		return -EINVAL;
 
-	new_ns = create_new_namespaces(flags, tsk->nsproxy, user_ns, tsk->fs);
+	new_ns = create_new_namespaces(flags, old_ns, user_ns, tsk->fs);
 	if (IS_ERR(new_ns))
 		return  PTR_ERR(new_ns);
 
diff --git a/kernel/rootns.c b/kernel/rootns.c
index 32bb8ef5ed58..cfc33c243dba 100644
--- a/kernel/rootns.c
+++ b/kernel/rootns.c
@@ -479,3 +479,131 @@ SYSCALL_DEFINE2(rootns_kill, int, rootnsfd, int, sig)
 
 	return rootns_kill_members(fd_file(f)->private_data, sig);
 }
+
+/**
+ * DOC: CLONE_INTO_ROOTNS
+ *
+ * Passing ``CLONE_INTO_ROOTNS`` in ``struct clone_args.flags`` (with
+ * ``size >= CLONE_ARGS_SIZE_VER3``) spawns the child process into the root
+ * namespace identified by ``struct clone_args.rootns``.
+ *
+ * Once ``"/"`` is mounted in the root namespace's mount namespace, the first
+ * caller transitions the ``rootns`` from ``ROOTNS_INIT`` through
+ * ``ROOTNS_FORKING`` to ``ROOTNS_RUNNING`` as PID 1 of its PID namespace
+ * while concurrent bootstrap callers wait killably. Subsequent callers join
+ * the running PID namespace until teardown begins.
+ *
+ * The caller must hold ``CAP_SYS_ADMIN`` in the target user namespace and run
+ * in an ancestor active PID namespace. The child inherits the caller's
+ * credentials and switches to the target user namespace.
+ *
+ * ``CLONE_INTO_ROOTNS`` may be combined with the following ``CLONE_*`` flags:
+ *
+ * - ``CLONE_VFORK``
+ * - ``CLONE_VM`` (requires ``CLONE_VFORK``)
+ * - ``CLONE_PIDFD``
+ * - ``CLONE_PIDFD_AUTOKILL``
+ * - ``CLONE_AUTOREAP``
+ * - ``CLONE_CLEAR_SIGHAND``
+ * - ``CLONE_INTO_CGROUP``
+ * - ``CLONE_NNP``
+ *
+ * Returns ``-EBADF`` if ``rootns`` is not an open file descriptor, ``-EINVAL``
+ * for unsupported flags, invalid argument size, or non-``rootns`` file
+ * descriptors, ``-ENOENT`` before ``"/"`` is installed, ``-EXDEV`` if the
+ * caller's active PID namespace is not an ancestor, ``-EPERM`` without
+ * ``CAP_SYS_ADMIN`` in the target user namespace, ``-EBUSY`` if the PID
+ * namespace already has an external init process, and ``-ESRCH`` once teardown
+ * has started.
+ */
+int rootns_prepare_fork(struct kernel_clone_args *args)
+{
+	struct file *file __free(fput) = fget(args->rootns_fd);
+	struct path root __free(path_put) = {};
+	struct pid_namespace *pid_ns;
+	bool bootstrapping = false;
+	struct rootns *rootns;
+	int ret;
+
+	if (!file)
+		return -EBADF;
+	if (!is_rootns_file(file))
+		return -EINVAL;
+
+	rootns = file->private_data;
+	if (!ns_capable(rootns->user_ns, CAP_SYS_ADMIN))
+		return -EPERM;
+
+	pid_ns = rootns->ns->pid_ns_for_children;
+	if (!pidns_is_ancestor(pid_ns, task_active_pid_ns(current)))
+		return -EXDEV;
+
+	ret = mnt_ns_get_root(rootns->ns->mnt_ns, &root);
+	if (ret)
+		return ret;
+
+	for (;;) {
+		bool wait = false;
+
+		scoped_guard(spinlock, &rootns->lock) {
+			switch (rootns->state) {
+			case ROOTNS_INIT:
+				if (READ_ONCE(pid_ns->child_reaper))
+					return -EBUSY;
+				if (!(READ_ONCE(pid_ns->pid_allocated) & PIDNS_ADDING))
+					return -ESRCH;
+				WRITE_ONCE(rootns->state, ROOTNS_FORKING);
+				bootstrapping = true;
+				break;
+			case ROOTNS_FORKING:
+				wait = true;
+				break;
+			case ROOTNS_RUNNING:
+				if (!(READ_ONCE(pid_ns->pid_allocated) & PIDNS_ADDING))
+					return -ESRCH;
+				break;
+			case ROOTNS_DEAD:
+				return -ESRCH;
+			}
+		}
+		if (!wait)
+			break;
+
+		ret = wait_event_killable(rootns->waitq,
+					  READ_ONCE(rootns->state) != ROOTNS_FORKING);
+		if (ret)
+			return ret;
+	}
+
+	args->rootns_file = no_free_ptr(file);
+	args->rootns = rootns;
+	args->rootns_bootstrapping = bootstrapping;
+	return 0;
+}
+
+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;
+}
diff --git a/kernel/time/namespace_vdso.c b/kernel/time/namespace_vdso.c
index 5ac7b6a6d3a8..3ab12d1ee342 100644
--- a/kernel/time/namespace_vdso.c
+++ b/kernel/time/namespace_vdso.c
@@ -142,6 +142,14 @@ void timens_commit(struct task_struct *tsk, struct time_namespace *ns)
 	vdso_join_timens(tsk, ns);
 }
 
+void timens_commit_fork(struct task_struct *tsk, struct time_namespace *ns,
+			bool shared_vm)
+{
+	timens_set_vvar_page(tsk, ns);
+	if (!shared_vm)
+		vdso_join_timens(tsk, ns);
+}
+
 int timens_vdso_alloc_vvar_page(struct time_namespace *ns)
 {
 	ns->vvar_page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index cd748e1cbace..3bea86647191 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -1372,6 +1372,13 @@ static void userns_put(struct ns_common *ns)
 	put_user_ns(to_user_ns(ns));
 }
 
+int install_user_ns_cred(struct cred *cred, struct user_namespace *user_ns)
+{
+	put_user_ns(cred->user_ns);
+	set_cred_user_ns(cred, get_user_ns(user_ns));
+	return set_cred_ucounts(cred);
+}
+
 static int userns_install(struct nsset *nsset, struct ns_common *ns)
 {
 	struct user_namespace *user_ns = to_user_ns(ns);
@@ -1397,10 +1404,7 @@ static int userns_install(struct nsset *nsset, struct ns_common *ns)
 	if (!cred)
 		return -EINVAL;
 
-	put_user_ns(cred->user_ns);
-	set_cred_user_ns(cred, get_user_ns(user_ns));
-
-	if (set_cred_ucounts(cred) < 0)
+	if (install_user_ns_cred(cred, user_ns) < 0)
 		return -EINVAL;
 
 	return 0;
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 08/13] fs: Support FSCONFIG_SET_ROOTNS in fsconfig()
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (6 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 07/13] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 09/13] fs: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
                   ` (5 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

fsopen() and fsmount() gate on CAP_SYS_ADMIN in the caller's current
mount namespace and initialize filesystem contexts from current's user,
network, PID, and IPC namespaces, preventing an unprivileged external
manager from creating superblocks and detached mounts for an unentered
root namespace.

Add FSCONFIG_SET_ROOTNS so callers holding CAP_SYS_ADMIN in the target
rootns user namespace can bind a newly opened fs_context to that rootns
once before offering parameters. Allow unprivileged callers to open
FS_USERNS_MOUNT contexts in FS_CONTEXT_AWAITING_NS without module
autoloading until FSCONFIG_SET_ROOTNS authorizes and initializes the
context, allocate fsmount()'s anonymous mount namespace in fc->user_ns,
enforce mount_too_revealing() for unprivileged callers in init_mnt_ns,
and wire ->set_rootns() for proc and mqueue.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 fs/filesystems.c           |  15 +++++
 fs/fs_context.c            |  20 ++++--
 fs/fsopen.c                | 121 ++++++++++++++++++++++++++++++++++---
 fs/internal.h              |   6 ++
 fs/namespace.c             |  35 +++++++++--
 fs/proc/root.c             |  18 ++++++
 include/linux/fs_context.h |   5 ++
 include/uapi/linux/mount.h |   1 +
 ipc/mqueue.c               |  13 ++++
 9 files changed, 216 insertions(+), 18 deletions(-)

diff --git a/fs/filesystems.c b/fs/filesystems.c
index 3083d904df9b..9429844bf6bf 100644
--- a/fs/filesystems.c
+++ b/fs/filesystems.c
@@ -18,6 +18,7 @@
 #include <linux/uaccess.h>
 #include <linux/fs_parser.h>
 #include <linux/rculist.h>
+#include "internal.h"
 
 /*
  * Read-mostly filesystem drivers list.
@@ -390,6 +391,20 @@ static struct file_system_type *__get_fs_type(const char *name, int len)
 	return fs;
 }
 
+struct file_system_type *get_fs_type_noload(const char *name)
+{
+	struct file_system_type *fs;
+	const char *dot = strchr(name, '.');
+	int len = dot ? dot - name : strlen(name);
+
+	fs = __get_fs_type(name, len);
+	if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
+		put_filesystem(fs);
+		fs = NULL;
+	}
+	return fs;
+}
+
 struct file_system_type *get_fs_type(const char *name)
 {
 	struct file_system_type *fs;
diff --git a/fs/fs_context.c b/fs/fs_context.c
index a50584df97be..542dede2f864 100644
--- a/fs/fs_context.c
+++ b/fs/fs_context.c
@@ -259,7 +259,8 @@ static struct fs_context *alloc_fs_context(struct file_system_type *fs_type,
 				      struct dentry *reference,
 				      unsigned int sb_flags,
 				      unsigned int sb_flags_mask,
-				      enum fs_context_purpose purpose)
+				      enum fs_context_purpose purpose,
+				      bool init)
 {
 	struct fs_context *fc;
 	int ret = -ENOMEM;
@@ -292,6 +293,9 @@ static struct fs_context *alloc_fs_context(struct file_system_type *fs_type,
 		break;
 	}
 
+	if (!init)
+		return fc;
+
 	ret = fc->fs_type->init_fs_context(fc);
 	if (ret < 0)
 		goto err_fc;
@@ -307,10 +311,16 @@ struct fs_context *fs_context_for_mount(struct file_system_type *fs_type,
 					unsigned int sb_flags)
 {
 	return alloc_fs_context(fs_type, NULL, sb_flags, 0,
-					FS_CONTEXT_FOR_MOUNT);
+				FS_CONTEXT_FOR_MOUNT, true);
 }
 EXPORT_SYMBOL(fs_context_for_mount);
 
+struct fs_context *fs_context_for_unpriv_mount(struct file_system_type *fs_type)
+{
+	return alloc_fs_context(fs_type, NULL, 0, 0,
+				FS_CONTEXT_FOR_MOUNT, false);
+}
+
 struct fs_context *fs_context_for_reconfigure(struct dentry *dentry,
 					unsigned int sb_flags,
 					unsigned int sb_flags_mask)
@@ -320,7 +330,8 @@ struct fs_context *fs_context_for_reconfigure(struct dentry *dentry,
 		return ERR_PTR(-EINVAL);
 
 	return alloc_fs_context(dentry->d_sb->s_type, dentry, sb_flags,
-				sb_flags_mask, FS_CONTEXT_FOR_RECONFIGURE);
+				sb_flags_mask, FS_CONTEXT_FOR_RECONFIGURE,
+				true);
 }
 
 /**
@@ -337,7 +348,8 @@ struct fs_context *fs_context_for_submount(struct file_system_type *type,
 	struct fs_context *fc;
 	int ret;
 
-	fc = alloc_fs_context(type, reference, 0, 0, FS_CONTEXT_FOR_SUBMOUNT);
+	fc = alloc_fs_context(type, reference, 0, 0, FS_CONTEXT_FOR_SUBMOUNT,
+			      true);
 	if (IS_ERR(fc))
 		return fc;
 
diff --git a/fs/fsopen.c b/fs/fsopen.c
index 70024870fefa..3e36270baadb 100644
--- a/fs/fsopen.c
+++ b/fs/fsopen.c
@@ -13,9 +13,14 @@
 #include <linux/security.h>
 #include <linux/anon_inodes.h>
 #include <linux/namei.h>
+#include <linux/capability.h>
+#include <linux/nsproxy.h>
+#include <linux/rootns.h>
+#include <linux/user_namespace.h>
 #include <linux/file.h>
 #include <uapi/linux/mount.h>
 #include <linux/audit.h>
+#include <net/net_namespace.h>
 #include "internal.h"
 #include "mount.h"
 
@@ -41,6 +46,76 @@ static inline const char *fetch_message_locked(struct fc_log *log, size_t len,
 	return p;
 }
 
+/**
+ * DOC: FSCONFIG_SET_ROOTNS
+ *
+ * ``fsconfig(fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL, rootnsfd)`` binds a newly
+ * opened filesystem context to ``rootnsfd`` once before any parameters are
+ * supplied (subsequent calls fail with ``-EBUSY``).
+ *
+ * The caller must hold ``CAP_SYS_ADMIN`` in the target ``rootns`` user
+ * namespace, allowing unprivileged callers to configure ``FS_USERNS_MOUNT``
+ * filesystems without entering the user namespace first.
+ *
+ * The context is initialized against the ``rootns`` network namespace,
+ * ``fc->user_ns`` is delegated to the ``rootns`` user namespace for
+ * ``FS_USERNS_MOUNT`` and ``FS_USERNS_DELEGATABLE`` filesystems when the
+ * mounter ``fsuid``/``fsgid`` map into it or the caller lacks
+ * ``CAP_SYS_ADMIN`` in its own user namespace, and ``proc`` and ``mqueue``
+ * contexts bind to the target ``rootns`` PID and IPC namespaces.
+ */
+static int fsconfig_set_rootns(struct fs_context *fc, struct fs_parameter *param)
+{
+	struct user_namespace *user_ns;
+	struct rootns *c;
+	int ret;
+
+	if (!is_rootns_file(param->file))
+		return -EINVAL;
+
+	c = param->file->private_data;
+	user_ns = c->user_ns;
+	if (!ns_capable(user_ns, CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (fc->need_free && fc->ops && fc->ops->free)
+		fc->ops->free(fc);
+	fc->need_free = false;
+	fc->fs_private = NULL;
+	fc->s_fs_info = NULL;
+	fc->ops = NULL;
+	fc->sb_flags = 0;
+	fc->global = false;
+	security_free_mnt_opts(&fc->security);
+
+	put_net(fc->net_ns);
+	fc->net_ns = get_net(c->ns->net_ns);
+	put_user_ns(fc->user_ns);
+	if ((fc->fs_type->fs_flags & (FS_USERNS_MOUNT | FS_USERNS_DELEGATABLE)) &&
+	    ((kuid_has_mapping(user_ns, fc->cred->fsuid) &&
+	      kgid_has_mapping(user_ns, fc->cred->fsgid)) ||
+	     !ns_capable(fc->cred->user_ns, CAP_SYS_ADMIN)))
+		fc->user_ns = get_user_ns(user_ns);
+	else
+		fc->user_ns = get_user_ns(fc->cred->user_ns);
+
+	ret = fc->fs_type->init_fs_context(fc);
+	if (ret < 0) {
+		fc->phase = FS_CONTEXT_FAILED;
+		return ret;
+	}
+	fc->need_free = true;
+
+	if (fc->ops->set_rootns) {
+		ret = fc->ops->set_rootns(fc, c);
+		if (ret < 0)
+			return ret;
+	}
+	fc->rootns_bound = true;
+	fc->phase = FS_CONTEXT_CREATE_PARAMS;
+	return 0;
+}
+
 /*
  * Allow the user to read back any error, warning or informational messages.
  * Only one message is returned for each read(2) call.
@@ -123,9 +198,11 @@ SYSCALL_DEFINE2(fsopen, const char __user *, _fs_name, unsigned int, flags)
 	struct file_system_type *fs_type;
 	struct fs_context *fc;
 	const char *fs_name;
+	bool priv;
 	int ret;
 
-	if (!may_mount())
+	priv = may_mount();
+	if (!priv && !IS_ENABLED(CONFIG_ROOTNS))
 		return -EPERM;
 
 	if (flags & ~FSOPEN_CLOEXEC)
@@ -137,17 +214,23 @@ SYSCALL_DEFINE2(fsopen, const char __user *, _fs_name, unsigned int, flags)
 
 	audit_log_fsopen(fs_name);
 
-	fs_type = get_fs_type(fs_name);
+	fs_type = priv ? get_fs_type(fs_name) : get_fs_type_noload(fs_name);
 	kfree(fs_name);
 	if (!fs_type)
-		return -ENODEV;
+		return priv ? -ENODEV : -EPERM;
 
-	fc = fs_context_for_mount(fs_type, 0);
+	if (!priv && !(fs_type->fs_flags & FS_USERNS_MOUNT)) {
+		put_filesystem(fs_type);
+		return -EPERM;
+	}
+
+	fc = priv ? fs_context_for_mount(fs_type, 0) :
+		    fs_context_for_unpriv_mount(fs_type);
 	put_filesystem(fs_type);
 	if (IS_ERR(fc))
 		return PTR_ERR(fc);
 
-	fc->phase = FS_CONTEXT_CREATE_PARAMS;
+	fc->phase = priv ? FS_CONTEXT_CREATE_NS : FS_CONTEXT_AWAITING_NS;
 
 	ret = fscontext_alloc_log(fc);
 	if (ret < 0)
@@ -222,7 +305,8 @@ static int vfs_cmd_create(struct fs_context *fc, bool exclusive)
 	struct super_block *sb;
 	int ret;
 
-	if (fc->phase != FS_CONTEXT_CREATE_PARAMS)
+	if (fc->phase != FS_CONTEXT_CREATE_NS &&
+	    fc->phase != FS_CONTEXT_CREATE_PARAMS)
 		return -EBUSY;
 
 	if (!mount_capable(fc))
@@ -291,6 +375,8 @@ static int vfs_fsconfig_locked(struct fs_context *fc, int cmd,
 	ret = finish_clean_context(fc);
 	if (ret)
 		return ret;
+	if (fc->phase == FS_CONTEXT_AWAITING_NS && cmd != FSCONFIG_SET_ROOTNS)
+		return -EPERM;
 	switch (cmd) {
 	case FSCONFIG_CMD_CREATE:
 		return vfs_cmd_create(fc, false);
@@ -298,9 +384,17 @@ static int vfs_fsconfig_locked(struct fs_context *fc, int cmd,
 		return vfs_cmd_create(fc, true);
 	case FSCONFIG_CMD_RECONFIGURE:
 		return vfs_cmd_reconfigure(fc);
+	case FSCONFIG_SET_ROOTNS:
+		if (fc->phase != FS_CONTEXT_AWAITING_NS &&
+		    fc->phase != FS_CONTEXT_CREATE_NS)
+			return -EBUSY;
+		return fsconfig_set_rootns(fc, param);
+
 	default:
-		if (fc->phase != FS_CONTEXT_CREATE_PARAMS &&
-		    fc->phase != FS_CONTEXT_RECONF_PARAMS)
+		if (fc->phase == FS_CONTEXT_CREATE_NS)
+			fc->phase = FS_CONTEXT_CREATE_PARAMS;
+		else if (fc->phase != FS_CONTEXT_CREATE_PARAMS &&
+			 fc->phase != FS_CONTEXT_RECONF_PARAMS)
 			return -EBUSY;
 
 		return vfs_parse_fs_param(fc, param);
@@ -390,6 +484,10 @@ SYSCALL_DEFINE5(fsconfig,
 		if (!_key || _value || aux < 0)
 			return -EINVAL;
 		break;
+	case FSCONFIG_SET_ROOTNS:
+		if (_key || _value || aux < 0)
+			return -EINVAL;
+		break;
 	case FSCONFIG_CMD_CREATE:
 	case FSCONFIG_CMD_CREATE_EXCL:
 	case FSCONFIG_CMD_RECONFIGURE:
@@ -457,6 +555,12 @@ SYSCALL_DEFINE5(fsconfig,
 			goto out_key;
 		param.dirfd = aux;
 		break;
+	case FSCONFIG_SET_ROOTNS:
+		ret = -EBADF;
+		param.file = fget(aux);
+		if (!param.file)
+			goto out_key;
+		break;
 	default:
 		break;
 	}
@@ -482,6 +586,7 @@ SYSCALL_DEFINE5(fsconfig,
 			putname(param.name);
 		break;
 	case FSCONFIG_SET_FD:
+	case FSCONFIG_SET_ROOTNS:
 		if (param.file)
 			fput(param.file);
 		break;
diff --git a/fs/internal.h b/fs/internal.h
index 3f2fbac40f8e..d6815bf6ea9b 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -40,12 +40,18 @@ int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
  */
 extern void __init chrdev_init(void);
 
+/*
+ * filesystems.c
+ */
+struct file_system_type *get_fs_type_noload(const char *name);
+
 /*
  * fs_context.c
  */
 extern int parse_monolithic_mount_data(struct fs_context *, void *);
 extern void vfs_clean_context(struct fs_context *fc);
 extern int finish_clean_context(struct fs_context *fc);
+struct fs_context *fs_context_for_unpriv_mount(struct file_system_type *fs_type);
 
 /*
  * namei.c
diff --git a/fs/namespace.c b/fs/namespace.c
index 781380945d78..a6c0a31e275a 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -4623,7 +4623,8 @@ SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
 	    !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
 		return -EPERM;
 
-	if (!(flags & FSMOUNT_NAMESPACE) && !may_mount())
+	if (!(flags & FSMOUNT_NAMESPACE) && !IS_ENABLED(CONFIG_ROOTNS) &&
+	    !may_mount())
 		return -EPERM;
 
 	if (attr_flags & ~FSMOUNT_VALID_FLAGS)
@@ -4658,6 +4659,16 @@ SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
 	if (ret)
 		return ret;
 
+	if (!(flags & FSMOUNT_NAMESPACE)) {
+		if (fc->rootns_bound) {
+			if (!ns_capable(fc->user_ns, CAP_SYS_ADMIN) &&
+			    !may_mount())
+				return -EPERM;
+		} else if (!may_mount()) {
+			return -EPERM;
+		}
+	}
+
 	/* There must be a valid superblock or we can't mount it */
 	ret = -EINVAL;
 	if (!fc->root)
@@ -4699,7 +4710,8 @@ SYSCALL_DEFINE3(fsmount, int, fs_fd, unsigned int, flags,
 		return FD_ADD((flags & FSMOUNT_CLOEXEC) ? O_CLOEXEC : 0,
 			      open_new_namespace(&new_path, MOUNT_COPY_NEW));
 
-	ns = alloc_mnt_ns(current->nsproxy->mnt_ns->user_ns, true);
+	ns = alloc_mnt_ns(fc->rootns_bound ? fc->user_ns :
+			  current->nsproxy->mnt_ns->user_ns, true);
 	if (IS_ERR(ns))
 		return PTR_ERR(ns);
 	mnt = real_mount(new_path.mnt);
@@ -6582,6 +6594,7 @@ static bool mnt_already_visible(struct mnt_namespace *ns,
 				const struct super_block *sb,
 				int *new_mnt_flags)
 {
+	bool foreign_ns = !ns_capable_noaudit(ns->user_ns, CAP_SYS_ADMIN);
 	int new_flags = *new_mnt_flags;
 	struct mount *mnt;
 
@@ -6611,6 +6624,11 @@ static bool mnt_already_visible(struct mnt_namespace *ns,
 		/* Don't miss readonly hidden in the superblock flags */
 		if (sb_rdonly(mnt->mnt.mnt_sb))
 			mnt_flags |= MNT_LOCK_READONLY;
+		if (foreign_ns) {
+			if (mnt_flags & MNT_READONLY)
+				mnt_flags |= MNT_LOCK_READONLY;
+			mnt_flags |= MNT_LOCK_ATIME;
+		}
 
 		/* Verify the mount flags are equal to or more permissive
 		 * than the proposed new mount.
@@ -6629,7 +6647,7 @@ static bool mnt_already_visible(struct mnt_namespace *ns,
 		list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
 			struct inode *inode = child->mnt_mountpoint->d_inode;
 			/* Only worry about locked mounts */
-			if (!(child->mnt.mnt_flags & MNT_LOCKED))
+			if (!foreign_ns && !(child->mnt.mnt_flags & MNT_LOCKED))
 				continue;
 			/* Is the directory permanently empty? */
 			if (!is_empty_dir_inode(inode))
@@ -6650,13 +6668,18 @@ static bool mount_too_revealing(const struct super_block *sb, int *new_mnt_flags
 	struct mnt_namespace *ns = current->nsproxy->mnt_ns;
 	unsigned long s_iflags;
 
-	if (ns->user_ns == &init_user_ns)
-		return false;
-
 	/* Can this filesystem be too revealing? */
 	if (!(sb->s_type->fs_flags & FS_USERNS_MOUNT_RESTRICTED))
 		return false;
 
+	if (ns->user_ns == &init_user_ns &&
+	    ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN))
+		return false;
+
+	if (!ns_capable_noaudit(ns->user_ns, CAP_SYS_ADMIN) &&
+	    current_chrooted())
+		return true;
+
 	s_iflags = sb->s_iflags;
 	if ((s_iflags & required_iflags) != required_iflags) {
 		WARN_ONCE(1, "Expected s_iflags to contain 0x%lx\n",
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 7fbbe92bf73a..323296b03089 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -15,6 +15,8 @@
 #include <linux/sched/stat.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
+#include <linux/nsproxy.h>
+#include <linux/rootns.h>
 #include <linux/user_namespace.h>
 #include <linux/fs_context.h>
 #include <linux/mount.h>
@@ -323,6 +325,21 @@ static int proc_get_tree(struct fs_context *fc)
 	return get_tree_nodev(fc, proc_fill_super);
 }
 
+static int proc_set_rootns(struct fs_context *fc, struct rootns *rootns)
+{
+	struct proc_fs_context *ctx = fc->fs_private;
+	struct pid_namespace *target = rootns->ns->pid_ns_for_children;
+
+	if (!pidns_is_ancestor(target, task_active_pid_ns(current)))
+		return invalfc(fc, "cannot set pidns to non-descendant pidns");
+
+	put_pid_ns(ctx->pid_ns);
+	ctx->pid_ns = get_pid_ns(target);
+	put_user_ns(fc->user_ns);
+	fc->user_ns = get_user_ns(ctx->pid_ns->user_ns);
+	return 0;
+}
+
 static void proc_fs_context_free(struct fs_context *fc)
 {
 	struct proc_fs_context *ctx = fc->fs_private;
@@ -334,6 +351,7 @@ static void proc_fs_context_free(struct fs_context *fc)
 static const struct fs_context_operations proc_fs_context_ops = {
 	.free		= proc_fs_context_free,
 	.parse_param	= proc_parse_param,
+	.set_rootns	= proc_set_rootns,
 	.get_tree	= proc_get_tree,
 	.reconfigure	= proc_reconfigure,
 };
diff --git a/include/linux/fs_context.h b/include/linux/fs_context.h
index d1727dffecc5..b1adcd6ed693 100644
--- a/include/linux/fs_context.h
+++ b/include/linux/fs_context.h
@@ -21,6 +21,7 @@ struct file_system_type;
 struct mnt_namespace;
 struct net;
 struct pid_namespace;
+struct rootns;
 struct super_block;
 struct user_namespace;
 struct vfsmount;
@@ -36,6 +37,8 @@ enum fs_context_purpose {
  * Userspace usage phase for fsopen/fspick.
  */
 enum fs_context_phase {
+	FS_CONTEXT_AWAITING_NS,		/* Unprivileged context awaiting target ns */
+	FS_CONTEXT_CREATE_NS,		/* Set namespaces for sb creation */
 	FS_CONTEXT_CREATE_PARAMS,	/* Loading params for sb creation */
 	FS_CONTEXT_CREATING,		/* A superblock is being created */
 	FS_CONTEXT_AWAITING_MOUNT,	/* Superblock created, awaiting fsmount() */
@@ -110,6 +113,7 @@ struct fs_context {
 	bool			global:1;	/* Goes into &init_user_ns */
 	bool			oldapi:1;	/* Coming from mount(2) */
 	bool			exclusive:1;    /* create new superblock, reject existing one */
+	bool			rootns_bound:1;	/* Bound via FSCONFIG_SET_ROOTNS */
 };
 
 struct fs_context_operations {
@@ -117,6 +121,7 @@ struct fs_context_operations {
 	int (*dup)(struct fs_context *fc, struct fs_context *src_fc);
 	int (*parse_param)(struct fs_context *fc, struct fs_parameter *param);
 	int (*parse_monolithic)(struct fs_context *fc, void *data);
+	int (*set_rootns)(struct fs_context *fc, struct rootns *rootns);
 	int (*get_tree)(struct fs_context *fc);
 	int (*reconfigure)(struct fs_context *fc);
 };
diff --git a/include/uapi/linux/mount.h b/include/uapi/linux/mount.h
index ac865edac517..cb55cfcfc92e 100644
--- a/include/uapi/linux/mount.h
+++ b/include/uapi/linux/mount.h
@@ -105,6 +105,7 @@ enum fsconfig_command {
 	FSCONFIG_CMD_CREATE	= 6,	/* Create new or reuse existing superblock */
 	FSCONFIG_CMD_RECONFIGURE = 7,	/* Invoke superblock reconfiguration */
 	FSCONFIG_CMD_CREATE_EXCL = 8,	/* Create new superblock, fail if reusing existing superblock */
+	FSCONFIG_SET_ROOTNS	= 9,	/* Set a rootns, supplied by fd */
 };
 
 /*
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 322c3dd98c44..f94e9b566bd0 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -32,6 +32,7 @@
 #include <linux/mutex.h>
 #include <linux/nsproxy.h>
 #include <linux/pid.h>
+#include <linux/rootns.h>
 #include <linux/ipc_namespace.h>
 #include <linux/user_namespace.h>
 #include <linux/slab.h>
@@ -400,6 +401,17 @@ static struct inode *mqueue_get_inode(struct super_block *sb,
 	return ERR_PTR(ret);
 }
 
+static int mqueue_set_rootns(struct fs_context *fc, struct rootns *rootns)
+{
+	struct mqueue_fs_context *ctx = fc->fs_private;
+
+	put_ipc_ns(ctx->ipc_ns);
+	ctx->ipc_ns = get_ipc_ns(rootns->ns->ipc_ns);
+	put_user_ns(fc->user_ns);
+	fc->user_ns = get_user_ns(ctx->ipc_ns->user_ns);
+	return 0;
+}
+
 static int mqueue_fill_super(struct super_block *sb, struct fs_context *fc)
 {
 	struct inode *inode;
@@ -1613,6 +1625,7 @@ static const struct super_operations mqueue_super_ops = {
 
 static const struct fs_context_operations mqueue_fs_context_ops = {
 	.free		= mqueue_fs_context_free,
+	.set_rootns	= mqueue_set_rootns,
 	.get_tree	= mqueue_get_tree,
 };
 
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 09/13] fs: Support MOVE_MOUNT_T_MNTNS in move_mount()
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (7 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 08/13] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 10/13] arch: Wire up rootns system calls Jarkko Sakkinen
                   ` (4 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

move_mount() currently resolves target paths only against the caller's
filesystem view or anonymous mount fds, preventing an external manager
from populating an empty mount namespace or hot-mounting into an
existing container's mount namespace without entering it first.

Add MOVE_MOUNT_T_MNTNS to attach detached anonymous mount trees into a
target mount namespace nsfs file descriptor. Installing "/" attaches the
initial root mount onto the nullfs root of an empty mount namespace at
most once, while relative target paths attach anonymous mounts beneath
the live mount namespace root and reject root-mount aliases.

Check CAP_SYS_ADMIN in the target mount namespace's owning user
namespace instead of caller may_mount(), check nsfs mount loops against
the destination mount namespace, and lock moved mount trees inside
attach_recursive_mnt() when crossing user namespace boundaries.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 fs/namespace.c             | 194 +++++++++++++++++++++++++++++++------
 include/uapi/linux/mount.h |   3 +-
 2 files changed, 168 insertions(+), 29 deletions(-)

diff --git a/fs/namespace.c b/fs/namespace.c
index a6c0a31e275a..2bd973a490d3 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -2202,7 +2202,8 @@ struct mnt_namespace *mnt_ns_from_dentry(struct dentry *dentry)
 	return to_mnt_ns(get_proc_ns(dentry->d_inode));
 }
 
-static bool mnt_ns_loop(struct dentry *dentry)
+static bool mnt_ns_loop_target(struct dentry *dentry,
+			       struct mnt_namespace *target_mnt_ns)
 {
 	/* Could bind mounting the mount namespace inode cause a
 	 * mount namespace loop?
@@ -2212,7 +2213,12 @@ static bool mnt_ns_loop(struct dentry *dentry)
 	if (!mnt_ns)
 		return false;
 
-	return current->nsproxy->mnt_ns->ns.ns_id >= mnt_ns->ns.ns_id;
+	return target_mnt_ns->ns.ns_id >= mnt_ns->ns.ns_id;
+}
+
+static bool mnt_ns_loop(struct dentry *dentry)
+{
+	return mnt_ns_loop_target(dentry, current->nsproxy->mnt_ns);
 }
 
 struct mount *copy_tree(struct mount *src_root, struct dentry *dentry,
@@ -2423,10 +2429,11 @@ static bool __has_children(struct mount *mnt, struct dentry *dentry)
  *
  * locks: mount_locked_reader || namespace_shared && pinned(subtree)
  */
-static bool check_for_nsfs_mounts(struct mount *subtree)
+static bool check_for_nsfs_mounts(struct mount *subtree,
+				  struct mnt_namespace *target_mnt_ns)
 {
 	for (struct mount *p = subtree; p; p = next_mnt(p, subtree))
-		if (mnt_ns_loop(p->mnt.mnt_root))
+		if (mnt_ns_loop_target(p->mnt.mnt_root, target_mnt_ns))
 			return false;
 	return true;
 }
@@ -2464,7 +2471,7 @@ struct vfsmount *clone_private_mount(const struct path *path)
 		if (!anon_ns_root(old_mnt))
 			return ERR_PTR(-EINVAL);
 
-		if (!check_for_nsfs_mounts(old_mnt))
+		if (!check_for_nsfs_mounts(old_mnt, current->nsproxy->mnt_ns))
 			return ERR_PTR(-EINVAL);
 	}
 
@@ -2564,6 +2571,8 @@ int count_mounts(struct mnt_namespace *ns, struct mount *mnt)
 enum mnt_tree_flags_t {
 	MNT_TREE_BENEATH = BIT(0),
 	MNT_TREE_PROPAGATION = BIT(1),
+	MNT_TREE_MNTNS = BIT(2),
+	MNT_TREE_MNTNS_INIT = BIT(3),
 };
 
 /**
@@ -2639,6 +2648,7 @@ static int attach_recursive_mnt(struct mount *source_mnt,
 	HLIST_HEAD(tree_list);
 	struct mnt_namespace *ns = dest_mnt->mnt_ns;
 	struct user_namespace *user_ns = ns->user_ns;
+	struct user_namespace *source_user_ns;
 	struct pinned_mountpoint root = {};
 	struct mountpoint *shorter = NULL;
 	struct mount *child, *p;
@@ -2662,6 +2672,8 @@ static int attach_recursive_mnt(struct mount *source_mnt,
 		user_ns = current->nsproxy->mnt_ns->user_ns;
 	else
 		user_ns = ns->user_ns;
+	source_user_ns = (!moving && source_mnt->mnt_ns) ?
+			 source_mnt->mnt_ns->user_ns : user_ns;
 
 	/*
 	 * Preallocate a mountpoint in case the new mounts need to be
@@ -2730,6 +2742,12 @@ static int attach_recursive_mnt(struct mount *source_mnt,
 		/* Notice when we are propagating across user namespaces */
 		if (child->mnt_parent->mnt_ns->user_ns != user_ns)
 			lock_mnt_tree(child);
+		if (!is_anon_ns(child->mnt_parent->mnt_ns) &&
+		    child->mnt_parent->mnt_ns->user_ns != source_user_ns) {
+			lock_mnt_tree(child);
+			if (list_empty(&child->mnt_expire))
+				child->mnt.mnt_flags |= MNT_LOCKED;
+		}
 		q = __lookup_mnt(&child->mnt_parent->mnt,
 				 child->mnt_mountpoint);
 		commit_tree(child);
@@ -3131,7 +3149,7 @@ static int do_loopback(const struct path *path, const char *old_name,
 		return PTR_ERR(mnt);
 
 	/* the copy may carry mount namespace files from below the source */
-	if (recurse && !check_for_nsfs_mounts(mnt))
+	if (recurse && !check_for_nsfs_mounts(mnt, current->nsproxy->mnt_ns))
 		err = -EINVAL;
 	else
 		err = graft_tree(mnt, &mp);
@@ -3779,6 +3797,7 @@ static int do_move_mount(const struct path *old_path,
 			 enum mnt_tree_flags_t flags)
 {
 	struct mount *old = real_mount(old_path->mnt);
+	struct mnt_namespace *target_mnt_ns;
 	int err;
 	bool beneath = flags & MNT_TREE_BENEATH;
 
@@ -3792,7 +3811,13 @@ static int do_move_mount(const struct path *old_path,
 	if (IS_ERR(mp.parent))
 		return PTR_ERR(mp.parent);
 
-	if (check_mnt(old)) {
+	if (flags & MNT_TREE_MNTNS) {
+		if (!anon_ns_root(old) || old->mnt_ns == mp.parent->mnt_ns)
+			return -EINVAL;
+		if ((flags & MNT_TREE_MNTNS_INIT) &&
+		    mp.parent != real_mount(new_path->mnt))
+			return -EBUSY;
+	} else if (check_mnt(old)) {
 		/* if the source is in our namespace... */
 		/* ... it should be detachable from parent */
 		if (!mnt_has_parent(old) || IS_MNT_LOCKED(old))
@@ -3840,7 +3865,9 @@ static int do_move_mount(const struct path *old_path,
 	 */
 	if (IS_MNT_SHARED(mp.parent) && tree_contains_unbindable(old))
 		return -EINVAL;
-	if (!check_for_nsfs_mounts(old))
+	target_mnt_ns = is_anon_ns(mp.parent->mnt_ns) ?
+			current->nsproxy->mnt_ns : mp.parent->mnt_ns;
+	if (!check_for_nsfs_mounts(old, target_mnt_ns))
 		return -ELOOP;
 	if (mount_is_ancestor(old, mp.parent))
 		return -ELOOP;
@@ -4751,6 +4778,127 @@ static inline int vfs_move_mount(const struct path *from_path,
 	return do_move_mount(from_path, to_path, mflags);
 }
 
+static int lookup_move_mount_from(int from_dfd,
+				  const char __user *from_pathname,
+				  unsigned int flags, struct path *from_path)
+{
+	unsigned int uflags = 0;
+	unsigned int lflags = 0;
+
+	if (flags & MOVE_MOUNT_F_EMPTY_PATH)
+		uflags = AT_EMPTY_PATH;
+
+	CLASS(filename_maybe_null, from_name)(from_pathname, uflags);
+	if (!from_name && from_dfd >= 0) {
+		CLASS(fd_raw, f_from)(from_dfd);
+		if (fd_empty(f_from))
+			return -EBADF;
+
+		*from_path = fd_file(f_from)->f_path;
+		path_get(from_path);
+		return 0;
+	}
+
+	if (flags & MOVE_MOUNT_F_SYMLINKS)
+		lflags |= LOOKUP_FOLLOW;
+	if (flags & MOVE_MOUNT_F_AUTOMOUNTS)
+		lflags |= LOOKUP_AUTOMOUNT;
+	return filename_lookup(from_dfd, from_name, lflags, from_path, NULL);
+}
+
+/**
+ * DOC: MOVE_MOUNT_T_MNTNS
+ *
+ * ``MOVE_MOUNT_T_MNTNS`` installs detached anonymous mount trees into a target
+ * mount namespace ``nsfs`` file descriptor supplied as ``to_dfd``:
+ *
+ * 1. ``to_pathname`` of ``"/"`` attaches the initial root mount onto the
+ *    ``nullfs`` root of an empty mount namespace at most once.
+ *
+ * 2. Relative ``to_pathname`` values resolve beneath the live root of the
+ *    target mount namespace.
+ *
+ * Capability is checked against ``CAP_SYS_ADMIN`` in the target mount
+ * namespace's owning user namespace, and source trees crossing user namespace
+ * boundaries are locked with ``MNT_LOCKED`` and locked mount flags.
+ */
+static int move_mount_mntns(int from_dfd, const char __user *from_pathname,
+			    int to_dfd, const char __user *to_pathname,
+			    unsigned int flags, enum mnt_tree_flags_t mflags)
+{
+	struct path from_path __free(path_put) = {};
+	struct path to_path __free(path_put) = {};
+	struct mnt_namespace *target_mnt_ns;
+	unsigned int lflags;
+	struct ns_common *ns;
+	bool is_root;
+	int ret;
+
+	CLASS(filename_maybe_null, to_name)(to_pathname, AT_EMPTY_PATH);
+	if (IS_ERR(to_name))
+		return PTR_ERR(to_name);
+	if (!to_name)
+		return -EINVAL;
+
+	CLASS(fd, f_mntns)(to_dfd);
+	if (fd_empty(f_mntns))
+		return -EBADF;
+	if (!proc_ns_file(fd_file(f_mntns)))
+		return -EINVAL;
+
+	ns = get_proc_ns(file_inode(fd_file(f_mntns)));
+	if (ns->ns_type != CLONE_NEWNS)
+		return -EINVAL;
+
+	target_mnt_ns = to_mnt_ns(ns);
+	if (is_anon_ns(target_mnt_ns))
+		return -EINVAL;
+	if (!ns_capable(target_mnt_ns->user_ns, CAP_SYS_ADMIN))
+		return -EPERM;
+
+	is_root = to_name->name[0] == '/' && to_name->name[1] == '\0';
+	if (is_root) {
+		if (flags & MOVE_MOUNT_BENEATH)
+			return -EINVAL;
+
+		to_path.mnt = mntget(&target_mnt_ns->root->mnt);
+		to_path.dentry = dget(target_mnt_ns->root->mnt.mnt_root);
+		mflags |= MNT_TREE_MNTNS_INIT;
+	} else {
+		struct path mntns_root __free(path_put) = {};
+
+		if (to_name->name[0] == '/')
+			return -EINVAL;
+
+		ret = mnt_ns_get_root(target_mnt_ns, &mntns_root);
+		if (ret)
+			return ret;
+
+		lflags = 0;
+		if (flags & MOVE_MOUNT_T_SYMLINKS)
+			lflags |= LOOKUP_FOLLOW;
+		if (flags & MOVE_MOUNT_T_AUTOMOUNTS)
+			lflags |= LOOKUP_AUTOMOUNT;
+		ret = filename_lookup(AT_FDCWD, to_name, lflags, &to_path,
+				      &mntns_root);
+		if (ret)
+			return ret;
+		if (real_mount(to_path.mnt)->mnt_ns != target_mnt_ns ||
+		    to_path.mnt == &target_mnt_ns->root->mnt)
+			return -EINVAL;
+		if (real_mount(to_path.mnt)->mnt_parent == target_mnt_ns->root &&
+		    to_path.dentry == to_path.mnt->mnt_root)
+			return (flags & MOVE_MOUNT_BENEATH) ? -EINVAL : -EBUSY;
+	}
+
+	ret = lookup_move_mount_from(from_dfd, from_pathname, flags,
+				     &from_path);
+	if (ret)
+		return ret;
+
+	return vfs_move_mount(&from_path, &to_path, mflags | MNT_TREE_MNTNS);
+}
+
 /*
  * Move a mount from one place to another.  In combination with
  * fsopen()/fsmount() this is used to install a new mount and in combination
@@ -4770,7 +4918,7 @@ SYSCALL_DEFINE5(move_mount,
 	enum mnt_tree_flags_t mflags = 0;
 	int ret = 0;
 
-	if (!may_mount())
+	if (!(flags & MOVE_MOUNT_T_MNTNS) && !may_mount())
 		return -EPERM;
 
 	if (flags & ~MOVE_MOUNT__MASK)
@@ -4783,6 +4931,13 @@ SYSCALL_DEFINE5(move_mount,
 	if (flags & MOVE_MOUNT_SET_GROUP)	mflags |= MNT_TREE_PROPAGATION;
 	if (flags & MOVE_MOUNT_BENEATH)		mflags |= MNT_TREE_BENEATH;
 
+	if (unlikely(flags & MOVE_MOUNT_T_MNTNS)) {
+		if (flags & (MOVE_MOUNT_T_EMPTY_PATH | MOVE_MOUNT_SET_GROUP))
+			return -EINVAL;
+		return move_mount_mntns(from_dfd, from_pathname,
+					to_dfd, to_pathname, flags, mflags);
+	}
+
 	uflags = 0;
 	if (flags & MOVE_MOUNT_T_EMPTY_PATH)
 		uflags = AT_EMPTY_PATH;
@@ -4806,25 +4961,8 @@ SYSCALL_DEFINE5(move_mount,
 			return ret;
 	}
 
-	uflags = 0;
-	if (flags & MOVE_MOUNT_F_EMPTY_PATH)
-		uflags = AT_EMPTY_PATH;
-
-	CLASS(filename_maybe_null,from_name)(from_pathname, uflags);
-	if (!from_name && from_dfd >= 0) {
-		CLASS(fd_raw, f_from)(from_dfd);
-		if (fd_empty(f_from))
-			return -EBADF;
-
-		return vfs_move_mount(&fd_file(f_from)->f_path, &to_path, mflags);
-	}
-
-	lflags = 0;
-	if (flags & MOVE_MOUNT_F_SYMLINKS)
-		lflags |= LOOKUP_FOLLOW;
-	if (flags & MOVE_MOUNT_F_AUTOMOUNTS)
-		lflags |= LOOKUP_AUTOMOUNT;
-	ret = filename_lookup(from_dfd, from_name, lflags, &from_path, NULL);
+	ret = lookup_move_mount_from(from_dfd, from_pathname, flags,
+				     &from_path);
 	if (ret)
 		return ret;
 
diff --git a/include/uapi/linux/mount.h b/include/uapi/linux/mount.h
index cb55cfcfc92e..7fa93de08ceb 100644
--- a/include/uapi/linux/mount.h
+++ b/include/uapi/linux/mount.h
@@ -75,9 +75,10 @@
 #define MOVE_MOUNT_T_SYMLINKS		0x00000010 /* Follow symlinks on to path */
 #define MOVE_MOUNT_T_AUTOMOUNTS		0x00000020 /* Follow automounts on to path */
 #define MOVE_MOUNT_T_EMPTY_PATH		0x00000040 /* Empty to path permitted */
+#define MOVE_MOUNT_T_MNTNS		0x00000080 /* Resolve to_dfd as mntns fd */
 #define MOVE_MOUNT_SET_GROUP		0x00000100 /* Set sharing group instead */
 #define MOVE_MOUNT_BENEATH		0x00000200 /* Mount beneath top mount */
-#define MOVE_MOUNT__MASK		0x00000377
+#define MOVE_MOUNT__MASK		0x000003f7
 
 /*
  * fsopen() flags.
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 10/13] arch: Wire up rootns system calls
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (8 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 09/13] fs: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 11/13] docs: Document root namespace uAPI Jarkko Sakkinen
                   ` (3 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Now that the core root namespace lifecycle and VFS mount-tree
installation are in place, expose rootns_create() (473), rootns_wait()
(474), and rootns_kill() (475) across all architecture system call
tables and asm-generic unistd.h.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 arch/alpha/kernel/syscalls/syscall.tbl      |  3 +++
 arch/arm/tools/syscall.tbl                  |  3 +++
 arch/arm64/tools/syscall_32.tbl             |  3 +++
 arch/m68k/kernel/syscalls/syscall.tbl       |  3 +++
 arch/microblaze/kernel/syscalls/syscall.tbl |  3 +++
 arch/mips/kernel/syscalls/syscall_n32.tbl   |  3 +++
 arch/mips/kernel/syscalls/syscall_n64.tbl   |  3 +++
 arch/mips/kernel/syscalls/syscall_o32.tbl   |  3 +++
 arch/parisc/kernel/syscalls/syscall.tbl     |  3 +++
 arch/powerpc/kernel/syscalls/syscall.tbl    |  3 +++
 arch/s390/kernel/syscalls/syscall.tbl       |  3 +++
 arch/sh/kernel/syscalls/syscall.tbl         |  3 +++
 arch/sparc/kernel/syscalls/syscall.tbl      |  3 +++
 arch/x86/entry/syscalls/syscall_32.tbl      |  3 +++
 arch/x86/entry/syscalls/syscall_64.tbl      |  3 +++
 arch/xtensa/kernel/syscalls/syscall.tbl     |  3 +++
 include/uapi/asm-generic/unistd.h           | 10 +++++++++-
 scripts/syscall.tbl                         |  3 +++
 18 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/arch/alpha/kernel/syscalls/syscall.tbl b/arch/alpha/kernel/syscalls/syscall.tbl
index 52e3538cc7df..c7bec286deff 100644
--- a/arch/alpha/kernel/syscalls/syscall.tbl
+++ b/arch/alpha/kernel/syscalls/syscall.tbl
@@ -512,3 +512,6 @@
 580	common	listns				sys_listns
 581	common	rseq_slice_yield		sys_rseq_slice_yield
 582	common	fchroot				sys_fchroot
+583	common	rootns_create			sys_rootns_create
+584	common	rootns_wait			sys_rootns_wait
+585	common	rootns_kill			sys_rootns_kill
diff --git a/arch/arm/tools/syscall.tbl b/arch/arm/tools/syscall.tbl
index 55717ed32c27..59f78bf991c9 100644
--- a/arch/arm/tools/syscall.tbl
+++ b/arch/arm/tools/syscall.tbl
@@ -487,3 +487,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/arm64/tools/syscall_32.tbl b/arch/arm64/tools/syscall_32.tbl
index df2d1d82fb3c..8ef57696c6a8 100644
--- a/arch/arm64/tools/syscall_32.tbl
+++ b/arch/arm64/tools/syscall_32.tbl
@@ -484,3 +484,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait		compat_sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/m68k/kernel/syscalls/syscall.tbl b/arch/m68k/kernel/syscalls/syscall.tbl
index ba7a4d8903d0..36eb16ae659f 100644
--- a/arch/m68k/kernel/syscalls/syscall.tbl
+++ b/arch/m68k/kernel/syscalls/syscall.tbl
@@ -472,3 +472,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/microblaze/kernel/syscalls/syscall.tbl b/arch/microblaze/kernel/syscalls/syscall.tbl
index 76d7cbe2a133..54739d61a9ee 100644
--- a/arch/microblaze/kernel/syscalls/syscall.tbl
+++ b/arch/microblaze/kernel/syscalls/syscall.tbl
@@ -478,3 +478,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/mips/kernel/syscalls/syscall_n32.tbl b/arch/mips/kernel/syscalls/syscall_n32.tbl
index 9ae88e4eac61..f0a58c6b4516 100644
--- a/arch/mips/kernel/syscalls/syscall_n32.tbl
+++ b/arch/mips/kernel/syscalls/syscall_n32.tbl
@@ -411,3 +411,6 @@
 470	n32	listns				sys_listns
 471	n32	rseq_slice_yield		sys_rseq_slice_yield
 472	n32	fchroot				sys_fchroot
+473	n32	rootns_create			sys_rootns_create
+474	n32	rootns_wait			compat_sys_rootns_wait
+475	n32	rootns_kill			sys_rootns_kill
diff --git a/arch/mips/kernel/syscalls/syscall_n64.tbl b/arch/mips/kernel/syscalls/syscall_n64.tbl
index 83dc93a0712f..c1d2774c6283 100644
--- a/arch/mips/kernel/syscalls/syscall_n64.tbl
+++ b/arch/mips/kernel/syscalls/syscall_n64.tbl
@@ -387,3 +387,6 @@
 470	n64	listns				sys_listns
 471	n64	rseq_slice_yield		sys_rseq_slice_yield
 472	n64	fchroot				sys_fchroot
+473	n64	rootns_create			sys_rootns_create
+474	n64	rootns_wait			sys_rootns_wait
+475	n64	rootns_kill			sys_rootns_kill
diff --git a/arch/mips/kernel/syscalls/syscall_o32.tbl b/arch/mips/kernel/syscalls/syscall_o32.tbl
index 9c62429c9b7b..99a753234dbf 100644
--- a/arch/mips/kernel/syscalls/syscall_o32.tbl
+++ b/arch/mips/kernel/syscalls/syscall_o32.tbl
@@ -460,3 +460,6 @@
 470	o32	listns				sys_listns
 471	o32	rseq_slice_yield		sys_rseq_slice_yield
 472	o32	fchroot				sys_fchroot
+473	o32	rootns_create			sys_rootns_create
+474	o32	rootns_wait			sys_rootns_wait			compat_sys_rootns_wait
+475	o32	rootns_kill			sys_rootns_kill
diff --git a/arch/parisc/kernel/syscalls/syscall.tbl b/arch/parisc/kernel/syscalls/syscall.tbl
index 88adc4016cce..f3bac8085491 100644
--- a/arch/parisc/kernel/syscalls/syscall.tbl
+++ b/arch/parisc/kernel/syscalls/syscall.tbl
@@ -471,3 +471,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait			compat_sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/powerpc/kernel/syscalls/syscall.tbl b/arch/powerpc/kernel/syscalls/syscall.tbl
index cfbb70039ff0..7ab1948f76b7 100644
--- a/arch/powerpc/kernel/syscalls/syscall.tbl
+++ b/arch/powerpc/kernel/syscalls/syscall.tbl
@@ -563,3 +563,6 @@
 470	common	listns				sys_listns
 471	nospu	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	nospu	rootns_create			sys_rootns_create
+474	nospu	rootns_wait			sys_rootns_wait			compat_sys_rootns_wait
+475	nospu	rootns_kill			sys_rootns_kill
diff --git a/arch/s390/kernel/syscalls/syscall.tbl b/arch/s390/kernel/syscalls/syscall.tbl
index 1b45e68a217b..7f8cd4147860 100644
--- a/arch/s390/kernel/syscalls/syscall.tbl
+++ b/arch/s390/kernel/syscalls/syscall.tbl
@@ -399,3 +399,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/sh/kernel/syscalls/syscall.tbl b/arch/sh/kernel/syscalls/syscall.tbl
index ace068dff0de..9bfcb96dcdeb 100644
--- a/arch/sh/kernel/syscalls/syscall.tbl
+++ b/arch/sh/kernel/syscalls/syscall.tbl
@@ -476,3 +476,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/sparc/kernel/syscalls/syscall.tbl b/arch/sparc/kernel/syscalls/syscall.tbl
index 5b9fe0e8140f..a847f4cbea3a 100644
--- a/arch/sparc/kernel/syscalls/syscall.tbl
+++ b/arch/sparc/kernel/syscalls/syscall.tbl
@@ -518,3 +518,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait			compat_sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index 2c172ef48dfd..e49c96692038 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -478,3 +478,6 @@
 470	i386	listns			sys_listns
 471	i386	rseq_slice_yield	sys_rseq_slice_yield
 472	i386	fchroot			sys_fchroot
+473	i386	rootns_create		sys_rootns_create
+474	i386	rootns_wait		sys_rootns_wait		compat_sys_rootns_wait
+475	i386	rootns_kill		sys_rootns_kill
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index d5b6045b0090..d6f7fb7be172 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -397,6 +397,9 @@
 470	common	listns			sys_listns
 471	common	rseq_slice_yield	sys_rseq_slice_yield
 472	common	fchroot			sys_fchroot
+473	common	rootns_create		sys_rootns_create
+474	common	rootns_wait		sys_rootns_wait
+475	common	rootns_kill		sys_rootns_kill
 
 #
 # Due to a historical design error, certain syscalls are numbered differently
diff --git a/arch/xtensa/kernel/syscalls/syscall.tbl b/arch/xtensa/kernel/syscalls/syscall.tbl
index d354bb231796..268c0d577788 100644
--- a/arch/xtensa/kernel/syscalls/syscall.tbl
+++ b/arch/xtensa/kernel/syscalls/syscall.tbl
@@ -443,3 +443,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/unistd.h
index 5b7e77a7c736..571db09eb571 100644
--- a/include/uapi/asm-generic/unistd.h
+++ b/include/uapi/asm-generic/unistd.h
@@ -867,8 +867,16 @@ __SYSCALL(__NR_rseq_slice_yield, sys_rseq_slice_yield)
 #define __NR_fchroot 472
 __SYSCALL(__NR_fchroot, sys_fchroot)
 
+/* kernel/rootns.c */
+#define __NR_rootns_create 473
+__SYSCALL(__NR_rootns_create, sys_rootns_create)
+#define __NR_rootns_wait 474
+__SC_COMP(__NR_rootns_wait, sys_rootns_wait, compat_sys_rootns_wait)
+#define __NR_rootns_kill 475
+__SYSCALL(__NR_rootns_kill, sys_rootns_kill)
+
 #undef __NR_syscalls
-#define __NR_syscalls 473
+#define __NR_syscalls 476
 
 /*
  * 32 bit systems traditionally used different
diff --git a/scripts/syscall.tbl b/scripts/syscall.tbl
index 0ab531605120..e9ff99c03b2b 100644
--- a/scripts/syscall.tbl
+++ b/scripts/syscall.tbl
@@ -413,3 +413,6 @@
 470	common	listns				sys_listns
 471	common	rseq_slice_yield		sys_rseq_slice_yield
 472	common	fchroot				sys_fchroot
+473	common	rootns_create			sys_rootns_create
+474	common	rootns_wait			sys_rootns_wait			compat_sys_rootns_wait
+475	common	rootns_kill			sys_rootns_kill
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 11/13] docs: Document root namespace uAPI
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (9 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 10/13] arch: Wire up rootns system calls Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 12/13] selftests/rootns: Add root namespace test suite Jarkko Sakkinen
                   ` (2 subsequent siblings)
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Userspace container managers need a clear specification of rootns state
transitions, namespace fd ioctls, mount-tree construction, credential
rules, and process creation semantics.

Add Documentation/userspace-api/rootns.rst to include the kernel-doc
sections and system call reference from kernel/rootns.c,
include/uapi/linux/rootns.h, fs/fsopen.c, and fs/namespace.c, and
register the rootns ioctl magic in ioctl-number.rst.

Co-developed-by: David Howells <dhowells@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 Documentation/userspace-api/index.rst         |  1 +
 .../userspace-api/ioctl/ioctl-number.rst      |  1 +
 Documentation/userspace-api/rootns.rst        | 47 +++++++++++++++++++
 3 files changed, 49 insertions(+)
 create mode 100644 Documentation/userspace-api/rootns.rst

diff --git a/Documentation/userspace-api/index.rst b/Documentation/userspace-api/index.rst
index a68b1bea57a8..56d0ac4eb087 100644
--- a/Documentation/userspace-api/index.rst
+++ b/Documentation/userspace-api/index.rst
@@ -17,6 +17,7 @@ System calls
    :maxdepth: 1
 
    unshare
+   rootns
    futex2
    ebpf/index
    ioctl/index
diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst
index dbe462040999..d8dc926ea283 100644
--- a/Documentation/userspace-api/ioctl/ioctl-number.rst
+++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
@@ -385,6 +385,7 @@ Code  Seq#    Include File                                             Comments
 0xB8  01-02  uapi/misc/mrvl_cn10k_dpi.h                                Marvell CN10K DPI driver
 0xB8  all    uapi/linux/mshv.h                                         Microsoft Hyper-V /dev/mshv driver
                                                                        <mailto:linux-hyperv@vger.kernel.org>
+0xB9  00-0F  uapi/linux/rootns.h                                       Root namespace uAPI
 0xBA  00-0F  uapi/linux/liveupdate.h                                   Pasha Tatashin
                                                                        <mailto:pasha.tatashin@soleen.com>
 0xC0  00-0F  linux/usb/iowarrior.h
diff --git a/Documentation/userspace-api/rootns.rst b/Documentation/userspace-api/rootns.rst
new file mode 100644
index 000000000000..a7724539a9fe
--- /dev/null
+++ b/Documentation/userspace-api/rootns.rst
@@ -0,0 +1,47 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+===================
+Root namespace uAPI
+===================
+
+Overview
+========
+
+.. kernel-doc:: kernel/rootns.c
+   :doc: Overview
+
+Flags
+=====
+
+.. kernel-doc:: include/uapi/linux/rootns.h
+   :identifiers: rootns_flags
+
+Ioctls
+======
+
+.. kernel-doc:: include/uapi/linux/rootns.h
+   :doc: ROOTNS_GET_NSFD
+
+System calls
+============
+
+.. kernel-doc:: kernel/rootns.c
+   :identifiers: sys_rootns_create sys_rootns_wait sys_rootns_kill
+
+Process creation
+================
+
+.. kernel-doc:: kernel/rootns.c
+   :doc: CLONE_INTO_ROOTNS
+
+Filesystem configuration
+========================
+
+.. kernel-doc:: fs/fsopen.c
+   :doc: FSCONFIG_SET_ROOTNS
+
+Mount tree installation
+=======================
+
+.. kernel-doc:: fs/namespace.c
+   :doc: MOVE_MOUNT_T_MNTNS
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 12/13] selftests/rootns: Add root namespace test suite
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (10 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 11/13] docs: Document root namespace uAPI Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:35 ` [RFC PATCH v3 13/13] MAINTAINERS: Add entry for ROOT NAMESPACE Jarkko Sakkinen
  2026-11-18 19:54 ` [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Verify the root namespace and mount-namespace configuration uAPI and
security invariants across privileged, unprivileged, and edge-case
scenarios.

Add a kselftest harness suite under tools/testing/selftests/rootns
exercising rootns creation, ROOTNS_GET_NSFD, clone3(CLONE_INTO_ROOTNS)
init and concurrent bootstrap lifecycle, poll(EPOLLHUP) and
WNOHANG/rusage reporting, unprivileged external FSCONFIG_SET_ROOTNS and
MOVE_MOUNT_T_MNTNS setup without entering a user namespace, hot-mounting
into existing mount namespaces, pivot_root(), and setns() isolation.

Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 tools/testing/selftests/Makefile          |    1 +
 tools/testing/selftests/rootns/.gitignore |    2 +
 tools/testing/selftests/rootns/Makefile   |    5 +
 tools/testing/selftests/rootns/config     |   10 +
 tools/testing/selftests/rootns/smoke.c    | 1934 +++++++++++++++++++++
 5 files changed, 1952 insertions(+)
 create mode 100644 tools/testing/selftests/rootns/.gitignore
 create mode 100644 tools/testing/selftests/rootns/Makefile
 create mode 100644 tools/testing/selftests/rootns/config
 create mode 100644 tools/testing/selftests/rootns/smoke.c

diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 07c3719f8b04..7c44f93e57a4 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -117,6 +117,7 @@ TARGETS += rdma
 TARGETS += resctrl
 TARGETS += riscv
 TARGETS += rlimits
+TARGETS += rootns
 TARGETS += rseq
 TARGETS += rtc
 TARGETS += rust
diff --git a/tools/testing/selftests/rootns/.gitignore b/tools/testing/selftests/rootns/.gitignore
new file mode 100644
index 000000000000..9a018c20d310
--- /dev/null
+++ b/tools/testing/selftests/rootns/.gitignore
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+/smoke
diff --git a/tools/testing/selftests/rootns/Makefile b/tools/testing/selftests/rootns/Makefile
new file mode 100644
index 000000000000..79162fba3c2b
--- /dev/null
+++ b/tools/testing/selftests/rootns/Makefile
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0
+
+CFLAGS += -Wall -Wextra -O2 -g $(KHDR_INCLUDES)
+TEST_GEN_PROGS := smoke
+include ../lib.mk
diff --git a/tools/testing/selftests/rootns/config b/tools/testing/selftests/rootns/config
new file mode 100644
index 000000000000..21b1aecc003b
--- /dev/null
+++ b/tools/testing/selftests/rootns/config
@@ -0,0 +1,10 @@
+CONFIG_CGROUPS=y
+CONFIG_IPC_NS=y
+CONFIG_NET_NS=y
+CONFIG_PID_NS=y
+CONFIG_PROC_FS=y
+CONFIG_ROOTNS=y
+CONFIG_TIME_NS=y
+CONFIG_TMPFS=y
+CONFIG_USER_NS=y
+CONFIG_UTS_NS=y
diff --git a/tools/testing/selftests/rootns/smoke.c b/tools/testing/selftests/rootns/smoke.c
new file mode 100644
index 000000000000..f0e3158ea4be
--- /dev/null
+++ b/tools/testing/selftests/rootns/smoke.c
@@ -0,0 +1,1934 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2026 Opinsys Oy
+ */
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <linux/magic.h>
+#include <linux/mount.h>
+#include <linux/nsfs.h>
+#include <linux/rootns.h>
+#include <linux/sched.h>
+#include "kselftest_harness.h"
+
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434
+#endif
+
+#ifndef __NR_clone3
+#define __NR_clone3 435
+#endif
+
+#ifndef __NR_rootns_create
+#if defined(__alpha__)
+#define __NR_rootns_create 583
+#define __NR_rootns_wait 584
+#define __NR_rootns_kill 585
+#elif defined(__mips__)
+#if defined(_MIPS_SIM) && defined(_MIPS_SIM_ABI32) && _MIPS_SIM == _MIPS_SIM_ABI32
+#define __NR_rootns_create (4000 + 473)
+#define __NR_rootns_wait (4000 + 474)
+#define __NR_rootns_kill (4000 + 475)
+#elif defined(_MIPS_SIM) && defined(_MIPS_SIM_NABI32) && _MIPS_SIM == _MIPS_SIM_NABI32
+#define __NR_rootns_create (6000 + 473)
+#define __NR_rootns_wait (6000 + 474)
+#define __NR_rootns_kill (6000 + 475)
+#else
+#define __NR_rootns_create (5000 + 473)
+#define __NR_rootns_wait (5000 + 474)
+#define __NR_rootns_kill (5000 + 475)
+#endif
+#else
+#define __NR_rootns_create 473
+#define __NR_rootns_wait 474
+#define __NR_rootns_kill 475
+#endif
+#endif
+
+#ifndef MNT_DETACH
+#define MNT_DETACH 2
+#endif
+
+#ifndef AT_RECURSIVE
+#define AT_RECURSIVE 0x8000
+#endif
+
+static int sys_umount2(const char *target, int flags)
+{
+	return syscall(__NR_umount2, target, flags);
+}
+
+static int sys_open_tree(int dfd, const char *path, unsigned int flags)
+{
+	return syscall(__NR_open_tree, dfd, path, flags);
+}
+
+static int sys_move_mount(int from_dfd, const char *from_path, int to_dfd,
+			  const char *to_path, unsigned int flags)
+{
+	return syscall(__NR_move_mount, from_dfd, from_path, to_dfd, to_path,
+		       flags);
+}
+
+static int sys_fsopen(const char *fsname, unsigned int flags)
+{
+	return syscall(__NR_fsopen, fsname, flags);
+}
+
+static int sys_fsconfig(int fsfd, unsigned int cmd, const char *key,
+			const void *value, int aux)
+{
+	return syscall(__NR_fsconfig, fsfd, cmd, key, value, aux);
+}
+
+static int sys_fsmount(int fsfd, unsigned int flags, unsigned int attr_flags)
+{
+	return syscall(__NR_fsmount, fsfd, flags, attr_flags);
+}
+
+static int sys_pidfd_open(pid_t pid, unsigned int flags)
+{
+	return syscall(__NR_pidfd_open, pid, flags);
+}
+
+static int sys_pivot_root(const char *new_root, const char *put_old)
+{
+	return syscall(__NR_pivot_root, new_root, put_old);
+}
+
+static int sys_rootns_create(unsigned int flags)
+{
+	return syscall(__NR_rootns_create, flags);
+}
+
+static int rootns_get_nsfd(int cfd, unsigned long nstype)
+{
+	return ioctl(cfd, ROOTNS_GET_NSFD, nstype);
+}
+
+static pid_t sys_clone3(struct clone_args *args, size_t size)
+{
+	fflush(stdout);
+	fflush(stderr);
+	return syscall(__NR_clone3, args, size);
+}
+
+static pid_t clone_into_rootns(int cfd, __u64 extra_flags)
+{
+	struct clone_args args = {
+		.flags = CLONE_INTO_ROOTNS | extra_flags,
+		.exit_signal = SIGCHLD,
+		.rootns = (__u64)(unsigned int)cfd,
+	};
+
+	return sys_clone3(&args, sizeof(args));
+}
+
+static int sys_rootns_wait(int cfd, int *status, unsigned int options,
+			   struct rusage *ru)
+{
+	return syscall(__NR_rootns_wait, cfd, status, options, ru);
+}
+
+static int sys_rootns_kill(int cfd, int sig)
+{
+	return syscall(__NR_rootns_kill, cfd, sig);
+}
+
+static int wait_for_pid_exit(pid_t pid, int *status, int timeout_ms)
+{
+	struct pollfd pfd;
+	int pidfd;
+	int ret;
+
+	pidfd = sys_pidfd_open(pid, 0);
+	if (pidfd >= 0) {
+		pfd.fd = pidfd;
+		pfd.events = POLLIN;
+		do {
+			ret = poll(&pfd, 1, timeout_ms);
+		} while (ret < 0 && errno == EINTR);
+		close(pidfd);
+
+		if (ret == 0) {
+			errno = ETIMEDOUT;
+			return -1;
+		}
+		if (ret < 0)
+			return -1;
+	} else if (errno != ESRCH) {
+		return -1;
+	}
+
+	do {
+		ret = waitpid(pid, status, 0);
+	} while (ret < 0 && errno == EINTR);
+
+	return (ret == pid) ? 0 : -1;
+}
+
+static void kill_and_reap_pid(pid_t pid)
+{
+	int status;
+
+	if (pid <= 0)
+		return;
+	if (kill(pid, SIGKILL) < 0 && errno != ESRCH)
+		return;
+	(void)waitpid(pid, &status, 0);
+}
+
+static int reap_child_exit_code(pid_t pid)
+{
+	int status = 0;
+
+	if (wait_for_pid_exit(pid, &status, 5000) < 0) {
+		kill_and_reap_pid(pid);
+		return -1;
+	}
+	if (!WIFEXITED(status))
+		return -2;
+	return WEXITSTATUS(status);
+}
+
+static int clone_exit(void *arg)
+{
+	(void)arg;
+	return 0;
+}
+
+static int clone_with_flags(int flags)
+{
+	const size_t stack_size = 64 * 1024;
+	void *stack;
+	pid_t pid;
+	int status;
+	int ret;
+
+	stack = malloc(stack_size);
+	if (!stack)
+		return -ENOMEM;
+
+	pid = clone(clone_exit, (char *)stack + stack_size,
+		    SIGCHLD | flags, NULL);
+	if (pid < 0)
+		ret = -errno;
+	else if (waitpid(pid, &status, 0) < 0)
+		ret = -errno;
+	else if (!WIFEXITED(status) || WEXITSTATUS(status))
+		ret = -EIO;
+	else
+		ret = 0;
+
+	free(stack);
+	return ret;
+}
+
+static int send_fd(int sockfd, int fd)
+{
+	char control[CMSG_SPACE(sizeof(fd))];
+	char marker = 'R';
+	struct iovec iov = {
+		.iov_base = &marker,
+		.iov_len = sizeof(marker),
+	};
+	struct msghdr msg = {
+		.msg_iov = &iov,
+		.msg_iovlen = 1,
+		.msg_control = control,
+		.msg_controllen = sizeof(control),
+	};
+	struct cmsghdr *cmsg;
+
+	memset(control, 0, sizeof(control));
+	cmsg = CMSG_FIRSTHDR(&msg);
+	cmsg->cmsg_level = SOL_SOCKET;
+	cmsg->cmsg_type = SCM_RIGHTS;
+	cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
+	memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
+
+	return (sendmsg(sockfd, &msg, 0) < 0) ? -1 : 0;
+}
+
+static int recv_fd(int sockfd)
+{
+	char control[CMSG_SPACE(sizeof(int))];
+	char marker;
+	int fd;
+	struct iovec iov = {
+		.iov_base = &marker,
+		.iov_len = sizeof(marker),
+	};
+	struct msghdr msg = {
+		.msg_iov = &iov,
+		.msg_iovlen = 1,
+		.msg_control = control,
+		.msg_controllen = sizeof(control),
+	};
+	struct cmsghdr *cmsg;
+	ssize_t n;
+
+	memset(control, 0, sizeof(control));
+	n = recvmsg(sockfd, &msg, 0);
+	if (n <= 0) {
+		if (n == 0)
+			errno = EPROTO;
+		return -1;
+	}
+
+	cmsg = CMSG_FIRSTHDR(&msg);
+	if (!cmsg ||
+	    cmsg->cmsg_level != SOL_SOCKET ||
+	    cmsg->cmsg_type != SCM_RIGHTS ||
+	    cmsg->cmsg_len < CMSG_LEN(sizeof(fd))) {
+		errno = EPROTO;
+		return -1;
+	}
+
+	memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd));
+	return fd;
+}
+
+static int send_unshared_mntns_and_wait(int sockfd)
+{
+	ssize_t nread;
+	char ch;
+	int nsfd;
+	int ret;
+
+	if (unshare(CLONE_NEWNS) < 0)
+		return 1;
+
+	nsfd = open("/proc/self/ns/mnt", O_RDONLY | O_CLOEXEC);
+	if (nsfd < 0)
+		return 2;
+
+	ret = send_fd(sockfd, nsfd);
+	close(nsfd);
+	if (ret < 0)
+		return 3;
+
+	nread = read(sockfd, &ch, sizeof(ch));
+	if (nread != (ssize_t)sizeof(ch))
+		return 4;
+
+	return 0;
+}
+
+static int create_rootns_as_uid(uid_t uid, unsigned int flags, int *cfd)
+{
+	int pipefd[2];
+	ssize_t nread;
+	int err = 0;
+	int status;
+	int sv[2];
+	pid_t pid;
+
+	*cfd = -1;
+	if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0)
+		return -errno;
+
+	if (pipe2(pipefd, O_CLOEXEC) < 0) {
+		err = -errno;
+		close(sv[0]);
+		close(sv[1]);
+		return err;
+	}
+
+	pid = fork();
+	if (pid < 0) {
+		err = -errno;
+		close(pipefd[0]);
+		close(pipefd[1]);
+		close(sv[0]);
+		close(sv[1]);
+		return err;
+	}
+
+	if (pid == 0) {
+		int child_fd = -1;
+
+		close(pipefd[0]);
+		close(sv[0]);
+
+		if (setresuid(uid, uid, uid) < 0) {
+			err = errno;
+			goto out_child;
+		}
+
+		child_fd = sys_rootns_create(flags);
+		if (child_fd < 0) {
+			err = errno;
+			goto out_child;
+		}
+
+		if (send_fd(sv[1], child_fd) < 0)
+			err = errno;
+
+out_child:
+		if (child_fd >= 0)
+			close(child_fd);
+		(void)write(pipefd[1], &err, sizeof(err));
+		close(pipefd[1]);
+		close(sv[1]);
+		_exit(err ? 1 : 0);
+	}
+
+	close(pipefd[1]);
+	close(sv[1]);
+
+	nread = read(pipefd[0], &err, sizeof(err));
+	close(pipefd[0]);
+	if (nread != (ssize_t)sizeof(err))
+		err = (nread < 0) ? errno : EPROTO;
+
+	if (!err) {
+		*cfd = recv_fd(sv[0]);
+		if (*cfd < 0)
+			err = errno;
+	}
+	close(sv[0]);
+
+	if (waitpid(pid, &status, 0) != pid) {
+		if (!err)
+			err = errno;
+	} else if (!err && (!WIFEXITED(status) || WEXITSTATUS(status))) {
+		err = ECHILD;
+	}
+
+	if (err && *cfd >= 0) {
+		close(*cfd);
+		*cfd = -1;
+	}
+
+	return err ? -err : 0;
+}
+
+static int mount_root_with_dirs(int cfd, bool make_dirs)
+{
+	static const char *const dirs[] = { "proc", "mnt", "tmp" };
+	int saved_errno;
+	int mntns_fd;
+	int rootfd;
+	int fsfd;
+	size_t i;
+
+	mntns_fd = rootns_get_nsfd(cfd, CLONE_NEWNS);
+	if (mntns_fd < 0)
+		return -1;
+
+	fsfd = sys_fsopen("tmpfs", 0);
+	if (fsfd < 0)
+		goto err_mntns;
+
+	if (sys_fsconfig(fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL, cfd) < 0)
+		goto err_fsfd;
+	if (sys_fsconfig(fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) < 0)
+		goto err_fsfd;
+
+	rootfd = sys_fsmount(fsfd, 0, 0);
+	if (rootfd < 0)
+		goto err_fsfd;
+
+	if (make_dirs) {
+		for (i = 0; i < ARRAY_SIZE(dirs); i++) {
+			if (mkdirat(rootfd, dirs[i], 0755) < 0 &&
+			    errno != EEXIST)
+				goto err_rootfd;
+		}
+	}
+
+	if (sys_move_mount(rootfd, "", mntns_fd, "/",
+			   MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS) < 0)
+		goto err_rootfd;
+
+	close(rootfd);
+	close(fsfd);
+	close(mntns_fd);
+	return 0;
+
+err_rootfd:
+	saved_errno = errno;
+	close(rootfd);
+	errno = saved_errno;
+err_fsfd:
+	saved_errno = errno;
+	close(fsfd);
+	errno = saved_errno;
+err_mntns:
+	saved_errno = errno;
+	close(mntns_fd);
+	errno = saved_errno;
+	return -1;
+}
+
+static int mount_root(int cfd)
+{
+	return mount_root_with_dirs(cfd, true);
+}
+
+static int mount_proc(int cfd, bool need_proc)
+{
+	const char *fstype = need_proc ? "proc" : "tmpfs";
+	int saved_errno;
+	int mntns_fd;
+	int fsfd;
+	int mfd;
+
+	mntns_fd = rootns_get_nsfd(cfd, CLONE_NEWNS);
+	if (mntns_fd < 0)
+		return -1;
+
+	fsfd = sys_fsopen(fstype, 0);
+	if (fsfd < 0)
+		goto err_mntns;
+
+	if (sys_fsconfig(fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL, cfd) < 0)
+		goto err_fsfd;
+	if (sys_fsconfig(fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) < 0)
+		goto err_fsfd;
+
+	mfd = sys_fsmount(fsfd, 0, 0);
+	if (mfd < 0)
+		goto err_fsfd;
+
+	if (sys_move_mount(mfd, "", mntns_fd, "proc",
+			   MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS) < 0) {
+		saved_errno = errno;
+		close(mfd);
+		errno = saved_errno;
+		goto err_fsfd;
+	}
+
+	close(mfd);
+	close(fsfd);
+	close(mntns_fd);
+	return 0;
+
+err_fsfd:
+	saved_errno = errno;
+	close(fsfd);
+	errno = saved_errno;
+err_mntns:
+	saved_errno = errno;
+	close(mntns_fd);
+	errno = saved_errno;
+	return -1;
+}
+
+static int create_test_rootns(bool need_proc, unsigned int flags)
+{
+	int saved_errno;
+	int cfd;
+
+	cfd = sys_rootns_create(flags);
+	if (cfd < 0)
+		return -1;
+
+	if (mount_root(cfd) < 0 || mount_proc(cfd, need_proc) < 0) {
+		saved_errno = errno;
+		close(cfd);
+		errno = saved_errno;
+		return -1;
+	}
+
+	return cfd;
+}
+
+static int write_pid_id_maps(pid_t pid, uid_t uid, gid_t gid)
+{
+	char path[64];
+	char map[32];
+	int len;
+	int fd;
+
+	snprintf(path, sizeof(path), "/proc/%d/setgroups", (int)pid);
+	fd = open(path, O_WRONLY | O_CLOEXEC);
+	if (fd >= 0) {
+		(void)write(fd, "deny\n", 5);
+		close(fd);
+	}
+
+	snprintf(path, sizeof(path), "/proc/%d/uid_map", (int)pid);
+	fd = open(path, O_WRONLY | O_CLOEXEC);
+	if (fd < 0)
+		return -errno;
+	len = snprintf(map, sizeof(map), "0 %u 1\n", (unsigned int)uid);
+	if (write(fd, map, (size_t)len) != len) {
+		close(fd);
+		return -EIO;
+	}
+	close(fd);
+
+	snprintf(path, sizeof(path), "/proc/%d/gid_map", (int)pid);
+	fd = open(path, O_WRONLY | O_CLOEXEC);
+	if (fd < 0)
+		return -errno;
+	len = snprintf(map, sizeof(map), "0 %u 1\n", (unsigned int)gid);
+	if (write(fd, map, (size_t)len) != len) {
+		close(fd);
+		return -EIO;
+	}
+	close(fd);
+
+	return 0;
+}
+
+static int drop_to_unpriv_uid(uid_t uid)
+{
+	if (geteuid() == 0) {
+		if (setresgid(uid, uid, uid) < 0 ||
+		    setresuid(uid, uid, uid) < 0 ||
+		    prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) < 0)
+			return -errno;
+	}
+	return 0;
+}
+
+static int enter_unpriv_user_mntns(uid_t drop_uid)
+{
+	char map[32];
+	uid_t uid;
+	gid_t gid;
+	int ret;
+	int fd;
+	int len;
+
+	ret = drop_to_unpriv_uid(drop_uid);
+	if (ret < 0)
+		return ret;
+
+	uid = geteuid();
+	gid = getegid();
+	if (unshare(CLONE_NEWUSER | CLONE_NEWNS) < 0)
+		return -errno;
+
+	fd = open("/proc/self/setgroups", O_WRONLY | O_CLOEXEC);
+	if (fd >= 0) {
+		(void)write(fd, "deny\n", 5);
+		close(fd);
+	}
+
+	fd = open("/proc/self/uid_map", O_WRONLY | O_CLOEXEC);
+	if (fd < 0)
+		return -errno;
+	len = snprintf(map, sizeof(map), "0 %u 1\n", (unsigned int)uid);
+	if (write(fd, map, (size_t)len) != len) {
+		close(fd);
+		return -EIO;
+	}
+	close(fd);
+
+	fd = open("/proc/self/gid_map", O_WRONLY | O_CLOEXEC);
+	if (fd < 0)
+		return -errno;
+	len = snprintf(map, sizeof(map), "0 %u 1\n", (unsigned int)gid);
+	if (write(fd, map, (size_t)len) != len) {
+		close(fd);
+		return -EIO;
+	}
+	close(fd);
+
+	return 0;
+}
+
+FIXTURE(rootns) {
+	int cfd;
+};
+
+FIXTURE_SETUP(rootns) {
+	self->cfd = create_test_rootns(false, ROOTNS_KILL_ON_CLOSE |
+				       ROOTNS_CLOSE_ON_EXEC);
+	if (self->cfd < 0 && geteuid() != 0 &&
+	    (errno == EPERM || errno == EACCES || errno == EINVAL ||
+	     errno == ENOSPC || errno == EOVERFLOW))
+		SKIP(return, "pre-idmap submount setup requires mapped userns");
+	ASSERT_GE(self->cfd, 0);
+}
+
+FIXTURE_TEARDOWN(rootns) {
+	if (self->cfd >= 0)
+		close(self->cfd);
+}
+
+TEST_F(rootns, create) {
+	ASSERT_GE(self->cfd, 0);
+	ASSERT_EQ(sys_rootns_create(~ROOTNS_ALL_FLAGS), -1);
+	ASSERT_EQ(errno, EINVAL);
+}
+
+TEST_F(rootns, kill) {
+	int ready_pipe[2];
+	int hold_pipe[2];
+	char ch;
+	int status;
+	pid_t pid1;
+	pid_t pid2;
+	int ret;
+
+	ASSERT_EQ(pipe2(ready_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(hold_pipe, O_CLOEXEC), 0);
+
+	pid1 = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid1, 0);
+	if (pid1 == 0) {
+		close(self->cfd);
+		close(ready_pipe[0]);
+		close(ready_pipe[1]);
+		close(hold_pipe[0]);
+		close(hold_pipe[1]);
+		for (;;)
+			pause();
+	}
+
+	pid2 = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid2, 0);
+	if (pid2 == 0) {
+		pid_t child;
+
+		close(self->cfd);
+		close(ready_pipe[0]);
+		close(hold_pipe[0]);
+		child = fork();
+		if (child < 0)
+			_exit(1);
+		if (child == 0) {
+			ch = 'r';
+			(void)write(ready_pipe[1], &ch, 1);
+			close(ready_pipe[1]);
+			for (;;)
+				pause();
+		}
+		close(ready_pipe[1]);
+		close(hold_pipe[1]);
+		for (;;)
+			pause();
+	}
+	close(ready_pipe[1]);
+	close(hold_pipe[1]);
+
+	ASSERT_EQ(read(ready_pipe[0], &ch, 1), 1);
+	close(ready_pipe[0]);
+
+	ASSERT_EQ(sys_rootns_kill(self->cfd, SIGKILL), 0);
+	ASSERT_EQ(read(hold_pipe[0], &ch, 1), 0);
+	close(hold_pipe[0]);
+
+	ret = wait_for_pid_exit(pid2, &status, 5000);
+	if (ret < 0) {
+		kill_and_reap_pid(pid2);
+		kill_and_reap_pid(pid1);
+		ASSERT_EQ(ret, 0);
+	}
+	ASSERT_TRUE(WIFSIGNALED(status));
+	ASSERT_EQ(WTERMSIG(status), SIGKILL);
+
+	ret = wait_for_pid_exit(pid1, &status, 5000);
+	if (ret < 0) {
+		kill_and_reap_pid(pid1);
+		ASSERT_EQ(ret, 0);
+	}
+	ASSERT_TRUE(WIFSIGNALED(status));
+	ASSERT_EQ(WTERMSIG(status), SIGKILL);
+}
+
+TEST_F(rootns, wait) {
+	int status = 0;
+	pid_t pid;
+
+	pid = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0)
+		_exit(123);
+
+	ASSERT_EQ(sys_rootns_wait(self->cfd, &status, 0, NULL), pid);
+	ASSERT_TRUE(WIFEXITED(status));
+	ASSERT_EQ(WEXITSTATUS(status), 123);
+	ASSERT_EQ(reap_child_exit_code(pid), 123);
+}
+
+TEST_F(rootns, poll) {
+	struct pollfd pfd;
+	struct rusage ru;
+	int status = 0;
+	int pipefd[2];
+	pid_t pid;
+
+	ASSERT_EQ(pipe2(pipefd, O_CLOEXEC), 0);
+
+	pid = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		char ch;
+
+		close(self->cfd);
+		close(pipefd[1]);
+		(void)read(pipefd[0], &ch, 1);
+		close(pipefd[0]);
+		_exit(42);
+	}
+	close(pipefd[0]);
+
+	ASSERT_EQ(sys_rootns_wait(self->cfd, &status, WNOHANG, NULL), 0);
+
+	pfd.fd = self->cfd;
+	pfd.events = POLLIN;
+	pfd.revents = 0;
+	ASSERT_EQ(poll(&pfd, 1, 0), 0);
+
+	close(pipefd[1]);
+
+	ASSERT_EQ(poll(&pfd, 1, 5000), 1);
+	ASSERT_NE(pfd.revents & POLLHUP, 0);
+
+	memset(&ru, 0xff, sizeof(ru));
+	ASSERT_EQ(sys_rootns_wait(self->cfd, &status, WNOHANG, &ru), pid);
+	ASSERT_TRUE(WIFEXITED(status));
+	ASSERT_EQ(WEXITSTATUS(status), 42);
+	ASSERT_GE(ru.ru_utime.tv_sec, 0);
+	ASSERT_GE(ru.ru_maxrss, 0);
+	ASSERT_EQ(reap_child_exit_code(pid), 42);
+}
+
+TEST_F(rootns, clone_dead) {
+	int status = 0;
+	pid_t pid;
+
+	pid = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0)
+		_exit(0);
+
+	ASSERT_EQ(sys_rootns_wait(self->cfd, &status, 0, NULL), pid);
+	ASSERT_TRUE(WIFEXITED(status));
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+
+	ASSERT_EQ(clone_into_rootns(self->cfd, 0), -1);
+	ASSERT_EQ(errno, ESRCH);
+}
+
+TEST_F(rootns, nested_ns) {
+	int go_pipe[2];
+	pid_t pid;
+	int nsfd;
+	int ret;
+
+	nsfd = open("/proc/self/ns/mnt", O_RDONLY | O_CLOEXEC);
+	ASSERT_GE(nsfd, 0);
+	ASSERT_EQ(pipe2(go_pipe, O_CLOEXEC), 0);
+
+	pid = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		char ch;
+
+		close(self->cfd);
+		close(go_pipe[1]);
+		if (read(go_pipe[0], &ch, 1) != 1)
+			_exit(6);
+		close(go_pipe[0]);
+
+		if (unshare(CLONE_NEWNS))
+			_exit(1);
+		if (clone_with_flags(CLONE_NEWNS))
+			_exit(2);
+		if (clone_with_flags(CLONE_NEWUSER))
+			_exit(3);
+		if (unshare(CLONE_NEWUSER))
+			_exit(4);
+		if (setns(nsfd, CLONE_NEWNS) != -1 || errno != EPERM)
+			_exit(5);
+
+		close(nsfd);
+		_exit(0);
+	}
+	close(go_pipe[0]);
+	close(nsfd);
+
+	ret = write_pid_id_maps(pid, geteuid(), getegid());
+	if (ret < 0) {
+		close(go_pipe[1]);
+		kill_and_reap_pid(pid);
+		ASSERT_EQ(ret, 0);
+	}
+	ASSERT_EQ(write(go_pipe[1], "g", 1), 1);
+	close(go_pipe[1]);
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+}
+
+TEST_F(rootns, setns_same) {
+	unsigned int flags = ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC;
+	ssize_t nwritten;
+	pid_t pid1;
+	pid_t pid2;
+	char ch;
+	int nsfd;
+	int cfd;
+	int sv[2];
+
+	cfd = create_test_rootns(true, flags);
+	ASSERT_GE(cfd, 0);
+	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv), 0);
+
+	pid1 = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid1, 0);
+	if (pid1 == 0) {
+		int ret;
+
+		close(self->cfd);
+		close(cfd);
+		close(sv[0]);
+		ret = send_unshared_mntns_and_wait(sv[1]);
+		close(sv[1]);
+		_exit(ret);
+	}
+	close(sv[1]);
+
+	nsfd = recv_fd(sv[0]);
+	ASSERT_GE(nsfd, 0);
+
+	pid2 = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid2, 0);
+	if (pid2 == 0) {
+		int ret;
+
+		close(self->cfd);
+		close(cfd);
+		close(sv[0]);
+		ret = setns(nsfd, CLONE_NEWNS);
+		close(nsfd);
+		_exit(ret ? 1 : 0);
+	}
+	close(nsfd);
+
+	ASSERT_EQ(reap_child_exit_code(pid2), 0);
+
+	ch = 'x';
+	nwritten = write(sv[0], &ch, sizeof(ch));
+	ASSERT_EQ(nwritten, (ssize_t)sizeof(ch));
+	close(sv[0]);
+
+	ASSERT_EQ(reap_child_exit_code(pid1), 0);
+	close(cfd);
+}
+
+TEST_F(rootns, setns_foreign) {
+	unsigned int flags = ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC;
+	ssize_t nwritten;
+	int alpha_cfd;
+	int beta_cfd;
+	pid_t alpha_pid;
+	pid_t beta_pid;
+	char ch;
+	int nsfd;
+	int sv[2];
+
+	alpha_cfd = create_test_rootns(true, flags);
+	ASSERT_GE(alpha_cfd, 0);
+
+	beta_cfd = create_test_rootns(true, flags);
+	ASSERT_GE(beta_cfd, 0);
+
+	ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv), 0);
+
+	beta_pid = clone_into_rootns(beta_cfd, 0);
+	ASSERT_GE(beta_pid, 0);
+	if (beta_pid == 0) {
+		int ret;
+
+		close(self->cfd);
+		close(alpha_cfd);
+		close(beta_cfd);
+		close(sv[0]);
+		ret = send_unshared_mntns_and_wait(sv[1]);
+		close(sv[1]);
+		_exit(ret);
+	}
+	close(sv[1]);
+
+	nsfd = recv_fd(sv[0]);
+	ASSERT_GE(nsfd, 0);
+
+	alpha_pid = clone_into_rootns(alpha_cfd, 0);
+	ASSERT_GE(alpha_pid, 0);
+	if (alpha_pid == 0) {
+		int ret;
+
+		close(self->cfd);
+		close(alpha_cfd);
+		close(beta_cfd);
+		close(sv[0]);
+		ret = setns(nsfd, CLONE_NEWNS);
+		close(nsfd);
+		if (ret != -1 || errno != EPERM)
+			_exit(1);
+		_exit(0);
+	}
+	close(nsfd);
+
+	ASSERT_EQ(reap_child_exit_code(alpha_pid), 0);
+
+	ch = 'x';
+	nwritten = write(sv[0], &ch, sizeof(ch));
+	ASSERT_EQ(nwritten, (ssize_t)sizeof(ch));
+	close(sv[0]);
+
+	ASSERT_EQ(reap_child_exit_code(beta_pid), 0);
+
+	close(alpha_cfd);
+	close(beta_cfd);
+}
+
+TEST_F(rootns, submount) {
+	pid_t pid;
+
+	pid = clone_into_rootns(self->cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		struct statfs st;
+
+		close(self->cfd);
+		if (statfs("/proc", &st) < 0)
+			_exit(1);
+		if ((unsigned long)st.f_type != (unsigned long)TMPFS_MAGIC)
+			_exit(2);
+		_exit(0);
+	}
+
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+}
+
+TEST_F(rootns, proc) {
+	int cfd;
+	pid_t pid;
+
+	cfd = create_test_rootns(true, ROOTNS_KILL_ON_CLOSE |
+				 ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+
+	pid = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		struct statfs st;
+		char target[32];
+		ssize_t len;
+
+		close(self->cfd);
+		close(cfd);
+		if (getpid() != 1)
+			_exit(1);
+		if (statfs("/proc", &st) < 0)
+			_exit(2);
+		if ((unsigned long)st.f_type != (unsigned long)PROC_SUPER_MAGIC)
+			_exit(3);
+		len = readlink("/proc/self", target, sizeof(target) - 1);
+		if (len <= 0)
+			_exit(4);
+		target[len] = '\0';
+		if (strcmp(target, "1") != 0)
+			_exit(5);
+		_exit(0);
+	}
+
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+	close(cfd);
+}
+
+TEST_F(rootns, pivot_root) {
+	unsigned int flags = ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC;
+	int ready_pipe[2];
+	int hold_pipe[2];
+	int go_pipe[2];
+	pid_t pid2;
+	char ch;
+	int cfd;
+	pid_t pid;
+	int ret;
+
+	cfd = create_test_rootns(false, flags);
+	ASSERT_GE(cfd, 0);
+	ASSERT_EQ(pipe2(go_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(ready_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(hold_pipe, O_CLOEXEC), 0);
+
+	pid = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		int marker_fd;
+		int fsfd;
+		int mfd;
+		int nsfd;
+
+		close(self->cfd);
+		close(cfd);
+		close(go_pipe[1]);
+		close(ready_pipe[0]);
+		close(hold_pipe[1]);
+
+		if (read(go_pipe[0], &ch, 1) != 1)
+			_exit(13);
+		close(go_pipe[0]);
+
+		fsfd = sys_fsopen("tmpfs", 0);
+		if (fsfd < 0)
+			_exit(1);
+		if (sys_fsconfig(fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) < 0)
+			_exit(2);
+		mfd = sys_fsmount(fsfd, 0, 0);
+		close(fsfd);
+		if (mfd < 0)
+			_exit(3);
+		if (mkdirat(mfd, "old", 0755) < 0)
+			_exit(4);
+		marker_fd = openat(mfd, "pivoted",
+				   O_CREAT | O_WRONLY | O_CLOEXEC, 0644);
+		if (marker_fd < 0)
+			_exit(5);
+		close(marker_fd);
+		if (sys_move_mount(mfd, "", AT_FDCWD, "/mnt",
+				   MOVE_MOUNT_F_EMPTY_PATH) < 0)
+			_exit(6);
+		close(mfd);
+
+		if (chdir("/mnt") < 0)
+			_exit(7);
+		if (sys_pivot_root(".", "old") < 0)
+			_exit(8);
+		if (sys_umount2("/old", MNT_DETACH) < 0)
+			_exit(9);
+
+		nsfd = sys_open_tree(AT_FDCWD, "/",
+				     OPEN_TREE_NAMESPACE | OPEN_TREE_CLOEXEC);
+		if (nsfd < 0)
+			_exit(10);
+		if (setns(nsfd, CLONE_NEWNS) < 0)
+			_exit(11);
+		close(nsfd);
+
+		if (write(ready_pipe[1], "r", 1) != 1)
+			_exit(12);
+		close(ready_pipe[1]);
+		(void)read(hold_pipe[0], &ch, 1);
+		close(hold_pipe[0]);
+		_exit(0);
+	}
+	close(go_pipe[0]);
+	close(ready_pipe[1]);
+	close(hold_pipe[0]);
+
+	ret = write_pid_id_maps(pid, geteuid(), getegid());
+	if (ret < 0) {
+		close(go_pipe[1]);
+		close(ready_pipe[0]);
+		close(hold_pipe[1]);
+		kill_and_reap_pid(pid);
+		close(cfd);
+		ASSERT_EQ(ret, 0);
+	}
+	ASSERT_EQ(write(go_pipe[1], "g", 1), 1);
+	close(go_pipe[1]);
+
+	ASSERT_EQ(read(ready_pipe[0], &ch, 1), 1);
+	close(ready_pipe[0]);
+
+	pid2 = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid2, 0);
+	if (pid2 == 0) {
+		close(self->cfd);
+		close(cfd);
+		close(hold_pipe[1]);
+		if (access("/pivoted", F_OK) < 0)
+			_exit(1);
+		_exit(0);
+	}
+	ASSERT_EQ(reap_child_exit_code(pid2), 0);
+
+	close(hold_pipe[1]);
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+	close(cfd);
+}
+
+TEST_F(rootns, kill_on_close) {
+	int status;
+	pid_t pid;
+	int cfd;
+	int ret;
+
+	cfd = create_test_rootns(false, ROOTNS_KILL_ON_CLOSE);
+	ASSERT_GE(cfd, 0);
+
+	pid = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		close(self->cfd);
+		close(cfd);
+		for (;;)
+			pause();
+	}
+
+	close(cfd);
+
+	ret = wait_for_pid_exit(pid, &status, 5000);
+	if (ret < 0) {
+		kill_and_reap_pid(pid);
+		ASSERT_EQ(ret, 0);
+	}
+	ASSERT_TRUE(WIFSIGNALED(status));
+	ASSERT_EQ(WTERMSIG(status), SIGKILL);
+}
+
+TEST_F(rootns, mount_perms) {
+	int mntns_fd = -1;
+	int cfd = -1;
+	int rootfsfd;
+	pid_t pid;
+	int mfd;
+	int ret;
+
+	ret = create_rootns_as_uid(1000, ROOTNS_CLOSE_ON_EXEC, &cfd);
+	if (ret == -EPERM || ret == -EACCES || ret == -EINVAL)
+		SKIP(return, "unprivileged rootns creation is unavailable");
+	ASSERT_EQ(ret, 0);
+
+	mntns_fd = rootns_get_nsfd(cfd, CLONE_NEWNS);
+	ASSERT_GE(mntns_fd, 0);
+
+	pid = fork();
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		int u_fsfd;
+		int u_mfd;
+
+		close(self->cfd);
+		ret = enter_unpriv_user_mntns(2000);
+		if (ret == -EPERM || ret == -EACCES || ret == -EINVAL ||
+		    ret == -ENOSPC)
+			_exit(0);
+		if (ret < 0)
+			_exit(1);
+
+		if (rootns_get_nsfd(cfd, CLONE_NEWNS) != -1 || errno != EPERM)
+			_exit(2);
+
+		u_fsfd = sys_fsopen("tmpfs", 0);
+		if (u_fsfd < 0)
+			_exit(3);
+		if (sys_fsconfig(u_fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL,
+				 cfd) != -1 || errno != EPERM)
+			_exit(4);
+		if (sys_fsconfig(u_fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) < 0)
+			_exit(5);
+
+		u_mfd = sys_fsmount(u_fsfd, 0, 0);
+		if (u_mfd < 0)
+			_exit(6);
+		if (sys_move_mount(u_mfd, "", mntns_fd, "/",
+				   MOVE_MOUNT_F_EMPTY_PATH |
+				   MOVE_MOUNT_T_MNTNS) != -1 ||
+		    errno != EPERM)
+			_exit(7);
+
+		close(u_mfd);
+		close(u_fsfd);
+		close(mntns_fd);
+		close(cfd);
+		_exit(0);
+	}
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+
+	if (geteuid() == 0) {
+		rootfsfd = sys_fsopen("tmpfs", 0);
+		ASSERT_GE(rootfsfd, 0);
+		ASSERT_EQ(sys_fsconfig(rootfsfd, FSCONFIG_SET_ROOTNS, NULL,
+				       NULL, cfd), 0);
+		ASSERT_EQ(sys_fsconfig(rootfsfd, FSCONFIG_CMD_CREATE, NULL,
+				       NULL, 0), 0);
+		mfd = sys_fsmount(rootfsfd, 0, 0);
+		ASSERT_GE(mfd, 0);
+		close(rootfsfd);
+
+		pid = fork();
+		ASSERT_GE(pid, 0);
+		if (pid == 0) {
+			close(self->cfd);
+			if (setresgid(1000, 1000, 1000) < 0 ||
+			    setresuid(1000, 1000, 1000) < 0)
+				_exit(1);
+			if (sys_move_mount(mfd, "", mntns_fd, "/",
+					   MOVE_MOUNT_F_EMPTY_PATH |
+					   MOVE_MOUNT_T_MNTNS) < 0)
+				_exit(2);
+			close(mfd);
+			close(mntns_fd);
+			close(cfd);
+			_exit(0);
+		}
+		close(mfd);
+		ASSERT_EQ(reap_child_exit_code(pid), 0);
+	}
+
+	close(mntns_fd);
+	close(cfd);
+}
+
+TEST_F(rootns, mount_attached) {
+	int mntns_fd;
+	int cfd;
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+
+	mntns_fd = rootns_get_nsfd(cfd, CLONE_NEWNS);
+	ASSERT_GE(mntns_fd, 0);
+
+	ASSERT_EQ(sys_move_mount(AT_FDCWD, "/", mntns_fd, "/",
+				 MOVE_MOUNT_T_MNTNS), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	/* Passing rootnsfd instead of mnt_ns fd must also be rejected. */
+	ASSERT_EQ(sys_move_mount(AT_FDCWD, "/", cfd, "/",
+				 MOVE_MOUNT_T_MNTNS), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	close(mntns_fd);
+	close(cfd);
+}
+
+TEST_F(rootns, mount_empty_path) {
+	int mntns_fd;
+	int cfd;
+	int mfd;
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+
+	mntns_fd = rootns_get_nsfd(cfd, CLONE_NEWNS);
+	ASSERT_GE(mntns_fd, 0);
+
+	mfd = sys_open_tree(AT_FDCWD, "/", OPEN_TREE_CLONE | AT_RECURSIVE);
+	ASSERT_GE(mfd, 0);
+
+	ASSERT_EQ(sys_move_mount(mfd, "", mntns_fd, "",
+				 MOVE_MOUNT_F_EMPTY_PATH |
+				 MOVE_MOUNT_T_MNTNS), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	close(mfd);
+	close(mntns_fd);
+	close(cfd);
+}
+
+TEST_F(rootns, clone_perms) {
+	pid_t pid;
+	int cfd;
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+
+	ASSERT_EQ(clone_into_rootns(cfd, 0), -1);
+	ASSERT_EQ(errno, ENOENT);
+
+	ASSERT_EQ(mount_root(cfd), 0);
+
+	pid = fork();
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		int ret;
+
+		close(self->cfd);
+		ret = enter_unpriv_user_mntns(2000);
+		if (ret == -EPERM || ret == -EACCES || ret == -EINVAL ||
+		    ret == -ENOSPC) {
+			close(cfd);
+			_exit(0);
+		}
+		if (ret < 0)
+			_exit(1);
+		if (clone_into_rootns(cfd, 0) != -1 || errno != EPERM)
+			_exit(2);
+		close(cfd);
+		_exit(0);
+	}
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+
+	pid = fork();
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		pid_t ent_pid;
+
+		close(self->cfd);
+		if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0)
+			_exit(1);
+		ent_pid = clone_into_rootns(cfd, 0);
+		if (ent_pid < 0)
+			_exit(2);
+		if (ent_pid == 0) {
+			close(cfd);
+			if (getpid() != 1)
+				_exit(3);
+			if (prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0) != 1)
+				_exit(4);
+			_exit(0);
+		}
+		close(cfd);
+		_exit(reap_child_exit_code(ent_pid) == 0 ? 0 : 5);
+	}
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+
+	close(cfd);
+}
+
+TEST_F(rootns, clone_flags) {
+	static const __u64 bad_flags[] = {
+		CLONE_NEWNS,
+		CLONE_NEWPID,
+		CLONE_NEWUSER,
+		CLONE_EMPTY_MNTNS,
+		CLONE_FS,
+		CLONE_THREAD | CLONE_SIGHAND | CLONE_VM,
+		CLONE_PARENT,
+		CLONE_SYSVSEM,
+		CLONE_VM,
+	};
+	struct clone_args args;
+	int pipefd[2];
+	int pidfd = -1;
+	int bad_fd;
+	pid_t pid;
+	size_t i;
+	int cfd;
+
+	memset(&args, 0, sizeof(args));
+	args.flags = CLONE_INTO_ROOTNS;
+	args.exit_signal = SIGCHLD;
+	args.rootns = (__u64)self->cfd;
+	ASSERT_EQ(sys_clone3(&args, CLONE_ARGS_SIZE_VER2), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	args.rootns = (__u64)-1;
+	ASSERT_EQ(sys_clone3(&args, sizeof(args)), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	ASSERT_EQ(pipe2(pipefd, O_CLOEXEC), 0);
+	ASSERT_EQ(clone_into_rootns(pipefd[0], 0), -1);
+	ASSERT_EQ(errno, EINVAL);
+	bad_fd = pipefd[0];
+	close(pipefd[0]);
+	close(pipefd[1]);
+
+	ASSERT_EQ(clone_into_rootns(bad_fd, 0), -1);
+	ASSERT_EQ(errno, EBADF);
+
+	for (i = 0; i < ARRAY_SIZE(bad_flags); i++) {
+		memset(&args, 0, sizeof(args));
+		args.flags = CLONE_INTO_ROOTNS | bad_flags[i];
+		args.rootns = (__u64)self->cfd;
+		if (!(bad_flags[i] & (CLONE_THREAD | CLONE_PARENT)))
+			args.exit_signal = SIGCHLD;
+		ASSERT_EQ(sys_clone3(&args, sizeof(args)), -1);
+		ASSERT_EQ(errno, EINVAL);
+	}
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+	ASSERT_EQ(clone_into_rootns(cfd, CLONE_VM | CLONE_VFORK), -1);
+	ASSERT_EQ(errno, ENOENT);
+	close(cfd);
+
+	memset(&args, 0, sizeof(args));
+	args.flags = CLONE_INTO_ROOTNS | CLONE_VFORK | CLONE_PIDFD |
+		     CLONE_CLEAR_SIGHAND | CLONE_NNP;
+	args.pidfd = (__u64)(uintptr_t)&pidfd;
+	args.exit_signal = SIGCHLD;
+	args.rootns = (__u64)self->cfd;
+	pid = sys_clone3(&args, sizeof(args));
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		close(self->cfd);
+		if (getpid() != 1)
+			_exit(1);
+		if (prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0) != 1)
+			_exit(2);
+		_exit(0);
+	}
+	ASSERT_GE(pidfd, 0);
+	close(pidfd);
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+}
+
+TEST_F(rootns, fsconfig) {
+	pid_t pid;
+	int fsfd;
+	int cfd;
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	ASSERT_GE(cfd, 0);
+
+	fsfd = sys_fsopen("tmpfs", 0);
+	ASSERT_GE(fsfd, 0);
+	ASSERT_EQ(sys_fsconfig(fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL, cfd), 0);
+	ASSERT_EQ(sys_fsconfig(fsfd, FSCONFIG_SET_ROOTNS, NULL, NULL, cfd), -1);
+	ASSERT_EQ(errno, EBUSY);
+	close(fsfd);
+	close(cfd);
+
+	pid = fork();
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		int ucfd;
+		int mfd;
+		int tfd;
+		int rfd;
+		int ret;
+
+		close(self->cfd);
+		ret = drop_to_unpriv_uid(1000);
+		if (ret == -EINVAL)
+			_exit(0);
+		if (ret < 0)
+			_exit(1);
+
+		ucfd = sys_rootns_create(ROOTNS_CLOSE_ON_EXEC);
+		if (ucfd < 0) {
+			if (errno == EPERM || errno == EACCES ||
+			    errno == EINVAL || errno == ENOSPC)
+				_exit(0);
+			_exit(2);
+		}
+
+		tfd = sys_fsopen("tmpfs", 0);
+		if (tfd < 0)
+			_exit(3);
+		if (sys_fsconfig(tfd, FSCONFIG_SET_ROOTNS, NULL, NULL, ucfd) < 0)
+			_exit(4);
+		if (sys_fsconfig(tfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) < 0)
+			_exit(5);
+		mfd = sys_fsmount(tfd, 0, 0);
+		if (mfd < 0)
+			_exit(6);
+		close(mfd);
+		close(tfd);
+
+		rfd = sys_fsopen("devtmpfs", 0);
+		if (rfd < 0) {
+			if (errno == ENODEV || errno == EPERM) {
+				close(ucfd);
+				_exit(0);
+			}
+			_exit(7);
+		}
+		if (sys_fsconfig(rfd, FSCONFIG_SET_ROOTNS, NULL, NULL, ucfd) < 0)
+			_exit(8);
+		if (sys_fsconfig(rfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0) != -1 ||
+		    errno != EPERM)
+			_exit(9);
+
+		close(rfd);
+		close(ucfd);
+		_exit(0);
+	}
+
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+}
+
+TEST_F(rootns, clone_concurrent) {
+	unsigned int seen_mask = 0;
+	int init_hold_pipe[2];
+	int peer_hold_pipe[2];
+	int init_worker = -1;
+	int start_pipe[2];
+	int ready_pipe[2];
+	pid_t workers[4];
+	int status = 0;
+	int i;
+
+	ASSERT_EQ(pipe2(start_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(ready_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(init_hold_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(peer_hold_pipe, O_CLOEXEC), 0);
+
+	for (i = 0; i < 4; i++) {
+		workers[i] = fork();
+		ASSERT_GE(workers[i], 0);
+		if (workers[i] == 0) {
+			pid_t ent_pid;
+			char ch;
+
+			close(start_pipe[1]);
+			close(ready_pipe[0]);
+			close(init_hold_pipe[1]);
+			close(peer_hold_pipe[1]);
+
+			(void)read(start_pipe[0], &ch, 1);
+			close(start_pipe[0]);
+
+			ent_pid = clone_into_rootns(self->cfd, 0);
+			if (ent_pid < 0)
+				_exit(1);
+			if (ent_pid == 0) {
+				unsigned char msg[2] = {
+					(unsigned char)i,
+					(unsigned char)getpid(),
+				};
+				int hold_fd = (msg[1] == 1) ?
+					      init_hold_pipe[0] :
+					      peer_hold_pipe[0];
+
+				close(self->cfd);
+				if (write(ready_pipe[1], msg, sizeof(msg)) !=
+				    (ssize_t)sizeof(msg))
+					_exit(2);
+				close(ready_pipe[1]);
+				(void)read(hold_fd, &ch, 1);
+				close(init_hold_pipe[0]);
+				close(peer_hold_pipe[0]);
+				_exit(0);
+			}
+
+			close(ready_pipe[1]);
+			close(init_hold_pipe[0]);
+			close(peer_hold_pipe[0]);
+			close(self->cfd);
+			_exit(reap_child_exit_code(ent_pid) == 0 ? 0 : 3);
+		}
+	}
+
+	close(start_pipe[0]);
+	close(ready_pipe[1]);
+	close(init_hold_pipe[0]);
+	close(peer_hold_pipe[0]);
+	close(start_pipe[1]);
+
+	for (i = 0; i < 4; i++) {
+		unsigned char msg[2] = { 0, 0 };
+
+		ASSERT_EQ(read(ready_pipe[0], msg, sizeof(msg)),
+			  (ssize_t)sizeof(msg));
+		ASSERT_LT(msg[0], 4);
+		ASSERT_GE(msg[1], 1);
+		ASSERT_LE(msg[1], 4);
+		if (msg[1] == 1)
+			init_worker = (int)msg[0];
+		seen_mask |= 1U << msg[1];
+	}
+	close(ready_pipe[0]);
+	ASSERT_EQ(seen_mask, 0x1eU);
+	ASSERT_GE(init_worker, 0);
+
+	close(peer_hold_pipe[1]);
+	for (i = 0; i < 4; i++) {
+		if (i != init_worker)
+			ASSERT_EQ(reap_child_exit_code(workers[i]), 0);
+	}
+
+	close(init_hold_pipe[1]);
+	ASSERT_EQ(reap_child_exit_code(workers[init_worker]), 0);
+
+	ASSERT_GT(sys_rootns_wait(self->cfd, &status, 0, NULL), 0);
+	ASSERT_TRUE(WIFEXITED(status));
+	ASSERT_EQ(WEXITSTATUS(status), 0);
+}
+
+TEST_F(rootns, move_mount_existing_mntns) {
+	int ready_pipe[2];
+	int hold_pipe[2];
+	char path[64];
+	int marker_fd;
+	int mntns_fd;
+	char ch;
+	pid_t pid;
+	int fsfd;
+	int mfd;
+
+	ASSERT_EQ(pipe2(ready_pipe, O_CLOEXEC), 0);
+	ASSERT_EQ(pipe2(hold_pipe, O_CLOEXEC), 0);
+
+	pid = fork();
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		struct statfs st;
+
+		close(self->cfd);
+		close(ready_pipe[0]);
+		close(hold_pipe[1]);
+
+		if (unshare(CLONE_NEWNS) < 0)
+			_exit(1);
+		if (write(ready_pipe[1], "r", 1) != 1)
+			_exit(2);
+		close(ready_pipe[1]);
+
+		if (read(hold_pipe[0], &ch, 1) != 1)
+			_exit(3);
+		close(hold_pipe[0]);
+
+		if (statfs("/tmp", &st) < 0)
+			_exit(4);
+		if ((unsigned long)st.f_type != (unsigned long)TMPFS_MAGIC)
+			_exit(5);
+		if (access("/tmp/hot_mounted", F_OK) < 0)
+			_exit(6);
+		_exit(0);
+	}
+	close(ready_pipe[1]);
+	close(hold_pipe[0]);
+
+	ASSERT_EQ(read(ready_pipe[0], &ch, 1), 1);
+	close(ready_pipe[0]);
+
+	snprintf(path, sizeof(path), "/proc/%d/ns/mnt", (int)pid);
+	mntns_fd = open(path, O_RDONLY | O_CLOEXEC);
+	ASSERT_GE(mntns_fd, 0);
+
+	fsfd = sys_fsopen("tmpfs", 0);
+	ASSERT_GE(fsfd, 0);
+	ASSERT_EQ(sys_fsconfig(fsfd, FSCONFIG_CMD_CREATE, NULL, NULL, 0), 0);
+	mfd = sys_fsmount(fsfd, 0, 0);
+	close(fsfd);
+	ASSERT_GE(mfd, 0);
+
+	marker_fd = openat(mfd, "hot_mounted",
+			   O_CREAT | O_WRONLY | O_CLOEXEC, 0644);
+	ASSERT_GE(marker_fd, 0);
+	close(marker_fd);
+
+	/* Existing mnt_ns already has "/", so "/" must fail with EBUSY. */
+	ASSERT_EQ(sys_move_mount(mfd, "", mntns_fd, "/",
+				 MOVE_MOUNT_F_EMPTY_PATH |
+				 MOVE_MOUNT_T_MNTNS), -1);
+	ASSERT_EQ(errno, EBUSY);
+
+	/* Hot-mounting onto a relative path inside the live mnt_ns succeeds. */
+	ASSERT_EQ(sys_move_mount(mfd, "", mntns_fd, "tmp",
+				 MOVE_MOUNT_F_EMPTY_PATH |
+				 MOVE_MOUNT_T_MNTNS), 0);
+	close(mfd);
+	close(mntns_fd);
+
+	ASSERT_EQ(write(hold_pipe[1], "g", 1), 1);
+	close(hold_pipe[1]);
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+}
+
+TEST(get_nsfd) {
+	static const unsigned long nstypes[] = {
+		CLONE_NEWNS,
+		CLONE_NEWCGROUP,
+		CLONE_NEWUTS,
+		CLONE_NEWIPC,
+		CLONE_NEWUSER,
+		CLONE_NEWNET,
+		CLONE_NEWTIME,
+	};
+	int hold_pipe[2];
+	int nsfd;
+	pid_t pid;
+	size_t i;
+	int cfd;
+
+	cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
+	if (cfd < 0 && geteuid() != 0 &&
+	    (errno == EPERM || errno == EACCES ||
+	     errno == EINVAL || errno == ENOSPC))
+		SKIP(return, "unprivileged rootns creation is unavailable");
+	ASSERT_GE(cfd, 0);
+
+	ASSERT_EQ(rootns_get_nsfd(cfd, 0), -1);
+	ASSERT_EQ(errno, EINVAL);
+
+	/* CLONE_NEWPID requires init to be running. */
+	ASSERT_EQ(rootns_get_nsfd(cfd, CLONE_NEWPID), -1);
+	ASSERT_EQ(errno, ESRCH);
+
+	for (i = 0; i < ARRAY_SIZE(nstypes); i++) {
+		int type;
+
+		nsfd = rootns_get_nsfd(cfd, nstypes[i]);
+		if (nstypes[i] == CLONE_NEWTIME && nsfd < 0 &&
+		    errno == EOPNOTSUPP)
+			continue;
+		ASSERT_GE(nsfd, 0);
+		type = ioctl(nsfd, NS_GET_NSTYPE);
+		ASSERT_EQ((unsigned long)type, nstypes[i]);
+		close(nsfd);
+	}
+
+	ASSERT_EQ(mount_root_with_dirs(cfd, false), 0);
+	ASSERT_EQ(pipe2(hold_pipe, O_CLOEXEC), 0);
+
+	pid = clone_into_rootns(cfd, 0);
+	ASSERT_GE(pid, 0);
+	if (pid == 0) {
+		char ch;
+
+		close(cfd);
+		close(hold_pipe[1]);
+		(void)read(hold_pipe[0], &ch, 1);
+		close(hold_pipe[0]);
+		_exit(0);
+	}
+	close(hold_pipe[0]);
+
+	nsfd = rootns_get_nsfd(cfd, CLONE_NEWPID);
+	ASSERT_GE(nsfd, 0);
+	ASSERT_EQ(ioctl(nsfd, NS_GET_NSTYPE), CLONE_NEWPID);
+	close(nsfd);
+
+	close(hold_pipe[1]);
+	ASSERT_EQ(reap_child_exit_code(pid), 0);
+	close(cfd);
+}
+
+TEST(unpriv_no_userns) {
+	pid_t worker;
+
+	worker = fork();
+	ASSERT_GE(worker, 0);
+	if (worker == 0) {
+		int ready_pipe[2];
+		int go_pipe[2];
+		int status = 0;
+		pid_t pid;
+		char ch;
+		int tfd;
+		int cfd;
+		int ret;
+
+		ret = drop_to_unpriv_uid(1000);
+		if (ret == -EINVAL)
+			_exit(0);
+		if (ret < 0)
+			_exit(1);
+
+		/* Without FSCONFIG_SET_ROOTNS, unprivileged fsconfig fails. */
+		tfd = sys_fsopen("tmpfs", 0);
+		if (tfd >= 0) {
+			if (sys_fsconfig(tfd, FSCONFIG_CMD_CREATE, NULL, NULL,
+					 0) != -1 || errno != EPERM)
+				_exit(2);
+			close(tfd);
+		} else if (errno != EPERM) {
+			_exit(3);
+		}
+
+		cfd = sys_rootns_create(ROOTNS_KILL_ON_CLOSE |
+					ROOTNS_CLOSE_ON_EXEC);
+		if (cfd < 0) {
+			if (errno == EPERM || errno == EACCES ||
+			    errno == EINVAL || errno == ENOSPC)
+				_exit(0);
+			_exit(4);
+		}
+
+		if (mount_root_with_dirs(cfd, false) < 0)
+			_exit(5);
+
+		if (pipe2(go_pipe, O_CLOEXEC) < 0 ||
+		    pipe2(ready_pipe, O_CLOEXEC) < 0)
+			_exit(6);
+
+		pid = clone_into_rootns(cfd, 0);
+		if (pid < 0)
+			_exit(7);
+		if (pid == 0) {
+			struct statfs st;
+			char target[32];
+			ssize_t len;
+
+			close(cfd);
+			close(go_pipe[1]);
+			close(ready_pipe[0]);
+
+			if (read(go_pipe[0], &ch, 1) != 1)
+				_exit(1);
+			if (mkdir("/proc", 0755) < 0)
+				_exit(2);
+			if (write(ready_pipe[1], "m", 1) != 1)
+				_exit(3);
+			close(ready_pipe[1]);
+
+			if (read(go_pipe[0], &ch, 1) != 1)
+				_exit(4);
+			close(go_pipe[0]);
+
+			if (getpid() != 1 || geteuid() != 0)
+				_exit(5);
+			if (statfs("/proc", &st) < 0 ||
+			    (unsigned long)st.f_type !=
+			    (unsigned long)PROC_SUPER_MAGIC)
+				_exit(6);
+			len = readlink("/proc/self", target,
+				       sizeof(target) - 1);
+			if (len <= 0)
+				_exit(7);
+			target[len] = '\0';
+			if (strcmp(target, "1") != 0)
+				_exit(8);
+			_exit(0);
+		}
+		close(go_pipe[0]);
+		close(ready_pipe[1]);
+
+		if (write_pid_id_maps(pid, geteuid(), getegid()) < 0) {
+			kill_and_reap_pid(pid);
+			_exit(8);
+		}
+		if (write(go_pipe[1], "1", 1) != 1) {
+			kill_and_reap_pid(pid);
+			_exit(9);
+		}
+		if (read(ready_pipe[0], &ch, 1) != 1) {
+			kill_and_reap_pid(pid);
+			_exit(10);
+		}
+		close(ready_pipe[0]);
+
+		/* Hot-mount proc from unprivileged host process (no unshare). */
+		if (mount_proc(cfd, true) < 0) {
+			kill_and_reap_pid(pid);
+			_exit(11);
+		}
+
+		if (write(go_pipe[1], "2", 1) != 1) {
+			kill_and_reap_pid(pid);
+			_exit(12);
+		}
+		close(go_pipe[1]);
+
+		if (sys_rootns_wait(cfd, &status, 0, NULL) != pid ||
+		    !WIFEXITED(status) || WEXITSTATUS(status) != 0)
+			_exit(13);
+		if (reap_child_exit_code(pid) != 0)
+			_exit(14);
+
+		close(cfd);
+		_exit(0);
+	}
+
+	ASSERT_EQ(reap_child_exit_code(worker), 0);
+}
+
+TEST_HARNESS_MAIN
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* [RFC PATCH v3 13/13] MAINTAINERS: Add entry for ROOT NAMESPACE
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (11 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 12/13] selftests/rootns: Add root namespace test suite Jarkko Sakkinen
@ 2026-11-18 19:35 ` Jarkko Sakkinen
  2026-11-18 19:54 ` [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
  13 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:35 UTC (permalink / raw)
  To: David Howells
  Cc: Jarkko Sakkinen, linux-api, linux-doc, linux-fsdevel,
	linux-kernel, linux-kselftest, linux-mm, linux-security-module,
	Alexander Viro, Andrew Morton, Andy Lutomirski,
	Anna-Maria Behnsen, Ben Segall, Christian Brauner,
	David Hildenbrand, Davidlohr Bueso, Dietmar Eggemann,
	Frederic Weisbecker, Ingo Molnar, Jan Kara, John Johansen,
	Jonathan Corbet, Juri Lelli, Kees Cook, K Prateek Nayak,
	Liam R. Howlett, Lorenzo Stoakes, Manfred Spraul, Mel Gorman,
	Michal Hocko, Mike Rapoport, Neal Gompa, Paul Moore,
	Pavel Tikhomirov, Peter Zijlstra, Randy Dunlap, Serge Hallyn,
	Shuah Khan, Steven Rostedt, Suren Baghdasaryan, Thomas Gleixner,
	Valentin Schneider, Vincent Guittot, Vincenzo Frascino,
	Vlastimil Babka, Zygmunt Krynicki

Record maintainership and mailing list routing for the root namespace
subsystem across its uAPI headers, core implementation, documentation,
and selftests.

Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
---
 MAINTAINERS | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index 7cbce21ba45a..072be5ec7fd8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -24533,6 +24533,17 @@ F:	include/linux/mfd/rohm-bd96802.h
 F:	include/linux/mfd/rohm-generic.h
 F:	include/linux/mfd/rohm-shared.h
 
+ROOT NAMESPACE
+M:	David Howells <dhowells@redhat.com>
+M:	Jarkko Sakkinen <jarkko@kernel.org>
+L:	linux-fsdevel@vger.kernel.org
+S:	Maintained
+F:	Documentation/userspace-api/rootns.rst
+F:	include/linux/rootns.h
+F:	include/uapi/linux/rootns.h
+F:	kernel/rootns.c
+F:	tools/testing/selftests/rootns/
+
 ROTATION DRIVER FOR ALLWINNER A83T
 M:	Jernej Skrabec <jernej.skrabec@gmail.com>
 L:	linux-media@vger.kernel.org
-- 
2.47.3


^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [RFC PATCH v3 00/13] Namespace for namespace roots
  2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
                   ` (12 preceding siblings ...)
  2026-11-18 19:35 ` [RFC PATCH v3 13/13] MAINTAINERS: Add entry for ROOT NAMESPACE Jarkko Sakkinen
@ 2026-11-18 19:54 ` Jarkko Sakkinen
  2026-11-18 20:42   ` Jarkko Sakkinen
  13 siblings, 1 reply; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 19:54 UTC (permalink / raw)
  To: David Howells
  Cc: linux-api, linux-doc, linux-fsdevel, linux-kernel,
	linux-kselftest, linux-mm, linux-security-module, Alexander Viro,
	Andrew Morton, Andy Lutomirski, Anna-Maria Behnsen, Ben Segall,
	Christian Brauner, David Hildenbrand, Davidlohr Bueso,
	Dietmar Eggemann, Frederic Weisbecker, Ingo Molnar, Jan Kara,
	John Johansen, Jonathan Corbet, Juri Lelli, Kees Cook,
	K Prateek Nayak, Liam R. Howlett, Lorenzo Stoakes,
	Manfred Spraul, Mel Gorman, Michal Hocko, Mike Rapoport,
	Neal Gompa, Paul Moore, Pavel Tikhomirov, Peter Zijlstra,
	Randy Dunlap, Serge Hallyn, Shuah Khan, Steven Rostedt,
	Suren Baghdasaryan, Thomas Gleixner, Valentin Schneider,
	Vincent Guittot, Vincenzo Frascino, Vlastimil Babka,
	Zygmunt Krynicki

On Wed, Nov 18, 2026 at 09:35:26PM +0200, Jarkko Sakkinen wrote:
> OVERVIEW
> ========
> 
> A root namespace (rootns) is a kernel object backed by a file descriptor
> that binds together:
> 
> 1. A full set of detached namespaces owned by a fresh user namespace.
> 2. A dedicated PID namespace for spawning processes into, signaling
>    members, and polling or waiting on PID 1 exit.
> 3. An initially empty mount namespace (CLONE_EMPTY_MNTNS) populated
>    directly in its target user namespace before going live, without
>    inheriting host mounts or cloning staged trees, while still allowing
>    new mounts to be attached at runtime.
> 
> Work on this feature started in 2025 from David Howells' container object
> patch set [1], which I turned into a namespace for namespace roots and
> rebuilt around that premise.
> 
> While the patch set is manually written, the original motivation came
> from isolating LLM agents. Running untrusted agent workloads made it
> clear that OCI runtimes need to minimize their live configuration
> surface.
> 
> Assembling mounts, credentials, and namespaces inside helper processes
> with a half-configured container is what I see as the main challenge,
> and the existential debate around namespaces and container objects is an
> unfocused discussion topic.
> 
> [1] https://lore.kernel.org/all/155059610368.17079.2220554006494174417.stgit@warthog.procyon.org.uk/
> 
> IMPLEMENTATION
> ==============
> 
> rootns_create() allocates a rootns instance backed by a pollable
> anonymous inode fd, creating a fresh owning user namespace and a full set
> of detached namespaces: empty mount (CLONE_EMPTY_MNTNS), PID, UTS, IPC,
> network, cgroup, and time. ioctl(rootnsfd, ROOTNS_GET_NSFD, nstype)
> returns nsfs file descriptors for individual member namespaces when
> standalone namespace operations are needed.
> 
> Superblocks are configured directly in the target user namespace via
> fsopen(), FSCONFIG_SET_ROOTNS, and fsmount(), allowing unprivileged
> callers to assemble FS_USERNS_MOUNT filesystems without holding
> CAP_SYS_ADMIN in their own user namespace or entering the target user
> namespace first. move_mount(..., MOVE_MOUNT_T_MNTNS) operates on any
> non-anonymous mount namespace fd: on an empty mount namespace it installs
> "/" onto the nullfs root once, and it attaches relative submounts both
> before entry and into live mount namespaces.
> 
> Once "/" is installed, processes are spawned into the rootns via clone3()
> with CLONE_INTO_ROOTNS and struct clone_args.rootns, without mutating the
> caller in place. Pairing CLONE_INTO_ROOTNS with CLONE_VM | CLONE_VFORK
> and opening the target binary via openat2(..., RESOLVE_IN_ROOT) on the
> retained "/" mount fd allows spawning with execveat() without copying
> page tables.
> 
> The first entrant becomes PID 1; once it exits and
> zap_pid_ns_processes() reaps all members, poll() reports EPOLLHUP and
> rootns_wait() returns init's exit status and rusage. rootns_kill() walks
> pid_ns->idr under tasklist_lock to signal member thread groups.
> 
> CHANGES
> =======
> 
> v3:
> - The patch set size increased predominantly because the coverage of
>   kselftest had to widened to cover the introduced changes.
> - Replace MOVE_MOUNT_T_ROOTNS_ROOT with MOVE_MOUNT_T_MNTNS targeting
>   mnt_ns nsfs fds, and add ioctl(ROOTNS_GET_NSFD) to open member
>   namespace fds (Andy Lutomirski).
> - Allow unprivileged fsopen(), FSCONFIG_SET_ROOTNS, and fsmount() to
>   configure and mount FS_USERNS_MOUNT filesystems directly in the target
>   user namespace without entering it first (Andy Lutomirski).
> - Fix locking, refcounting, credential/dumpability/timens setup,
>   pivot_root() lookup, and cross-userns mount checks across copy_rootns(),
>   CLONE_INTO_ROOTNS, rootns_kill(), FSCONFIG_SET_ROOTNS, and move_mount()
>   (Sashiko).
> - Mark PowerPC rootns syscalls nospu (Sashiko).
> - Update documentation and kselftests.

I.e. before PID 1 and /proc/<pid>/ns/* existss, nsfd for namespace other
than root nsfd can be acquired as follows:

	int mnts_fd = ioctl(root_fd, ROOTNS_GET_NSFD, CLONE_NEWNS);

Br, Jarkko

^ permalink raw reply	[flat|nested] 16+ messages in thread

* Re: [RFC PATCH v3 00/13] Namespace for namespace roots
  2026-11-18 19:54 ` [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
@ 2026-11-18 20:42   ` Jarkko Sakkinen
  0 siblings, 0 replies; 16+ messages in thread
From: Jarkko Sakkinen @ 2026-11-18 20:42 UTC (permalink / raw)
  To: David Howells
  Cc: linux-api, linux-doc, linux-fsdevel, linux-kernel,
	linux-kselftest, linux-mm, linux-security-module, Alexander Viro,
	Andrew Morton, Andy Lutomirski, Anna-Maria Behnsen, Ben Segall,
	Christian Brauner, David Hildenbrand, Davidlohr Bueso,
	Dietmar Eggemann, Frederic Weisbecker, Ingo Molnar, Jan Kara,
	John Johansen, Jonathan Corbet, Juri Lelli, Kees Cook,
	K Prateek Nayak, Liam R. Howlett, Lorenzo Stoakes,
	Manfred Spraul, Mel Gorman, Michal Hocko, Mike Rapoport,
	Neal Gompa, Paul Moore, Pavel Tikhomirov, Peter Zijlstra,
	Randy Dunlap, Serge Hallyn, Shuah Khan, Steven Rostedt,
	Suren Baghdasaryan, Thomas Gleixner, Valentin Schneider,
	Vincent Guittot, Vincenzo Frascino, Vlastimil Babka,
	Zygmunt Krynicki

On Wed, Nov 18, 2026 at 09:54:32PM +0200, Jarkko Sakkinen wrote:
> On Wed, Nov 18, 2026 at 09:35:26PM +0200, Jarkko Sakkinen wrote:
> > OVERVIEW
> > ========
> > 
> > A root namespace (rootns) is a kernel object backed by a file descriptor
> > that binds together:
> > 
> > 1. A full set of detached namespaces owned by a fresh user namespace.
> > 2. A dedicated PID namespace for spawning processes into, signaling
> >    members, and polling or waiting on PID 1 exit.
> > 3. An initially empty mount namespace (CLONE_EMPTY_MNTNS) populated
> >    directly in its target user namespace before going live, without
> >    inheriting host mounts or cloning staged trees, while still allowing
> >    new mounts to be attached at runtime.
> > 
> > Work on this feature started in 2025 from David Howells' container object
> > patch set [1], which I turned into a namespace for namespace roots and
> > rebuilt around that premise.
> > 
> > While the patch set is manually written, the original motivation came
> > from isolating LLM agents. Running untrusted agent workloads made it
> > clear that OCI runtimes need to minimize their live configuration
> > surface.
> > 
> > Assembling mounts, credentials, and namespaces inside helper processes
> > with a half-configured container is what I see as the main challenge,
> > and the existential debate around namespaces and container objects is an
> > unfocused discussion topic.
> > 
> > [1] https://lore.kernel.org/all/155059610368.17079.2220554006494174417.stgit@warthog.procyon.org.uk/
> > 
> > IMPLEMENTATION
> > ==============
> > 
> > rootns_create() allocates a rootns instance backed by a pollable
> > anonymous inode fd, creating a fresh owning user namespace and a full set
> > of detached namespaces: empty mount (CLONE_EMPTY_MNTNS), PID, UTS, IPC,
> > network, cgroup, and time. ioctl(rootnsfd, ROOTNS_GET_NSFD, nstype)
> > returns nsfs file descriptors for individual member namespaces when
> > standalone namespace operations are needed.
> > 
> > Superblocks are configured directly in the target user namespace via
> > fsopen(), FSCONFIG_SET_ROOTNS, and fsmount(), allowing unprivileged
> > callers to assemble FS_USERNS_MOUNT filesystems without holding
> > CAP_SYS_ADMIN in their own user namespace or entering the target user
> > namespace first. move_mount(..., MOVE_MOUNT_T_MNTNS) operates on any
> > non-anonymous mount namespace fd: on an empty mount namespace it installs
> > "/" onto the nullfs root once, and it attaches relative submounts both
> > before entry and into live mount namespaces.
> > 
> > Once "/" is installed, processes are spawned into the rootns via clone3()
> > with CLONE_INTO_ROOTNS and struct clone_args.rootns, without mutating the
> > caller in place. Pairing CLONE_INTO_ROOTNS with CLONE_VM | CLONE_VFORK
> > and opening the target binary via openat2(..., RESOLVE_IN_ROOT) on the
> > retained "/" mount fd allows spawning with execveat() without copying
> > page tables.
> > 
> > The first entrant becomes PID 1; once it exits and
> > zap_pid_ns_processes() reaps all members, poll() reports EPOLLHUP and
> > rootns_wait() returns init's exit status and rusage. rootns_kill() walks
> > pid_ns->idr under tasklist_lock to signal member thread groups.
> > 
> > CHANGES
> > =======
> > 
> > v3:
> > - The patch set size increased predominantly because the coverage of
> >   kselftest had to widened to cover the introduced changes.
> > - Replace MOVE_MOUNT_T_ROOTNS_ROOT with MOVE_MOUNT_T_MNTNS targeting
> >   mnt_ns nsfs fds, and add ioctl(ROOTNS_GET_NSFD) to open member
> >   namespace fds (Andy Lutomirski).
> > - Allow unprivileged fsopen(), FSCONFIG_SET_ROOTNS, and fsmount() to
> >   configure and mount FS_USERNS_MOUNT filesystems directly in the target
> >   user namespace without entering it first (Andy Lutomirski).
> > - Fix locking, refcounting, credential/dumpability/timens setup,
> >   pivot_root() lookup, and cross-userns mount checks across copy_rootns(),
> >   CLONE_INTO_ROOTNS, rootns_kill(), FSCONFIG_SET_ROOTNS, and move_mount()
> >   (Sashiko).
> > - Mark PowerPC rootns syscalls nospu (Sashiko).
> > - Update documentation and kselftests.
> 
> I.e. before PID 1 and /proc/<pid>/ns/* existss, nsfd for namespace other
> than root nsfd can be acquired as follows:
> 
> 	int mnts_fd = ioctl(root_fd, ROOTNS_GET_NSFD, CLONE_NEWNS);


Unprivileged caller becomes the owner of rootns->user_ns. Each mount
syscall then just checks CAP_SYS_ADMIN against rootns->user_ns.

The user space wiring goes along the lines of:

        int root_fd = rootns_create(ROOTNS_KILL_ON_CLOSE | ROOTNS_CLOSE_ON_EXEC);
        int mntns_fd = ioctl(root_fd, ROOTNS_GET_NSFD, CLONE_NEWNS);

        int tmpfs_fd = fsopen("tmpfs", 0);
        fsconfig(tmpfs_fd, FSCONFIG_SET_ROOTNS, NULL, NULL, root_fd);
        fsconfig(tmpfs_fd, FSCONFIG_CMD_CREATE, NULL, NULL, 0);
        int rootfs_fd = fsmount(tmpfs_fd, 0, 0);

        move_mount(rootfs_fd, "", mntns_fd, "/", MOVE_MOUNT_F_EMPTY_PATH | MOVE_MOUNT_T_MNTNS);

        struct clone_args args = {
                .flags  = CLONE_INTO_ROOTNS,
                .rootns = root_fd,
        };
        pid_t pid = clone3(&args, sizeof(args));

Note that example is uncompiled :-)

This example makes me feel that perhaps RootNS is not the best possible
name for this but this rather should be e.g., NullNS?

Br, Jarkko

^ permalink raw reply	[flat|nested] 16+ messages in thread

end of thread, other threads:[~2026-11-18 20:42 UTC | newest]

Thread overview: 16+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-18 19:35 [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 01/13] nsproxy: Pass nsproxy to create_new_namespaces() Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 02/13] rootns: Add core infrastructure for root namespaces Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 03/13] rootns: Track init lifecycle via copy_process() and pid_namespace Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 04/13] rootns: Add rootns_create() system call Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 05/13] rootns: Add rootns_wait() " Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 06/13] rootns: Add rootns_kill() " Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 07/13] fork: Support CLONE_INTO_ROOTNS in clone3() Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 08/13] fs: Support FSCONFIG_SET_ROOTNS in fsconfig() Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 09/13] fs: Support MOVE_MOUNT_T_MNTNS in move_mount() Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 10/13] arch: Wire up rootns system calls Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 11/13] docs: Document root namespace uAPI Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 12/13] selftests/rootns: Add root namespace test suite Jarkko Sakkinen
2026-11-18 19:35 ` [RFC PATCH v3 13/13] MAINTAINERS: Add entry for ROOT NAMESPACE Jarkko Sakkinen
2026-11-18 19:54 ` [RFC PATCH v3 00/13] Namespace for namespace roots Jarkko Sakkinen
2026-11-18 20:42   ` Jarkko Sakkinen

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®