Count rlimits in each user namespace
Subsystems (12)
PATCH v4 1/7 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. Add a ucounts reference to struct cred, so that RLIMIT_NPROC can switch from using a per user limit to using a per user per user namespace limit.
--- include/linux/cred.h | 1 + include/linux/user_namespace.h | 7 ++++-- kernel/cred.c | 20 +++++++++++++-- kernel/ucount.c | 46 ++++++++++++++++++++++++++-------- kernel/user_namespace.c | 1 + 5 files changed, 61 insertions(+), 14 deletions(-)
include/linux/cred.h +1 -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 {
include/linux/user_namespace.h +5 -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;
@@ -102,6 +102,9 @@ 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 *get_ucounts (struct ucounts *ucounts); +void put_ucounts (struct ucounts *ucounts); +void set_cred_ucounts (struct cred *cred,struct user_namespace *ns,kuid_t uid);#ifdef CONFIG_USER_NS
kernel/cred.c +18 -2
@@ -119,6 +119,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); }
@@ -144,6 +146,9 @@ void __put_cred(struct cred *cred)BUG_ON (cred == current->cred);BUG_ON (cred == current->real_cred); +if (cred->ucounts) +BUG_ON (cred->ucounts->ns != cred->user_ns); +if (cred->non_rcu)put_cred_rcu (&cred->rcu);else
@@ -270,6 +275,7 @@ struct cred *prepare_creds(void)get_group_info (new->group_info);get_uid (new->user);get_user_ns (new->user_ns); +get_ucounts (new->ucounts);#ifdef CONFIG_KEYS key_get (new->session_keyring);
@@ -363,6 +369,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags) ret =create_user_ns (new);if (ret <0 ) goto error_put; +set_cred_ucounts (new, new->user_ns, new->euid); }#ifdef CONFIG_KEYS
@@ -485,8 +492,11 @@ 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) { +if (new->user != old->user) +atomic_inc (&new->user->processes); +set_cred_ucounts (new, new->user_ns, new->euid); + }rcu_assign_pointer (task->real_cred, new);rcu_assign_pointer (task->cred, new);if (new->user != old->user)
@@ -661,6 +671,11 @@ void __init cred_init(void)/* allocate a slab in which we can store credentials */ cred_jar =kmem_cache_create ("cred_jar" ,sizeof (struct cred ),0 ,SLAB_HWCACHE_ALIGN |SLAB_PANIC |SLAB_ACCOUNT ,NULL ); +/* +* This is needed here because this is the first cred and there is no +* ucount reference to copy. +*/ +set_cred_ucounts (&init_cred, &init_user_ns,GLOBAL_ROOT_UID ); }/**
@@ -704,6 +719,7 @@ struct cred *prepare_kernel_cred(struct task_struct *daemon)get_uid (new->user);get_user_ns (new->user_ns);get_group_info (new->group_info); +get_ucounts (new->ucounts);#ifdef CONFIG_KEYS new->session_keyring =NULL ;
kernel/ucount.c +36 -10
90 lines not on this page · raw message
kernel/user_namespace.c +1 -0
@@ -1280,6 +1280,7 @@ 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)); +set_cred_ucounts (cred, user_ns, cred->euid);return 0 ; }
Signature · 1 line
2.29.2
PATCH v4 2/7 Move RLIMIT_NPROC counter to ucounts
In reply to Alexey GladkovRLIMIT_NPROC is implemented on top of ucounts. The process counter is tied to the user in the user namespace. Therefore, there is no longer one single counter for the user. Instead, there is now one counter for each user namespace. Thus, getting the RLIMIT_NPROC counter value to check the rlimit becomes meaningless.
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 if the user has the appropriate capability.
--- fs/exec.c | 2 +- fs/io-wq.c | 22 ++++++------- fs/io-wq.h | 2 +- fs/io_uring.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 | 60 ++++++++++++++++++++++++++++++++++ kernel/user.c | 1 - kernel/user_namespace.c | 3 +- 14 files changed, 102 insertions(+), 29 deletions(-)
fs/exec.c +1 -1
@@ -1870,7 +1870,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; }
fs/io-wq.c +10 -12
@@ -20,6 +20,7 @@#include <linux/blk-cgroup.h> #include <linux/audit.h> #include <linux/cpu.h> +#include <linux/user_namespace.h> #include "../kernel/sched/sched.h" #include "io-wq.h"
@@ -120,7 +121,7 @@ struct io_wq {io_wq_work_fn *do_work;struct task_struct *manager; -struct user_struct *user; +const struct cred *cred;refcount_t refs;struct completion done;
@@ -234,7 +235,7 @@ static void io_worker_exit(struct io_worker *worker)if (worker->flags &IO_WORKER_F_RUNNING )atomic_dec (&acct->nr_running);if (!(worker->flags &IO_WORKER_F_BOUND )) -atomic_dec (&wqe->wq->user->processes); +dec_rlimit_ucounts (wqe->wq->cred->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); worker->flags =0 ;preempt_enable ();
@@ -364,15 +365,15 @@ static void __io_worker_busy(struct io_wqe *wqe, struct io_worker *worker, worker->flags |=IO_WORKER_F_BOUND ; wqe->acct[IO_WQ_ACCT_UNBOUND ].nr_workers--; wqe->acct[IO_WQ_ACCT_BOUND ].nr_workers++; -atomic_dec (&wqe->wq->user->processes); +dec_rlimit_ucounts (wqe->wq->cred->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); }else { worker->flags &= ~IO_WORKER_F_BOUND ; wqe->acct[IO_WQ_ACCT_UNBOUND ].nr_workers++; wqe->acct[IO_WQ_ACCT_BOUND ].nr_workers--; -atomic_inc (&wqe->wq->user->processes); +inc_rlimit_ucounts (wqe->wq->cred->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); }io_wqe_inc_running (wqe, worker); - } + } }/*
@@ -707,7 +708,7 @@ static bool create_io_worker(struct io_wq *wq, struct io_wqe *wqe, int index)raw_spin_unlock_irq (&wqe->lock);if (index ==IO_WQ_ACCT_UNBOUND ) -atomic_inc (&wq->user->processes); +inc_rlimit_ucounts (wq->cred->ucounts,UCOUNT_RLIMIT_NPROC ,1 );refcount_inc (&wq->refs);wake_up_process (worker->task);
@@ -838,7 +839,7 @@ static bool io_wq_can_queue(struct io_wqe *wqe, struct io_wqe_acct *acct,if (free_worker)return true; -if (atomic_read (&wqe->wq->user->processes) >= acct->max_workers && +if (is_ucounts_overlimit (wqe->wq->cred->ucounts,UCOUNT_RLIMIT_NPROC , acct->max_workers) && !(capable (CAP_SYS_RESOURCE ) ||capable (CAP_SYS_ADMIN )))return false;
@@ -1074,7 +1075,7 @@ struct io_wq *io_wq_create(unsigned bounded, struct io_wq_data *data) wq->do_work = data->do_work;/* caller must already hold a reference to this */ - wq->user = data->user; + wq->cred = data->cred; ret = -ENOMEM ;for_each_node (node) {
@@ -1090,10 +1091,7 @@ struct io_wq *io_wq_create(unsigned bounded, struct io_wq_data *data) wqe->node = alloc_node; wqe->acct[IO_WQ_ACCT_BOUND ].max_workers = bounded;atomic_set (&wqe->acct[IO_WQ_ACCT_BOUND ].nr_running,0 ); -if (wq->user) { - wqe->acct[IO_WQ_ACCT_UNBOUND ].max_workers = -task_rlimit (current,RLIMIT_NPROC ); - } + wqe->acct[IO_WQ_ACCT_UNBOUND ].max_workers =task_rlimit (current,RLIMIT_NPROC );atomic_set (&wqe->acct[IO_WQ_ACCT_UNBOUND ].nr_running,0 ); wqe->wq = wq;raw_spin_lock_init (&wqe->lock);
fs/io-wq.h +1 -1
@@ -111,7 +111,7 @@ typedef void (free_work_fn)(struct io_wq_work *);typedef struct io_wq_work *(io_wq_work_fn )(struct io_wq_work *);struct io_wq_data { -struct user_struct *user; +const struct cred *cred;io_wq_work_fn *do_work;free_work_fn *free_work;
fs/io_uring.c +1 -1
@@ -7985,7 +7985,7 @@ static int io_init_wq_offload(struct io_ring_ctx *ctx,unsigned int concurrency;int ret =0 ; - data.user = ctx->user; + data.cred = ctx->creds; data.free_work = io_free_work; data.do_work = io_wq_submit_work;
include/linux/cred.h +2 -0
@@ -371,6 +371,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) \ ({ \
@@ -387,6 +388,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;
@@ -106,6 +109,16 @@ struct ucounts *get_ucounts(struct ucounts *ucounts);void put_ucounts (struct ucounts *ucounts);void set_cred_ucounts (struct cred *cred,struct user_namespace *ns,kuid_t uid); +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,long max); +#ifdef CONFIG_USER_NS static inline struct user_namespace *get_user_ns (struct user_namespace *ns)
kernel/cred.c +5 -5
@@ -357,7 +357,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 ; }
@@ -391,8 +391,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 ;
@@ -493,14 +493,13 @@ int commit_creds(struct cred *new)*/ alter_cred_subscribers (new,2 );if (new->user != old->user || new->user_ns != old->user_ns) { -if (new->user != old->user) -atomic_inc (&new->user->processes);set_cred_ucounts (new, new->user_ns, new->euid); +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 */
@@ -676,6 +675,7 @@ void __init cred_init(void)* ucount reference to copy. */ set_cred_ucounts (&init_cred, &init_user_ns,GLOBAL_ROOT_UID ); +inc_rlimit_ucounts (init_cred.ucounts,UCOUNT_RLIMIT_NPROC ,1 ); }/**
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,10 +819,12 @@ 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);
@@ -1964,8 +1966,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;
@@ -2368,7 +2369,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
@@ -474,7 +474,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 +60 -0
84 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 · 1 line
2.29.2
v4 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.11-rc2
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
---------
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 (7):
Add a reference to ucounts for each cred
Move RLIMIT_NPROC counter to ucounts
Move RLIMIT_MSGQUEUE counter to ucounts
Move RLIMIT_SIGPENDING counter to ucounts
Move RLIMIT_MEMLOCK counter to ucounts
Move RLIMIT_NPROC check to the place where we increment the counter
kselftests: Add test to check for rlimit changes in different user
namespaces
fs/exec.c | 2 +- fs/hugetlbfs/inode.c | 17 +- fs/io-wq.c | 22 ++- fs/io-wq.h | 2 +- fs/io_uring.c | 2 +- fs/proc/array.c | 2 +- include/linux/cred.h | 3 + include/linux/hugetlb.h | 3 +- include/linux/mm.h | 4 +- include/linux/sched/user.h | 6 - include/linux/shmem_fs.h | 2 +- include/linux/signal_types.h | 4 +- include/linux/user_namespace.h | 23 ++- ipc/mqueue.c | 29 ++-- ipc/shm.c | 31 ++-- kernel/cred.c | 46 ++++- kernel/exit.c | 2 +- kernel/fork.c | 12 +- kernel/signal.c | 53 +++--- kernel/sys.c | 13 -- kernel/ucount.c | 109 ++++++++++-- kernel/user.c | 2 - kernel/user_namespace.c | 7 +- mm/memfd.c | 4 +- mm/mlock.c | 35 ++-- mm/mmap.c | 3 +- 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 ++++++++++++++++++ 32 files changed, 448 insertions(+), 169 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 · 6 lines
2.29.2 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v4 4/7 Move RLIMIT_SIGPENDING counter to ucounts
--- 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 | 53 ++++++++++++++-------------------- kernel/ucount.c | 1 + kernel/user.c | 1 - kernel/user_namespace.c | 1 + 9 files changed, 30 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
@@ -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 );#ifdef CONFIG_VMAP_STACK cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "fork:vm_stack_cache",
kernel/signal.c +22 -31
71 lines not on this page · raw message
kernel/ucount.c +1 -0
@@ -75,6 +75,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.2 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v4 3/7 Move RLIMIT_MSGQUEUE counter to ucounts
In reply to Alexey Gladkov--- include/linux/sched/user.h | 4 ---- include/linux/user_namespace.h | 1 + ipc/mqueue.c | 29 +++++++++++++++-------------- kernel/fork.c | 1 + kernel/ucount.c | 1 + kernel/user_namespace.c | 1 + 6 files changed, 19 insertions(+), 18 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 +15 -14
@@ -144,7 +144,7 @@ struct mqueue_inode_info {struct pid *notify_owner;u32 notify_self_exec_id;struct user_namespace *notify_user_ns; -struct user_struct *user;/* user who created, for accounting */ +struct ucounts *ucounts;/* user who created, for accounting */ struct sock *notify_sock;struct sk_buff *notify_cookie;
@@ -292,7 +292,6 @@ static struct inode *mqueue_get_inode(struct super_block *sb, struct ipc_namespace *ipc_ns, umode_t mode, struct mq_attr *attr) { - struct user_struct *u = current_user(); struct inode *inode;int ret = -ENOMEM ;
@@ -309,6 +308,8 @@ static struct inode *mqueue_get_inode(struct super_block *sb,if (S_ISREG (mode)) {struct mqueue_inode_info *info;unsigned long mq_bytes, mq_treesize; +struct ucounts *ucounts; +bool overlimit; inode->i_fop = &mqueue_file_operations; inode->i_size =FILENT_SIZE ;
@@ -321,7 +322,7 @@ static struct inode *mqueue_get_inode(struct super_block *sb, info->notify_owner =NULL ; info->notify_user_ns =NULL ; info->qsize =0 ; - info->user =NULL ;/* set when all is ok */ + info->ucounts =NULL ;/* set when all is ok */ info->msg_tree =RB_ROOT ; info->msg_tree_rightmost =NULL ; info->node_cache =NULL ;
@@ -371,19 +372,19 @@ static struct inode *mqueue_get_inode(struct super_block *sb,if (mq_bytes + mq_treesize < mq_bytes) goto out_inode; mq_bytes += mq_treesize; + ucounts =current_ucounts ();spin_lock (&mq_lock); -if (u->mq_bytes + mq_bytes < u->mq_bytes || - u->mq_bytes + mq_bytes >rlimit (RLIMIT_MSGQUEUE )) { + overlimit =inc_rlimit_ucounts_and_test (ucounts,UCOUNT_RLIMIT_MSGQUEUE , + mq_bytes,rlimit (RLIMIT_MSGQUEUE )); +if (overlimit) { +dec_rlimit_ucounts (ucounts,UCOUNT_RLIMIT_MSGQUEUE , mq_bytes);spin_unlock (&mq_lock);/* mqueue_evict_inode() releases info->messages */ ret = -EMFILE ; goto out_inode; } - u->mq_bytes += mq_bytes;spin_unlock (&mq_lock); - -/* all is ok */ - info->user =get_uid (u); + info->ucounts =get_ucounts (ucounts); }else if (S_ISDIR (mode)) {inc_nlink (inode);/* Some things misbehave if size == 0 on a directory */
@@ -497,7 +498,7 @@ static void mqueue_free_inode(struct inode *inode)static void mqueue_evict_inode (struct inode *inode) {struct mqueue_inode_info *info; -struct user_struct *user; +struct ucounts *ucounts;struct ipc_namespace *ipc_ns;struct msg_msg *msg, *nmsg;LIST_HEAD (tmp_msg);
@@ -520,8 +521,8 @@ static void mqueue_evict_inode(struct inode *inode)free_msg (msg); } - user = info->user; -if (user) { + ucounts = info->ucounts; +if (ucounts) {unsigned long mq_bytes, mq_treesize;/* Total amount of bytes accounted for the mqueue */
@@ -533,7 +534,7 @@ static void mqueue_evict_inode(struct inode *inode) info->attr.mq_msgsize);spin_lock (&mq_lock); - user->mq_bytes -= mq_bytes; +dec_rlimit_ucounts (ucounts,UCOUNT_RLIMIT_MSGQUEUE , mq_bytes);/* * get_ns_from_inode() ensures that the * (ipc_ns = sb->s_fs_info) is either a valid ipc_ns
@@ -543,7 +544,7 @@ static void mqueue_evict_inode(struct inode *inode)if (ipc_ns) ipc_ns->mq_queues_count--;spin_unlock (&mq_lock); -free_uid (user); +put_ucounts (ucounts); }if (ipc_ns)put_ipc_ns (ipc_ns);
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 );#ifdef CONFIG_VMAP_STACK cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "fork:vm_stack_cache",
kernel/ucount.c +1 -0
@@ -75,6 +75,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 · 1 line
2.29.2
PATCH v4 5/7 Move RLIMIT_MEMLOCK counter to ucounts
In reply to Alexey Gladkov--- fs/hugetlbfs/inode.c | 17 ++++++++--------- include/linux/hugetlb.h | 3 +-- include/linux/mm.h | 4 ++-- include/linux/shmem_fs.h | 2 +- include/linux/user_namespace.h | 1 + ipc/shm.c | 31 ++++++++++++++++-------------- kernel/fork.c | 1 + kernel/ucount.c | 1 + kernel/user_namespace.c | 1 + mm/memfd.c | 4 +--- mm/mlock.c | 35 +++++++++++++--------------------- mm/mmap.c | 3 +-- mm/shmem.c | 8 ++++---- 13 files changed, 52 insertions(+), 59 deletions(-)
fs/hugetlbfs/inode.c +8 -9
@@ -1451,34 +1451,35 @@ 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,int creat_flags,int page_size_log) {struct inode *inode;struct vfsmount *mnt;int hstate_idx;struct file *file; +const struct cred *cred; hstate_idx =get_hstate_idx (page_size_log);if (hstate_idx <0 )return ERR_PTR (-ENODEV ); - *user =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)) { + cred =current_cred (); +if (user_shm_lock (size, cred)) {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 ;return ERR_PTR (-EPERM ); } + }else { + cred =NULL ; } file =ERR_PTR (-ENOSPC );
@@ -1503,10 +1504,8 @@ struct file *hugetlb_file_setup(const char *name, size_t size,iput (inode); out: -if (*user) { -user_shm_unlock (size, *user); - *user =NULL ; - } +if (cred) +user_shm_unlock (size, cred);return file; }
include/linux/hugetlb.h +1 -2
@@ -434,8 +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, -int page_size_log); +int creat_flags,int page_size_log);static inline bool is_file_hugepages (struct file *file) {
include/linux/mm.h +2 -2
@@ -1628,8 +1628,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 ,const struct cred *); +extern void user_shm_unlock (size_t ,const struct cred *);/* * Parameter block passed down to zap_pte_range in exceptional cases.
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,const struct cred *cred);#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 +17 -14
@@ -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; +const struct cred *mlock_cred;/* 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_cred); +else if (shp->mlock_cred)user_shm_unlock (i_size_read (file_inode (shm_file)), - shp->mlock_user); + shp->mlock_cred);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_cred =NULL ; shp->shm_perm.security =NULL ; error =security_shm_alloc (&shp->shm_perm);
@@ -650,8 +650,9 @@ 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 , +HUGETLB_SHMFS_INODE , (shmflg >>SHM_HUGE_SHIFT ) &SHM_HUGE_MASK ); + shp->mlock_cred =current_cred (); }else {/* * Do not allow no accounting for OVERCOMMIT_NEVER, even
@@ -663,8 +664,10 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params) file =shmem_kernel_file_setup (name, size, acctflag); } error =PTR_ERR (file); -if (IS_ERR (file)) +if (IS_ERR (file)) { + shp->mlock_cred =NULL ; goto no_file; + } shp->shm_cprid =get_pid (task_tgid (current)); shp->shm_lprid =NULL ;
@@ -698,8 +701,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_cred) +user_shm_unlock (size, shp->mlock_cred);fput (file);ipc_rcu_putref (&shp->shm_perm, shm_rcu_free);return error;
@@ -1105,12 +1108,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 (); +const struct cred *cred =current_cred (); - err =shmem_lock (shm_file,1 , user); + err =shmem_lock (shm_file,1 , cred);if (!err && !(shp->shm_perm.mode &SHM_LOCKED )) { shp->shm_perm.mode |=SHM_LOCKED ; - shp->mlock_user = user; + shp->mlock_cred = cred; } goto out_unlock0; }
@@ -1118,9 +1121,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_cred); shp->shm_perm.mode &= ~SHM_LOCKED ; - shp->mlock_user =NULL ; + shp->mlock_cred =NULL ;get_file (shm_file);ipc_unlock_object (&shp->shm_perm);rcu_read_unlock ();
kernel/fork.c +1 -0
@@ -826,6 +826,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
@@ -78,6 +78,7 @@ static struct ctl_table user_table[] = { { }, { }, { }, + { }, { } };#endif /* CONFIG_SYSCTL */
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 +1 -3
@@ -297,9 +297,7 @@ SYSCALL_DEFINE2(memfd_create, }if (flags &MFD_HUGETLB ) { -struct user_struct *user =NULL ; - - file =hugetlb_file_setup (name,0 ,VM_NORESERVE , &user, + file =hugetlb_file_setup (name,0 ,VM_NORESERVE ,HUGETLB_ANONHUGE_INODE , (flags >>MFD_HUGE_SHIFT ) &MFD_HUGE_MASK );
mm/mlock.c +13 -22
@@ -812,15 +812,10 @@ SYSCALL_DEFINE0(munlockall)return ret; } -/* -* Objects with different lifetime than processes (SHM_LOCK and SHM_HUGETLB -* shm segments) get accounted against the user_struct instead. -*/ -static DEFINE_SPINLOCK (shmlock_user_lock); - -int user_shm_lock (size_t size,struct user_struct *user) +int user_shm_lock (size_t size,const struct cred *cred) {unsigned long lock_limit, locked; +bool overlimit;int allowed =0 ; locked = (size +PAGE_SIZE -1 ) >>PAGE_SHIFT ;
@@ -828,22 +823,18 @@ int user_shm_lock(size_t size, struct user_struct *user)if (lock_limit ==RLIM_INFINITY ) allowed =1 ; lock_limit >>=PAGE_SHIFT ; -spin_lock (&shmlock_user_lock); -if (!allowed && - locked + user->locked_shm > lock_limit && !capable (CAP_IPC_LOCK )) - goto out; -get_uid (user); - user->locked_shm += locked; - allowed =1 ; -out: -spin_unlock (&shmlock_user_lock); -return allowed; + + overlimit =inc_rlimit_ucounts_and_test (cred->ucounts,UCOUNT_RLIMIT_MEMLOCK , + locked, lock_limit); + +if (!allowed && overlimit && !capable (CAP_IPC_LOCK )) { +dec_rlimit_ucounts (cred->ucounts,UCOUNT_RLIMIT_MEMLOCK , locked); +return 0 ; + } +return 1 ; } -void user_shm_unlock (size_t size,struct user_struct *user) +void user_shm_unlock (size_t size,const struct cred *cred) { -spin_lock (&shmlock_user_lock); - user->locked_shm -= (size +PAGE_SIZE -1 ) >>PAGE_SHIFT ; -spin_unlock (&shmlock_user_lock); -free_uid (user); +dec_rlimit_ucounts (cred->ucounts,UCOUNT_RLIMIT_MEMLOCK , (size +PAGE_SIZE -1 ) >>PAGE_SHIFT ); }
mm/mmap.c +1 -2
@@ -1607,7 +1607,6 @@ 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 hstate *hs; hs =hstate_sizelog ((flags >>MAP_HUGE_SHIFT ) &MAP_HUGE_MASK );
@@ -1623,7 +1622,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 , +HUGETLB_ANONHUGE_INODE , (flags >>MAP_HUGE_SHIFT ) &MAP_HUGE_MASK );if (IS_ERR (file))return PTR_ERR (file);
mm/shmem.c +4 -4
@@ -2225,7 +2225,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,const struct cred *cred) {struct inode *inode =file_inode (file);struct shmem_inode_info *info =SHMEM_I (inode);
@@ -2237,13 +2237,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, cred)) 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 ) && cred) { +user_shm_unlock (inode->i_size, cred); info->flags &= ~VM_LOCKED ;mapping_clear_unevictable (file->f_mapping); }
Signature · 6 lines
2.29.2 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v4 6/7 Move RLIMIT_NPROC check to the place where we increment the counter
In reply to Alexey GladkovAfter calling set_user(), we always have to call commit_creds() to apply new credentials upon the current task. There is no need to separate limit check and counter incrementing.
--- kernel/cred.c | 22 +++++++++++++++++----- kernel/sys.c | 13 ------------- 2 files changed, 17 insertions(+), 18 deletions(-)
kernel/cred.c +17 -5
@@ -487,14 +487,26 @@ int commit_creds(struct cred *new)if (!gid_eq (new->fsgid, old->fsgid))key_fsgid_changed (new); -/* do it -* RLIMIT_NPROC limits on user->processes have already been checked -* in set_user(). -*/ alter_cred_subscribers (new,2 );if (new->user != old->user || new->user_ns != old->user_ns) { +bool overlimit; +set_cred_ucounts (new, new->user_ns, new->euid); -inc_rlimit_ucounts (new->ucounts,UCOUNT_RLIMIT_NPROC ,1 ); + + overlimit =inc_rlimit_ucounts_and_test (new->ucounts,UCOUNT_RLIMIT_NPROC , +1 ,rlimit (RLIMIT_NPROC )); + +/* +* We don't fail in case of NPROC limit excess here because too many +* poorly written programs don't check set*uid() return code, assuming +* it never fails if called by root. We may still enforce NPROC limit +* for programs doing set*uid()+execve() by harmlessly deferring the +* failure to the execve() stage. +*/ +if (overlimit && new->user !=INIT_USER ) + current->flags |=PF_NPROC_EXCEEDED ; +else + current->flags &= ~PF_NPROC_EXCEEDED ; }rcu_assign_pointer (task->real_cred, new);rcu_assign_pointer (task->cred, new);
kernel/sys.c +0 -13
@@ -467,19 +467,6 @@ static int set_user(struct cred *new)if (!new_user)return -EAGAIN ; -/* -* We don't fail in case of NPROC limit excess here because too many -* poorly written programs don't check set*uid() return code, assuming -* it never fails if called by root. We may still enforce NPROC limit -* for programs doing set*uid()+execve() by harmlessly deferring the -* failure to the execve() stage. -*/ -if (is_ucounts_overlimit (new->ucounts,UCOUNT_RLIMIT_NPROC ,rlimit (RLIMIT_NPROC )) && - new_user !=INIT_USER ) - current->flags |=PF_NPROC_EXCEEDED ; -else - current->flags &= ~PF_NPROC_EXCEEDED ; -free_uid (new->user); new->user = new_user;return 0 ;
Signature · 6 lines
2.29.2 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers
PATCH v4 7/7 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
@@ -46,6 +46,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.2 _______________________________________________ Containers mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/containers