From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 04BA4606A68C for ; Sun, 22 Nov 2026 01:18:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=XAHpuIYM Received: by kanga.kvack.org (Postfix) id 64E956B05B1; Sat, 21 Nov 2026 20:18:31 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 6261C6B05B2; Sat, 21 Nov 2026 20:18:31 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 515386B05B3; Sat, 21 Nov 2026 20:18:31 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id 2660E6B05B1 for ; Sat, 21 Nov 2026 20:18:31 -0500 (EST) Received: from smtpin28.hostedemail.com (lb01a-stub [10.200.18.249]) by unirelay05.hostedemail.com (Postfix) with ESMTP id 9ACCC405C8 for ; Sun, 22 Nov 2026 01:18:30 +0000 (UTC) X-FDA: 85460994780.28.1B57ABD Received: from sea.source.kernel.org (sea.source.kernel.org [172.234.252.31]) by imf24.hostedemail.com (Postfix) with ESMTP id D9F65180003 for ; Sun, 22 Nov 2026 01:18:28 +0000 (UTC) Authentication-Results: imf24.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20260515 header.b=XAHpuIYM; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf24.hostedemail.com: domain of jarkko@kernel.org designates 172.234.252.31 as permitted sender) smtp.mailfrom=jarkko@kernel.org ARC-Seal: i=1; a=rsa-sha256; d=hostedemail.com; s=arc-20220608; cv=none; t=1795310309; b=bEtJrE/wptWHleRkKMn7MfIQVr4xonywsUrP8uAW2lr9+bhqLb9ZjEhh8gdbBrGVKV5YPj olhrw8lW7cM1tzXd4UiIs1b6RJilWZCoLM5oK9+w7JMR1erFbioH5zA4uP8qqrvAyqqJ2+ 9vzUqjJq+PwW9guVb3blQJ6NbPLyvTE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1795310309; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=XpNXS5ojTHex5pjAQ7N0N2KGFefBBIyu7p5qnr1DII0=; b=27YTIQ4Jt4ZJpOxaLcXKtQjA22jLFK7GfMdJWI+HLLYjXcWqTaOkuSIjH9NUAFbcxJy8dI 8nvT0afgKi8BR4nWs4wTPQueffzb7xjSqJgPQv+EENSK1uH13poSfUeygCnGQQGfwmo9kE WtM4fsfCJY8xnK88RZN9eW9m2RB4V0A= ARC-Authentication-Results: i=1; imf24.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20260515 header.b=XAHpuIYM; dmarc=pass (policy=quarantine) header.from=kernel.org; spf=pass (imf24.hostedemail.com: domain of jarkko@kernel.org designates 172.234.252.31 as permitted sender) smtp.mailfrom=jarkko@kernel.org Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with UTF8SMTP id 6B98240574; Sun, 22 Nov 2026 01:18:27 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with UTF8SMTPSA id 9D64A1F000C6; Sun, 22 Nov 2026 01:18:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795310307; bh=XpNXS5ojTHex5pjAQ7N0N2KGFefBBIyu7p5qnr1DII0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=XAHpuIYMuvHESYcs1Wf38my26Pzo1vppP2wTqjgHcpcKf3ir4AQdkPxWkTbbaG4EP H8eD7np2SyVvPL7FYCmRVAAli32d6oyxehJrYsVouDRscGsi1GiOJq7Jl9CzrhyPut /KGpybTrKmBRubL/tAPgkmqhQsCbee8uahz6CSzMjfGiVj2ukkpp7oervNvygdT5K2 bP05dNojuhC2zNwKAAfgMVJ5TI0RgyAFObzJ+q49YJrMf1PttNwrfHcmvKBCPLK0AV RKVqwCs1RbwD6oDX0aF4mr4SRfTPMOj4OfsiGiKaRNg8I79yxO6JtBYsMAan+eoWFg DPNAboGNRYGOA== From: Jarkko Sakkinen To: linux-fsdevel@vger.kernel.org Cc: Jarkko Sakkinen , bpf@vger.kernel.org, containers@lists.linux.dev, linux-api@vger.kernel.org, linux-arch@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-mm@kvack.org, linux-security-module@vger.kernel.org, Aleksa Sarai , Alexander Mikhalitsyn , Alexander Viro , Andy Lutomirski , Arnd Bergmann , Christian Brauner , David Howells , Giuseppe Scrivano , Hugh Dickins , Jan Kara , Jeff Layton , Jonathan Corbet , Josef Bacik , Kees Cook , KP Singh , Lennart Poettering , Neal Gompa , Oleg Nesterov , Paul Moore , Pavel Tikhomirov , Serge Hallyn , Shuah Khan , Zygmunt Krynicki Subject: [RFC PATCH v6 02/26] userns: Add userns_set_idmap() system call Date: Sun, 22 Nov 2026 03:17:45 +0200 Message-ID: <20261122011809.2667684-3-jarkko@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261122011809.2667684-1-jarkko@kernel.org> References: <20261122011809.2667684-1-jarkko@kernel.org> X-Archived-By: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Stat-Signature: 8bonbhihbu56e4ygbn3hm65wqgwdmwpx X-Rspam-User: X-Spam-Status: No, score=-18.8 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_PASS, SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=4.0.1 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: D9F65180003 X-HE-Tag: 1795310308-742340 X-HE-Meta: U2FsdGVkX1+QL4ntUclpWheX78WQ+sk7LT3odAbTZ+RoKpadKkfunlTmuYd7Isb2eHhaxO4SzC5vzpH0BiLQMfvjCMDXPJOJGCo9Y2b2cxI7HpU6B3LL2cpNc1R3iRYsZZDRk4hcPbT4Z6Msi2p7oFB2tCvZkIzYx+0soY7tr4xwOmGbmKN9MfB3dfZmjWWy6+VrO02fMn0OUoJBUTPbjlqE/v3wd9/q222BTKnasAICo0K16Yj6EIpawQXHykVQcCqIDrgHiLYgcwPadWLLbYzmOyFC86AHJg0kWB23GqSpK2VtRpJUTAODGz0eRmJfJoXYSbsp8/dxd2Y8wTiv4FLezIv36GFRZsvjSwEVAMbuW0mpFXDOZzXBmwKXhSxv249NegXsdoe1MrCQDkrgJxxKTpAw6v1atgz2ugmRVPRb+RX581PJObM8FHRfwKVei+orFcCqd93xLzCAluIHrKqR6iM0y1alf5yG6VEmaSI63a9DEDmhYfxt26Q7QfeZkeJKgnfDxy7RTORXiadHoOYkPamRCy+GlC8lSZMBsHLcrOG5Eg+orEfSrrvxCvKQUuleNGcUrC8/mgazcQavtxLJl80AG7nZMYIR06rPS5OBcagCCYJl+QdEEoZoaJIKsZoHH3kFLlAVvfoWtMyWa9F57Riyw0vHUnAHKRaqIaHBSxSMpInwy/FKr+JOncRPNRC3Sc30qzg//AS/e+JY2OVH0iBD2Aldl8CaGCY/zDxPbCiVQB9LerxWF3cOSR+G99219DdwPbUQ7ugH1P2ouc+pXaxB8Oi8zyrcScvCbN/aUhn4HLODGn52SK1Gk8wc8HONodcP3UsMc0IxIw633pSlSm7MdpZrszfy1JB6trTVv7JpKSUyrD2keryIg1wZ/VjPrqbgZyZMJN4T2OXc/PgF2YiqDW5RrdPCdhlM/K5RpczXqy5T7f6CItlP9BUc1AjnBRbUFKvNAU18nTv NHjc6fK6 z78u5E79abzPZzzXu6FJ9C9N7eDXwZiZUMdh9QwWIQ4zlmSZgi6K4FG52QyWNOyAy9SOhB78c2Y9xRyitBh5dfGF1Ius59l1gUbQJHZdQxO1/pa/brh6xx9FFxbyizM4qdwMfvewvcvE5FjHYH6cse5KWpansLuFJjazyoqku/7gUeJNUbtQZ2qQTuY/U0htO3DZr/pQnZZ59dBzMIEgOUO3MXgIbOwuo2xLDymkmF6SdJOy8uUJqkRr3uP7o4n1FGQ20ByCMEQ9VEGpRRjx2MJ/CjkPJL/Y12MCyjNicXXQmPJVjRwFAiVKsDwRxvq8V/7tNr7FXTNXgvyqStzD7L+NgvlUPZbJGDtlILDSIc3KPKCcOjjkz0Op+762W+xzMhvbDpbz+fJ00AmxA0luvPwe980xHL5y8llJCMPR0NoGldwqufTkYaE/Nz5n52BEFJMI30YECIwIqDpjeB6RFDfR6wA== Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 Configuring UID, GID, and project ID mappings currently requires writing formatted text to /proc//{uid_map,gid_map,projid_map,setgroups}, which depends on a live task in /proc and enforces write(2) file-opener CAP_SETUID/CAP_SETGID checks that prevent passing an unprivileged userns file descriptor over SCM_RIGHTS to a dedicated CAP_SETUID/CAP_SETGID mapping helper. Add userns_set_idmap() to atomically configure setgroups policy and UID, GID, and project ID extents directly on a CLONE_NEWUSER nsfs file descriptor. Expose USERNS_SETGROUPS_ALLOWED in uapi/linux/nsfs.h as the flags bitmask when installing a GID mapping so setgroups(2) is disabled by default unless explicitly preserved. Require CAP_SYS_ADMIN over the target user namespace in either the caller's or the file opener's credentials, and check parent ID-range capabilities strictly against the caller's credentials. Signed-off-by: Jarkko Sakkinen --- include/linux/syscalls.h | 4 + include/linux/user_namespace.h | 2 - include/uapi/linux/nsfs.h | 46 ++++++ kernel/sys_ni.c | 1 + kernel/user_namespace.c | 258 +++++++++++++++++++++++++++++++++ 5 files changed, 309 insertions(+), 2 deletions(-) diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index 552d9710a0d5..72308cc11908 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -77,6 +77,7 @@ struct cachestat; struct statmount; struct mnt_id_req; struct ns_id_req; +struct userns_idmap; struct xattr_args; struct file_attr; @@ -909,6 +910,9 @@ asmlinkage long sys_clock_adjtime32(clockid_t which_clock, struct old_timex32 __user *tx); asmlinkage long sys_syncfs(int fd); asmlinkage long sys_setns(int fd, int nstype); +asmlinkage long sys_userns_set_idmap(int fd, + const struct userns_idmap __user *map, + size_t size, unsigned int flags); asmlinkage long sys_pidfd_open(pid_t pid, unsigned int flags); asmlinkage long sys_sendmmsg(int fd, struct mmsghdr __user *msg, unsigned int vlen, unsigned flags); diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h index 91232053775d..b4a50edfe003 100644 --- a/include/linux/user_namespace.h +++ b/include/linux/user_namespace.h @@ -35,8 +35,6 @@ struct uid_gid_map { /* 64 bytes -- 1 cache line */ }; }; -#define USERNS_SETGROUPS_ALLOWED 1UL - #define USERNS_INIT_FLAGS USERNS_SETGROUPS_ALLOWED struct ucounts; diff --git a/include/uapi/linux/nsfs.h b/include/uapi/linux/nsfs.h index e5909266ec3f..f919b19a2c74 100644 --- a/include/uapi/linux/nsfs.h +++ b/include/uapi/linux/nsfs.h @@ -44,6 +44,52 @@ struct mnt_ns_info { #define NS_GET_MNTNS_ID _IOR(NSIO, 5, __u64) #define NS_GET_ID _IOR(NSIO, 13, __u64) +/** + * struct userns_idmap_extent - Single ID mapping range for userns_set_idmap() + * @first: First ID inside the target user namespace. + * @lower_first: First ID inside the parent user namespace. + * @count: Number of consecutive IDs in the range. + * @reserved: Reserved for future use; must be zero. + */ +struct userns_idmap_extent { + __u32 first; + __u32 lower_first; + __u32 count; + __u32 reserved; +}; + +/** + * enum userns_flags - User namespace flags + * @USERNS_SETGROUPS_ALLOWED: Allow setgroups(2) inside the user namespace + * once its GID mapping is established. + */ +enum userns_flags { + USERNS_SETGROUPS_ALLOWED = (1 << 0), +}; + +/** + * struct userns_idmap - Arguments for userns_set_idmap() + * @nr_uid_extents: Number of entries in @uid_extents. + * @nr_gid_extents: Number of entries in @gid_extents. + * @nr_projid_extents: Number of entries in @projid_extents. + * @reserved: Reserved for future use; must be zero. + * @uid_extents: User pointer to array of &struct userns_idmap_extent for UIDs. + * @gid_extents: User pointer to array of &struct userns_idmap_extent for GIDs. + * @projid_extents: User pointer to array of &struct userns_idmap_extent for + * project IDs. + */ +struct userns_idmap { + __u32 nr_uid_extents; + __u32 nr_gid_extents; + __u32 nr_projid_extents; + __u32 reserved; + __aligned_u64 uid_extents; + __aligned_u64 gid_extents; + __aligned_u64 projid_extents; +}; + +#define USERNS_IDMAP_SIZE_VER0 40 /* sizeof first published struct */ + enum init_ns_ino { IPC_NS_INIT_INO = 0xEFFFFFFFU, UTS_NS_INIT_INO = 0xEFFFFFFEU, diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index c8be0abaa407..e3202e7cc2a1 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -172,6 +172,7 @@ COND_SYSCALL_COMPAT(fadvise64_64); COND_SYSCALL(lsm_get_self_attr); COND_SYSCALL(lsm_set_self_attr); COND_SYSCALL(lsm_list_modules); +COND_SYSCALL(userns_set_idmap); /* CONFIG_MMU only */ COND_SYSCALL(swapon); diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c index 6b9673dcdc67..e151ffc1f708 100644 --- a/kernel/user_namespace.c +++ b/kernel/user_namespace.c @@ -22,7 +22,11 @@ #include #include #include +#include #include +#include +#include +#include static struct kmem_cache *user_ns_cachep __ro_after_init; static DEFINE_MUTEX(userns_state_mutex); @@ -1150,6 +1154,260 @@ static ssize_t map_write(struct file *file, const char __user *buf, return ret; } +static bool idmap_maps_root(const struct uid_gid_map *new_map) +{ + unsigned int idx; + + for (idx = 0; idx < new_map->nr_extents; idx++) { + const struct uid_gid_extent *e; + + if (new_map->nr_extents <= UID_GID_MAP_MAX_BASE_EXTENTS) + e = &new_map->extent[idx]; + else + e = &new_map->forward[idx]; + if (e->lower_first == 0) + return true; + } + return false; +} + +static bool caller_idmap_permitted(struct user_namespace *ns, int cap_setid, + unsigned long ns_flags, + const struct uid_gid_map *new_map) +{ + const struct cred *cred = current_cred(); + + if (cap_setid == CAP_SETUID && idmap_maps_root(new_map)) { + if (cred->user_ns == ns) { + if (!ns->parent_could_setfcap) + return false; + } else { + if (!ns_capable(ns->parent, CAP_SETFCAP)) + return false; + } + } + + if (new_map->nr_extents == 1 && new_map->extent[0].count == 1 && + uid_eq(ns->owner, cred->euid)) { + u32 id = new_map->extent[0].lower_first; + + if (cap_setid == CAP_SETUID) { + kuid_t uid = make_kuid(ns->parent, id); + + if (uid_eq(uid, cred->euid)) + return true; + } else if (cap_setid == CAP_SETGID) { + kgid_t gid = make_kgid(ns->parent, id); + + if (!(ns_flags & USERNS_SETGROUPS_ALLOWED) && + gid_eq(gid, cred->egid)) + return true; + } + } + + if (!cap_valid(cap_setid)) + return ns_capable(ns, CAP_SYS_ADMIN) || + ns_capable(ns->parent, CAP_SETUID); + + return ns_capable(ns->parent, cap_setid); +} + +static int prepare_caller_idmap(struct user_namespace *ns, int cap_setid, + unsigned long ns_flags, + struct uid_gid_map *new_map, + struct uid_gid_map *parent_map) +{ + if (!caller_idmap_permitted(ns, cap_setid, ns_flags, new_map)) + return -EPERM; + + return resolve_new_idmap(new_map, parent_map); +} + +static int parse_user_idmap_extents(__u64 uptr, __u32 nr_extents, + struct uid_gid_map *new_map) +{ + const struct userns_idmap_extent __user *uext = u64_to_user_ptr(uptr); + unsigned int i; + int ret; + + if (!nr_extents || nr_extents > UID_GID_MAP_MAX_EXTENTS || !uptr) + return -EINVAL; + + for (i = 0; i < nr_extents; i++) { + struct userns_idmap_extent kext; + struct uid_gid_extent extent; + + if (copy_from_user(&kext, &uext[i], sizeof(kext))) + return -EFAULT; + if (kext.reserved) + return -EINVAL; + + extent.first = kext.first; + extent.lower_first = kext.lower_first; + extent.count = kext.count; + + ret = validate_and_insert_extent(new_map, &extent); + if (ret < 0) + return ret; + } + return 0; +} + +/** + * sys_userns_set_idmap - Configure ID mappings on a user namespace fd + * @fd: File descriptor referencing a %CLONE_NEWUSER ``nsfs`` namespace + * @map: User pointer to &struct userns_idmap configuration + * @size: Size of @map structure in bytes (%USERNS_IDMAP_SIZE_VER0..%PAGE_SIZE) + * @flags: Bitmask of &enum userns_flags values (%USERNS_SETGROUPS_ALLOWED) + * + * Atomically configure UID, GID, and project ID mappings (and, when + * @map->nr_gid_extents is non-zero, the %USERNS_SETGROUPS_ALLOWED policy) of + * @fd. Requires ``CAP_SYS_ADMIN`` over the target user namespace in the + * caller's or @fd opener's credentials, with parent ID ranges authorized + * against the caller's credentials. + * + * Return: 0 on success, negative error code on failure. + */ +SYSCALL_DEFINE4(userns_set_idmap, int, fd, + const struct userns_idmap __user *, map, + size_t, size, unsigned int, flags) +{ + struct uid_gid_map new_uid = {}, new_gid = {}, new_projid = {}; + struct userns_idmap req = {}; + struct ns_common *ns_common; + struct user_namespace *ns; + unsigned long new_flags; + struct file *filp; + bool file_ok; + int ret; + + BUILD_BUG_ON(sizeof(struct userns_idmap) != USERNS_IDMAP_SIZE_VER0); + + if (flags & ~USERNS_SETGROUPS_ALLOWED) + return -EINVAL; + + CLASS(fd, f)(fd); + if (fd_empty(f)) + return -EBADF; + + filp = fd_file(f); + if (!proc_ns_file(filp)) + return -EINVAL; + + ns_common = get_proc_ns(file_inode(filp)); + if (ns_common->ns_type != CLONE_NEWUSER) + return -EINVAL; + ns = to_user_ns(ns_common); + + if (!map || size < USERNS_IDMAP_SIZE_VER0) + return -EINVAL; + if (unlikely(size > PAGE_SIZE)) + return -E2BIG; + ret = copy_struct_from_user(&req, sizeof(req), map, size); + if (ret) + return ret; + if (req.reserved) + return -EINVAL; + if (!req.nr_uid_extents != !req.uid_extents || + !req.nr_gid_extents != !req.gid_extents || + !req.nr_projid_extents != !req.projid_extents) + return -EINVAL; + if (!req.nr_uid_extents && !req.nr_gid_extents && + !req.nr_projid_extents) + return -EINVAL; + if ((flags & USERNS_SETGROUPS_ALLOWED) && !req.nr_gid_extents) + return -EINVAL; + + if (!ns->parent) + return -EPERM; + if (current_user_ns() != ns && current_user_ns() != ns->parent) + return -EPERM; + + file_ok = (filp->f_cred->user_ns == ns || + filp->f_cred->user_ns == ns->parent) && + file_ns_capable(filp, ns, CAP_SYS_ADMIN); + if (!ns_capable(ns, CAP_SYS_ADMIN) && !file_ok) + return -EPERM; + + if (req.nr_uid_extents) { + ret = parse_user_idmap_extents(req.uid_extents, + req.nr_uid_extents, &new_uid); + if (ret < 0) + goto out_free; + } + if (req.nr_gid_extents) { + ret = parse_user_idmap_extents(req.gid_extents, + req.nr_gid_extents, &new_gid); + if (ret < 0) + goto out_free; + } + if (req.nr_projid_extents) { + ret = parse_user_idmap_extents(req.projid_extents, + req.nr_projid_extents, + &new_projid); + if (ret < 0) + goto out_free; + } + + mutex_lock(&userns_state_mutex); + new_flags = ns->flags; + ret = -EPERM; + + if (req.nr_uid_extents && ns->uid_map.nr_extents != 0) + goto out_unlock; + if (req.nr_gid_extents && ns->gid_map.nr_extents != 0) + goto out_unlock; + if (req.nr_projid_extents && ns->projid_map.nr_extents != 0) + goto out_unlock; + + if (req.nr_gid_extents) { + if ((flags & USERNS_SETGROUPS_ALLOWED) && + !(new_flags & USERNS_SETGROUPS_ALLOWED)) + goto out_unlock; + if (!(flags & USERNS_SETGROUPS_ALLOWED)) + new_flags &= ~USERNS_SETGROUPS_ALLOWED; + } + + if (req.nr_uid_extents) { + ret = prepare_caller_idmap(ns, CAP_SETUID, new_flags, &new_uid, + &ns->parent->uid_map); + if (ret < 0) + goto out_unlock; + } + if (req.nr_gid_extents) { + ret = prepare_caller_idmap(ns, CAP_SETGID, new_flags, &new_gid, + &ns->parent->gid_map); + if (ret < 0) + goto out_unlock; + } + if (req.nr_projid_extents) { + ret = prepare_caller_idmap(ns, -1, new_flags, &new_projid, + &ns->parent->projid_map); + if (ret < 0) + goto out_unlock; + } + + if (new_flags != ns->flags) + WRITE_ONCE(ns->flags, new_flags); + if (req.nr_uid_extents) + commit_new_idmap(&ns->uid_map, &new_uid); + if (req.nr_gid_extents) + commit_new_idmap(&ns->gid_map, &new_gid); + if (req.nr_projid_extents) + commit_new_idmap(&ns->projid_map, &new_projid); + + mutex_unlock(&userns_state_mutex); + return 0; + +out_unlock: + mutex_unlock(&userns_state_mutex); +out_free: + free_new_idmap(&new_uid); + free_new_idmap(&new_gid); + free_new_idmap(&new_projid); + return ret; +} + ssize_t proc_uid_map_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos) { -- 2.47.3