[mirror_ubuntu-zesty-kernel.git] / kernel / ucount.c

/*
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation, version 2 of the
 *  License.
 */

#include <linux/stat.h>
#include <linux/sysctl.h>
#include <linux/slab.h>
#include <linux/hash.h>
#include <linux/user_namespace.h>

#define UCOUNTS_HASHTABLE_BITS 10
static struct hlist_head ucounts_hashtable[(1 << UCOUNTS_HASHTABLE_BITS)];
static DEFINE_SPINLOCK(ucounts_lock);

#define ucounts_hashfn(ns, uid)						\
	hash_long((unsigned long)__kuid_val(uid) + (unsigned long)(ns), \
		  UCOUNTS_HASHTABLE_BITS)
#define ucounts_hashentry(ns, uid)	\
	(ucounts_hashtable + ucounts_hashfn(ns, uid))


#ifdef CONFIG_SYSCTL
static struct ctl_table_set *
set_lookup(struct ctl_table_root *root)
{
	return &current_user_ns()->set;
}

static int set_is_seen(struct ctl_table_set *set)
{
	return &current_user_ns()->set == set;
}

static int set_permissions(struct ctl_table_header *head,
				  struct ctl_table *table)
{
	struct user_namespace *user_ns =
		container_of(head->set, struct user_namespace, set);
	int mode;

	/* Allow users with CAP_SYS_RESOURCE unrestrained access */
	if (ns_capable(user_ns, CAP_SYS_RESOURCE))
		mode = (table->mode & S_IRWXU) >> 6;
	else
	/* Allow all others at most read-only access */
		mode = table->mode & S_IROTH;
	return (mode << 6) | (mode << 3) | mode;
}

static struct ctl_table_root set_root = {
	.lookup = set_lookup,
	.permissions = set_permissions,
};

static int zero = 0;
static int int_max = INT_MAX;
#define UCOUNT_ENTRY(name) 				\
	{						\
		.procname	= name,			\
		.maxlen		= sizeof(int),		\
		.mode		= 0644,			\
		.proc_handler	= proc_dointvec_minmax,	\
		.extra1		= &zero,		\
		.extra2		= &int_max,		\
	}
static struct ctl_table user_table[] = {
	UCOUNT_ENTRY("max_user_namespaces"),
	UCOUNT_ENTRY("max_pid_namespaces"),
	UCOUNT_ENTRY("max_uts_namespaces"),
	UCOUNT_ENTRY("max_ipc_namespaces"),
	UCOUNT_ENTRY("max_net_namespaces"),
	UCOUNT_ENTRY("max_mnt_namespaces"),
	UCOUNT_ENTRY("max_cgroup_namespaces"),
	{ }
};
#endif /* CONFIG_SYSCTL */

bool setup_userns_sysctls(struct user_namespace *ns)
{
#ifdef CONFIG_SYSCTL
	struct ctl_table *tbl;
	setup_sysctl_set(&ns->set, &set_root, set_is_seen);
	tbl = kmemdup(user_table, sizeof(user_table), GFP_KERNEL);
	if (tbl) {
		int i;
		for (i = 0; i < UCOUNT_COUNTS; i++) {
			tbl[i].data = &ns->ucount_max[i];
		}
		ns->sysctls = __register_sysctl_table(&ns->set, "user", tbl);
	}
	if (!ns->sysctls) {
		kfree(tbl);
		retire_sysctl_set(&ns->set);
		return false;
	}
#endif
	return true;
}

void retire_userns_sysctls(struct user_namespace *ns)
{
#ifdef CONFIG_SYSCTL
	struct ctl_table *tbl;

	tbl = ns->sysctls->ctl_table_arg;
	unregister_sysctl_table(ns->sysctls);
	retire_sysctl_set(&ns->set);
	kfree(tbl);
#endif
}

static struct ucounts *find_ucounts(struct user_namespace *ns, kuid_t uid, struct hlist_head *hashent)
{
	struct ucounts *ucounts;

	hlist_for_each_entry(ucounts, hashent, node) {
		if (uid_eq(ucounts->uid, uid) && (ucounts->ns == ns))
			return ucounts;
	}
	return NULL;
}

static struct ucounts *get_ucounts(struct user_namespace *ns, kuid_t uid)
{
	struct hlist_head *hashent = ucounts_hashentry(ns, uid);
	struct ucounts *ucounts, *new;

