Count rlimits in each user namespace
Subsystems (11)
v9 cover Count rlimits in each user namespace
Preface
-------
These patches are for binding the rlimit counters to a user in user namespace. This patch set can be applied on top of:
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git v5.12-rc4
Problem
-------
The RLIMIT_NPROC, RLIMIT_MEMLOCK, RLIMIT_SIGPENDING, RLIMIT_MSGQUEUE rlimits implementation places the counters in user_struct [1]. These limits are global between processes and persists for the lifetime of the process, even if processes are in different user namespaces.
To illustrate the impact of rlimits, let's say there is a program that does not fork. Some service-A wants to run this program as user X in multiple containers. Since the program never fork the service wants to set RLIMIT_NPROC=1.
service-A
\- program (uid=1000, container1, rlimit_nproc=1) \- program (uid=1000, container2, rlimit_nproc=1)
The service-A sets RLIMIT_NPROC=1 and runs the program in container1. When the service-A tries to run a program with RLIMIT_NPROC=1 in container2 it fails since user X already has one running process.
The problem is not that the limit from container1 affects container2. The problem is that limit is verified against the global counter that reflects the number of processes in all containers.
This problem can be worked around by using different users for each container but in this case we face a different problem of uid mapping when transferring files from one container to another.
Eric W. Biederman mentioned this issue [2][3].
Introduced changes
------------------
To address the problem, we bind rlimit counters to user namespace. Each counter reflects the number of processes in a given uid in a given user namespace. The result is a tree of rlimit counters with the biggest value at the root (aka init_user_ns). The limit is considered exceeded if it's exceeded up in the tree.
[1]: https://lore.kernel.org/containers/[email protected]/
[2]: https://lists.linuxfoundation.org/pipermail/containers/2020-August/042096.html
[3]: https://lists.linuxfoundation.org/pipermail/containers/2020-October/042524.html
Changelog
---------
v9:
* Used a negative value to check that the ucounts->count is close to overflow.
* Rebased onto v5.12-rc4.
v8:
* Used atomic_t for ucounts reference counting. Also added counter overflow check (thanks to Linus Torvalds for the idea).
* Fixed other issues found by lkp-tests project in the patch that Reimplements RLIMIT_MEMLOCK on top of ucounts.
v7:
* Fixed issues found by lkp-tests project in the patch that Reimplements RLIMIT_MEMLOCK on top of ucounts.
v6:
* Fixed issues found by lkp-tests project.
* Rebased onto v5.11.
v5:
* Split the first commit into two commits: change ucounts.count type to atomic_long_t and add ucounts to cred. These commits were merged by mistake during the rebase.
* The __get_ucounts() renamed to alloc_ucounts().
* The cred.ucounts update has been moved from commit_creds() as it did not allow to handle errors.
* Added error handling of set_cred_ucounts().
v4:
* Reverted the type change of ucounts.count to refcount_t.
* Fixed typo in the kernel/cred.c
v3:
* Added get_ucounts() function to increase the reference count. The existing get_counts() function renamed to __get_ucounts().
* The type of ucounts.count changed from atomic_t to refcount_t.
* Dropped 'const' from set_cred_ucounts() arguments.
* Fixed a bug with freeing the cred structure after calling cred_alloc_blank().
* Commit messages have been updated.
* Added selftest.
v2:
* RLIMIT_MEMLOCK, RLIMIT_SIGPENDING and RLIMIT_MSGQUEUE are migrated to ucounts.
* Added ucounts for pair uid and user namespace into cred.
* Added the ability to increase ucount by more than 1.
v1:
* After discussion with Eric W. Biederman, I increased the size of ucounts to atomic_long_t.
* Added ucount_max to avoid the fork bomb.
--
Alexey Gladkov (8):
Increase size of ucounts to atomic_long_t
Add a reference to ucounts for each cred
Use atomic_t for ucounts reference counting
Reimplement RLIMIT_NPROC on top of ucounts
Reimplement RLIMIT_MSGQUEUE on top of ucounts Reimplement RLIMIT_SIGPENDING on top of ucounts Reimplement RLIMIT_MEMLOCK on top of ucounts
kselftests: Add test to check for rlimit changes in different user
namespaces
fs/exec.c | 6 +- fs/hugetlbfs/inode.c | 16 +- fs/proc/array.c | 2 +- include/linux/cred.h | 4 + include/linux/hugetlb.h | 4 +- include/linux/mm.h | 4 +- include/linux/sched/user.h | 7 - include/linux/shmem_fs.h | 2 +- include/linux/signal_types.h | 4 +- include/linux/user_namespace.h | 26 ++- ipc/mqueue.c | 41 ++--- ipc/shm.c | 26 +-- kernel/cred.c | 50 +++++- kernel/exit.c | 2 +- kernel/fork.c | 18 +- kernel/signal.c | 57 +++---- kernel/sys.c | 14 +- kernel/ucount.c | 133 ++++++++++++--- kernel/user.c | 3 - kernel/user_namespace.c | 9 +- mm/memfd.c | 4 +- mm/mlock.c | 23 ++- mm/mmap.c | 4 +- mm/shmem.c | 8 +- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/rlimits/.gitignore | 2 + tools/testing/selftests/rlimits/Makefile | 6 + tools/testing/selftests/rlimits/config | 1 + .../selftests/rlimits/rlimits-per-userns.c | 161 ++++++++++++++++++ 29 files changed, 493 insertions(+), 145 deletions(-) create mode 100644 tools/testing/selftests/rlimits/.gitignore create mode 100644 tools/testing/selftests/rlimits/Makefile create mode 100644 tools/testing/selftests/rlimits/config create mode 100644 tools/testing/selftests/rlimits/rlimits-per-userns.c
Signature · 1 line
2.29.3
PATCH v9 1/8 Increase size of ucounts to atomic_long_t
RLIMIT_MSGQUEUE and RLIMIT_MEMLOCK use unsigned long to store their counters. As a preparation for moving rlimits based on ucounts, we need to increase the size of the variable to long.
--- include/linux/user_namespace.h | 4 ++-- kernel/ucount.c | 16 ++++++++-------- 2 files changed, 10 insertions(+), 10 deletions(-)
include/linux/user_namespace.h +2 -2
@@ -85,7 +85,7 @@ struct user_namespace {struct ctl_table_header *sysctls;#endif struct ucounts *ucounts; -int ucount_max[UCOUNT_COUNTS ]; +long ucount_max[UCOUNT_COUNTS ]; } __randomize_layout;struct ucounts {
@@ -93,7 +93,7 @@ struct ucounts {struct user_namespace *ns;kuid_t uid;int count; -atomic_t ucount[UCOUNT_COUNTS ]; +atomic_long_t ucount[UCOUNT_COUNTS ]; };extern struct user_namespace init_user_ns;
kernel/ucount.c +8 -8
@@ -175,14 +175,14 @@ static void put_ucounts(struct ucounts *ucounts)kfree (ucounts); } -static inline bool atomic_inc_below (atomic_t *v,int u) +static inline bool atomic_long_inc_below (atomic_long_t *v,int u) { -int c, old; - c =atomic_read (v); +long c, old; + c =atomic_long_read (v);for (;;) {if (unlikely (c >= u))return false; - old =atomic_cmpxchg (v, c, c+1 ); + old =atomic_long_cmpxchg (v, c, c+1 );if (likely (old == c))return true; c = old;
@@ -196,17 +196,17 @@ struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid,struct user_namespace *tns; ucounts =get_ucounts (ns, uid);for (iter = ucounts; iter; iter = tns->ucounts) { -int max; +long max; tns = iter->ns; max =READ_ONCE (tns->ucount_max[type]); -if (!atomic_inc_below (&iter->ucount[type], max)) +if (!atomic_long_inc_below (&iter->ucount[type], max)) goto fail; }return ucounts; fail: bad = iter;for (iter = ucounts; iter != bad; iter = iter->ns->ucounts) -atomic_dec (&iter->ucount[type]); +atomic_long_dec (&iter->ucount[type]);put_ucounts (ucounts);return NULL ;
@@ -216,7 +216,7 @@ void dec_ucount(struct ucounts *ucounts, enum ucount_type type) {struct ucounts *iter;for (iter = ucounts; iter; iter = iter->ns->ucounts) { -int dec =atomic_dec_if_positive (&iter->ucount[type]); +long dec =atomic_long_dec_if_positive (&iter->ucount[type]);WARN_ON_ONCE (dec <0 ); }put_ucounts (ucounts);
Signature · 1 line
2.29.3
PATCH v9 2/8 Add a reference to ucounts for each cred
In reply to Alexey GladkovFor RLIMIT_NPROC and some other rlimits the user_struct that holds the global limit is kept alive for the lifetime of a process by keeping it in struct cred. Adding a pointer to ucounts in the struct cred will allow to track RLIMIT_NPROC not only for user in the system, but for user in the user_namespace.
Updating ucounts may require memory allocation which may fail. So, we cannot change cred.ucounts in the commit_creds() because this function cannot fail and it should always return 0. For this reason, we modify cred.ucounts before calling the commit_creds().
Changelog
v6:
* Fix null-ptr-deref in is_ucounts_overlimit() detected by trinity. This error was caused by the fact that cred_alloc_blank() left the ucounts pointer empty.
--- fs/exec.c | 4 ++++ include/linux/cred.h | 2 ++ include/linux/user_namespace.h | 4 ++++ kernel/cred.c | 40 ++++++++++++++++++++++++++++++++++ kernel/fork.c | 6 +++++ kernel/sys.c | 12 ++++++++++ kernel/ucount.c | 40 +++++++++++++++++++++++++++++++--- kernel/user_namespace.c | 3 +++ 8 files changed, 108 insertions(+), 3 deletions(-)
fs/exec.c +4 -0
@@ -1360,6 +1360,10 @@ int begin_new_exec(struct linux_binprm * bprm)WRITE_ONCE (me->self_exec_id, me->self_exec_id +1 );flush_signal_handlers (me,0 ); + retval =set_cred_ucounts (bprm->cred); +if (retval <0 ) + goto out_unlock; +/* * install the new credentials for this executable */
include/linux/cred.h +2 -0
@@ -144,6 +144,7 @@ struct cred {#endif struct user_struct *user;/* real user ID subscription */ struct user_namespace *user_ns;/* user_ns the caps and keyrings are relative to. */ +struct ucounts *ucounts;struct group_info *group_info;/* supplementary groups for euid/fsgid */ /* RCU deletion */ union {
@@ -170,6 +171,7 @@ extern int set_security_override_from_ctx(struct cred *, const char *);extern int set_create_files_as (struct cred *,struct inode *);extern int cred_fscmp (const struct cred *,const struct cred *);extern void __init cred_init (void ); +extern int set_cred_ucounts (struct cred *);/* * check for validity of credentials
include/linux/user_namespace.h +4 -0
@@ -97,11 +97,15 @@ struct ucounts { };extern struct user_namespace init_user_ns; +extern struct ucounts init_ucounts;bool setup_userns_sysctls (struct user_namespace *ns);void retire_userns_sysctls (struct user_namespace *ns);struct ucounts *inc_ucount (struct user_namespace *ns,kuid_t uid,enum ucount_type type);void dec_ucount (struct ucounts *ucounts,enum ucount_type type); +struct ucounts *alloc_ucounts (struct user_namespace *ns,kuid_t uid); +struct ucounts *get_ucounts (struct ucounts *ucounts); +void put_ucounts (struct ucounts *ucounts);#ifdef CONFIG_USER_NS
kernel/cred.c +40 -0
@@ -60,6 +60,7 @@ struct cred init_cred = { .user = INIT_USER, .user_ns = &init_user_ns, .group_info = &init_groups, + .ucounts = &init_ucounts, };static inline void set_cred_subscribers (struct cred *cred,int n)
@@ -119,6 +120,8 @@ static void put_cred_rcu(struct rcu_head *rcu)if (cred->group_info)put_group_info (cred->group_info);free_uid (cred->user); +if (cred->ucounts) +put_ucounts (cred->ucounts);put_user_ns (cred->user_ns);kmem_cache_free (cred_jar, cred); }
@@ -222,6 +225,7 @@ struct cred *cred_alloc_blank(void)#ifdef CONFIG_DEBUG_CREDENTIALS new->magic =CRED_MAGIC ;#endif + new->ucounts =get_ucounts (&init_ucounts);if (security_cred_alloc_blank (new,GFP_KERNEL_ACCOUNT ) <0 ) goto error;
@@ -284,6 +288,11 @@ struct cred *prepare_creds(void)if (security_prepare_creds (new, old,GFP_KERNEL_ACCOUNT ) <0 ) goto error; + + new->ucounts =get_ucounts (new->ucounts); +if (!new->ucounts) + goto error; +validate_creds (new);return new;
@@ -363,6 +372,8 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags) ret =create_user_ns (new);if (ret <0 ) goto error_put; +if (set_cred_ucounts (new) <0 ) + goto error_put; }#ifdef CONFIG_KEYS
@@ -653,6 +664,31 @@ int cred_fscmp(const struct cred *a, const struct cred *b) }EXPORT_SYMBOL (cred_fscmp); +int set_cred_ucounts (struct cred *new) +{ +struct task_struct *task = current; +const struct cred *old = task->real_cred; +struct ucounts *old_ucounts = new->ucounts; + +if (new->user == old->user && new->user_ns == old->user_ns) +return 0 ; + +/* +* This optimization is needed because alloc_ucounts() uses locks +* for table lookups. +*/ +if (old_ucounts && old_ucounts->ns == new->user_ns &&uid_eq (old_ucounts->uid, new->euid)) +return 0 ; + +if (!(new->ucounts =alloc_ucounts (new->user_ns, new->euid))) +return -EAGAIN ; + +if (old_ucounts) +put_ucounts (old_ucounts); + +return 0 ; +} +/* * initialise the credentials stuff */
@@ -719,6 +755,10 @@ struct cred *prepare_kernel_cred(struct task_struct *daemon)if (security_prepare_creds (new, old,GFP_KERNEL_ACCOUNT ) <0 ) goto error; + new->ucounts =get_ucounts (new->ucounts); +if (!new->ucounts) + goto error; +put_cred (old);validate_creds (new);return new;
kernel/fork.c +6 -0
@@ -2995,6 +2995,12 @@ int ksys_unshare(unsigned long unshare_flags)if (err) goto bad_unshare_cleanup_cred; +if (new_cred) { + err =set_cred_ucounts (new_cred); +if (err) + goto bad_unshare_cleanup_cred; + } +if (new_fs || new_fd || do_sysvsem || new_cred || new_nsproxy) {if (do_sysvsem) {/*
kernel/sys.c +12 -0
@@ -552,6 +552,10 @@ long __sys_setreuid(uid_t ruid, uid_t euid)if (retval <0 ) goto error; + retval =set_cred_ucounts (new); +if (retval <0 ) + goto error; +return commit_creds (new); error:
@@ -610,6 +614,10 @@ long __sys_setuid(uid_t uid)if (retval <0 ) goto error; + retval =set_cred_ucounts (new); +if (retval <0 ) + goto error; +return commit_creds (new); error:
@@ -685,6 +693,10 @@ long __sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)if (retval <0 ) goto error; + retval =set_cred_ucounts (new); +if (retval <0 ) + goto error; +return commit_creds (new); error:
kernel/ucount.c +37 -3
@@ -8,6 +8,12 @@#include <linux/kmemleak.h> #include <linux/user_namespace.h> +struct ucounts init_ucounts = { + .ns = &init_user_ns, + .uid =GLOBAL_ROOT_UID , + .count =1 , +}; +#define UCOUNTS_HASHTABLE_BITS 10static struct hlist_head ucounts_hashtable[(1 <<UCOUNTS_HASHTABLE_BITS )];static DEFINE_SPINLOCK (ucounts_lock);
@@ -125,7 +131,15 @@ static struct ucounts *find_ucounts(struct user_namespace *ns, kuid_t uid, strucreturn NULL ; } -static struct ucounts *get_ucounts (struct user_namespace *ns,kuid_t uid) +static void hlist_add_ucounts (struct ucounts *ucounts) +{ +struct hlist_head *hashent =ucounts_hashentry (ucounts->ns, ucounts->uid); +spin_lock_irq (&ucounts_lock); +hlist_add_head (&ucounts->node, hashent); +spin_unlock_irq (&ucounts_lock); +} + +struct ucounts *alloc_ucounts (struct user_namespace *ns,kuid_t uid) {struct hlist_head *hashent =ucounts_hashentry (ns, uid);struct ucounts *ucounts, *new;
@@ -160,7 +174,26 @@ static struct ucounts *get_ucounts(struct user_namespace *ns, kuid_t uid)return ucounts; } -static void put_ucounts (struct ucounts *ucounts) +struct ucounts *get_ucounts (struct ucounts *ucounts) +{ +unsigned long flags; + +if (!ucounts) +return NULL ; + +spin_lock_irqsave (&ucounts_lock, flags); +if (ucounts->count ==INT_MAX ) { +WARN_ONCE (1 ,"ucounts: counter has reached its maximum value" ); + ucounts =NULL ; + }else { + ucounts->count +=1 ; + } +spin_unlock_irqrestore (&ucounts_lock, flags); + +return ucounts; +} + +void put_ucounts (struct ucounts *ucounts) {unsigned long flags;
@@ -194,7 +227,7 @@ struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid, {struct ucounts *ucounts, *iter, *bad;struct user_namespace *tns; - ucounts =get_ucounts (ns, uid); + ucounts =alloc_ucounts (ns, uid);for (iter = ucounts; iter; iter = tns->ucounts) {long max; tns = iter->ns;
@@ -237,6 +270,7 @@ static __init int user_namespace_sysctl_init(void)BUG_ON (!user_header);BUG_ON (!setup_userns_sysctls (&init_user_ns));#endif +hlist_add_ucounts (&init_ucounts);return 0 ; }subsys_initcall (user_namespace_sysctl_init);
kernel/user_namespace.c +3 -0
@@ -1281,6 +1281,9 @@ static int userns_install(struct nsset *nsset, struct ns_common *ns)put_user_ns (cred->user_ns);set_cred_user_ns (cred,get_user_ns (user_ns)); +if (set_cred_ucounts (cred) <0 ) +return -EINVAL ; +return 0 ; }
Signature · 1 line
2.29.3
PATCH v9 3/8 Use atomic_t for ucounts reference counting
In reply to Alexey GladkovThe current implementation of the ucounts reference counter requires the use of spin_lock. We're going to use get_ucounts() in more performance critical areas like a handling of RLIMIT_SIGPENDING.
Now we need to use spin_lock only if we want to change the hashtable.
v9:
* Use a negative value to check that the ucounts->count is close to overflow.
--- include/linux/user_namespace.h | 4 +-- kernel/ucount.c | 53 ++++++++++++---------------------- 2 files changed, 21 insertions(+), 36 deletions(-)
include/linux/user_namespace.h +2 -2
@@ -92,7 +92,7 @@ struct ucounts {struct hlist_node node;struct user_namespace *ns;kuid_t uid; -int count; +atomic_t count;atomic_long_t ucount[UCOUNT_COUNTS ]; };
@@ -104,7 +104,7 @@ void retire_userns_sysctls(struct user_namespace *ns);struct ucounts *inc_ucount (struct user_namespace *ns,kuid_t uid,enum ucount_type type);void dec_ucount (struct ucounts *ucounts,enum ucount_type type);struct ucounts *alloc_ucounts (struct user_namespace *ns,kuid_t uid); -struct ucounts *get_ucounts (struct ucounts *ucounts); +struct ucounts *__must_check get_ucounts (struct ucounts *ucounts);void put_ucounts (struct ucounts *ucounts);#ifdef CONFIG_USER_NS
kernel/ucount.c +19 -34
87 lines not on this page · raw message
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v9 5/8 Reimplement RLIMIT_MSGQUEUE on top of ucounts
In reply to Alexey GladkovThe rlimit counter is tied to uid in the user_namespace. This allows rlimit values to be specified in userns even if they are already globally exceeded by the user. However, the value of the previous user_namespaces cannot be exceeded.
--- include/linux/sched/user.h | 4 ---- include/linux/user_namespace.h | 1 + ipc/mqueue.c | 41 ++++++++++++++++++---------------- kernel/fork.c | 1 + kernel/ucount.c | 1 + kernel/user_namespace.c | 1 + 6 files changed, 26 insertions(+), 23 deletions(-)
include/linux/sched/user.h +0 -4
@@ -18,10 +18,6 @@ struct user_struct {#endif #ifdef CONFIG_EPOLL atomic_long_t epoll_watches;/* The number of file descriptors currently watched */ -#endif -#ifdef CONFIG_POSIX_MQUEUE -/* protected by mq_lock */ -unsigned long mq_bytes;/* How many bytes can be allocated to mqueue? */ #endif unsigned long locked_shm;/* How many pages of mlocked shm ? */ unsigned long unix_inflight;/* How many files in flight in unix sockets */
include/linux/user_namespace.h +1 -0
@@ -51,6 +51,7 @@ enum ucount_type {UCOUNT_INOTIFY_WATCHES , #endifUCOUNT_RLIMIT_NPROC , +UCOUNT_RLIMIT_MSGQUEUE , UCOUNT_COUNTS, };
ipc/mqueue.c +22 -19
91 lines not on this page · raw message
kernel/fork.c +1 -0
@@ -823,6 +823,7 @@ void __init fork_init(void) init_user_ns.ucount_max[i] = max_threads/2 ; init_user_ns.ucount_max[UCOUNT_RLIMIT_NPROC ] =task_rlimit (&init_task,RLIMIT_NPROC ); + init_user_ns.ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =task_rlimit (&init_task,RLIMIT_MSGQUEUE );#ifdef CONFIG_VMAP_STACK cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "fork:vm_stack_cache",
kernel/ucount.c +1 -0
@@ -81,6 +81,7 @@ static struct ctl_table user_table[] = {UCOUNT_ENTRY ("max_inotify_instances" ), UCOUNT_ENTRY("max_inotify_watches"), #endif + { }, { }, { } };
kernel/user_namespace.c +1 -0
@@ -122,6 +122,7 @@ int create_user_ns(struct cred *new) ns->ucount_max[i] =INT_MAX ; } ns->ucount_max[UCOUNT_RLIMIT_NPROC ] =rlimit (RLIMIT_NPROC ); + ns->ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =rlimit (RLIMIT_MSGQUEUE ); ns->ucounts = ucounts;/* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v9 4/8 Reimplement RLIMIT_NPROC on top of ucounts
In reply to Alexey GladkovThe rlimit counter is tied to uid in the user_namespace. This allows rlimit values to be specified in userns even if they are already globally exceeded by the user. However, the value of the previous user_namespaces cannot be exceeded.
To illustrate the impact of rlimits, let's say there is a program that does not fork. Some service-A wants to run this program as user X in multiple containers. Since the program never fork the service wants to set RLIMIT_NPROC=1.
service-A
\- program (uid=1000, container1, rlimit_nproc=1) \- program (uid=1000, container2, rlimit_nproc=1)
The service-A sets RLIMIT_NPROC=1 and runs the program in container1. When the service-A tries to run a program with RLIMIT_NPROC=1 in container2 it fails since user X already has one running process.
We cannot use existing inc_ucounts / dec_ucounts because they do not allow us to exceed the maximum for the counter. Some rlimits can be overlimited by root or if the user has the appropriate capability.
--- fs/exec.c | 2 +- include/linux/cred.h | 2 ++ include/linux/sched/user.h | 1 - include/linux/user_namespace.h | 13 ++++++++ kernel/cred.c | 10 +++--- kernel/exit.c | 2 +- kernel/fork.c | 9 ++--- kernel/sys.c | 2 +- kernel/ucount.c | 61 ++++++++++++++++++++++++++++++++++ kernel/user.c | 1 - kernel/user_namespace.c | 3 +- 11 files changed, 91 insertions(+), 15 deletions(-)
fs/exec.c +1 -1
@@ -1878,7 +1878,7 @@ static int do_execveat_common(int fd, struct filename *filename,* whether NPROC limit is still exceeded. */ if ((current->flags &PF_NPROC_EXCEEDED ) && -atomic_read (¤t_user ()->processes) >rlimit (RLIMIT_NPROC )) { +is_ucounts_overlimit (current_ucounts (),UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC ))) { retval = -EAGAIN ; goto out_ret; }
include/linux/cred.h +2 -0
@@ -372,6 +372,7 @@ static inline void put_cred(const struct cred *_cred)#define task_uid (task) (task_cred_xxx((task), uid))#define task_euid (task) (task_cred_xxx((task), euid)) +#define task_ucounts (task) (task_cred_xxx((task), ucounts))#define current_cred_xxx (xxx) \ ({ \
@@ -388,6 +389,7 @@ static inline void put_cred(const struct cred *_cred)#define current_fsgid () (current_cred_xxx(fsgid))#define current_cap () (current_cred_xxx(cap_effective))#define current_user () (current_cred_xxx(user)) +#define current_ucounts () (current_cred_xxx(ucounts))extern struct user_namespace init_user_ns;#ifdef CONFIG_USER_NS
include/linux/sched/user.h +0 -1
@@ -12,7 +12,6 @@*/ struct user_struct {refcount_t __count;/* reference count */ -atomic_t processes;/* How many processes does this user have? */ atomic_t sigpending;/* How many pending signals does this user have? */ #ifdef CONFIG_FANOTIFY atomic_t fanotify_listeners;
include/linux/user_namespace.h +13 -0
@@ -50,9 +50,12 @@ enum ucount_type { UCOUNT_INOTIFY_INSTANCES, UCOUNT_INOTIFY_WATCHES, #endif + UCOUNT_RLIMIT_NPROC, UCOUNT_COUNTS, }; +#define MAX_PER_NAMESPACE_UCOUNTS UCOUNT_RLIMIT_NPROC + struct user_namespace { struct uid_gid_map uid_map; struct uid_gid_map gid_map;
@@ -107,6 +110,16 @@ struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid);struct ucounts *__must_check get_ucounts (struct ucounts *ucounts);void put_ucounts (struct ucounts *ucounts); +static inline long get_ucounts_value (struct ucounts *ucounts,enum ucount_type type) +{ +return atomic_long_read (&ucounts->ucount[type]); +} + +bool inc_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v); +bool inc_rlimit_ucounts_and_test (struct ucounts *ucounts,enum ucount_type type,long v,long max); +void dec_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v); +bool is_ucounts_overlimit (struct ucounts *ucounts,enum ucount_type type,unsigned long max); +#ifdef CONFIG_USER_NS static inline struct user_namespace *get_user_ns (struct user_namespace *ns)
kernel/cred.c +5 -5
@@ -360,7 +360,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)kdebug ("share_creds(%p{%d,%d})" , p->cred,atomic_read (&p->cred->usage),read_cred_subscribers (p->cred)); -atomic_inc (&p->cred->user->processes); +inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );return 0 ; }
@@ -395,8 +395,8 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags) }#endif -atomic_inc (&new->user->processes); p->cred = p->real_cred =get_cred (new); +inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );alter_cred_subscribers (new,2 );validate_creds (new);return 0 ;
@@ -496,12 +496,12 @@ int commit_creds(struct cred *new)* in set_user(). */ alter_cred_subscribers (new,2 ); -if (new->user != old->user) -atomic_inc (&new->user->processes); +if (new->user != old->user || new->user_ns != old->user_ns) +inc_rlimit_ucounts (new->ucounts,UCOUNT_RLIMIT_NPROC ,1 );rcu_assign_pointer (task->real_cred, new);rcu_assign_pointer (task->cred, new);if (new->user != old->user) -atomic_dec (&old->user->processes); +dec_rlimit_ucounts (old->ucounts,UCOUNT_RLIMIT_NPROC ,1 );alter_cred_subscribers (old,-2 );/* send notifications */
kernel/exit.c +1 -1
@@ -188,7 +188,7 @@ void release_task(struct task_struct *p)/* don't need to get the RCU readlock here - the process is dead and * can't be modifying its own credentials. But shut RCU-lockdep up */ rcu_read_lock (); -atomic_dec (&__task_cred (p)->user->processes); +dec_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );rcu_read_unlock ();cgroup_release (p);
kernel/fork.c +5 -4
@@ -819,9 +819,11 @@ void __init fork_init(void) init_task.signal->rlim[RLIMIT_SIGPENDING ] = init_task.signal->rlim[RLIMIT_NPROC ]; -for (i =0 ; i <UCOUNT_COUNTS ; i++) +for (i =0 ; i <MAX_PER_NAMESPACE_UCOUNTS ; i++) init_user_ns.ucount_max[i] = max_threads/2 ; + init_user_ns.ucount_max[UCOUNT_RLIMIT_NPROC ] =task_rlimit (&init_task,RLIMIT_NPROC ); +#ifdef CONFIG_VMAP_STACK cpuhp_setup_state (CPUHP_BP_PREPARE_DYN ,"fork:vm_stack_cache" ,NULL , free_vm_stack_cache);
@@ -1972,8 +1974,7 @@ static __latent_entropy struct task_struct *copy_process(DEBUG_LOCKS_WARN_ON (!p->softirqs_enabled);#endif retval = -EAGAIN ; -if (atomic_read (&p->real_cred->user->processes) >= -task_rlimit (p,RLIMIT_NPROC )) { +if (is_ucounts_overlimit (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC ))) {if (p->real_cred->user !=INIT_USER && !capable (CAP_SYS_RESOURCE ) && !capable (CAP_SYS_ADMIN )) goto bad_fork_free;
@@ -2376,7 +2377,7 @@ static __latent_entropy struct task_struct *copy_process(#endif delayacct_tsk_free (p); bad_fork_cleanup_count: -atomic_dec (&p->cred->user->processes); +dec_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );exit_creds (p); bad_fork_free: p->state =TASK_DEAD ;
kernel/sys.c +1 -1
@@ -473,7 +473,7 @@ static int set_user(struct cred *new)* for programs doing set*uid()+execve() by harmlessly deferring the * failure to the execve() stage. */ -if (atomic_read (&new_user->processes) >=rlimit (RLIMIT_NPROC ) && +if (is_ucounts_overlimit (new->ucounts,UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC )) && new_user !=INIT_USER ) current->flags |=PF_NPROC_EXCEEDED ;else
kernel/ucount.c +61 -0
91 lines not on this page · raw message
kernel/user.c +0 -1
@@ -98,7 +98,6 @@ static DEFINE_SPINLOCK(uidhash_lock);/* root_user.__count is 1, for init task cred */ struct user_struct root_user = { .__count =REFCOUNT_INIT (1 ), - .processes =ATOMIC_INIT (1 ), .sigpending =ATOMIC_INIT (0 ), .locked_shm =0 , .uid =GLOBAL_ROOT_UID ,
kernel/user_namespace.c +2 -1
@@ -118,9 +118,10 @@ int create_user_ns(struct cred *new) ns->owner = owner; ns->group = group;INIT_WORK (&ns->work, free_user_ns); -for (i =0 ; i <UCOUNT_COUNTS ; i++) { +for (i =0 ; i <MAX_PER_NAMESPACE_UCOUNTS ; i++) { ns->ucount_max[i] =INT_MAX ; } + ns->ucount_max[UCOUNT_RLIMIT_NPROC ] =rlimit (RLIMIT_NPROC ); ns->ucounts = ucounts;/* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v9 6/8 Reimplement RLIMIT_SIGPENDING on top of ucounts
In reply to Alexey GladkovThe rlimit counter is tied to uid in the user_namespace. This allows rlimit values to be specified in userns even if they are already globally exceeded by the user. However, the value of the previous user_namespaces cannot be exceeded.
--- fs/proc/array.c | 2 +- include/linux/sched/user.h | 1 - include/linux/signal_types.h | 4 ++- include/linux/user_namespace.h | 1 + kernel/fork.c | 1 + kernel/signal.c | 57 ++++++++++++++++------------------ kernel/ucount.c | 1 + kernel/user.c | 1 - kernel/user_namespace.c | 1 + 9 files changed, 34 insertions(+), 35 deletions(-)
fs/proc/array.c +1 -1
@@ -284,7 +284,7 @@ static inline void task_sig(struct seq_file *m, struct task_struct *p)collect_sigign_sigcatch (p, &ignored, &caught); num_threads =get_nr_threads (p);rcu_read_lock ();/* FIXME: is this correct? */ - qsize =atomic_read (&__task_cred (p)->user->sigpending); + qsize =get_ucounts_value (task_ucounts (p),UCOUNT_RLIMIT_SIGPENDING );rcu_read_unlock (); qlim =task_rlimit (p,RLIMIT_SIGPENDING );unlock_task_sighand (p, &flags);
include/linux/sched/user.h +0 -1
@@ -12,7 +12,6 @@*/ struct user_struct {refcount_t __count;/* reference count */ -atomic_t sigpending;/* How many pending signals does this user have? */ #ifdef CONFIG_FANOTIFY atomic_t fanotify_listeners;#endif
include/linux/signal_types.h +3 -1
@@ -13,6 +13,8 @@ typedef struct kernel_siginfo { __SIGINFO; } kernel_siginfo_t; +struct ucounts ; +/* * Real Time signals may be queued. */
@@ -21,7 +23,7 @@ struct sigqueue {struct list_head list;int flags;kernel_siginfo_t info; -struct user_struct *user; +struct ucounts *ucounts; };/* flags values. */
include/linux/user_namespace.h +1 -0
@@ -52,6 +52,7 @@ enum ucount_type {#endif UCOUNT_RLIMIT_NPROC ,UCOUNT_RLIMIT_MSGQUEUE , +UCOUNT_RLIMIT_SIGPENDING , UCOUNT_COUNTS, };
kernel/fork.c +1 -0
@@ -824,6 +824,7 @@ void __init fork_init(void) init_user_ns.ucount_max[UCOUNT_RLIMIT_NPROC ] =task_rlimit (&init_task,RLIMIT_NPROC ); init_user_ns.ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =task_rlimit (&init_task,RLIMIT_MSGQUEUE ); + init_user_ns.ucount_max[UCOUNT_RLIMIT_SIGPENDING ] =task_rlimit (&init_task,RLIMIT_SIGPENDING );#ifdef CONFIG_VMAP_STACK cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "fork:vm_stack_cache",
kernel/signal.c +26 -31
75 lines not on this page · raw message
kernel/ucount.c +1 -0
@@ -81,6 +81,7 @@ static struct ctl_table user_table[] = {UCOUNT_ENTRY ("max_inotify_instances" ), UCOUNT_ENTRY("max_inotify_watches"), #endif + { }, { }, { }, { }
kernel/user.c +0 -1
@@ -98,7 +98,6 @@ static DEFINE_SPINLOCK(uidhash_lock);/* root_user.__count is 1, for init task cred */ struct user_struct root_user = { .__count =REFCOUNT_INIT (1 ), - .sigpending =ATOMIC_INIT (0 ), .locked_shm =0 , .uid =GLOBAL_ROOT_UID , .ratelimit =RATELIMIT_STATE_INIT (root_user.ratelimit,0 ,0 ),
kernel/user_namespace.c +1 -0
@@ -123,6 +123,7 @@ int create_user_ns(struct cred *new) } ns->ucount_max[UCOUNT_RLIMIT_NPROC ] =rlimit (RLIMIT_NPROC ); ns->ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =rlimit (RLIMIT_MSGQUEUE ); + ns->ucount_max[UCOUNT_RLIMIT_SIGPENDING ] =rlimit (RLIMIT_SIGPENDING ); ns->ucounts = ucounts;/* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v9 7/8 Reimplement RLIMIT_MEMLOCK on top of ucounts
In reply to Alexey GladkovThe rlimit counter is tied to uid in the user_namespace. This allows rlimit values to be specified in userns even if they are already globally exceeded by the user. However, the value of the previous user_namespaces cannot be exceeded.
Changelog
v8:
* Fix issues found by lkp-tests project.
v7:
* Keep only ucounts for RLIMIT_MEMLOCK checks instead of struct cred.
v6:
* Fix bug in hugetlb_file_setup() detected by trinity.
--- fs/hugetlbfs/inode.c | 16 ++++++++-------- include/linux/hugetlb.h | 4 ++-- include/linux/mm.h | 4 ++-- include/linux/sched/user.h | 1 - include/linux/shmem_fs.h | 2 +- include/linux/user_namespace.h | 1 + ipc/shm.c | 26 +++++++++++++------------- kernel/fork.c | 1 + kernel/ucount.c | 1 + kernel/user.c | 1 - kernel/user_namespace.c | 1 + mm/memfd.c | 4 ++-- mm/mlock.c | 23 +++++++++++++++-------- mm/mmap.c | 4 ++-- mm/shmem.c | 8 ++++---- 15 files changed, 53 insertions(+), 44 deletions(-)
fs/hugetlbfs/inode.c +8 -8
@@ -1443,7 +1443,7 @@ static int get_hstate_idx(int page_size_log)* otherwise hugetlb_reserve_pages reserves one less hugepages than intended. */ struct file *hugetlb_file_setup (const char *name,size_t size, -vm_flags_t acctflag,struct user_struct **user, +vm_flags_t acctflag,struct ucounts **ucounts,int creat_flags,int page_size_log) {struct inode *inode;
@@ -1455,20 +1455,20 @@ struct file *hugetlb_file_setup(const char *name, size_t size,if (hstate_idx <0 )return ERR_PTR (-ENODEV ); - *user =NULL ; + *ucounts =NULL ; mnt = hugetlbfs_vfsmount[hstate_idx];if (!mnt)return ERR_PTR (-ENOENT );if (creat_flags ==HUGETLB_SHMFS_INODE && !can_do_hugetlb_shm ()) { - *user =current_user (); -if (user_shm_lock (size, *user)) { + *ucounts =current_ucounts (); +if (user_shm_lock (size, *ucounts)) {task_lock (current);pr_warn_once ("%s (%d): Using mlock ulimits for SHM_HUGETLB is deprecated\n" , current->comm, current->pid);task_unlock (current); }else { - *user =NULL ; + *ucounts =NULL ;return ERR_PTR (-EPERM ); } }
@@ -1495,9 +1495,9 @@ struct file *hugetlb_file_setup(const char *name, size_t size,iput (inode); out: -if (*user) { -user_shm_unlock (size, *user); - *user =NULL ; +if (*ucounts) { +user_shm_unlock (size, *ucounts); + *ucounts =NULL ; }return file; }
include/linux/hugetlb.h +2 -2
@@ -434,7 +434,7 @@ static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)extern const struct file_operations hugetlbfs_file_operations;extern const struct vm_operations_struct hugetlb_vm_ops;struct file *hugetlb_file_setup (const char *name,size_t size,vm_flags_t acct, -struct user_struct **user,int creat_flags, +struct ucounts **ucounts,int creat_flags,int page_size_log);static inline bool is_file_hugepages (struct file *file)
@@ -454,7 +454,7 @@ static inline struct hstate *hstate_inode(struct inode *i)#define is_file_hugepages (file) falsestatic inline struct file *hugetlb_file_setup (const char *name,size_t size,vm_flags_t acctflag, -struct user_struct **user,int creat_flags, +struct ucounts **ucounts,int creat_flags,int page_size_log) {return ERR_PTR (-ENOSYS );
include/linux/mm.h +2 -2
@@ -1658,8 +1658,8 @@ extern bool can_do_mlock(void);#else static inline bool can_do_mlock (void ) {return false; }#endif -extern int user_shm_lock (size_t ,struct user_struct *); -extern void user_shm_unlock (size_t ,struct user_struct *); +extern int user_shm_lock (size_t ,struct ucounts *); +extern void user_shm_unlock (size_t ,struct ucounts *);/* * Parameter block passed down to zap_pte_range in exceptional cases.
include/linux/sched/user.h +0 -1
@@ -18,7 +18,6 @@ struct user_struct {#ifdef CONFIG_EPOLL atomic_long_t epoll_watches;/* The number of file descriptors currently watched */ #endif -unsigned long locked_shm;/* How many pages of mlocked shm ? */ unsigned long unix_inflight;/* How many files in flight in unix sockets */ atomic_long_t pipe_bufs;/* how many pages are allocated in pipe buffers */
include/linux/shmem_fs.h +1 -1
@@ -65,7 +65,7 @@ extern struct file *shmem_file_setup_with_mnt(struct vfsmount *mnt,extern int shmem_zero_setup (struct vm_area_struct *);extern unsigned long shmem_get_unmapped_area (struct file *,unsigned long addr,unsigned long len,unsigned long pgoff,unsigned long flags); -extern int shmem_lock (struct file *file,int lock,struct user_struct *user); +extern int shmem_lock (struct file *file,int lock,struct ucounts *ucounts);#ifdef CONFIG_SHMEM extern const struct address_space_operations shmem_aops;static inline bool shmem_mapping (struct address_space *mapping)
include/linux/user_namespace.h +1 -0
@@ -53,6 +53,7 @@ enum ucount_type {UCOUNT_RLIMIT_NPROC ,UCOUNT_RLIMIT_MSGQUEUE ,UCOUNT_RLIMIT_SIGPENDING , +UCOUNT_RLIMIT_MEMLOCK , UCOUNT_COUNTS, };
ipc/shm.c +13 -13
@@ -60,7 +60,7 @@ struct shmid_kernel /* private to the kernel */time64_t shm_ctim;struct pid *shm_cprid;struct pid *shm_lprid; -struct user_struct *mlock_user; +struct ucounts *mlock_ucounts;/* The task created the shm object. NULL if the task is dead. */ struct task_struct *shm_creator;
@@ -286,10 +286,10 @@ static void shm_destroy(struct ipc_namespace *ns, struct shmid_kernel *shp)shm_rmid (ns, shp);shm_unlock (shp);if (!is_file_hugepages (shm_file)) -shmem_lock (shm_file,0 , shp->mlock_user); -else if (shp->mlock_user) +shmem_lock (shm_file,0 , shp->mlock_ucounts); +else if (shp->mlock_ucounts)user_shm_unlock (i_size_read (file_inode (shm_file)), - shp->mlock_user); + shp->mlock_ucounts);fput (shm_file);ipc_update_pid (&shp->shm_cprid,NULL );ipc_update_pid (&shp->shm_lprid,NULL );
@@ -625,7 +625,7 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params) shp->shm_perm.key = key; shp->shm_perm.mode = (shmflg &S_IRWXUGO ); - shp->mlock_user =NULL ; + shp->mlock_ucounts =NULL ; shp->shm_perm.security =NULL ; error =security_shm_alloc (&shp->shm_perm);
@@ -650,7 +650,7 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params)if (shmflg &SHM_NORESERVE ) acctflag =VM_NORESERVE ; file =hugetlb_file_setup (name, hugesize, acctflag, - &shp->mlock_user,HUGETLB_SHMFS_INODE , + &shp->mlock_ucounts,HUGETLB_SHMFS_INODE , (shmflg >>SHM_HUGE_SHIFT ) &SHM_HUGE_MASK ); }else {/*
@@ -698,8 +698,8 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params) no_id:ipc_update_pid (&shp->shm_cprid,NULL );ipc_update_pid (&shp->shm_lprid,NULL ); -if (is_file_hugepages (file) && shp->mlock_user) -user_shm_unlock (size, shp->mlock_user); +if (is_file_hugepages (file) && shp->mlock_ucounts) +user_shm_unlock (size, shp->mlock_ucounts);fput (file);ipc_rcu_putref (&shp->shm_perm, shm_rcu_free);return error;
@@ -1105,12 +1105,12 @@ static int shmctl_do_lock(struct ipc_namespace *ns, int shmid, int cmd) goto out_unlock0;if (cmd ==SHM_LOCK ) { -struct user_struct *user =current_user (); +struct ucounts *ucounts =current_ucounts (); - err =shmem_lock (shm_file,1 , user); + err =shmem_lock (shm_file,1 , ucounts);if (!err && !(shp->shm_perm.mode &SHM_LOCKED )) { shp->shm_perm.mode |=SHM_LOCKED ; - shp->mlock_user = user; + shp->mlock_ucounts = ucounts; } goto out_unlock0; }
@@ -1118,9 +1118,9 @@ static int shmctl_do_lock(struct ipc_namespace *ns, int shmid, int cmd)/* SHM_UNLOCK */ if (!(shp->shm_perm.mode &SHM_LOCKED )) goto out_unlock0; -shmem_lock (shm_file,0 , shp->mlock_user); +shmem_lock (shm_file,0 , shp->mlock_ucounts); shp->shm_perm.mode &= ~SHM_LOCKED ; - shp->mlock_user =NULL ; + shp->mlock_ucounts =NULL ;get_file (shm_file);ipc_unlock_object (&shp->shm_perm);rcu_read_unlock ();
kernel/fork.c +1 -0
@@ -825,6 +825,7 @@ void __init fork_init(void) init_user_ns.ucount_max[UCOUNT_RLIMIT_NPROC ] =task_rlimit (&init_task,RLIMIT_NPROC ); init_user_ns.ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =task_rlimit (&init_task,RLIMIT_MSGQUEUE ); init_user_ns.ucount_max[UCOUNT_RLIMIT_SIGPENDING ] =task_rlimit (&init_task,RLIMIT_SIGPENDING ); + init_user_ns.ucount_max[UCOUNT_RLIMIT_MEMLOCK ] =task_rlimit (&init_task,RLIMIT_MEMLOCK );#ifdef CONFIG_VMAP_STACK cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "fork:vm_stack_cache",
kernel/ucount.c +1 -0
@@ -84,6 +84,7 @@ static struct ctl_table user_table[] = { { }, { }, { }, + { }, { } };#endif /* CONFIG_SYSCTL */
kernel/user.c +0 -1
@@ -98,7 +98,6 @@ static DEFINE_SPINLOCK(uidhash_lock);/* root_user.__count is 1, for init task cred */ struct user_struct root_user = { .__count =REFCOUNT_INIT (1 ), - .locked_shm =0 , .uid =GLOBAL_ROOT_UID , .ratelimit =RATELIMIT_STATE_INIT (root_user.ratelimit,0 ,0 ), };
kernel/user_namespace.c +1 -0
@@ -124,6 +124,7 @@ int create_user_ns(struct cred *new) ns->ucount_max[UCOUNT_RLIMIT_NPROC ] =rlimit (RLIMIT_NPROC ); ns->ucount_max[UCOUNT_RLIMIT_MSGQUEUE ] =rlimit (RLIMIT_MSGQUEUE ); ns->ucount_max[UCOUNT_RLIMIT_SIGPENDING ] =rlimit (RLIMIT_SIGPENDING ); + ns->ucount_max[UCOUNT_RLIMIT_MEMLOCK ] =rlimit (RLIMIT_MEMLOCK ); ns->ucounts = ucounts;/* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
mm/memfd.c +2 -2
@@ -297,9 +297,9 @@ SYSCALL_DEFINE2(memfd_create, }if (flags &MFD_HUGETLB ) { -struct user_struct *user =NULL ; +struct ucounts *ucounts =NULL ; - file =hugetlb_file_setup (name,0 ,VM_NORESERVE , &user, + file =hugetlb_file_setup (name,0 ,VM_NORESERVE , &ucounts,HUGETLB_ANONHUGE_INODE , (flags >>MFD_HUGE_SHIFT ) &MFD_HUGE_MASK );
mm/mlock.c +15 -8
@@ -817,9 +817,10 @@ SYSCALL_DEFINE0(munlockall)*/ static DEFINE_SPINLOCK (shmlock_user_lock); -int user_shm_lock (size_t size,struct user_struct *user) +int user_shm_lock (size_t size,struct ucounts *ucounts) {unsigned long lock_limit, locked; +bool overlimit;int allowed =0 ; locked = (size +PAGE_SIZE -1 ) >>PAGE_SHIFT ;
@@ -828,21 +829,27 @@ int user_shm_lock(size_t size, struct user_struct *user) allowed =1 ; lock_limit >>=PAGE_SHIFT ;spin_lock (&shmlock_user_lock); -if (!allowed && - locked + user->locked_shm > lock_limit && !capable (CAP_IPC_LOCK )) + overlimit =inc_rlimit_ucounts_and_test (ucounts,UCOUNT_RLIMIT_MEMLOCK , + locked, lock_limit); + +if (!allowed && overlimit && !capable (CAP_IPC_LOCK )) { +dec_rlimit_ucounts (ucounts,UCOUNT_RLIMIT_MEMLOCK , locked); + goto out; + } +if (!get_ucounts (ucounts)) { +dec_rlimit_ucounts (ucounts,UCOUNT_RLIMIT_MEMLOCK , locked); goto out; -get_uid (user); - user->locked_shm += locked; + } allowed =1 ; out:spin_unlock (&shmlock_user_lock);return allowed; } -void user_shm_unlock (size_t size,struct user_struct *user) +void user_shm_unlock (size_t size,struct ucounts *ucounts) {spin_lock (&shmlock_user_lock); - user->locked_shm -= (size +PAGE_SIZE -1 ) >>PAGE_SHIFT ; +dec_rlimit_ucounts (ucounts,UCOUNT_RLIMIT_MEMLOCK , (size +PAGE_SIZE -1 ) >>PAGE_SHIFT );spin_unlock (&shmlock_user_lock); -free_uid (user); +put_ucounts (ucounts); }
mm/mmap.c +2 -2
@@ -1605,7 +1605,7 @@ unsigned long ksys_mmap_pgoff(unsigned long addr, unsigned long len, goto out_fput; } }else if (flags &MAP_HUGETLB ) { -struct user_struct *user =NULL ; +struct ucounts *ucounts =NULL ;struct hstate *hs; hs =hstate_sizelog ((flags >>MAP_HUGE_SHIFT ) &MAP_HUGE_MASK );
@@ -1621,7 +1621,7 @@ unsigned long ksys_mmap_pgoff(unsigned long addr, unsigned long len,*/ file =hugetlb_file_setup (HUGETLB_ANON_FILE , len,VM_NORESERVE , - &user,HUGETLB_ANONHUGE_INODE , + &ucounts,HUGETLB_ANONHUGE_INODE , (flags >>MAP_HUGE_SHIFT ) &MAP_HUGE_MASK );if (IS_ERR (file))return PTR_ERR (file);
mm/shmem.c +4 -4
@@ -2227,7 +2227,7 @@ static struct mempolicy *shmem_get_policy(struct vm_area_struct *vma, }#endif -int shmem_lock (struct file *file,int lock,struct user_struct *user) +int shmem_lock (struct file *file,int lock,struct ucounts *ucounts) {struct inode *inode =file_inode (file);struct shmem_inode_info *info =SHMEM_I (inode);
@@ -2239,13 +2239,13 @@ int shmem_lock(struct file *file, int lock, struct user_struct *user)* no serialization needed when called from shm_destroy(). */ if (lock && !(info->flags &VM_LOCKED )) { -if (!user_shm_lock (inode->i_size, user)) +if (!user_shm_lock (inode->i_size, ucounts)) goto out_nomem; info->flags |=VM_LOCKED ;mapping_set_unevictable (file->f_mapping); } -if (!lock && (info->flags &VM_LOCKED ) && user) { -user_shm_unlock (inode->i_size, user); +if (!lock && (info->flags &VM_LOCKED ) && ucounts) { +user_shm_unlock (inode->i_size, ucounts); info->flags &= ~VM_LOCKED ;mapping_clear_unevictable (file->f_mapping); }
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v9 8/8 kselftests: Add test to check for rlimit changes in different user namespaces
In reply to Alexey GladkovThe testcase runs few instances of the program with RLIMIT_NPROC=1 from user uid=60000, in different user namespaces.
--- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/rlimits/.gitignore | 2 + tools/testing/selftests/rlimits/Makefile | 6 + tools/testing/selftests/rlimits/config | 1 + .../selftests/rlimits/rlimits-per-userns.c | 161 ++++++++++++++++++ 5 files changed, 171 insertions(+) create mode 100644 tools/testing/selftests/rlimits/.gitignore create mode 100644 tools/testing/selftests/rlimits/Makefile create mode 100644 tools/testing/selftests/rlimits/config create mode 100644 tools/testing/selftests/rlimits/rlimits-per-userns.c
tools/testing/selftests/Makefile +1 -0
@@ -48,6 +48,7 @@ TARGETS += proc TARGETS += pstore TARGETS += ptrace TARGETS += openat2 +TARGETS += rlimits TARGETS += rseq TARGETS += rtc TARGETS += seccomp
tools/testing/selftests/rlimits/.gitignore new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0-only +rlimits-per-userns
tools/testing/selftests/rlimits/Makefile new file +6 -0
@@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0-or-later + +CFLAGS += -Wall -O2 -g +TEST_GEN_PROGS := rlimits-per-userns + +include ../lib.mk
tools/testing/selftests/rlimits/config new file +1 -0
@@ -0,0 +1 @@ +CONFIG_USER_NS=y
tools/testing/selftests/rlimits/rlimits-per-userns.c new file +161 -0
161 lines not on this page · raw message
Signature · 6 lines
2.29.3 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
Re: [PATCH v9 4/8] Reimplement RLIMIT_NPROC on top of ucounts
In reply to Alexey GladkovQuoted 14 lines · Alexey Gladkov
The rlimit counter is tied to uid in the
user_namespace. This allows rlimit values to be specified in userns even if they are already globally exceeded by the user. However, the value of the previoususer_namespacescannot be exceeded.To illustrate the impact of rlimits, let's say there is a program that does not fork. Some service-A wants to run this program as user X in multiple containers. Since the program never fork the service wants to set RLIMIT_NPROC=1.
service-A
\- program (uid=1000, container1, rlimit_nproc=1) \- program (uid=1000, container2, rlimit_nproc=1)
Quoted 7 lines
The service-A sets RLIMIT_NPROC=1 and runs the program in container1. When the service-A tries to run a program with RLIMIT_NPROC=1 in container2 it fails since user X already has one running process.
We cannot use existing
inc_ucounts/dec_ucountsbecause they do not allow us to exceed the maximum for the counter. Some rlimits can be overlimited by root or if the user has the appropriate capability.
In general this looks good.
My comments are going to be on the infrastructure this patch introduces rather than the change to RLIMIT_NPROC. Perhaps these would fare better as separate patches.
To preserve the existing semantics of incrementing and decrementing rlimits in places separate from where the limits are checked you correctly introduce inc_rlimit_ucounts and dec_rlimit_ucounts.
This separation means that for a short period of time the values in the counts can overflow. Which is something that the current ucount helpers don't allow. Taking advantage of the entire negative range for the counts, just like we take advantage of the entire negative range in get_ucounts seems a reasonable thing to do.
On 32bit using "atomic_long_t" instead of "unsigned long" to hold the counts has the downside that RLIMIT_MSGQUEUE and RLIMIT_MEMLOCK are limited to 2GiB instead of 4GiB. I don't think anyone cares but it should be mentioned in case someone does.
The functions inc_rlimit_ucounts and inc_rlimit_ucounts_test need to return overflow in the unlikely event the count values becomes negative.
Also when setting ns->ucount_max[] in create_user_ns because one value is signed and the other is unsigned. Care should be taken so that rlimit_infinity is translated into the largest positive value the type can hold.
Eric
Quoted 221 lines
Signed-off-by Alexey Gladkov <[email protected]>--- fs/exec.c | 2 +- include/linux/cred.h | 2 ++ include/linux/sched/user.h | 1 - include/linux/user_namespace.h | 13 ++++++++ kernel/cred.c | 10 +++--- kernel/exit.c | 2 +- kernel/fork.c | 9 ++--- kernel/sys.c | 2 +- kernel/ucount.c | 61 ++++++++++++++++++++++++++++++++++ kernel/user.c | 1 - kernel/user_namespace.c | 3 +- 11 files changed, 91 insertions(+), 15 deletions(-)fs/exec.c +1
-1@@ -1878,7 +1878,7 @@ static int do_execveat_common(int fd, struct filename *filename,* whether NPROC limit is still exceeded. */ if ((current->flags &PF_NPROC_EXCEEDED ) && -atomic_read (¤t_user ()->processes) >rlimit (RLIMIT_NPROC )) { +is_ucounts_overlimit (current_ucounts (),UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC ))) { retval = -EAGAIN ; goto out_ret; }include/linux/cred.h +2
-0@@ -372,6 +372,7 @@ static inline void put_cred(const struct cred *_cred)#define task_uid (task) (task_cred_xxx((task), uid))#define task_euid (task) (task_cred_xxx((task), euid)) +#define task_ucounts (task) (task_cred_xxx((task), ucounts))#define current_cred_xxx (xxx) \ ({ \@@ -388,6 +389,7 @@ static inline void put_cred(const struct cred *_cred)#define current_fsgid () (current_cred_xxx(fsgid))#define current_cap () (current_cred_xxx(cap_effective))#define current_user () (current_cred_xxx(user)) +#define current_ucounts () (current_cred_xxx(ucounts))extern struct user_namespace init_user_ns;#ifdef CONFIG_USER_NS include/linux/sched/user.h +0
-1@@ -12,7 +12,6 @@*/ struct user_struct {refcount_t __count;/* reference count */ -atomic_t processes;/* How many processes does this user have? */ atomic_t sigpending;/* How many pending signals does this user have? */ #ifdef CONFIG_FANOTIFY atomic_t fanotify_listeners;include/linux/user_namespace.h +13
-0@@ -50,9 +50,12 @@ enum ucount_type { UCOUNT_INOTIFY_INSTANCES, UCOUNT_INOTIFY_WATCHES, #endif + UCOUNT_RLIMIT_NPROC, UCOUNT_COUNTS, }; +#define MAX_PER_NAMESPACE_UCOUNTS UCOUNT_RLIMIT_NPROC + struct user_namespace { struct uid_gid_map uid_map; struct uid_gid_map gid_map;@@ -107,6 +110,16 @@ struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid);struct ucounts *__must_check get_ucounts (struct ucounts *ucounts);void put_ucounts (struct ucounts *ucounts); +static inline long get_ucounts_value (struct ucounts *ucounts,enum ucount_type type) +{ +return atomic_long_read (&ucounts->ucount[type]); +} + +bool inc_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v); +bool inc_rlimit_ucounts_and_test (struct ucounts *ucounts,enum ucount_type type,long v,long max); +void dec_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v); +bool is_ucounts_overlimit (struct ucounts *ucounts,enum ucount_type type,unsigned long max); +#ifdef CONFIG_USER_NS static inline struct user_namespace *get_user_ns (struct user_namespace *ns)kernel/cred.c +5
-5@@ -360,7 +360,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)kdebug ("share_creds(%p{%d,%d})" , p->cred,atomic_read (&p->cred->usage),read_cred_subscribers (p->cred)); -atomic_inc (&p->cred->user->processes); +inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );return 0 ; }@@ -395,8 +395,8 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags) }#endif -atomic_inc (&new->user->processes); p->cred = p->real_cred =get_cred (new); +inc_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );alter_cred_subscribers (new,2 );validate_creds (new);return 0 ;@@ -496,12 +496,12 @@ int commit_creds(struct cred *new)* in set_user(). */ alter_cred_subscribers (new,2 ); -if (new->user != old->user) -atomic_inc (&new->user->processes); +if (new->user != old->user || new->user_ns != old->user_ns) +inc_rlimit_ucounts (new->ucounts,UCOUNT_RLIMIT_NPROC ,1 );rcu_assign_pointer (task->real_cred, new);rcu_assign_pointer (task->cred, new);if (new->user != old->user) -atomic_dec (&old->user->processes); +dec_rlimit_ucounts (old->ucounts,UCOUNT_RLIMIT_NPROC ,1 );alter_cred_subscribers (old,-2 );/* send notifications */ kernel/exit.c +1
-1@@ -188,7 +188,7 @@ void release_task(struct task_struct *p)/* don't need to get the RCU readlock here - the process is dead and * can't be modifying its own credentials. But shut RCU-lockdep up */ rcu_read_lock (); -atomic_dec (&__task_cred (p)->user->processes); +dec_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );rcu_read_unlock ();cgroup_release (p);kernel/fork.c +5
-4@@ -819,9 +819,11 @@ void __init fork_init(void) init_task.signal->rlim[RLIMIT_SIGPENDING ] = init_task.signal->rlim[RLIMIT_NPROC ]; -for (i =0 ; i <UCOUNT_COUNTS ; i++) +for (i =0 ; i <MAX_PER_NAMESPACE_UCOUNTS ; i++) init_user_ns.ucount_max[i] = max_threads/2 ; + init_user_ns.ucount_max[UCOUNT_RLIMIT_NPROC ] =task_rlimit (&init_task,RLIMIT_NPROC ); +#ifdef CONFIG_VMAP_STACK cpuhp_setup_state (CPUHP_BP_PREPARE_DYN ,"fork:vm_stack_cache" ,NULL , free_vm_stack_cache);@@ -1972,8 +1974,7 @@ static __latent_entropy struct task_struct *copy_process(DEBUG_LOCKS_WARN_ON (!p->softirqs_enabled);#endif retval = -EAGAIN ; -if (atomic_read (&p->real_cred->user->processes) >= -task_rlimit (p,RLIMIT_NPROC )) { +if (is_ucounts_overlimit (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC ))) {if (p->real_cred->user !=INIT_USER && !capable (CAP_SYS_RESOURCE ) && !capable (CAP_SYS_ADMIN )) goto bad_fork_free;@@ -2376,7 +2377,7 @@ static __latent_entropy struct task_struct *copy_process(#endif delayacct_tsk_free (p); bad_fork_cleanup_count: -atomic_dec (&p->cred->user->processes); +dec_rlimit_ucounts (task_ucounts (p),UCOUNT_RLIMIT_NPROC ,1 );exit_creds (p); bad_fork_free: p->state =TASK_DEAD ;kernel/sys.c +1
-1@@ -473,7 +473,7 @@ static int set_user(struct cred *new)* for programs doing set*uid()+execve() by harmlessly deferring the * failure to the execve() stage. */ -if (atomic_read (&new_user->processes) >=rlimit (RLIMIT_NPROC ) && +if (is_ucounts_overlimit (new->ucounts,UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC )) && new_user !=INIT_USER ) current->flags |=PF_NPROC_EXCEEDED ;else kernel/ucount.c +4
-0@@ -7,6 +7,7 @@#include <linux/hash.h> #include <linux/kmemleak.h> #include <linux/user_namespace.h> +#include <linux/security.h> struct ucounts init_ucounts = { .ns = &init_user_ns,@@ -80,6 +81,7 @@ static struct ctl_table user_table[] = {UCOUNT_ENTRY ("max_inotify_instances" ), UCOUNT_ENTRY("max_inotify_watches"), #endif + { }, { } };#endif /* CONFIG_SYSCTL */ @@ -207,6 +209,19 @@ static inline bool atomic_long_inc_below(atomic_long_t *v, int u) } } +static inline long atomic_long_dec_value (atomic_long_t *v,long n) +{
kernel/ucount.c static inline bool atomic_long_inc_below(atomic_long_t *v, int u) · line 223
Quoted 10 lines
kernel/ucount.c +10
-0+long c, old; + c =atomic_long_read (v); +for (;;) { + old =atomic_long_cmpxchg (v, c, c - n); +if (likely (old == c)) +return c; + c = old; + } +return c; +}
Just use atomic_add_long_return.
Quoted 7 lines
kernel/ucount.c +1
-0+struct ucounts *inc_ucount (struct user_namespace *ns,kuid_t uid,enum ucount_type type) {@@ -240,6 +255,51 @@ void dec_ucount(struct ucounts *ucounts, enum ucount_type type)put_ucounts (ucounts); }
kernel/ucount.c void dec_ucount(struct ucounts *ucounts, enum ucount_type type) · line 266
Quoted 10 lines
kernel/ucount.c +9
-0+bool inc_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v) +{ +struct ucounts *iter; +bool overlimit = false; + +for (iter = ucounts; iter; iter = iter->ns->ucounts) { +long max =READ_ONCE (iter->ns->ucount_max[type]); +if (atomic_long_add_return (v, &iter->ucount[type]) > max) + overlimit = true;
Please check for negative to detect counter overflow. At least the mq code already checks for overflow.
kernel/ucount.c void dec_ucount(struct ucounts *ucounts, enum ucount_type type) · line 277
Quoted 11 lines
kernel/ucount.c +11
-0+ } + +return overlimit; +} + +bool inc_rlimit_ucounts_and_test (struct ucounts *ucounts,enum ucount_type type, +long v,long max) +{ +bool overlimit =inc_rlimit_ucounts (ucounts, type, v); +if (!overlimit &&get_ucounts_value (ucounts, type) > max) + overlimit = true;
The return of get_ucounts_value also needs to be checked for negative.
kernel/ucount.c void dec_ucount(struct ucounts *ucounts, enum ucount_type type) · line 285
Quoted 8 lines
kernel/ucount.c +8
-0+return overlimit; +} + +void dec_rlimit_ucounts (struct ucounts *ucounts,enum ucount_type type,long v) +{ +struct ucounts *iter; +for (iter = ucounts; iter; iter = iter->ns->ucounts) { +long dec =atomic_long_dec_value (&iter->ucount[type], v);
atomic_long_add_return(&iter->ucount[type], -v);
Quoted 45 lines
kernel/ucount.c +18
-0+WARN_ON_ONCE (dec <0 ); + } +} + +bool is_ucounts_overlimit (struct ucounts *ucounts,enum ucount_type type,unsigned long max) +{ +struct ucounts *iter; +if (get_ucounts_value (ucounts, type) > max) +return true; +for (iter = ucounts; iter; iter = iter->ns->ucounts) { + max =READ_ONCE (iter->ns->ucount_max[type]); +if (get_ucounts_value (iter, type) > max) +return true; + } +return false; +} +static __init int user_namespace_sysctl_init (void ) {#ifdef CONFIG_SYSCTL @@ -256,6 +316,7 @@ static __init int user_namespace_sysctl_init(void)BUG_ON (!setup_userns_sysctls (&init_user_ns));#endif hlist_add_ucounts (&init_ucounts); +inc_rlimit_ucounts (&init_ucounts,UCOUNT_RLIMIT_NPROC ,1 );return 0 ; }subsys_initcall (user_namespace_sysctl_init);kernel/user.c +0
-1@@ -98,7 +98,6 @@ static DEFINE_SPINLOCK(uidhash_lock);/* root_user.__count is 1, for init task cred */ struct user_struct root_user = { .__count =REFCOUNT_INIT (1 ), - .processes =ATOMIC_INIT (1 ), .sigpending =ATOMIC_INIT (0 ), .locked_shm =0 , .uid =GLOBAL_ROOT_UID ,kernel/user_namespace.c +0
-0
kernel/user_namespace.c int create_user_ns(struct cred *new) · line 124
Quoted 8 lines
kernel/user_namespace.c +2
-1@@ -118,9 +118,10 @@ int create_user_ns(struct cred *new) ns->owner = owner; ns->group = group;INIT_WORK (&ns->work, free_user_ns); -for (i =0 ; i <UCOUNT_COUNTS ; i++) { +for (i =0 ; i <MAX_PER_NAMESPACE_UCOUNTS ; i++) { ns->ucount_max[i] =INT_MAX ; } + ns->ucount_max[UCOUNT_RLIMIT_NPROC ] =rlimit (RLIMIT_NPROC );
This should have a special case that translates RLIMIT_INFINITY to LONG_MAX.
Quoted 3 lines
kernel/user_namespace.c +0
-0ns->ucounts = ucounts;/* Inherit USERNS_SETGROUPS_ALLOWED from our parent */
Re: [PATCH v9 6/8] Reimplement RLIMIT_SIGPENDING on top of ucounts
In reply to Alexey GladkovA small bug below.
Eric
Quoted 50 lines
kernel/signal.c +10
-28@@ -413,49 +413,44 @@ void task_join_group_stop(struct task_struct *task)static struct sigqueue *__sigqueue_alloc (int sig,struct task_struct *t,gfp_t flags,int override_rlimit) { -struct sigqueue *q =NULL ; -struct user_struct *user; -int sigpending; +struct sigqueue *q =kmem_cache_alloc (sigqueue_cachep, flags); -/* -* Protect access to @t credentials. This can go away when all -* callers hold rcu read lock. -* -* NOTE! A pending signal will hold on to the user refcount, -* and we get/put the refcount only when the sigpending count -* changes from/to zero. -*/ -rcu_read_lock (); - user =__task_cred (t)->user; - sigpending =atomic_inc_return (&user->sigpending); -if (sigpending ==1 ) -get_uid (user); -rcu_read_unlock (); +if (likely (q !=NULL )) { +bool overlimit; -if (override_rlimit ||likely (sigpending <=task_rlimit (t,RLIMIT_SIGPENDING ))) { - q =kmem_cache_alloc (sigqueue_cachep, flags); - }else { -print_dropped_signal (sig); - } - -if (unlikely (q ==NULL )) { -if (atomic_dec_and_test (&user->sigpending)) -free_uid (user); - }else {INIT_LIST_HEAD (&q->list); q->flags =0 ; - q->user = user; + +/* +* Protect access to @t credentials. This can go away when all +* callers hold rcu read lock. +*/ +rcu_read_lock (); + q->ucounts =get_ucounts (task_ucounts (t));
kernel/signal.c void task_join_group_stop(struct task_struct *task) · line 439
Quoted 10 lines
kernel/signal.c +10
-0+if (q->ucounts) { + overlimit =inc_rlimit_ucounts_and_test (q->ucounts,UCOUNT_RLIMIT_SIGPENDING , +1 ,task_rlimit (t,RLIMIT_SIGPENDING )); + +if (override_rlimit ||likely (!overlimit)) { +rcu_read_unlock (); +return q; + } + } +rcu_read_unlock ();
I believe you need to call __sigqueue_free here.
Quoted 10 lines
kernel/signal.c +2
-1} -return q; +print_dropped_signal (sig); +return NULL ; }static void __sigqueue_free (struct sigqueue *q) {if (q->flags &SIGQUEUE_PREALLOC )
kernel/signal.c void task_join_group_stop(struct task_struct *task) · line 456
Quoted 10 lines
kernel/signal.c +4
-2return ; -if (atomic_dec_and_test (&q->user->sigpending)) -free_uid (q->user); +if (q->ucounts) { +dec_rlimit_ucounts (q->ucounts,UCOUNT_RLIMIT_SIGPENDING ,1 ); +put_ucounts (q->ucounts); + }kmem_cache_free (sigqueue_cachep, q); }
Eric
Re: [PATCH v9 3/8] Use atomic_t for ucounts reference counting
In reply to Alexey GladkovQuoted 9 lines · Alexey Gladkov
The current implementation of the ucounts reference counter requires the use of
spin_lock. We're going to useget_ucounts()in more performance critical areas like a handling ofRLIMIT_SIGPENDING.Now we need to use
spin_lockonly if we want to change the hashtable.v9:
* Use a negative value to check that theucounts->countis close to overflow.
Overall this looks good, one small issue below.
Eric
Quoted 14 lines
kernel/ucount.c +1
-1@@ -11,7 +11,7 @@struct ucounts init_ucounts = { .ns = &init_user_ns, .uid =GLOBAL_ROOT_UID , - .count =1 , + .count =ATOMIC_INIT (1 ), };#define UCOUNTS_HASHTABLE_BITS 10
kernel/ucount.c static void hlist_add_ucounts(struct ucounts *ucounts) · line 145
Quoted 7 lines
kernel/ucount.c +4
-0@@ -139,6 +139,15 @@ static void hlist_add_ucounts(struct ucounts *ucounts)spin_unlock_irq (&ucounts_lock); } +struct ucounts *get_ucounts (struct ucounts *ucounts) +{ +if (ucounts &&atomic_add_negative (1 , &ucounts->count)) { +atomic_dec (&ucounts->count);
^^^^^^^^^^^^^^^^^^^^^^^^^^^
To handle the pathological case of all of the other uses calling put_ucounts after the value goes negative, the above should be put_ucounts intead of atomic_dec.
Quoted 75 lines
kernel/ucount.c +14
-33+ ucounts =NULL ; + } +return ucounts; +} +struct ucounts *alloc_ucounts (struct user_namespace *ns,kuid_t uid) {struct hlist_head *hashent =ucounts_hashentry (ns, uid);@@ -155,7 +164,7 @@ struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid) new->ns = ns; new->uid = uid; - new->count =0 ; +atomic_set (&new->count,1 );spin_lock_irq (&ucounts_lock); ucounts =find_ucounts (ns, uid, hashent);@@ -163,33 +172,12 @@ struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid)kfree (new); }else {hlist_add_head (&new->node, hashent); - ucounts = new; +spin_unlock_irq (&ucounts_lock); +return new; } } -if (ucounts->count ==INT_MAX ) - ucounts =NULL ; -else - ucounts->count +=1 ;spin_unlock_irq (&ucounts_lock); -return ucounts; -} - -struct ucounts *get_ucounts (struct ucounts *ucounts) -{ -unsigned long flags; - -if (!ucounts) -return NULL ; - -spin_lock_irqsave (&ucounts_lock, flags); -if (ucounts->count ==INT_MAX ) { -WARN_ONCE (1 ,"ucounts: counter has reached its maximum value" ); - ucounts =NULL ; - }else { - ucounts->count +=1 ; - } -spin_unlock_irqrestore (&ucounts_lock, flags); - + ucounts =get_ucounts (ucounts);return ucounts; }@@ -197,15 +185,12 @@ void put_ucounts(struct ucounts *ucounts) {unsigned long flags; -spin_lock_irqsave (&ucounts_lock, flags); - ucounts->count -=1 ; -if (!ucounts->count) +if (atomic_dec_and_test (&ucounts->count)) { +spin_lock_irqsave (&ucounts_lock, flags);hlist_del_init (&ucounts->node); -else - ucounts =NULL ; -spin_unlock_irqrestore (&ucounts_lock, flags); - -kfree (ucounts); +spin_unlock_irqrestore (&ucounts_lock, flags); +kfree (ucounts); + } }static inline bool atomic_long_inc_below (atomic_long_t *v,int u)
Quoted 100 lines · Alexey Gladkov
Preface
-------
These patches are for binding the rlimit counters to a user in user namespace. This patch set can be applied on top of:git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git v5.12-rc4
Problem
-------
TheRLIMIT_NPROC,RLIMIT_MEMLOCK,RLIMIT_SIGPENDING,RLIMIT_MSGQUEUErlimits implementation places the counters inuser_struct[1]. These limits are global between processes and persists for the lifetime of the process, even if processes are in different user namespaces.To illustrate the impact of rlimits, let's say there is a program that does not fork. Some service-A wants to run this program as user X in multiple containers. Since the program never fork the service wants to set RLIMIT_NPROC=1.
service-A
\- program (uid=1000, container1, rlimit_nproc=1) \- program (uid=1000, container2, rlimit_nproc=1)The service-A sets RLIMIT_NPROC=1 and runs the program in container1. When the service-A tries to run a program with RLIMIT_NPROC=1 in container2 it fails since user X already has one running process.
The problem is not that the limit from container1 affects container2. The problem is that limit is verified against the global counter that reflects the number of processes in all containers.
This problem can be worked around by using different users for each container but in this case we face a different problem of uid mapping when transferring files from one container to another.
Eric W. Biederman mentioned this issue [2][3].
Introduced changes
------------------
To address the problem, we bind rlimit counters to user namespace. Each counter reflects the number of processes in a given uid in a given user namespace. The result is a tree of rlimit counters with the biggest value at the root (akainit_user_ns). The limit is considered exceeded if it's exceeded up in the tree.[1]: https://lore.kernel.org/containers/[email protected]/
[2]: https://lists.linuxfoundation.org/pipermail/containers/2020-August/042096.html
[3]: https://lists.linuxfoundation.org/pipermail/containers/2020-October/042524.htmlChangelog
---------
v9:
* Used a negative value to check that theucounts->countis close to overflow.
* Rebased onto v5.12-rc4.v8:
* Usedatomic_tfor ucounts reference counting. Also added counter overflow check (thanks to Linus Torvalds for the idea).
* Fixed other issues found by lkp-tests project in the patch that ReimplementsRLIMIT_MEMLOCKon top of ucounts.v7:
* Fixed issues found by lkp-tests project in the patch that ReimplementsRLIMIT_MEMLOCKon top of ucounts.v6:
* Fixed issues found by lkp-tests project.
* Rebased onto v5.11.v5:
* Split the first commit into two commits: change ucounts.count type toatomic_long_tand add ucounts to cred. These commits were merged by mistake during the rebase.
* The__get_ucounts()renamed toalloc_ucounts().
* The cred.ucounts update has been moved fromcommit_creds()as it did not allow to handle errors.
* Added error handling ofset_cred_ucounts().v4:
* Reverted the type change of ucounts.count torefcount_t.
* Fixed typo in thekernel/cred.cv3:
* Addedget_ucounts()function to increase the reference count. The existingget_counts()function renamed to__get_ucounts().
* The type of ucounts.count changed fromatomic_ttorefcount_t.
* Dropped 'const' fromset_cred_ucounts()arguments.
* Fixed a bug with freeing the cred structure after callingcred_alloc_blank().
* Commit messages have been updated.
* Added selftest.v2:
*RLIMIT_MEMLOCK,RLIMIT_SIGPENDINGandRLIMIT_MSGQUEUEare migrated to ucounts.
* Added ucounts for pair uid and user namespace into cred.
* Added the ability to increase ucount by more than 1.v1:
* After discussion with Eric W. Biederman, I increased the size of ucounts toatomic_long_t.
* Addeducount_maxto avoid the fork bomb.--
Quoted 10 lines
Alexey Gladkov (8):
Increase size of ucounts toatomic_long_t
Add a reference to ucounts for each cred
Useatomic_tfor ucounts reference counting
ReimplementRLIMIT_NPROCon top of ucounts
ReimplementRLIMIT_MSGQUEUEon top of ucounts
ReimplementRLIMIT_SIGPENDINGon top of ucounts
ReimplementRLIMIT_MEMLOCKon top of ucounts
kselftests: Add test to check for rlimit changes in different user namespaces
Overall this looks good, and it is a very good sign that the automatic testing bots have not found anything. I found a few little nits. But thing are looking very good.
Eric
Re: [PATCH v9 4/8] Reimplement RLIMIT_NPROC on top of ucounts
In reply to Eric W. BiedermanQuoted 5 lines · Eric W. Biederman
Also when setting ns->ucount_max[] in
create_user_nsbecause one value is signed and the other is unsigned. Care should be taken so thatrlimit_infinityis translated into the largest positive value the type can hold.
You mean like that ?
ns->ucount_max[UCOUNT_RLIMIT_NPROC] = rlimit(RLIMIT_NPROC) <= LONG_MAX ?
rlimit(RLIMIT_NPROC) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_MSGQUEUE] = rlimit(RLIMIT_MSGQUEUE) <= LONG_MAX ? rlimit(RLIMIT_MSGQUEUE) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_SIGPENDING] = rlimit(RLIMIT_SIGPENDING) <= LONG_MAX ? rlimit(RLIMIT_SIGPENDING) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_MEMLOCK] = rlimit(RLIMIT_MEMLOCK) <= LONG_MAX ? rlimit(RLIMIT_MEMLOCK) : LONG_MAX;
Signature · 1 line
Rgrds, legion
Re: [PATCH v9 4/8] Reimplement RLIMIT_NPROC on top of ucounts
Quoted 9 lines · Alexey Gladkov
Quoted 5 lines · Eric W. Biederman
Also when setting ns->ucount_max[] in
create_user_nsbecause one value is signed and the other is unsigned. Care should be taken so thatrlimit_infinityis translated into the largest positive value the type can hold.You mean like that ?
Quoted 8 lines
ns->ucount_max[UCOUNT_RLIMIT_NPROC] =
rlimit(RLIMIT_NPROC)<=LONG_MAX?rlimit(RLIMIT_NPROC) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_MSGQUEUE] = rlimit(RLIMIT_MSGQUEUE) <= LONG_MAX ? rlimit(RLIMIT_MSGQUEUE) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_SIGPENDING] = rlimit(RLIMIT_SIGPENDING) <= LONG_MAX ? rlimit(RLIMIT_SIGPENDING) : LONG_MAX; ns->ucount_max[UCOUNT_RLIMIT_MEMLOCK] = rlimit(RLIMIT_MEMLOCK) <= LONG_MAX ? rlimit(RLIMIT_MEMLOCK) : LONG_MAX;
Yes.
I only got as far as:
if (rlimit(RLIMI_NNN) == RLIM_INFINITY) {
ns->ucount_max[UCOUNT_LIMIT_NNN] = LONG_MAX;
} else {
ns->ucount_max[UCOUNT_LMIT_NNN] = rlmit(RLIMIT_NNN);
}But forcing everything about LONG_MAX to LONG_MAX actually looks better in practice. Especially as that is effectively RLIMIT_INFINITY anyway.
Eric