2005-04-17 00:20:36 +02: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 15:23:07 +01:00
|
|
|
#include <linux/interrupt.h>
|
2007-07-16 08:40:59 +02:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/user_namespace.h>
|
2005-04-17 00:20:36 +02: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 08:40:59 +02:00
|
|
|
#define uidhashentry(ns, uid) ((ns)->uidhash_table + __uidhashfn((uid)))
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-12-07 05:33:20 +01:00
|
|
|
static struct kmem_cache *uid_cachep;
|
2006-01-25 15:23:07 +01: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-02-01 01:34:26 +01: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 15:23:07 +01:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static DEFINE_SPINLOCK(uidhash_lock);
|
|
|
|
|
|
|
|
struct user_struct root_user = {
|
|
|
|
.__count = ATOMIC_INIT(1),
|
|
|
|
.processes = ATOMIC_INIT(1),
|
|
|
|
.files = ATOMIC_INIT(0),
|
|
|
|
.sigpending = ATOMIC_INIT(0),
|
|
|
|
.mq_bytes = 0,
|
|
|
|
.locked_shm = 0,
|
|
|
|
#ifdef CONFIG_KEYS
|
|
|
|
.uid_keyring = &root_user_keyring,
|
|
|
|
.session_keyring = &root_session_keyring,
|
|
|
|
#endif
|
2007-10-15 17:00:09 +02:00
|
|
|
#ifdef CONFIG_FAIR_USER_SCHED
|
2007-10-15 17:00:14 +02:00
|
|
|
.tg = &init_task_group,
|
2007-10-15 17:00:09 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/*
|
|
|
|
* These routines must be called with the uidhash spinlock held!
|
|
|
|
*/
|
2007-10-17 08:30:09 +02:00
|
|
|
static void uid_hash_insert(struct user_struct *up, struct hlist_head *hashent)
|
2007-10-15 17:00:14 +02:00
|
|
|
{
|
|
|
|
hlist_add_head(&up->uidhash_node, hashent);
|
|
|
|
}
|
|
|
|
|
2007-10-17 08:30:09 +02:00
|
|
|
static void uid_hash_remove(struct user_struct *up)
|
2007-10-15 17:00:14 +02:00
|
|
|
{
|
|
|
|
hlist_del_init(&up->uidhash_node);
|
|
|
|
}
|
|
|
|
|
2007-10-17 08:30:09 +02:00
|
|
|
static struct user_struct *uid_hash_find(uid_t uid, struct hlist_head *hashent)
|
2007-10-15 17:00:14 +02:00
|
|
|
{
|
|
|
|
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 17:00:09 +02:00
|
|
|
#ifdef CONFIG_FAIR_USER_SCHED
|
2007-10-15 17:00:14 +02:00
|
|
|
|
|
|
|
static struct kobject uids_kobject; /* represents /sys/kernel/uids directory */
|
|
|
|
static DEFINE_MUTEX(uids_mutex);
|
|
|
|
|
2007-10-15 17:00:09 +02:00
|
|
|
static void sched_destroy_user(struct user_struct *up)
|
|
|
|
{
|
|
|
|
sched_destroy_group(up->tg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sched_create_user(struct user_struct *up)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
up->tg = sched_create_group();
|
|
|
|
if (IS_ERR(up->tg))
|
|
|
|
rc = -ENOMEM;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sched_switch_user(struct task_struct *p)
|
|
|
|
{
|
|
|
|
sched_move_task(p);
|
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
static inline void uids_mutex_lock(void)
|
|
|
|
{
|
|
|
|
mutex_lock(&uids_mutex);
|
|
|
|
}
|
2007-10-15 17:00:09 +02:00
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
static inline void uids_mutex_unlock(void)
|
|
|
|
{
|
|
|
|
mutex_unlock(&uids_mutex);
|
|
|
|
}
|
2007-10-15 17:00:09 +02:00
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/* return cpu shares held by the user */
|
|
|
|
ssize_t cpu_shares_show(struct kset *kset, char *buffer)
|
|
|
|
{
|
|
|
|
struct user_struct *up = container_of(kset, struct user_struct, kset);
|
2007-10-15 17:00:09 +02:00
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
return sprintf(buffer, "%lu\n", sched_group_shares(up->tg));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* modify cpu shares held by the user */
|
|
|
|
ssize_t cpu_shares_store(struct kset *kset, const char *buffer, size_t size)
|
|
|
|
{
|
|
|
|
struct user_struct *up = container_of(kset, struct user_struct, kset);
|
|
|
|
unsigned long shares;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
sscanf(buffer, "%lu", &shares);
|
|
|
|
|
|
|
|
rc = sched_group_set_shares(up->tg, shares);
|
|
|
|
|
|
|
|
return (rc ? rc : size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void user_attr_init(struct subsys_attribute *sa, char *name, int mode)
|
|
|
|
{
|
|
|
|
sa->attr.name = name;
|
|
|
|
sa->attr.mode = mode;
|
|
|
|
sa->show = cpu_shares_show;
|
|
|
|
sa->store = cpu_shares_store;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create "/sys/kernel/uids/<uid>" directory and
|
|
|
|
* "/sys/kernel/uids/<uid>/cpu_share" file for this user.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-10-15 17:00:14 +02:00
|
|
|
static int user_kobject_create(struct user_struct *up)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-10-15 17:00:14 +02:00
|
|
|
struct kset *kset = &up->kset;
|
|
|
|
struct kobject *kobj = &kset->kobj;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
memset(kset, 0, sizeof(struct kset));
|
|
|
|
kobj->parent = &uids_kobject; /* create under /sys/kernel/uids dir */
|
|
|
|
kobject_set_name(kobj, "%d", up->uid);
|
|
|
|
kset_init(kset);
|
|
|
|
user_attr_init(&up->user_attr, "cpu_share", 0644);
|
|
|
|
|
|
|
|
error = kobject_add(kobj);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
error = sysfs_create_file(kobj, &up->user_attr.attr);
|
|
|
|
if (error)
|
|
|
|
kobject_del(kobj);
|
|
|
|
|
2007-10-15 17:00:18 +02:00
|
|
|
kobject_uevent(kobj, KOBJ_ADD);
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
done:
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/* create these in sysfs filesystem:
|
|
|
|
* "/sys/kernel/uids" directory
|
|
|
|
* "/sys/kernel/uids/0" directory (for root user)
|
|
|
|
* "/sys/kernel/uids/0/cpu_share" file (for root user)
|
|
|
|
*/
|
|
|
|
int __init uids_kobject_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-10-15 17:00:14 +02:00
|
|
|
int error;
|
|
|
|
|
|
|
|
/* create under /sys/kernel dir */
|
|
|
|
uids_kobject.parent = &kernel_subsys.kobj;
|
2007-10-15 17:00:18 +02:00
|
|
|
uids_kobject.kset = &kernel_subsys;
|
2007-10-15 17:00:14 +02:00
|
|
|
kobject_set_name(&uids_kobject, "uids");
|
|
|
|
kobject_init(&uids_kobject);
|
|
|
|
|
|
|
|
error = kobject_add(&uids_kobject);
|
|
|
|
if (!error)
|
|
|
|
error = user_kobject_create(&root_user);
|
|
|
|
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/* work function to remove sysfs directory for a user and free up
|
|
|
|
* corresponding structures.
|
|
|
|
*/
|
|
|
|
static void remove_user_sysfs_dir(struct work_struct *w)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-10-15 17:00:14 +02:00
|
|
|
struct user_struct *up = container_of(w, struct user_struct, work);
|
|
|
|
struct kobject *kobj = &up->kset.kobj;
|
|
|
|
unsigned long flags;
|
|
|
|
int remove_user = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/* Make uid_hash_remove() + sysfs_remove_file() + kobject_del()
|
|
|
|
* atomic.
|
|
|
|
*/
|
|
|
|
uids_mutex_lock();
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
if (atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
|
|
|
|
uid_hash_remove(up);
|
|
|
|
remove_user = 1;
|
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
|
|
|
} else {
|
|
|
|
local_irq_restore(flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
if (!remove_user)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
sysfs_remove_file(kobj, &up->user_attr.attr);
|
2007-10-15 17:00:18 +02:00
|
|
|
kobject_uevent(kobj, KOBJ_REMOVE);
|
2007-10-15 17:00:14 +02:00
|
|
|
kobject_del(kobj);
|
|
|
|
|
|
|
|
sched_destroy_user(up);
|
|
|
|
key_put(up->uid_keyring);
|
|
|
|
key_put(up->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, up);
|
|
|
|
|
|
|
|
done:
|
|
|
|
uids_mutex_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
static inline void free_user(struct user_struct *up, unsigned long flags)
|
|
|
|
{
|
|
|
|
/* restore back the count */
|
|
|
|
atomic_inc(&up->__count);
|
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
|
|
|
|
|
|
|
INIT_WORK(&up->work, remove_user_sysfs_dir);
|
|
|
|
schedule_work(&up->work);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
#else /* CONFIG_FAIR_USER_SCHED */
|
|
|
|
|
|
|
|
static void sched_destroy_user(struct user_struct *up) { }
|
|
|
|
static int sched_create_user(struct user_struct *up) { return 0; }
|
|
|
|
static void sched_switch_user(struct task_struct *p) { }
|
|
|
|
static inline int user_kobject_create(struct user_struct *up) { return 0; }
|
|
|
|
static inline void uids_mutex_lock(void) { }
|
|
|
|
static inline void uids_mutex_unlock(void) { }
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
static inline void free_user(struct user_struct *up, unsigned long flags)
|
|
|
|
{
|
|
|
|
uid_hash_remove(up);
|
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
|
|
|
sched_destroy_user(up);
|
|
|
|
key_put(up->uid_keyring);
|
|
|
|
key_put(up->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, up);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_FAIR_USER_SCHED */
|
|
|
|
|
2005-04-17 00:20:36 +02: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-02-01 01:34:26 +01:00
|
|
|
unsigned long flags;
|
2007-07-16 08:40:59 +02:00
|
|
|
struct user_namespace *ns = current->nsproxy->user_ns;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_lock_irqsave(&uidhash_lock, flags);
|
2007-07-16 08:40:59 +02:00
|
|
|
ret = uid_hash_find(uid, uidhashentry(ns, uid));
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_uid(struct user_struct *up)
|
|
|
|
{
|
2006-02-01 01:34:26 +01:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-03-24 12:15:47 +01:00
|
|
|
if (!up)
|
|
|
|
return;
|
|
|
|
|
2006-02-01 01:34:26 +01:00
|
|
|
local_irq_save(flags);
|
2007-10-15 17:00:14 +02:00
|
|
|
if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
|
|
|
|
free_user(up, flags);
|
|
|
|
else
|
2006-03-24 12:15:47 +01:00
|
|
|
local_irq_restore(flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-07-16 08:40:59 +02:00
|
|
|
struct user_struct * alloc_uid(struct user_namespace *ns, uid_t uid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-09-19 07:46:44 +02:00
|
|
|
struct hlist_head *hashent = uidhashentry(ns, uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
struct user_struct *up;
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
/* Make uid_hash_find() + user_kobject_create() + uid_hash_insert()
|
|
|
|
* atomic.
|
|
|
|
*/
|
|
|
|
uids_mutex_lock();
|
|
|
|
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
up = uid_hash_find(uid, hashent);
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!up) {
|
|
|
|
struct user_struct *new;
|
|
|
|
|
2006-12-07 05:33:17 +01:00
|
|
|
new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!new)
|
|
|
|
return NULL;
|
|
|
|
new->uid = uid;
|
|
|
|
atomic_set(&new->__count, 1);
|
|
|
|
atomic_set(&new->processes, 0);
|
|
|
|
atomic_set(&new->files, 0);
|
|
|
|
atomic_set(&new->sigpending, 0);
|
2006-06-01 22:10:59 +02:00
|
|
|
#ifdef CONFIG_INOTIFY_USER
|
[PATCH] inotify
inotify is intended to correct the deficiencies of dnotify, particularly
its inability to scale and its terrible user interface:
* dnotify requires the opening of one fd per each directory
that you intend to watch. This quickly results in too many
open files and pins removable media, preventing unmount.
* dnotify is directory-based. You only learn about changes to
directories. Sure, a change to a file in a directory affects
the directory, but you are then forced to keep a cache of
stat structures.
* dnotify's interface to user-space is awful. Signals?
inotify provides a more usable, simple, powerful solution to file change
notification:
* inotify's interface is a system call that returns a fd, not SIGIO.
You get a single fd, which is select()-able.
* inotify has an event that says "the filesystem that the item
you were watching is on was unmounted."
* inotify can watch directories or files.
Inotify is currently used by Beagle (a desktop search infrastructure),
Gamin (a FAM replacement), and other projects.
See Documentation/filesystems/inotify.txt.
Signed-off-by: Robert Love <rml@novell.com>
Cc: John McCutchan <ttb@tentacle.dhs.org>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-12 23:06:03 +02:00
|
|
|
atomic_set(&new->inotify_watches, 0);
|
|
|
|
atomic_set(&new->inotify_devs, 0);
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
new->mq_bytes = 0;
|
|
|
|
new->locked_shm = 0;
|
|
|
|
|
2006-06-22 23:47:17 +02:00
|
|
|
if (alloc_uid_keyring(new, current) < 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
kmem_cache_free(uid_cachep, new);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:09 +02:00
|
|
|
if (sched_create_user(new) < 0) {
|
|
|
|
key_put(new->uid_keyring);
|
|
|
|
key_put(new->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, new);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-15 17:00:14 +02:00
|
|
|
if (user_kobject_create(new)) {
|
|
|
|
sched_destroy_user(new);
|
|
|
|
key_put(new->uid_keyring);
|
|
|
|
key_put(new->session_keyring);
|
|
|
|
kmem_cache_free(uid_cachep, new);
|
|
|
|
uids_mutex_unlock();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Before adding this, check whether we raced
|
|
|
|
* on adding the same user already..
|
|
|
|
*/
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
up = uid_hash_find(uid, hashent);
|
|
|
|
if (up) {
|
2007-10-15 17:00:14 +02:00
|
|
|
/* This case is not possible when CONFIG_FAIR_USER_SCHED
|
|
|
|
* is defined, since we serialize alloc_uid() using
|
|
|
|
* uids_mutex. Hence no need to call
|
|
|
|
* sched_destroy_user() or remove_user_sysfs_dir().
|
|
|
|
*/
|
2005-04-17 00:20:36 +02: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-02-01 01:34:26 +01:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
}
|
2007-10-15 17:00:14 +02:00
|
|
|
|
|
|
|
uids_mutex_unlock();
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return up;
|
|
|
|
}
|
|
|
|
|
|
|
|
void switch_uid(struct user_struct *new_user)
|
|
|
|
{
|
|
|
|
struct user_struct *old_user;
|
|
|
|
|
|
|
|
/* What if a process setreuid()'s and this brings the
|
|
|
|
* new uid over his NPROC rlimit? We can check this now
|
|
|
|
* cheaply with the new uid cache, so if it matters
|
|
|
|
* we should be checking for it. -DaveM
|
|
|
|
*/
|
|
|
|
old_user = current->user;
|
|
|
|
atomic_inc(&new_user->processes);
|
|
|
|
atomic_dec(&old_user->processes);
|
|
|
|
switch_uid_keyring(new_user);
|
|
|
|
current->user = new_user;
|
2007-10-15 17:00:09 +02:00
|
|
|
sched_switch_user(current);
|
2006-11-04 19:06:02 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to synchronize with __sigqueue_alloc()
|
|
|
|
* doing a get_uid(p->user).. If that saw the old
|
|
|
|
* user value, we need to wait until it has exited
|
|
|
|
* its critical region before we can free the old
|
|
|
|
* structure.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
|
|
|
spin_unlock_wait(¤t->sighand->siglock);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
free_uid(old_user);
|
|
|
|
suid_keys(current);
|
|
|
|
}
|
|
|
|
|
Fix user namespace exiting OOPs
It turned out, that the user namespace is released during the do_exit() in
exit_task_namespaces(), but the struct user_struct is released only during the
put_task_struct(), i.e. MUCH later.
On debug kernels with poisoned slabs this will cause the oops in
uid_hash_remove() because the head of the chain, which resides inside the
struct user_namespace, will be already freed and poisoned.
Since the uid hash itself is required only when someone can search it, i.e.
when the namespace is alive, we can safely unhash all the user_struct-s from
it during the namespace exiting. The subsequent free_uid() will complete the
user_struct destruction.
For example simple program
#include <sched.h>
char stack[2 * 1024 * 1024];
int f(void *foo)
{
return 0;
}
int main(void)
{
clone(f, stack + 1 * 1024 * 1024, 0x10000000, 0);
return 0;
}
run on kernel with CONFIG_USER_NS turned on will oops the
kernel immediately.
This was spotted during OpenVZ kernel testing.
Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Signed-off-by: Alexey Dobriyan <adobriyan@openvz.org>
Acked-by: "Serge E. Hallyn" <serue@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-09-19 07:46:45 +02:00
|
|
|
void release_uids(struct user_namespace *ns)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned long flags;
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *nd;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&uidhash_lock, flags);
|
|
|
|
/*
|
|
|
|
* collapse the chains so that the user_struct-s will
|
|
|
|
* be still alive, but not in hashes. subsequent free_uid()
|
|
|
|
* will free them.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < UIDHASH_SZ; i++) {
|
|
|
|
head = ns->uidhash_table + i;
|
|
|
|
while (!hlist_empty(head)) {
|
|
|
|
nd = head->first;
|
|
|
|
hlist_del_init(nd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&uidhash_lock, flags);
|
|
|
|
|
|
|
|
free_uid(ns->root_user);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static int __init uid_cache_init(void)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
|
2007-07-20 03:11:58 +02:00
|
|
|
0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
for(n = 0; n < UIDHASH_SZ; ++n)
|
2007-09-19 07:46:44 +02:00
|
|
|
INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Insert the root user immediately (init already runs as root) */
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_lock_irq(&uidhash_lock);
|
2007-07-16 08:40:59 +02:00
|
|
|
uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
|
2006-02-01 01:34:26 +01:00
|
|
|
spin_unlock_irq(&uidhash_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(uid_cache_init);
|