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 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. Co-developed-by: David Howells Signed-off-by: David Howells Signed-off-by: Jarkko Sakkinen --- include/linux/syscalls.h | 1 + kernel/rootns.c | 140 +++++++++++++++++++++++++++++++++++++++ kernel/sys_ni.c | 3 + 3 files changed, 144 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/kernel/rootns.c b/kernel/rootns.c index e3b203322ae2..904d75ce9d90 100644 --- a/kernel/rootns.c +++ b/kernel/rootns.c @@ -145,3 +145,143 @@ void exit_rootns(struct pid_namespace *pid_ns, struct task_struct *tsk) wake_up_poll(&c->waitq, EPOLLHUP); put_rootns(c); } + +/* + * Create credentials for a rootns. Drop keyrings from the new credential to + * avoid unnecessary pinning. + */ +static const struct cred *create_rootns_creds(unsigned int flags) +{ + struct cred *new; + int ret; + + new = prepare_creds(); + if (!new) + return ERR_PTR(-ENOMEM); + +#ifdef CONFIG_KEYS + key_put(new->thread_keyring); + new->thread_keyring = NULL; + key_put(new->process_keyring); + new->process_keyring = NULL; + key_put(new->session_keyring); + new->session_keyring = NULL; + key_put(new->request_key_auth); + new->request_key_auth = NULL; +#endif + if (!(flags & ROOTNS_USER)) + return new; + + ret = create_user_ns(new); + if (ret < 0) + goto err; + new->euid = new->user_ns->owner; + new->egid = new->user_ns->group; + + new->uid = new->euid; + new->suid = new->euid; + new->fsuid = new->euid; + new->gid = new->egid; + new->sgid = new->egid; + new->fsgid = new->egid; + ret = set_cred_ucounts(new); + if (ret < 0) + goto err; + return new; + +err: + abort_creds(new); + return ERR_PTR(ret); +} + +/* + * Create a new rootns. + */ +static struct rootns *create_rootns(unsigned int flags) +{ + u64 clone_flags = CLONE_NEWNS | CLONE_EMPTY_MNTNS | CLONE_NEWPID; + const struct cred *cred; + 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; + + cred = create_rootns_creds(flags); + if (IS_ERR(cred)) { + ret = PTR_ERR(cred); + goto err_put; + } + c->cred = cred; + ns_ref_active_get(cred->user_ns); + + if (!ns_capable(cred->user_ns, CAP_SYS_ADMIN)) { + ret = -EPERM; + goto err_put; + } + + if (flags & ROOTNS_CGROUP) + clone_flags |= CLONE_NEWCGROUP; + if (flags & ROOTNS_UTS) + clone_flags |= CLONE_NEWUTS; + if (flags & ROOTNS_IPC) + clone_flags |= CLONE_NEWIPC; + if (flags & ROOTNS_NET) + clone_flags |= CLONE_NEWNET; + + ns = create_new_namespaces(clone_flags, current->nsproxy, cred->user_ns, + NULL); + if (IS_ERR(ns)) { + ret = PTR_ERR(ns); + goto err_put; + } + + c->ns = ns; + ns->rootns = c; + ns->pid_ns_for_children->rootns = c; + 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 with dedicated empty mount and PID + * namespaces plus any optional namespaces requested in @flags. + * + * 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