Namespace for namespace roots
Subsystems (27)
v2 cover Namespace for namespace roots
OVERVIEW
========
A root namespace (rootns) is a kernel object backed by a file descriptor that binds together:
1. A full or partial set of detached namespaces.
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) that must be populated before going live, without inheriting host mount-tree ancestors.
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, pinning dedicated empty mount (CLONE_EMPTY_MNTNS) and PID namespaces along with any optional namespaces selected in flags.
Before entry, userspace populates the mount tree through the control fd:FSCONFIG_SET_ROOTNS binds a newly opened fs_context to the target rootns, and move_mount(..., MOVE_MOUNT_T_ROOTNS_ROOT) installs "/" onto the nullfs root once (transitioning the rootns to ROOTNS_READY) and attaches relative submounts beneath it.
Processes are spawned into a ready 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 RCU to signal member thread groups.
CHANGES
=======
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
========
v1: https://lore.kernel.org/linux-fsdevel/[email protected]/
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 installing rootns mount trees via 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 + Documentation/userspace-api/rootns.rst | 40 + 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/fsopen.c | 76 +- fs/namespace.c | 178 ++- fs/proc/root.c | 13 + include/linux/compat.h | 4 + include/linux/cred.h | 4 +- include/linux/fs_context.h | 3 + include/linux/nsproxy.h | 9 +- include/linux/pid_namespace.h | 4 + include/linux/rootns.h | 92 ++ include/linux/sched/task.h | 8 + include/linux/syscalls.h | 4 + include/uapi/asm-generic/unistd.h | 10 +- include/uapi/linux/mount.h | 4 +- include/uapi/linux/rootns.h | 38 + include/uapi/linux/sched.h | 5 + init/Kconfig | 9 + ipc/mqueue.c | 12 + kernel/Makefile | 2 + kernel/cred.c | 70 +- kernel/fork.c | 67 +- kernel/nsproxy.c | 41 +- kernel/pid_namespace.c | 2 + kernel/rootns.c | 593 ++++++++ kernel/sys_ni.c | 6 + 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 | 9 + tools/testing/selftests/rootns/smoke.c | 1381 +++++++++++++++++++ 49 files changed, 2680 insertions(+), 75 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
RFC PATCH v2 1/13 nsproxy: Pass nsproxy to create_new_namespaces()
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.
--- include/linux/nsproxy.h | 5 +++++ kernel/nsproxy.c | 32 ++++++++++++++++---------------- 2 files changed, 21 insertions(+), 16 deletions(-)
include/linux/nsproxy.h +5 -0
@@ -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);
kernel/nsproxy.c +16 -16
@@ -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);
Signature · 1 line
2.47.3
RFC PATCH v2 2/13 rootns: Add core infrastructure for root namespaces
In reply to Jarkko SakkinenLinux namespaces can be created and entered individually, but userspace orchestrators lack a single kernel object that binds a namespace set, a root mount, and an init process behind a pollable file descriptor.
Add struct rootns, its lifecycle states, reference counting, uAPI creation flags, 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, and report EPOLLHUP from poll() once the rootns reaches ROOTNS_DEAD.
--- include/linux/rootns.h | 66 ++++++++++++++++++++++ include/uapi/linux/rootns.h | 38 +++++++++++++ init/Kconfig | 9 +++ kernel/Makefile | 2 + kernel/rootns.c | 107 ++++++++++++++++++++++++++++++++++++ 5 files changed, 222 insertions(+) create mode 100644 include/linux/rootns.h create mode 100644 include/uapi/linux/rootns.h create mode 100644 kernel/rootns.c
include/linux/rootns.h new file +66 -0
@@ -0,0 +1,66 @@ +/* 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> +#include <linux/path.h> + +struct cred ; +struct file ; +struct nsproxy ; +struct pid ; +struct task_struct ; + +enum rootns_state { +ROOTNS_EMPTY =0 , +ROOTNS_READY =1 , +ROOTNS_FORKING =2 , +ROOTNS_RUNNING =3 , +ROOTNS_DEAD =4 , +}; + +/* +* The rootns object. +*/ +struct rootns { +refcount_t usage; +int exit_code;/* The exit code of 'init' */ +struct rusage rusage;/* Resource usage of 'init' */ +const struct cred *cred;/* Creds for this rootns, including userns */ +struct nsproxy *ns;/* This rootns's namespaces */ +struct path root;/* The root of the rootns's fs namespace */ +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 */
include/uapi/linux/rootns.h new file +38 -0
@@ -0,0 +1,38 @@ +/* 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 + +/** +* enum rootns_flags - Flags for rootns_create() +* @ROOTNS_CGROUP: Create a fresh cgroup namespace instead of inheriting. +* @ROOTNS_UTS: Create a fresh UTS namespace instead of inheriting. +* @ROOTNS_IPC: Create a fresh IPC namespace instead of inheriting. +* @ROOTNS_USER: Create a fresh user namespace owned by the caller. +* @ROOTNS_NET: Create a fresh network namespace instead of inheriting. +* @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_NAMESPACES: Mask of all optional namespace selection flags. +* @ROOTNS_ALL_FLAGS: Mask of all valid flags accepted by rootns_create(). +* +* Every root namespace unconditionally owns dedicated mount and PID +* namespaces. Optional namespace flags allocate fresh instances of the +* remaining namespaces instead of inheriting them from the caller. +*/ +enum rootns_flags { +ROOTNS_CGROUP =0x00000001 , +ROOTNS_UTS =0x00000002 , +ROOTNS_IPC =0x00000004 , +ROOTNS_USER =0x00000008 , +ROOTNS_NET =0x00000010 , +ROOTNS_KILL_ON_CLOSE =0x00000100 , +ROOTNS_CLOSE_ON_EXEC =0x00000200 , +ROOTNS_ALL_NAMESPACES =0x0000001f , +ROOTNS_ALL_FLAGS =0x0000031f , +}; + +#endif /* _UAPI_LINUX_ROOTNS_H */
init/Kconfig +9 -0
@@ -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, credentials, namespace set, and init + process lifecycle via rootns_create(), rootns_wait(), + rootns_kill(), and clone3() with CLONE_INTO_ROOTNS. + endif # NAMESPACES config CHECKPOINT_RESTORE
kernel/Makefile +2 -0
@@ -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.
kernel/rootns.c new file +107 -0
107 lines not on this page · raw message
Signature · 1 line
2.47.3
RFC PATCH v2 3/13 rootns: Track init lifecycle via copy_process() and pid_namespace
In reply to Jarkko SakkinenA 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 init PID and wake waiters in copy_rootns(), and invoke exit_rootns() from zap_pid_ns_processes() after the root namespace's PID namespace has killed and reaped all member tasks.
--- include/linux/pid_namespace.h | 4 ++++ include/linux/rootns.h | 12 +++++++++++ kernel/fork.c | 2 ++ kernel/pid_namespace.c | 2 ++ kernel/rootns.c | 40 +++++++++++++++++++++++++++++++++++ 5 files changed, 60 insertions(+)
include/linux/pid_namespace.h +4 -0
@@ -15,6 +15,7 @@#define MAX_PID_NS_LEVEL 32struct 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;
include/linux/rootns.h +12 -0
@@ -16,6 +16,7 @@ struct cred;struct file ;struct nsproxy ;struct pid ; +struct pid_namespace ;struct task_struct ;enum rootns_state {
@@ -47,6 +48,8 @@ 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 rootns *rootns); +void exit_rootns (struct pid_namespace *pid_ns,struct task_struct *tsk);#else static inline struct rootns *get_rootns (struct rootns *c) {
@@ -61,6 +64,15 @@ static inline bool is_rootns_file(struct file *file) {return false; } + +static inline void copy_rootns (struct task_struct *tsk,struct rootns *rootns) +{ +} + +static inline void exit_rootns (struct pid_namespace *pid_ns, +struct task_struct *tsk) +{ +}#endif /* CONFIG_ROOTNS */ #endif /* _LINUX_ROOTNS_H */
kernel/fork.c +2 -0
@@ -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>
@@ -2565,6 +2566,7 @@ __latent_entropy struct task_struct *copy_process(attach_pid (p,PIDTYPE_TGID );attach_pid (p,PIDTYPE_PGID );attach_pid (p,PIDTYPE_SID ); +copy_rootns (p,NULL );__this_cpu_inc (process_counts); }else { current->signal->nr_threads++;
kernel/pid_namespace.c +2 -0
@@ -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 ; }
kernel/rootns.c +40 -0
@@ -16,6 +16,7 @@#include <linux/ns_common.h> #include <linux/nsfs.h> #include <linux/pid.h> +#include <linux/pid_namespace.h> #include <linux/user_namespace.h> #include <linux/compat.h> #include <uapi/linux/rootns.h>
@@ -105,3 +106,42 @@ bool is_rootns_file(struct file *file) {return file->f_op == &rootns_fops; } + +void copy_rootns (struct task_struct *tsk,struct rootns *c) +{ +if (likely (!c ||READ_ONCE (c->state) !=ROOTNS_FORKING )) +return ; + + scoped_guard(spinlock, &c->lock) { +get_rootns (c); +WRITE_ONCE (c->init_pid,get_task_pid (tsk,PIDTYPE_TGID )); +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); +}
Signature · 1 line
2.47.3
RFC PATCH v2 4/13 rootns: Add rootns_create() system call
In reply to Jarkko SakkinenSetting 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 with dedicated empty mount (CLONE_EMPTY_MNTNS) and PID namespaces and return its control file descriptor. Create fresh optional namespaces selected in flags while inheriting unset ones from the caller, and pin active references for the lifetime of the rootns. Leave the newly created rootns in ROOTNS_EMPTY until userspace installs a root mount.
--- include/linux/syscalls.h | 1 + kernel/rootns.c | 139 +++++++++++++++++++++++++++++++++++++++ kernel/sys_ni.c | 3 + 3 files changed, 143 insertions(+)
include/linux/syscalls.h +1 -0
@@ -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
kernel/rootns.c +139 -0
142 lines not on this page · raw message
kernel/sys_ni.c +3 -0
@@ -398,3 +398,6 @@ COND_SYSCALL(rseq_slice_yield);COND_SYSCALL (uretprobe);COND_SYSCALL (uprobe); + +/* kernel/rootns.c */ +COND_SYSCALL (rootns_create);
Signature · 1 line
2.47.3
RFC PATCH v2 5/13 rootns: Add rootns_wait() system call
In reply to Jarkko Sakkinenwait4() 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.
--- include/linux/compat.h | 4 ++ include/linux/syscalls.h | 2 + kernel/rootns.c | 105 +++++++++++++++++++++++++++++++++++++++ kernel/sys_ni.c | 2 + 4 files changed, 113 insertions(+)
include/linux/compat.h +4 -0
@@ -779,6 +779,10 @@ asmlinkage long compat_sys_recvmmsg_time32(int fd, struct compat_mmsghdr __userasmlinkage 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,
include/linux/syscalls.h +2 -0
@@ -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
kernel/rootns.c +105 -0
114 lines not on this page · raw message
kernel/sys_ni.c +2 -0
@@ -401,3 +401,5 @@ COND_SYSCALL(uprobe);/* kernel/rootns.c */ COND_SYSCALL (rootns_create); +COND_SYSCALL (rootns_wait); +COND_SYSCALL_COMPAT (rootns_wait);
Signature · 1 line
2.47.3
RFC PATCH v2 6/13 rootns: Add rootns_kill() system call
In reply to Jarkko SakkinenSignaling every process inside a container from userspace via /proc is racy against concurrent fork() calls.
Add the rootns_kill() system call to walk the root namespace's PID namespace IDR under RCU and deliver a validated signal once to each thread group, aggregating per-process delivery results.
--- include/linux/syscalls.h | 1 + kernel/rootns.c | 65 ++++++++++++++++++++++++++++++++++++++++ kernel/sys_ni.c | 1 + 3 files changed, 67 insertions(+)
include/linux/syscalls.h +1 -0
@@ -1009,6 +1009,7 @@ asmlinkage long sys_lsm_list_modules(u64 __user *ids, u32 __user *size, u32 flagasmlinkage 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
kernel/rootns.c +65 -0
74 lines not on this page · raw message
kernel/sys_ni.c +1 -0
@@ -403,3 +403,4 @@ COND_SYSCALL(uprobe);COND_SYSCALL (rootns_create);COND_SYSCALL (rootns_wait);COND_SYSCALL_COMPAT (rootns_wait); +COND_SYSCALL (rootns_kill);
Signature · 1 line
2.47.3
RFC PATCH v2 7/13 fork: Support CLONE_INTO_ROOTNS in clone3()
In reply to Jarkko SakkinenMultithreaded 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_READY 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.
Require CAP_SYS_ADMIN in the target user namespace, forbid credential privilege escalation, and require an ancestor active PID namespace so the caller receives a valid child PID. 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.
--- include/linux/cred.h | 4 +- include/linux/nsproxy.h | 4 +- include/linux/rootns.h | 14 ++++ include/linux/sched/task.h | 8 +++ include/uapi/linux/sched.h | 5 ++ kernel/cred.c | 70 +++++++++++++------ kernel/fork.c | 67 +++++++++++++++--- kernel/nsproxy.c | 11 ++- kernel/rootns.c | 137 +++++++++++++++++++++++++++++++++++++ 9 files changed, 288 insertions(+), 32 deletions(-)
include/linux/cred.h +3 -1
@@ -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 );
include/linux/nsproxy.h +3 -1
@@ -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);
include/linux/rootns.h +14 -0
@@ -14,6 +14,7 @@struct cred ;struct file ; +struct kernel_clone_args ;struct nsproxy ;struct pid ;struct pid_namespace ;
@@ -50,6 +51,8 @@ void put_rootns(struct rootns *c);bool is_rootns_file (struct file *file);void copy_rootns (struct task_struct *tsk,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) {
@@ -73,6 +76,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 */
include/linux/sched/task.h +8 -0
@@ -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; };
include/uapi/linux/sched.h +5 -0
@@ -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
kernel/cred.c +50 -20
117 lines not on this page · raw message
kernel/fork.c +59 -8
158 lines not on this page · raw message
kernel/nsproxy.c +9 -2
@@ -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,18 @@ 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) { +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 +199,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);
kernel/rootns.c +137 -0
152 lines not on this page · raw message
Signature · 1 line
2.47.3
RFC PATCH v2 8/13 fs: Support FSCONFIG_SET_ROOTNS in fsconfig()
In reply to Jarkko Sakkinenfsopen() initializes a filesystem context from current's user, network, PID, and IPC namespaces, preventing an external manager from creating proc, mqueue, or userns-owned superblocks bound to 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. Update fc->net_ns, switch fc->user_ns for non-global FS_USERNS_MOUNT or FS_USERNS_DELEGATABLE filesystems whose mounter fsuid/fsgid map into the rootns user namespace, and pass the rootns to ->set_rootns() for proc and mqueue.
--- fs/fsopen.c | 76 ++++++++++++++++++++++++++++++++++++-- fs/proc/root.c | 13 +++++++ include/linux/fs_context.h | 3 ++ include/uapi/linux/mount.h | 1 + ipc/mqueue.c | 12 ++++++ 5 files changed, 101 insertions(+), 4 deletions(-)
fs/fsopen.c +72 -4
@@ -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,50 @@ 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. +* +* ``fc->net_ns`` is switched to the ``rootns`` network namespace, +* ``fc->user_ns`` is delegated for non-global ``FS_USERNS_MOUNT`` or +* ``FS_USERNS_DELEGATABLE`` filesystems when the mounter ``fsuid``/``fsgid`` +* map into the target 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; + +if (!is_rootns_file (param->file)) +return -EINVAL ; + + c = param->file->private_data; + user_ns = c->cred->user_ns; +if (!ns_capable (user_ns,CAP_SYS_ADMIN )) +return -EPERM ; + +put_net (fc->net_ns); + fc->net_ns =get_net (c->ns->net_ns); +if (!fc->global && + (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)) { +put_user_ns (fc->user_ns); + fc->user_ns =get_user_ns (user_ns); + } +if (fc->ops->set_rootns) + fc->ops->set_rootns (fc, c); + 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.
@@ -147,7 +196,7 @@ SYSCALL_DEFINE2(fsopen, const char __user *, _fs_name, unsigned int, flags)if (IS_ERR (fc))return PTR_ERR (fc); - fc->phase =FS_CONTEXT_CREATE_PARAMS ; + fc->phase =FS_CONTEXT_CREATE_NS ; ret =fscontext_alloc_log (fc);if (ret <0 )
@@ -222,7 +271,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))
@@ -298,9 +348,16 @@ 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_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 +447,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 +518,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 +549,7 @@ SYSCALL_DEFINE5(fsconfig,putname (param.name);break ;case FSCONFIG_SET_FD : +case FSCONFIG_SET_ROOTNS :if (param.file)fput (param.file);break ;
fs/proc/root.c +13 -0
@@ -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,16 @@ static int proc_get_tree(struct fs_context *fc)return get_tree_nodev (fc, proc_fill_super); } +static void proc_set_rootns (struct fs_context *fc,struct rootns *rootns) +{ +struct proc_fs_context *ctx = fc->fs_private; + +put_pid_ns (ctx->pid_ns); + ctx->pid_ns =get_pid_ns (rootns->ns->pid_ns_for_children); +put_user_ns (fc->user_ns); + fc->user_ns =get_user_ns (ctx->pid_ns->user_ns); +} +static void proc_fs_context_free (struct fs_context *fc) {struct proc_fs_context *ctx = fc->fs_private;
@@ -334,6 +346,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, };
include/linux/fs_context.h +3 -0
@@ -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,7 @@ enum fs_context_purpose {* Userspace usage phase for fsopen/fspick. */ enum fs_context_phase { +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() */
@@ -117,6 +119,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); +void (*set_rootns)(struct fs_context *fc,struct rootns *rootns);int (*get_tree)(struct fs_context *fc);int (*reconfigure)(struct fs_context *fc); };
include/uapi/linux/mount.h +1 -0
@@ -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 */ };/*
ipc/mqueue.c +12 -0
@@ -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,16 @@ static struct inode *mqueue_get_inode(struct super_block *sb,return ERR_PTR (ret); } +static void 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); +} +static int mqueue_fill_super (struct super_block *sb,struct fs_context *fc) {struct inode *inode;
@@ -1613,6 +1624,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, };
Signature · 1 line
2.47.3
RFC PATCH v2 9/13 fs: Support installing rootns mount trees via move_mount()
In reply to Jarkko SakkinenA newly created rootns starts with an empty nullfs-rooted mount namespace, and move_mount() only resolves target paths against the caller's own filesystem view.
Add MOVE_MOUNT_T_ROOTNS_ROOT to populate a rootns mount tree through its file descriptor before or after entry. Installing "/" attaches a detached anonymous mount tree onto the nullfs root of the rootns mount namespace once and transitions the rootns to ROOTNS_READY; relative target paths attach anonymous mounts underneath the installed rootns root while verifying the destination mount namespace.
Allocate fsmount() anonymous namespaces in fc->user_ns, check target user namespace CAP_SYS_ADMIN for MOVE_MOUNT_T_ROOTNS_ROOT instead of caller may_mount(), and lock moved mount trees when crossing user namespace boundaries.
--- fs/namespace.c | 178 ++++++++++++++++++++++++++++++++----- include/uapi/linux/mount.h | 3 +- 2 files changed, 157 insertions(+), 24 deletions(-)
fs/namespace.c +155 -23
@@ -34,6 +34,7 @@#include <linux/mnt_idmapping.h> #include <linux/pidfs.h> #include <linux/nstree.h> +#include <linux/rootns.h> #include "pnode.h" #include "internal.h"
@@ -2564,6 +2565,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_ROOTNS =BIT (2 ), +MNT_TREE_ROOTNS_INIT =BIT (3 ), };/**
@@ -3781,6 +3784,7 @@ static int do_move_mount(const struct path *old_path,struct mount *old =real_mount (old_path->mnt);int err;bool beneath = flags &MNT_TREE_BENEATH ; +bool lock_tree;if (!path_mounted (old_path))return -EINVAL ;
@@ -3792,7 +3796,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_ROOTNS ) { +if (!anon_ns_root (old) || old->mnt_ns == mp.parent->mnt_ns) +return -EINVAL ; +if ((flags &MNT_TREE_ROOTNS_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))
@@ -3845,7 +3855,16 @@ static int do_move_mount(const struct path *old_path,if (mount_is_ancestor (old, mp.parent))return -ELOOP ; -return attach_recursive_mnt (old, &mp); + lock_tree = (flags &MNT_TREE_ROOTNS ) && + old->mnt_ns->user_ns != mp.parent->mnt_ns->user_ns; + err =attach_recursive_mnt (old, &mp); +if (!err && lock_tree) { +scoped_guard (mount_writer) { +lock_mnt_tree (old); + old->mnt.mnt_flags |=MNT_LOCKED ; + } + } +return err; }static int do_move_mount_old (const struct path *path,const char *old_name)
@@ -4699,7 +4718,7 @@ 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->user_ns, true);if (IS_ERR (ns))return PTR_ERR (ns); mnt =real_mount (new_path.mnt);
@@ -4739,6 +4758,129 @@ 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_ROOTNS_ROOT +* +* ``MOVE_MOUNT_T_ROOTNS_ROOT`` installs detached anonymous mount trees into a +* target ``rootns`` control fd supplied as ``to_dfd``: +* +* 1. ``to_pathname`` of ``"/"`` attaches the initial root mount onto the +* ``nullfs`` root of the ``rootns`` mount namespace at most once and +* transitions the ``rootns`` to ``ROOTNS_READY``. +* +* 2. Relative ``to_pathname`` values resolve beneath the installed ``rootns`` +* root inside the ``rootns`` mount namespace. +* +* Capability is checked against ``CAP_SYS_ADMIN`` in the target ``rootns`` +* user namespace, and source trees crossing user namespace boundaries are +* locked with ``MNT_LOCKED`` and locked mount flags. +*/ +static int move_mount_rootns (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 *rootns_mnt_ns; +unsigned int lflags; +struct rootns *rootns; +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_rootns)(to_dfd); +if (fd_empty (f_rootns)) +return -EBADF ; +if (!is_rootns_file (fd_file (f_rootns))) +return -EINVAL ; + + rootns =fd_file (f_rootns)->private_data; +if (!ns_capable (rootns->cred->user_ns,CAP_SYS_ADMIN )) +return -EPERM ; + + rootns_mnt_ns = rootns->ns->mnt_ns; + is_root = to_name->name[0 ] =='/' && to_name->name[1 ] =='\0' ; +if (is_root) { +if (flags &MOVE_MOUNT_BENEATH ) +return -EINVAL ; +if (READ_ONCE (rootns->state) !=ROOTNS_EMPTY ) +return -EBUSY ; + + to_path.mnt =mntget (&rootns_mnt_ns->root->mnt); + to_path.dentry =dget (rootns_mnt_ns->root->mnt.mnt_root); + mflags |=MNT_TREE_ROOTNS_INIT ; + }else { +if (to_name->name[0 ] =='/' ) +return -EINVAL ; + + scoped_guard(spinlock, &rootns->lock) { +if (rootns->state ==ROOTNS_EMPTY ) +return -ENOENT ; + } + + 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, + &rootns->root); +if (ret) +return ret; +if (real_mount (to_path.mnt)->mnt_ns != rootns_mnt_ns) +return -EINVAL ; + } + + ret =lookup_move_mount_from (from_dfd, from_pathname, flags, + &from_path); +if (ret) +return ret; + + ret =vfs_move_mount (&from_path, &to_path, mflags |MNT_TREE_ROOTNS ); +if (!ret && is_root) { + scoped_guard(spinlock, &rootns->lock) { +path_get (&from_path); + rootns->root = from_path; +WRITE_ONCE (rootns->state,ROOTNS_READY ); + } + } + +return ret; +} +/* * Move a mount from one place to another. In combination with * fsopen()/fsmount() this is used to install a new mount and in combination
@@ -4758,7 +4900,7 @@ SYSCALL_DEFINE5(move_mount,enum mnt_tree_flags_t mflags =0 ;int ret =0 ; -if (!may_mount ()) +if (!(flags &MOVE_MOUNT_T_ROOTNS_ROOT ) && !may_mount ())return -EPERM ;if (flags & ~MOVE_MOUNT__MASK )
@@ -4771,6 +4913,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_ROOTNS_ROOT )) { +if (flags & (MOVE_MOUNT_T_EMPTY_PATH |MOVE_MOUNT_SET_GROUP )) +return -EINVAL ; +return move_mount_rootns (from_dfd, from_pathname, + to_dfd, to_pathname, flags, mflags); + } + uflags =0 ;if (flags &MOVE_MOUNT_T_EMPTY_PATH ) uflags =AT_EMPTY_PATH ;
@@ -4794,25 +4943,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;
include/uapi/linux/mount.h +2 -1
@@ -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_ROOTNS_ROOT 0x00000080/* Set as rootns root */ #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.
Signature · 1 line
2.47.3
RFC PATCH v2 10/13 arch: Wire up rootns system calls
In reply to Jarkko SakkinenNow 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.
--- 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(-)
arch/alpha/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/arm/tools/syscall.tbl +3 -0
@@ -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
arch/arm64/tools/syscall_32.tbl +3 -0
@@ -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
arch/m68k/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/microblaze/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/mips/kernel/syscalls/syscall_n32.tbl +3 -0
@@ -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
arch/mips/kernel/syscalls/syscall_n64.tbl +3 -0
@@ -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
arch/mips/kernel/syscalls/syscall_o32.tbl +3 -0
@@ -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
arch/parisc/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/powerpc/kernel/syscalls/syscall.tbl +3 -0
@@ -563,3 +563,6 @@ 470 common listns sys_listns 471 nospu 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
arch/s390/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/sh/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/sparc/kernel/syscalls/syscall.tbl +3 -0
@@ -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
arch/x86/entry/syscalls/syscall_32.tbl +3 -0
@@ -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
arch/x86/entry/syscalls/syscall_64.tbl +3 -0
@@ -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
arch/xtensa/kernel/syscalls/syscall.tbl +3 -0
@@ -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
include/uapi/asm-generic/unistd.h +9 -1
@@ -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
scripts/syscall.tbl +3 -0
@@ -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
Signature · 1 line
2.47.3
RFC PATCH v2 11/13 docs: Document root namespace uAPI
In reply to Jarkko SakkinenUserspace container managers need a clear specification of rootns state transitions, 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.
--- Documentation/userspace-api/index.rst | 1 + Documentation/userspace-api/rootns.rst | 40 ++++++++++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 Documentation/userspace-api/rootns.rst
Documentation/userspace-api/index.rst +1 -0
@@ -17,6 +17,7 @@ System calls :maxdepth: 1 unshare + rootns futex2 ebpf/index ioctl/index
Documentation/userspace-api/rootns.rst new file +40 -0
@@ -0,0 +1,40 @@ +.. 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 + +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_ROOTNS_ROOT
Signature · 1 line
2.47.3
RFC PATCH v2 12/13 selftests/rootns: Add root namespace test suite
In reply to Jarkko SakkinenVerify the root namespace uAPI and security invariants across privileged, unprivileged, and edge-case scenarios.
Add a kselftest harness suite under tools/testing/selftests/rootns exercising rootns creation, clone3(CLONE_INTO_ROOTNS) init and concurrent bootstrap lifecycle, poll(EPOLLHUP) and WNOHANG/rusage reporting, FSCONFIG_SET_ROOTNS and mount-tree installation, pivot_root() and OPEN_TREE_NAMESPACE inside a rootns, and entry and setns() permission enforcement.
--- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/rootns/.gitignore | 2 + tools/testing/selftests/rootns/Makefile | 5 + tools/testing/selftests/rootns/config | 9 + tools/testing/selftests/rootns/smoke.c | 1381 +++++++++++++++++++++ 5 files changed, 1398 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
tools/testing/selftests/Makefile +1 -0
@@ -117,6 +117,7 @@ TARGETS += rdma TARGETS += resctrl TARGETS += riscv TARGETS += rlimits +TARGETS += rootns TARGETS += rseq TARGETS += rtc TARGETS += rust
tools/testing/selftests/rootns/.gitignore new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +/smoke
tools/testing/selftests/rootns/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +CFLAGS += -Wall -Wextra -O2 -g $(KHDR_INCLUDES) +TEST_GEN_PROGS := smoke +include ../lib.mk
tools/testing/selftests/rootns/config new file +9 -0
@@ -0,0 +1,9 @@ +CONFIG_CGROUPS=y +CONFIG_IPC_NS=y +CONFIG_NET_NS=y +CONFIG_PID_NS=y +CONFIG_PROC_FS=y +CONFIG_ROOTNS=y +CONFIG_TMPFS=y +CONFIG_USER_NS=y +CONFIG_UTS_NS=y
tools/testing/selftests/rootns/smoke.c new file +1381 -0
1,381 lines not on this page · raw message
Signature · 1 line
2.47.3
RFC PATCH v2 13/13 MAINTAINERS: Add entry for ROOT NAMESPACE
In reply to Jarkko SakkinenRecord maintainership and mailing list routing for the root namespace subsystem across its uAPI headers, core implementation, documentation, and selftests.
--- MAINTAINERS | 11 +++++++++++ 1 file changed, 11 insertions(+)
MAINTAINERS +11 -0
@@ -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 <[email protected]> +M: Jarkko Sakkinen <[email protected]> +L: [email protected] +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 <[email protected]> L: [email protected]
Signature · 1 line
2.47.3