[GitHub/mt8127/android_kernel_alcatel_ttab.git] / kernel / user.c

/*
 * 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>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/user_namespace.h>

/*
 * 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)
#define uidhashentry(ns, uid)	((ns)->uidhash_table + __uidhashfn((uid)))

static struct kmem_cache *uid_cachep;

/*
 * 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.
 * 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..
 */
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
#ifdef CONFIG_FAIR_USER_SCHED
	.tg		= &init_task_group,
#endif
};

/*
 * These routines must be called with the uidhash spinlock held!
 */
static inline void uid_hash_insert(struct user_struct *up,
						struct hlist_head *hashent)
{
	hlist_add_head(&up->uidhash_node, hashent);
}

static inline void uid_hash_remove(struct user_struct *up)
{
	hlist_del_init(&up->uidhash_node);
}

static inline 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;
}

#ifdef CONFIG_FAIR_USER_SCHED

static struct kobject uids_kobject; /* represents /sys/kernel/uids directory */
static DEFINE_MUTEX(uids_mutex);

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);
}

static inline void uids_mutex_lock(void)
{
	mutex_lock(&uids_mutex);
}

static inline void uids_mutex_unlock(void)
{
	mutex_unlock(&uids_mutex);
}

/* 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);

	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.
 */
static int user_kobject_create(struct user_struct *up)
{
	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);

done:
	return error;
}

/* 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)
{
	int error;

	/* create under /sys/kernel dir */
	uids_kobject.parent = &kernel_subsys.kobj;
	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;
}

/* work function to remove sysfs directory for a user and free up
 * corresponding structures.
 */
static void remove_user_sysfs_dir(struct work_struct *w)
{
	struct user_struct *up = container_of(w, struct user_struct, work);
	struct kobject *kobj = &up->kset.kobj;
	unsigned long flags;
	int remove_user = 0;

	/* 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);
	}

	if (!remove_user)
		goto done;

	sysfs_remove_file(kobj, &up->user_attr.attr);
	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);
}

#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 */

/*
 * 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;
	unsigned long flags;
	struct user_namespace *ns = current->nsproxy->user_ns;

	spin_lock_irqsave(&uidhash_lock, flags);
	ret = uid_hash_find(uid, uidhashentry(ns, uid));
	spin_unlock_irqrestore(&uidhash_lock, flags);
	return ret;
}

void free_uid(struct user_struct *up)
{
	unsigned long flags;

	if (!up)
		return;

	local_irq_save(flags);
	if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
		free_user(up, flags);
	else
		local_irq_restore(flags);
}

struct user_struct * alloc_uid(struct user_namespace *ns, uid_t uid)
{
	struct hlist_head *hashent = uidhashentry(ns, uid);
	struct user_struct *up;

	/* Make uid_hash_find() + user_kobject_create() + uid_hash_insert()
	 * atomic.
	 */
	uids_mutex_lock();

	spin_lock_irq(&uidhash_lock);
	up = uid_hash_find(uid, hashent);
	spin_unlock_irq(&uidhash_lock);

	if (!up) {
		struct user_struct *new;

		new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
		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);
#ifdef CONFIG_INOTIFY_USER
		atomic_set(&new->inotify_watches, 0);
		atomic_set(&new->inotify_devs, 0);
#endif

		new->mq_bytes = 0;
		new->locked_shm = 0;

		if (alloc_uid_keyring(new, current) < 0) {
			kmem_cache_free(uid_cachep, new);
			return NULL;
		}

		if (sched_create_user(new) < 0) {
			key_put(new->uid_keyring);
			key_put(new->session_keyring);
			kmem_cache_free(uid_cachep, new);
			return NULL;
		}

		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;
		}

		/*
		 * Before adding this, check whether we raced
		 * on adding the same user already..
		 */
		spin_lock_irq(&uidhash_lock);
		up = uid_hash_find(uid, hashent);
		if (up) {
			/* 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().
			 */
			key_put(new->uid_keyring);
			key_put(new->session_keyring);
			kmem_cache_free(uid_cachep, new);
		} else {
			uid_hash_insert(new, hashent);
			up = new;
		}
		spin_unlock_irq(&uidhash_lock);

	}

	uids_mutex_unlock();

	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;
	sched_switch_user(current);

	/*
	 * 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(&current->sighand->siglock);

	free_uid(old_user);
	suid_keys(current);
}

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);
}

static int __init uid_cache_init(void)
{
	int n;

	uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
			0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

	for(n = 0; n < UIDHASH_SZ; ++n)
		INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);

	/* Insert the root user immediately (init already runs as root) */
	spin_lock_irq(&uidhash_lock);
	uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
	spin_unlock_irq(&uidhash_lock);

	return 0;
}