	spin_lock_irq(&ucounts_lock);
	ucounts = find_ucounts(ns, uid, hashent);
	if (!ucounts) {
		spin_unlock_irq(&ucounts_lock);

		new = kzalloc(sizeof(*new), GFP_KERNEL);
		if (!new)
			return NULL;

		new->ns = ns;
		new->uid = uid;
		atomic_set(&new->count, 0);

		spin_lock_irq(&ucounts_lock);
		ucounts = find_ucounts(ns, uid, hashent);
		if (ucounts) {
			kfree(new);
		} else {
			hlist_add_head(&new->node, hashent);
			ucounts = new;
		}
	}
	if (!atomic_add_unless(&ucounts->count, 1, INT_MAX))
		ucounts = NULL;
	spin_unlock_irq(&ucounts_lock);
	return ucounts;
}

static void put_ucounts(struct ucounts *ucounts)
{
	unsigned long flags;

	if (atomic_dec_and_test(&ucounts->count)) {
		spin_lock_irqsave(&ucounts_lock, flags);
		hlist_del_init(&ucounts->node);
		spin_unlock_irqrestore(&ucounts_lock, flags);

		kfree(ucounts);
	}
}

static inline bool atomic_inc_below(atomic_t *v, int u)
{
	int c, old;
	c = atomic_read(v);
	for (;;) {
		if (unlikely(c >= u))
			return false;
		old = atomic_cmpxchg(v, c, c+1);
		if (likely(old == c))
			return true;
		c = old;
	}
}

struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid,
			   enum ucount_type type)
{
	struct ucounts *ucounts, *iter, *bad;
	struct user_namespace *tns;
	ucounts = get_ucounts(ns, uid);
	for (iter = ucounts; iter; iter = tns->ucounts) {
		int max;
		tns = iter->ns;
		max = READ_ONCE(tns->ucount_max[type]);
		if (!atomic_inc_below(&iter->ucount[type], max))
			goto fail;
	}
	return ucounts;
fail:
	bad = iter;
	for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)
		atomic_dec(&iter->ucount[type]);

	put_ucounts(ucounts);
	return NULL;
}

void dec_ucount(struct ucounts *ucounts, enum ucount_type type)
{
	struct ucounts *iter;
	for (iter = ucounts; iter; iter = iter->ns->ucounts) {
		int dec = atomic_dec_if_positive(&iter->ucount[type]);
		WARN_ON_ONCE(dec < 0);
	}
	put_ucounts(ucounts);
}

static __init int user_namespace_sysctl_init(void)
{
#ifdef CONFIG_SYSCTL
	static struct ctl_table_header *user_header;
	static struct ctl_table empty[1];
	/*
	 * It is necessary to register the user directory in the
	 * default set so that registrations in the child sets work
	 * properly.
	 */
	user_header = register_sysctl("user", empty);
	kmemleak_ignore(user_header);
	BUG_ON(!user_header);
	BUG_ON(!setup_userns_sysctls(&init_user_ns));
#endif
	return 0;
}
subsys_initcall(user_namespace_sysctl_init);
Commit	Line	Data
dbec2846 EB	1	/*
	2	* This program is free software; you can redistribute it and/or
	3	* modify it under the terms of the GNU General Public License as
	4	* published by the Free Software Foundation, version 2 of the
	5	* License.
	6	*/
	7
	8	#include <linux/stat.h>
	9	#include <linux/sysctl.h>
	10	#include <linux/slab.h>
f6b2db1a	11	#include <linux/hash.h>
dbec2846 EB	12	#include <linux/user_namespace.h>
dbec2846 EB	13
f6b2db1a EB	14	#define UCOUNTS_HASHTABLE_BITS 10
	15	static struct hlist_head ucounts_hashtable[(1 << UCOUNTS_HASHTABLE_BITS)];
	16	static DEFINE_SPINLOCK(ucounts_lock);
	17
	18	#define ucounts_hashfn(ns, uid) \
	19	hash_long((unsigned long)__kuid_val(uid) + (unsigned long)(ns), \
	20	UCOUNTS_HASHTABLE_BITS)
	21	#define ucounts_hashentry(ns, uid) \
	22	(ucounts_hashtable + ucounts_hashfn(ns, uid))
	23
	24
