2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* The "user cache".
|
|
|
|
*
|
|
|
|
* (C) Copyright 1991-2000 Linus Torvalds
|
|
|
|
*
|
|
|
|
* We have a per-user structure to keep track of how many
|
|
|
|
* processes, files etc the user has claimed, in order to be
|
|
|
|
* able to have per-user limits for system resources.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/key.h>
|
2006-01-25 09:23:07 -05:00
|
|
|
#include <linux/interrupt.h>
|
2007-07-16 02:40:59 -04:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/user_namespace.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-02-08 07:18:23 -05:00
|
|
|
struct user_namespace init_user_ns = {
|
|
|
|
.kref = {
|
2009-02-26 19:27:38 -05:00
|
|
|
.refcount = ATOMIC_INIT(2),
|
2008-02-08 07:18:23 -05:00
|
|
|
},
|
2008-10-15 17:38:45 -04:00
|
|
|
.creator = &root_user,
|
2008-02-08 07:18:23 -05:00
|
|
|
};
|
|
|
|
EXPORT_SYMBOL_GPL(init_user_ns);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* UID task count cache, to get fast user lookup in "alloc_uid"
|
|
|
|
* when changing user ID's (ie setuid() and friends).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define UIDHASH_MASK (UIDHASH_SZ - 1)
|
|
|
|
#define __uidhashfn(uid) (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
|
2007-07-16 02:40:59 -04:00
|
|
|
#define uidhashentry(ns, uid) ((ns)->uidhash_table + __uidhashfn((uid)))
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-12-06 23:33:20 -05:00
|
|
|
static struct kmem_cache *uid_cachep;
|
2006-01-25 09:23:07 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The uidhash_lock is mostly taken from process context, but it is
|
|
|
|
* occasionally also taken from softirq/tasklet context, when
|
|
|
|
* task-structs get RCU-freed. Hence all locking must be softirq-safe.
|
2006-01-31 19:34:26 -05:00
|
|
|
* But free_uid() is also called with local interrupts disabled, and running
|
|
|
|
* local_bh_enable() with local interrupts disabled is an error - we'll run
|
|
|
|
* softirq callbacks, and they can unconditionally enable interrupts, and
|
|
|
|
* the caller of free_uid() didn't expect that..
|
2006-01-25 09:23:07 -05:00
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
static DEFINE_SPINLOCK(uidhash_lock);
|
|
|
|
|
2008-10-15 17:38:45 -04:00
|
|
|
/* root_user.__count is 2, 1 for init task cred, 1 for init_user_ns->creator */
|
2005-04-16 18:20:36 -04:00
|
|
|
struct user_struct root_user = {
|
2008-10-15 17:38:45 -04:00
|
|
|
.__count = ATOMIC_INIT(2),
|
2005-04-16 18:20:36 -04:00
|
|
|
.processes = ATOMIC_INIT(1),
|
|
|
|
.files = ATOMIC_INIT(0),
|
|
|
|
.sigpending = ATOMIC_INIT(0),
|
|
|
|
.locked_shm = 0,
|
2008-10-15 17:38:45 -04:00
|
|
|
.user_ns = &init_user_ns,
|
2005-04-16 18:20:36 -04:00
|
|
|
};
|
|
|
|
|
2007-10-15 11:00:14 -04:00
|
|
|
/*
|
|
|
|
* These routines must be called with the uidhash spinlock held!
|
|
|
|
*/
|
2007-10-17 02:30:09 -04:00
|
|
|
static void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
|
2007-10-15 11:00:14 -04:00
|
|
|
{
|
|
|
|
hlist_add_head(&up->uidhash_node, hashent);
|
|
|
|
}
|
|
|
|
|
2007-10-17 02:30:09 -04:00
|
|
|
static void uid_hash_remove(struct user_struct *up)
|
2007-10-15 11:00:14 -04:00
|
|
|
{
|
|
|
|
hlist_del_init(&up->uidhash_node);
|
2009-02-13 09:04:21 -05:00
|
|
|
put_user_ns(up->user_ns);
|
2007-10-15 11:00:14 -04:00
|
|
|
}
|
|
|
|
|
sched: delayed cleanup of user_struct
During bootup performance tracing we see repeated occurrences of
/sys/kernel/uid/* events for the same uid, leading to a,
in this case, rather pointless userspace processing for the
same uid over and over.
This is usually caused by tools which change their uid to "nobody",
to run without privileges to read data supplied by untrusted users.
This change delays the execution of the (already existing) scheduled
work, to cleanup the uid after one second, so the allocated and announced
uid can possibly be re-used by another process.
This is the current behavior, where almost every invocation of a
binary, which changes the uid, creates two events:
$ read START < /sys/kernel/uevent_seqnum; \
for i in `seq 100`; do su --shell=/bin/true bin; done; \
read END < /sys/kernel/uevent_seqnum; \
echo $(($END - $START))
178
With the delayed cleanup, we get only two events, and userspace finishes
a bit faster too:
$ read START < /sys/kernel/uevent_seqnum; \
for i in `seq 100`; do su --shell=/bin/true bin; done; \
read END < /sys/kernel/uevent_seqnum; \
echo $(($END - $START))
1
Acked-by: Dhaval Giani <dhaval@linux.vnet.ibm.com>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-03-24 10:43:30 -04:00
|
|
|
static struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
|
|
|
|
{
|
|
|
|
struct user_struct *user;
|
|
|
|
struct hlist_node *h;
|
|
|
|
|
|
|
|
hlist_for_each_entry(user, h, hashent, uidhash_node) {
|
|
|
|
if (user->uid == uid) {
|
|
|
|
atomic_inc(&user->__count);
|
|
|
|
return user;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-15 11:00:14 -04:00
|
|
|
/* IRQs are disabled and uidhash_lock is held upon function entry.
|
|
|
|
* IRQ state (as stored in flags) is restored and uidhash_lock released
|
|
|
|
* upon function exit.
|
|
|
|
*/
|
2008-10-15 17:38:45 -04:00
|
|
|
static void free_user(struct user_struct *up, unsigned long flags)
|
2010-10-26 17:22:43 -04:00
|
|
|
__releases(&uidhash_lock)
|
2007-10-15 11:00:14 -04:00
|
|
|
{
|
|
|
|
uid_hash_remove(up);
|
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
|
|
|
key_put(up->uid_keyring);
|
|
|
|
key_put(up->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, up);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Locate the user_struct for the passed UID. If found, take a ref on it. The
|
|
|
|
* caller must undo that ref with free_uid().
|
|
|
|
*
|
|
|
|
* If the user_struct could not be found, return NULL.
|
|
|
|
*/
|
|
|
|
struct user_struct *find_user(uid_t uid)
|
|
|
|
{
|
|
|
|
struct user_struct *ret;
|
2006-01-31 19:34:26 -05:00
|
|
|
unsigned long flags;
|
2008-11-24 16:24:10 -05:00
|
|
|
struct user_namespace *ns = current_user_ns();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_lock_irqsave(&uidhash_lock, flags);
|
2007-07-16 02:40:59 -04:00
|
|
|
ret = uid_hash_find(uid, uidhashentry(ns, uid));
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
2005-04-16 18:20:36 -04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_uid(struct user_struct *up)
|
|
|
|
{
|
2006-01-31 19:34:26 -05:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-03-24 06:15:47 -05:00
|
|
|
if (!up)
|
|
|
|
return;
|
|
|
|
|
2006-01-31 19:34:26 -05:00
|
|
|
local_irq_save(flags);
|
2007-10-15 11:00:14 -04:00
|
|
|
if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
|
|
|
|
free_user(up, flags);
|
|
|
|
else
|
2006-03-24 06:15:47 -05:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-04-30 03:54:54 -04:00
|
|
|
struct user_struct *alloc_uid(struct user_namespace *ns, uid_t uid)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-09-19 01:46:44 -04:00
|
|
|
struct hlist_head *hashent = uidhashentry(ns, uid);
|
2008-01-25 15:08:26 -05:00
|
|
|
struct user_struct *up, *new;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
up = uid_hash_find(uid, hashent);
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (!up) {
|
2008-04-30 03:54:54 -04:00
|
|
|
new = kmem_cache_zalloc(uid_cachep, GFP_KERNEL);
|
2008-01-25 15:08:26 -05:00
|
|
|
if (!new)
|
|
|
|
goto out_unlock;
|
2007-11-26 15:21:49 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
new->uid = uid;
|
|
|
|
atomic_set(&new->__count, 1);
|
|
|
|
|
2008-10-15 17:38:45 -04:00
|
|
|
new->user_ns = get_user_ns(ns);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Before adding this, check whether we raced
|
|
|
|
* on adding the same user already..
|
|
|
|
*/
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
up = uid_hash_find(uid, hashent);
|
|
|
|
if (up) {
|
2010-12-29 08:55:28 -05:00
|
|
|
put_user_ns(ns);
|
2005-04-16 18:20:36 -04:00
|
|
|
key_put(new->uid_keyring);
|
|
|
|
key_put(new->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, new);
|
|
|
|
} else {
|
|
|
|
uid_hash_insert(new, hashent);
|
|
|
|
up = new;
|
|
|
|
}
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2007-10-15 11:00:14 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
return up;
|
2008-01-25 15:08:26 -05:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
return NULL;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init uid_cache_init(void)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
|
2007-07-19 21:11:58 -04:00
|
|
|
0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
for(n = 0; n < UIDHASH_SZ; ++n)
|
2007-09-19 01:46:44 -04:00
|
|
|
INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Insert the root user immediately (init already runs as root) */
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2007-07-16 02:40:59 -04:00
|
|
|
uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
|
2006-01-31 19:34:26 -05:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(uid_cache_init);
|