module_init(uid_cache_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* The "user cache".
	3	*
	4	* (C) Copyright 1991-2000 Linus Torvalds
	5	*
	6	* We have a per-user structure to keep track of how many
	7	* processes, files etc the user has claimed, in order to be
	8	* able to have per-user limits for system resources.
	9	*/
	10
	11	#include <linux/init.h>
	12	#include <linux/sched.h>
	13	#include <linux/slab.h>
	14	#include <linux/bitops.h>
	15	#include <linux/key.h>
4021cb27	16	#include <linux/interrupt.h>
acce292c CLG	17	#include <linux/module.h>
acce292c CLG	18	#include <linux/user_namespace.h>
1da177e4 LT	19
	20	/*
	21	* UID task count cache, to get fast user lookup in "alloc_uid"
	22	* when changing user ID's (ie setuid() and friends).
	23	*/
	24
1da177e4 LT	25	#define UIDHASH_MASK (UIDHASH_SZ - 1)
1da177e4 LT	26	#define __uidhashfn(uid) (((uid >> UIDHASH_BITS) + uid) & UIDHASH_MASK)
acce292c	27	#define uidhashentry(ns, uid) ((ns)->uidhash_table + __uidhashfn((uid)))
1da177e4	28
e18b890b	29	static struct kmem_cache *uid_cachep;
4021cb27 IM	30
	31	/*
	32	* The uidhash_lock is mostly taken from process context, but it is
	33	* occasionally also taken from softirq/tasklet context, when
	34	* task-structs get RCU-freed. Hence all locking must be softirq-safe.
3fa97c9d AM	35	* But free_uid() is also called with local interrupts disabled, and running
	36	* local_bh_enable() with local interrupts disabled is an error - we'll run
	37	* softirq callbacks, and they can unconditionally enable interrupts, and
	38	* the caller of free_uid() didn't expect that..
4021cb27	39	*/
1da177e4 LT	40	static DEFINE_SPINLOCK(uidhash_lock);
	41
	42	struct user_struct root_user = {
	43	.__count = ATOMIC_INIT(1),
	44	.processes = ATOMIC_INIT(1),
	45	.files = ATOMIC_INIT(0),
	46	.sigpending = ATOMIC_INIT(0),
	47	.mq_bytes = 0,
	48	.locked_shm = 0,
	49	#ifdef CONFIG_KEYS
	50	.uid_keyring = &root_user_keyring,
	51	.session_keyring = &root_session_keyring,
	52	#endif
24e377a8	53	#ifdef CONFIG_FAIR_USER_SCHED
4cf86d77	54	.tg = &init_task_group,
24e377a8	55	#endif
1da177e4 LT	56	};
1da177e4 LT	57
5cb350ba DG	58	/*
	59	* These routines must be called with the uidhash spinlock held!
	60	*/
	61	static inline void uid_hash_insert(struct user_struct *up,
	62	struct hlist_head *hashent)
	63	{
	64	hlist_add_head(&up->uidhash_node, hashent);
	65	}
	66
	67	static inline void uid_hash_remove(struct user_struct *up)
	68	{
	69	hlist_del_init(&up->uidhash_node);
	70	}
	71
	72	static inline struct user_struct *uid_hash_find(uid_t uid,
	73	struct hlist_head *hashent)
	74	{
	75	struct user_struct *user;
	76	struct hlist_node *h;
	77
	78	hlist_for_each_entry(user, h, hashent, uidhash_node) {
	79	if (user->uid == uid) {
	80	atomic_inc(&user->__count);
	81	return user;
	82	}
	83	}
	84
	85	return NULL;
	86	}
	87
24e377a8	88	#ifdef CONFIG_FAIR_USER_SCHED
5cb350ba DG	89
	90	static struct kobject uids_kobject; /* represents /sys/kernel/uids directory */
	91	static DEFINE_MUTEX(uids_mutex);
	92
24e377a8 SV	93	static void sched_destroy_user(struct user_struct *up)
	94	{
	95	sched_destroy_group(up->tg);
	96	}
	97
	98	static int sched_create_user(struct user_struct *up)
	99	{
	100	int rc = 0;
	101
	102	up->tg = sched_create_group();
	103	if (IS_ERR(up->tg))
	104	rc = -ENOMEM;
	105
	106	return rc;
	107	}
	108
	109	static void sched_switch_user(struct task_struct *p)
	110	{
	111	sched_move_task(p);
	112	}
	113
5cb350ba DG	114	static inline void uids_mutex_lock(void)
	115	{
	116	mutex_lock(&uids_mutex);
	117	}
24e377a8	118
5cb350ba DG	119	static inline void uids_mutex_unlock(void)
	120	{
	121	mutex_unlock(&uids_mutex);
	122	}
24e377a8	123
5cb350ba DG	124	/* return cpu shares held by the user */
	125	ssize_t cpu_shares_show(struct kset kset, char buffer)
	126	{
	127	struct user_struct *up = container_of(kset, struct user_struct, kset);
24e377a8	128
5cb350ba DG	129	return sprintf(buffer, "%lu\n", sched_group_shares(up->tg));
	130	}
	131
	132	/* modify cpu shares held by the user */
	133	ssize_t cpu_shares_store(struct kset kset, const char buffer, size_t size)
	134	{
	135	struct user_struct *up = container_of(kset, struct user_struct, kset);
	136	unsigned long shares;
	137	int rc;
	138
	139	sscanf(buffer, "%lu", &shares);
	140
	141	rc = sched_group_set_shares(up->tg, shares);
	142
	143	return (rc ? rc : size);
	144	}
	145
	146	static void user_attr_init(struct subsys_attribute sa, char name, int mode)
	147	{
	148	sa->attr.name = name;
	149	sa->attr.mode = mode;
	150	sa->show = cpu_shares_show;
	151	sa->store = cpu_shares_store;
	152	}
	153
	154	/* Create "/sys/kernel/uids/<uid>" directory and
	155	* "/sys/kernel/uids/<uid>/cpu_share" file for this user.
1da177e4	156	*/
5cb350ba	157	static int user_kobject_create(struct user_struct *up)
1da177e4	158	{
5cb350ba DG	159	struct kset *kset = &up->kset;
	160	struct kobject *kobj = &kset->kobj;
	161	int error;
	162
	163	memset(kset, 0, sizeof(struct kset));
	164	kobj->parent = &uids_kobject; /* create under /sys/kernel/uids dir */
	165	kobject_set_name(kobj, "%d", up->uid);
	166	kset_init(kset);
	167	user_attr_init(&up->user_attr, "cpu_share", 0644);
	168
	169	error = kobject_add(kobj);
	170	if (error)
	171	goto done;
	172
	173	error = sysfs_create_file(kobj, &up->user_attr.attr);
	174	if (error)
	175	kobject_del(kobj);
	176
	177	done:
	178	return error;
1da177e4 LT	179	}
1da177e4 LT	180
5cb350ba DG	181	/* create these in sysfs filesystem:
	182	* "/sys/kernel/uids" directory
	183	* "/sys/kernel/uids/0" directory (for root user)
	184	* "/sys/kernel/uids/0/cpu_share" file (for root user)
	185	*/
	186	int __init uids_kobject_init(void)
1da177e4	187	{
5cb350ba DG	188	int error;
	189
	190	/* create under /sys/kernel dir */
	191	uids_kobject.parent = &kernel_subsys.kobj;
	192	kobject_set_name(&uids_kobject, "uids");
	193	kobject_init(&uids_kobject);
	194
	195	error = kobject_add(&uids_kobject);
	196	if (!error)
	197	error = user_kobject_create(&root_user);
	198
	199	return error;
1da177e4 LT	200	}
1da177e4 LT	201
5cb350ba DG	202	/* work function to remove sysfs directory for a user and free up
	203	* corresponding structures.
	204	*/
	205	static void remove_user_sysfs_dir(struct work_struct *w)
1da177e4	206	{
5cb350ba DG	207	struct user_struct *up = container_of(w, struct user_struct, work);
	208	struct kobject *kobj = &up->kset.kobj;
	209	unsigned long flags;
	210	int remove_user = 0;
1da177e4	211
5cb350ba DG	212	/* Make uid_hash_remove() + sysfs_remove_file() + kobject_del()
	213	* atomic.
	214	*/
	215	uids_mutex_lock();
	216
	217	local_irq_save(flags);
	218
	219	if (atomic_dec_and_lock(&up->__count, &uidhash_lock)) {
	220	uid_hash_remove(up);
	221	remove_user = 1;
	222	spin_unlock_irqrestore(&uidhash_lock, flags);
	223	} else {
	224	local_irq_restore(flags);
1da177e4 LT	225	}
1da177e4 LT	226
5cb350ba DG	227	if (!remove_user)
	228	goto done;
	229
	230	sysfs_remove_file(kobj, &up->user_attr.attr);
	231	kobject_del(kobj);
	232
	233	sched_destroy_user(up);
	234	key_put(up->uid_keyring);
	235	key_put(up->session_keyring);
	236	kmem_cache_free(uid_cachep, up);
	237
	238	done:
	239	uids_mutex_unlock();
	240	}
	241
	242	/* IRQs are disabled and uidhash_lock is held upon function entry.
	243	* IRQ state (as stored in flags) is restored and uidhash_lock released
	244	* upon function exit.
	245	*/
	246	static inline void free_user(struct user_struct *up, unsigned long flags)
	247	{
	248	/* restore back the count */
	249	atomic_inc(&up->__count);
	250	spin_unlock_irqrestore(&uidhash_lock, flags);
	251
	252	INIT_WORK(&up->work, remove_user_sysfs_dir);
	253	schedule_work(&up->work);
1da177e4 LT	254	}
1da177e4 LT	255
5cb350ba DG	256	#else /* CONFIG_FAIR_USER_SCHED */
	257
	258	static void sched_destroy_user(struct user_struct *up) { }
	259	static int sched_create_user(struct user_struct *up) { return 0; }
	260	static void sched_switch_user(struct task_struct *p) { }
	261	static inline int user_kobject_create(struct user_struct *up) { return 0; }
	262	static inline void uids_mutex_lock(void) { }
	263	static inline void uids_mutex_unlock(void) { }
	264
	265	/* IRQs are disabled and uidhash_lock is held upon function entry.
	266	* IRQ state (as stored in flags) is restored and uidhash_lock released
	267	* upon function exit.
	268	*/
	269	static inline void free_user(struct user_struct *up, unsigned long flags)
	270	{
	271	uid_hash_remove(up);
	272	spin_unlock_irqrestore(&uidhash_lock, flags);
	273	sched_destroy_user(up);
	274	key_put(up->uid_keyring);
	275	key_put(up->session_keyring);
	276	kmem_cache_free(uid_cachep, up);
	277	}
	278
	279	#endif /* CONFIG_FAIR_USER_SCHED */
	280
1da177e4 LT	281	/*
	282	* Locate the user_struct for the passed UID. If found, take a ref on it. The
	283	* caller must undo that ref with free_uid().
	284	*
	285	* If the user_struct could not be found, return NULL.
	286	*/
	287	struct user_struct *find_user(uid_t uid)
	288	{
	289	struct user_struct *ret;
3fa97c9d	290	unsigned long flags;
acce292c	291	struct user_namespace *ns = current->nsproxy->user_ns;
1da177e4	292
3fa97c9d	293	spin_lock_irqsave(&uidhash_lock, flags);
acce292c	294	ret = uid_hash_find(uid, uidhashentry(ns, uid));
3fa97c9d	295	spin_unlock_irqrestore(&uidhash_lock, flags);
1da177e4 LT	296	return ret;
	297	}
	298
	299	void free_uid(struct user_struct *up)
	300	{
3fa97c9d AM	301	unsigned long flags;
3fa97c9d AM	302
36f57413 AM	303	if (!up)
	304	return;
	305
3fa97c9d	306	local_irq_save(flags);
5cb350ba DG	307	if (atomic_dec_and_lock(&up->__count, &uidhash_lock))
	308	free_user(up, flags);
	309	else
36f57413	310	local_irq_restore(flags);
1da177e4 LT	311	}
1da177e4 LT	312
acce292c	313	struct user_struct * alloc_uid(struct user_namespace *ns, uid_t uid)
1da177e4	314	{
735de223	315	struct hlist_head *hashent = uidhashentry(ns, uid);
1da177e4 LT	316	struct user_struct *up;
1da177e4 LT	317
5cb350ba DG	318	/* Make uid_hash_find() + user_kobject_create() + uid_hash_insert()
	319	* atomic.
	320	*/
	321	uids_mutex_lock();
	322
3fa97c9d	323	spin_lock_irq(&uidhash_lock);
1da177e4	324	up = uid_hash_find(uid, hashent);
3fa97c9d	325	spin_unlock_irq(&uidhash_lock);
1da177e4 LT	326
	327	if (!up) {
	328	struct user_struct *new;
	329
e94b1766	330	new = kmem_cache_alloc(uid_cachep, GFP_KERNEL);
1da177e4 LT	331	if (!new)
	332	return NULL;
	333	new->uid = uid;
	334	atomic_set(&new->__count, 1);
	335	atomic_set(&new->processes, 0);
	336	atomic_set(&new->files, 0);
	337	atomic_set(&new->sigpending, 0);
2d9048e2	338	#ifdef CONFIG_INOTIFY_USER
0eeca283 RL	339	atomic_set(&new->inotify_watches, 0);
	340	atomic_set(&new->inotify_devs, 0);
	341	#endif
1da177e4 LT	342
	343	new->mq_bytes = 0;
	344	new->locked_shm = 0;
	345
d720024e	346	if (alloc_uid_keyring(new, current) < 0) {
1da177e4 LT	347	kmem_cache_free(uid_cachep, new);
	348	return NULL;
	349	}
	350
24e377a8 SV	351	if (sched_create_user(new) < 0) {
	352	key_put(new->uid_keyring);
	353	key_put(new->session_keyring);
	354	kmem_cache_free(uid_cachep, new);
	355	return NULL;
	356	}
	357
5cb350ba DG	358	if (user_kobject_create(new)) {
	359	sched_destroy_user(new);
	360	key_put(new->uid_keyring);
	361	key_put(new->session_keyring);
	362	kmem_cache_free(uid_cachep, new);
	363	uids_mutex_unlock();
	364	return NULL;
	365	}
	366
1da177e4 LT	367	/*
	368	* Before adding this, check whether we raced
	369	* on adding the same user already..
	370	*/
3fa97c9d	371	spin_lock_irq(&uidhash_lock);
1da177e4 LT	372	up = uid_hash_find(uid, hashent);
1da177e4 LT	373	if (up) {
5cb350ba DG	374	/* This case is not possible when CONFIG_FAIR_USER_SCHED
	375	* is defined, since we serialize alloc_uid() using
	376	* uids_mutex. Hence no need to call
	377	* sched_destroy_user() or remove_user_sysfs_dir().
	378	*/
1da177e4 LT	379	key_put(new->uid_keyring);
	380	key_put(new->session_keyring);
	381	kmem_cache_free(uid_cachep, new);
	382	} else {
	383	uid_hash_insert(new, hashent);
	384	up = new;
	385	}
3fa97c9d	386	spin_unlock_irq(&uidhash_lock);
1da177e4 LT	387
1da177e4 LT	388	}
5cb350ba DG	389
	390	uids_mutex_unlock();
	391
1da177e4 LT	392	return up;
	393	}
	394
	395	void switch_uid(struct user_struct *new_user)
	396	{
	397	struct user_struct *old_user;
	398
	399	/* What if a process setreuid()'s and this brings the
	400	* new uid over his NPROC rlimit? We can check this now
	401	* cheaply with the new uid cache, so if it matters
	402	* we should be checking for it. -DaveM
	403	*/
	404	old_user = current->user;
	405	atomic_inc(&new_user->processes);
	406	atomic_dec(&old_user->processes);
	407	switch_uid_keyring(new_user);
	408	current->user = new_user;
24e377a8	409	sched_switch_user(current);
45c18b0b LT	410
	411	/*
	412	* We need to synchronize with __sigqueue_alloc()
	413	* doing a get_uid(p->user).. If that saw the old
	414	* user value, we need to wait until it has exited
	415	* its critical region before we can free the old
	416	* structure.
	417	*/
	418	smp_mb();
	419	spin_unlock_wait(&current->sighand->siglock);
	420
1da177e4 LT	421	free_uid(old_user);
	422	suid_keys(current);
	423	}
	424
28f300d2 PE	425	void release_uids(struct user_namespace *ns)
	426	{
	427	int i;
	428	unsigned long flags;
	429	struct hlist_head *head;
	430	struct hlist_node *nd;
	431
	432	spin_lock_irqsave(&uidhash_lock, flags);
	433	/*
	434	* collapse the chains so that the user_struct-s will
	435	* be still alive, but not in hashes. subsequent free_uid()
	436	* will free them.
	437	*/
	438	for (i = 0; i < UIDHASH_SZ; i++) {
	439	head = ns->uidhash_table + i;
	440	while (!hlist_empty(head)) {
	441	nd = head->first;
	442	hlist_del_init(nd);
	443	}
	444	}
	445	spin_unlock_irqrestore(&uidhash_lock, flags);
	446
	447	free_uid(ns->root_user);
	448	}
1da177e4 LT	449
	450	static int __init uid_cache_init(void)
	451	{
	452	int n;
	453
	454	uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
20c2df83	455	0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL);
1da177e4 LT	456
1da177e4 LT	457	for(n = 0; n < UIDHASH_SZ; ++n)
735de223	458	INIT_HLIST_HEAD(init_user_ns.uidhash_table + n);
1da177e4 LT	459
1da177e4 LT	460	/* Insert the root user immediately (init already runs as root) */
3fa97c9d	461	spin_lock_irq(&uidhash_lock);
acce292c	462	uid_hash_insert(&root_user, uidhashentry(&init_user_ns, 0));
3fa97c9d	463	spin_unlock_irq(&uidhash_lock);
1da177e4 LT	464
	465	return 0;
	466	}
	467
	468	module_init(uid_cache_init);