dbec2846 EB	25	#ifdef CONFIG_SYSCTL
	26	static struct ctl_table_set *
	27	set_lookup(struct ctl_table_root *root)
	28	{
	29	return &current_user_ns()->set;
	30	}
	31
	32	static int set_is_seen(struct ctl_table_set *set)
	33	{
	34	return &current_user_ns()->set == set;
	35	}
	36
	37	static int set_permissions(struct ctl_table_header *head,
	38	struct ctl_table *table)
	39	{
	40	struct user_namespace *user_ns =
	41	container_of(head->set, struct user_namespace, set);
	42	int mode;
	43
	44	/* Allow users with CAP_SYS_RESOURCE unrestrained access */
	45	if (ns_capable(user_ns, CAP_SYS_RESOURCE))
	46	mode = (table->mode & S_IRWXU) >> 6;
	47	else
	48	/* Allow all others at most read-only access */
	49	mode = table->mode & S_IROTH;
	50	return (mode << 6) \| (mode << 3) \| mode;
	51	}
	52
	53	static struct ctl_table_root set_root = {
	54	.lookup = set_lookup,
	55	.permissions = set_permissions,
	56	};
	57
b376c3e1 EB	58	static int zero = 0;
b376c3e1 EB	59	static int int_max = INT_MAX;
25f9c081 EB	60	#define UCOUNT_ENTRY(name) \
	61	{ \
	62	.procname = name, \
	63	.maxlen = sizeof(int), \
	64	.mode = 0644, \
	65	.proc_handler = proc_dointvec_minmax, \
	66	.extra1 = &zero, \
	67	.extra2 = &int_max, \
	68	}
f6b2db1a	69	static struct ctl_table user_table[] = {
25f9c081	70	UCOUNT_ENTRY("max_user_namespaces"),
f333c700	71	UCOUNT_ENTRY("max_pid_namespaces"),
f7af3d1c	72	UCOUNT_ENTRY("max_uts_namespaces"),
aba35661	73	UCOUNT_ENTRY("max_ipc_namespaces"),
70328660	74	UCOUNT_ENTRY("max_net_namespaces"),
537f7ccb	75	UCOUNT_ENTRY("max_mnt_namespaces"),
d08311dd	76	UCOUNT_ENTRY("max_cgroup_namespaces"),
dbec2846 EB	77	{ }
	78	};
	79	#endif /* CONFIG_SYSCTL */
	80
	81	bool setup_userns_sysctls(struct user_namespace *ns)
	82	{
	83	#ifdef CONFIG_SYSCTL
	84	struct ctl_table *tbl;
	85	setup_sysctl_set(&ns->set, &set_root, set_is_seen);
f6b2db1a	86	tbl = kmemdup(user_table, sizeof(user_table), GFP_KERNEL);
dbec2846	87	if (tbl) {
25f9c081 EB	88	int i;
	89	for (i = 0; i < UCOUNT_COUNTS; i++) {
	90	tbl[i].data = &ns->ucount_max[i];
	91	}
f6b2db1a	92	ns->sysctls = __register_sysctl_table(&ns->set, "user", tbl);
dbec2846 EB	93	}
	94	if (!ns->sysctls) {
	95	kfree(tbl);
	96	retire_sysctl_set(&ns->set);
	97	return false;
	98	}
	99	#endif
	100	return true;
	101	}
	102
	103	void retire_userns_sysctls(struct user_namespace *ns)
	104	{
	105	#ifdef CONFIG_SYSCTL
	106	struct ctl_table *tbl;
	107
	108	tbl = ns->sysctls->ctl_table_arg;
	109	unregister_sysctl_table(ns->sysctls);
	110	retire_sysctl_set(&ns->set);
	111	kfree(tbl);
	112	#endif
	113	}
	114
f6b2db1a EB	115	static struct ucounts find_ucounts(struct user_namespace ns, kuid_t uid, struct hlist_head *hashent)
	116	{
	117	struct ucounts *ucounts;
	118
	119	hlist_for_each_entry(ucounts, hashent, node) {
	120	if (uid_eq(ucounts->uid, uid) && (ucounts->ns == ns))
	121	return ucounts;
	122	}
	123	return NULL;
	124	}
	125
	126	static struct ucounts get_ucounts(struct user_namespace ns, kuid_t uid)
	127	{
	128	struct hlist_head *hashent = ucounts_hashentry(ns, uid);
	129	struct ucounts ucounts, new;
	130
880a3854	131	spin_lock_irq(&ucounts_lock);
f6b2db1a EB	132	ucounts = find_ucounts(ns, uid, hashent);
f6b2db1a EB	133	if (!ucounts) {
880a3854	134	spin_unlock_irq(&ucounts_lock);
f6b2db1a EB	135
	136	new = kzalloc(sizeof(*new), GFP_KERNEL);
	137	if (!new)
	138	return NULL;
	139
	140	new->ns = ns;
	141	new->uid = uid;
	142	atomic_set(&new->count, 0);
	143
880a3854	144	spin_lock_irq(&ucounts_lock);
f6b2db1a EB	145	ucounts = find_ucounts(ns, uid, hashent);
	146	if (ucounts) {
	147	kfree(new);
	148	} else {
	149	hlist_add_head(&new->node, hashent);
	150	ucounts = new;
	151	}
	152	}
	153	if (!atomic_add_unless(&ucounts->count, 1, INT_MAX))
	154	ucounts = NULL;
880a3854	155	spin_unlock_irq(&ucounts_lock);
f6b2db1a EB	156	return ucounts;
	157	}
	158
	159	static void put_ucounts(struct ucounts *ucounts)
	160	{
880a3854 NB	161	unsigned long flags;
880a3854 NB	162
f6b2db1a	163	if (atomic_dec_and_test(&ucounts->count)) {
880a3854	164	spin_lock_irqsave(&ucounts_lock, flags);
f6b2db1a	165	hlist_del_init(&ucounts->node);
880a3854	166	spin_unlock_irqrestore(&ucounts_lock, flags);
f6b2db1a EB	167
	168	kfree(ucounts);
	169	}
	170	}
	171
b376c3e1 EB	172	static inline bool atomic_inc_below(atomic_t *v, int u)
	173	{
	174	int c, old;
	175	c = atomic_read(v);
	176	for (;;) {
	177	if (unlikely(c >= u))
	178	return false;
	179	old = atomic_cmpxchg(v, c, c+1);
	180	if (likely(old == c))
	181	return true;
	182	c = old;
	183	}
	184	}
	185
25f9c081 EB	186	struct ucounts inc_ucount(struct user_namespace ns, kuid_t uid,
25f9c081 EB	187	enum ucount_type type)
b376c3e1	188	{
f6b2db1a EB	189	struct ucounts ucounts, iter, *bad;
	190	struct user_namespace *tns;
	191	ucounts = get_ucounts(ns, uid);
	192	for (iter = ucounts; iter; iter = tns->ucounts) {
	193	int max;
	194	tns = iter->ns;
25f9c081 EB	195	max = READ_ONCE(tns->ucount_max[type]);
25f9c081 EB	196	if (!atomic_inc_below(&iter->ucount[type], max))
b376c3e1 EB	197	goto fail;
b376c3e1 EB	198	}
f6b2db1a	199	return ucounts;
b376c3e1	200	fail:
f6b2db1a EB	201	bad = iter;
f6b2db1a EB	202	for (iter = ucounts; iter != bad; iter = iter->ns->ucounts)
25f9c081	203	atomic_dec(&iter->ucount[type]);
b376c3e1	204
f6b2db1a EB	205	put_ucounts(ucounts);
f6b2db1a EB	206	return NULL;
b376c3e1 EB	207	}
b376c3e1 EB	208
25f9c081	209	void dec_ucount(struct ucounts *ucounts, enum ucount_type type)
b376c3e1	210	{
f6b2db1a EB	211	struct ucounts *iter;
f6b2db1a EB	212	for (iter = ucounts; iter; iter = iter->ns->ucounts) {
25f9c081	213	int dec = atomic_dec_if_positive(&iter->ucount[type]);
b376c3e1 EB	214	WARN_ON_ONCE(dec < 0);
b376c3e1 EB	215	}
f6b2db1a	216	put_ucounts(ucounts);
b376c3e1 EB	217	}
b376c3e1 EB	218
dbec2846 EB	219	static __init int user_namespace_sysctl_init(void)
	220	{
	221	#ifdef CONFIG_SYSCTL
f6b2db1a	222	static struct ctl_table_header *user_header;
dbec2846 EB	223	static struct ctl_table empty[1];
dbec2846 EB	224	/*
f6b2db1a	225	* It is necessary to register the user directory in the
dbec2846 EB	226	* default set so that registrations in the child sets work
	227	* properly.
	228	*/
f6b2db1a	229	user_header = register_sysctl("user", empty);
ed5bd7dc	230	kmemleak_ignore(user_header);
f6b2db1a	231	BUG_ON(!user_header);
dbec2846 EB	232	BUG_ON(!setup_userns_sysctls(&init_user_ns));
	233	#endif
	234	return 0;
	235	}
	236	subsys_initcall(user_namespace_sysctl_init);