[mirror_ubuntu-bionic-kernel.git] / net / core / netprio_cgroup.c

/*
 * net/core/netprio_cgroup.c	Priority Control Group
 *
 *		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; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	Neil Horman <nhorman@tuxdriver.com>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <linux/cgroup.h>
#include <linux/rcupdate.h>
#include <linux/atomic.h>
#include <net/rtnetlink.h>
#include <net/pkt_cls.h>
#include <net/sock.h>
#include <net/netprio_cgroup.h>

#include <linux/fdtable.h>

#define PRIOMAP_MIN_SZ		128

static inline struct cgroup_netprio_state *cgrp_netprio_state(struct cgroup *cgrp)
{
	return container_of(cgroup_subsys_state(cgrp, net_prio_subsys_id),
			    struct cgroup_netprio_state, css);
}

/*
 * Extend @dev->priomap so that it's large enough to accomodate
 * @target_idx.  @dev->priomap.priomap_len > @target_idx after successful
 * return.  Must be called under rtnl lock.
 */
static int extend_netdev_table(struct net_device *dev, u32 target_idx)
{
	struct netprio_map *old, *new;
	size_t new_sz, new_len;

	/* is the existing priomap large enough? */
	old = rtnl_dereference(dev->priomap);
	if (old && old->priomap_len > target_idx)
		return 0;

	/*
	 * Determine the new size.  Let's keep it power-of-two.  We start
	 * from PRIOMAP_MIN_SZ and double it until it's large enough to
	 * accommodate @target_idx.
	 */
	new_sz = PRIOMAP_MIN_SZ;
	while (true) {
		new_len = (new_sz - offsetof(struct netprio_map, priomap)) /
			sizeof(new->priomap[0]);
		if (new_len > target_idx)
			break;
		new_sz *= 2;
		/* overflowed? */
		if (WARN_ON(new_sz < PRIOMAP_MIN_SZ))
			return -ENOSPC;
	}

	/* allocate & copy */
	new = kzalloc(new_sz, GFP_KERNEL);
	if (!new) {
		pr_warn("Unable to alloc new priomap!\n");
		return -ENOMEM;
	}

	if (old)
		memcpy(new->priomap, old->priomap,
		       old->priomap_len * sizeof(old->priomap[0]));

	new->priomap_len = new_len;

	/* install the new priomap */
	rcu_assign_pointer(dev->priomap, new);
	if (old)
		kfree_rcu(old, rcu);
	return 0;
}

/**
 * netprio_prio - return the effective netprio of a cgroup-net_device pair
 * @cgrp: cgroup part of the target pair
 * @dev: net_device part of the target pair
 *
 * Should be called under RCU read or rtnl lock.
 */
static u32 netprio_prio(struct cgroup *cgrp, struct net_device *dev)
{
	struct netprio_map *map = rcu_dereference_rtnl(dev->priomap);

	if (map && cgrp->id < map->priomap_len)
		return map->priomap[cgrp->id];
	return 0;
}

/**
 * netprio_set_prio - set netprio on a cgroup-net_device pair
 * @cgrp: cgroup part of the target pair
 * @dev: net_device part of the target pair
 * @prio: prio to set
 *
 * Set netprio to @prio on @cgrp-@dev pair.  Should be called under rtnl
 * lock and may fail under memory pressure for non-zero @prio.
 */
static int netprio_set_prio(struct cgroup *cgrp, struct net_device *dev,
			    u32 prio)
{
	struct netprio_map *map;
	int ret;

	/* avoid extending priomap for zero writes */
	map = rtnl_dereference(dev->priomap);
	if (!prio && (!map || map->priomap_len <= cgrp->id))
		return 0;

	ret = extend_netdev_table(dev, cgrp->id);
	if (ret)
		return ret;

	map = rtnl_dereference(dev->priomap);
	map->priomap[cgrp->id] = prio;
	return 0;
}

static struct cgroup_subsys_state *cgrp_css_alloc(struct cgroup *cgrp)
{
	struct cgroup_netprio_state *cs;

	if (cgrp->parent && cgrp->parent->id)
		return ERR_PTR(-EINVAL);

	cs = kzalloc(sizeof(*cs), GFP_KERNEL);
	if (!cs)
		return ERR_PTR(-ENOMEM);

	return &cs->css;
}

static void cgrp_css_free(struct cgroup *cgrp)
{
	struct cgroup_netprio_state *cs = cgrp_netprio_state(cgrp);
	struct net_device *dev;

	rtnl_lock();
	for_each_netdev(&init_net, dev)
		WARN_ON_ONCE(netprio_set_prio(cgrp, dev, 0));
	rtnl_unlock();
	kfree(cs);
}

static u64 read_prioidx(struct cgroup *cgrp, struct cftype *cft)
{
	return cgrp->id;
}

static int read_priomap(struct cgroup *cont, struct cftype *cft,
			struct cgroup_map_cb *cb)
{
	struct net_device *dev;

	rcu_read_lock();
	for_each_netdev_rcu(&init_net, dev)
		cb->fill(cb, dev->name, netprio_prio(cont, dev));
	rcu_read_unlock();
	return 0;
}

static int write_priomap(struct cgroup *cgrp, struct cftype *cft,
			 const char *buffer)
{
	char devname[IFNAMSIZ + 1];
	struct net_device *dev;
	u32 prio;
	int ret;

	if (sscanf(buffer, "%"__stringify(IFNAMSIZ)"s %u", devname, &prio) != 2)
		return -EINVAL;

	dev = dev_get_by_name(&init_net, devname);
	if (!dev)
		return -ENODEV;

	rtnl_lock();

	ret = netprio_set_prio(cgrp, dev, prio);

	rtnl_unlock();
	dev_put(dev);
	return ret;
}

static int update_netprio(const void *v, struct file *file, unsigned n)
{
	int err;
	struct socket *sock = sock_from_file(file, &err);
	if (sock)
		sock->sk->sk_cgrp_prioidx = (u32)(unsigned long)v;
	return 0;
}

void net_prio_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)
{
	struct task_struct *p;
	void *v;

	cgroup_taskset_for_each(p, cgrp, tset) {
		task_lock(p);
		v = (void *)(unsigned long)task_netprioidx(p);
		iterate_fd(p->files, 0, update_netprio, v);
		task_unlock(p);
	}
}

static struct cftype ss_files[] = {
	{
		.name = "prioidx",
		.read_u64 = read_prioidx,
	},
	{
		.name = "ifpriomap",
		.read_map = read_priomap,
		.write_string = write_priomap,
	},
	{ }	/* terminate */
};

struct cgroup_subsys net_prio_subsys = {
	.name		= "net_prio",
	.css_alloc	= cgrp_css_alloc,
	.css_free	= cgrp_css_free,
	.attach		= net_prio_attach,
	.subsys_id	= net_prio_subsys_id,
	.base_cftypes	= ss_files,
	.module		= THIS_MODULE,

	/*
	 * net_prio has artificial limit on the number of cgroups and
	 * disallows nesting making it impossible to co-mount it with other
	 * hierarchical subsystems.  Remove the artificially low PRIOIDX_SZ
	 * limit and properly nest configuration such that children follow
	 * their parents' configurations by default and are allowed to
	 * override and remove the following.
	 */
	.broken_hierarchy = true,
};

static int netprio_device_event(struct notifier_block *unused,
				unsigned long event, void *ptr)
{
	struct net_device *dev = ptr;
	struct netprio_map *old;

	/*
	 * Note this is called with rtnl_lock held so we have update side
	 * protection on our rcu assignments
	 */

	switch (event) {
	case NETDEV_UNREGISTER:
		old = rtnl_dereference(dev->priomap);
		RCU_INIT_POINTER(dev->priomap, NULL);
		if (old)
			kfree_rcu(old, rcu);
		break;
	}
	return NOTIFY_DONE;
}

static struct notifier_block netprio_device_notifier = {
	.notifier_call = netprio_device_event
};

static int __init init_cgroup_netprio(void)
{
	int ret;

	ret = cgroup_load_subsys(&net_prio_subsys);
	if (ret)
		goto out;

	register_netdevice_notifier(&netprio_device_notifier);

out:
	return ret;
}

static void __exit exit_cgroup_netprio(void)
{
	struct netprio_map *old;
	struct net_device *dev;

	unregister_netdevice_notifier(&netprio_device_notifier);

	cgroup_unload_subsys(&net_prio_subsys);

	rtnl_lock();
	for_each_netdev(&init_net, dev) {
		old = rtnl_dereference(dev->priomap);
		RCU_INIT_POINTER(dev->priomap, NULL);
		if (old)
			kfree_rcu(old, rcu);
	}
	rtnl_unlock();
}

module_init(init_cgroup_netprio);
module_exit(exit_cgroup_netprio);
MODULE_LICENSE("GPL v2");
Commit	Line	Data
5bc1421e NH	1	/*
	2	* net/core/netprio_cgroup.c Priority Control Group
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: Neil Horman <nhorman@tuxdriver.com>
	10	*/
	11
e005d193 JP	12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
e005d193 JP	13
5bc1421e NH	14	#include <linux/module.h>
	15	#include <linux/slab.h>
	16	#include <linux/types.h>
	17	#include <linux/string.h>
	18	#include <linux/errno.h>
	19	#include <linux/skbuff.h>
	20	#include <linux/cgroup.h>
	21	#include <linux/rcupdate.h>
	22	#include <linux/atomic.h>
	23	#include <net/rtnetlink.h>
	24	#include <net/pkt_cls.h>
	25	#include <net/sock.h>
	26	#include <net/netprio_cgroup.h>
	27
406a3c63 JF	28	#include <linux/fdtable.h>
406a3c63 JF	29
4a6ee25c	30	#define PRIOMAP_MIN_SZ 128
5bc1421e NH	31
	32	static inline struct cgroup_netprio_state cgrp_netprio_state(struct cgroup cgrp)
	33	{
	34	return container_of(cgroup_subsys_state(cgrp, net_prio_subsys_id),
	35	struct cgroup_netprio_state, css);
	36	}
	37
4a6ee25c TH	38	/*
	39	* Extend @dev->priomap so that it's large enough to accomodate
	40	* @target_idx. @dev->priomap.priomap_len > @target_idx after successful
	41	* return. Must be called under rtnl lock.
	42	*/
	43	static int extend_netdev_table(struct net_device *dev, u32 target_idx)
5bc1421e	44	{
4a6ee25c TH	45	struct netprio_map old, new;
4a6ee25c TH	46	size_t new_sz, new_len;
5bc1421e	47
4a6ee25c	48	/* is the existing priomap large enough? */
52bca930	49	old = rtnl_dereference(dev->priomap);
4a6ee25c TH	50	if (old && old->priomap_len > target_idx)
	51	return 0;
	52
	53	/*
	54	* Determine the new size. Let's keep it power-of-two. We start
	55	* from PRIOMAP_MIN_SZ and double it until it's large enough to
	56	* accommodate @target_idx.
	57	*/
	58	new_sz = PRIOMAP_MIN_SZ;
	59	while (true) {
	60	new_len = (new_sz - offsetof(struct netprio_map, priomap)) /
	61	sizeof(new->priomap[0]);
	62	if (new_len > target_idx)
	63	break;
	64	new_sz *= 2;
	65	/* overflowed? */
	66	if (WARN_ON(new_sz < PRIOMAP_MIN_SZ))
	67	return -ENOSPC;
	68	}
5bc1421e	69
4a6ee25c TH	70	/* allocate & copy */
4a6ee25c TH	71	new = kzalloc(new_sz, GFP_KERNEL);
52bca930	72	if (!new) {
e005d193	73	pr_warn("Unable to alloc new priomap!\n");
ef209f15	74	return -ENOMEM;
5bc1421e NH	75	}
5bc1421e NH	76
52bca930 TH	77	if (old)
	78	memcpy(new->priomap, old->priomap,
	79	old->priomap_len * sizeof(old->priomap[0]));
5bc1421e	80
52bca930	81	new->priomap_len = new_len;
5bc1421e	82
4a6ee25c	83	/* install the new priomap */
52bca930 TH	84	rcu_assign_pointer(dev->priomap, new);
	85	if (old)
	86	kfree_rcu(old, rcu);
ef209f15 G	87	return 0;
	88	}
	89
666b0ebe TH	90	/**
	91	* netprio_prio - return the effective netprio of a cgroup-net_device pair
	92	* @cgrp: cgroup part of the target pair
	93	* @dev: net_device part of the target pair
	94	*
	95	* Should be called under RCU read or rtnl lock.
	96	*/
	97	static u32 netprio_prio(struct cgroup cgrp, struct net_device dev)
	98	{
	99	struct netprio_map *map = rcu_dereference_rtnl(dev->priomap);
	100
	101	if (map && cgrp->id < map->priomap_len)
	102	return map->priomap[cgrp->id];
	103	return 0;
	104	}
	105
	106	/**
	107	* netprio_set_prio - set netprio on a cgroup-net_device pair
	108	* @cgrp: cgroup part of the target pair
	109	* @dev: net_device part of the target pair
	110	* @prio: prio to set
	111	*
	112	* Set netprio to @prio on @cgrp-@dev pair. Should be called under rtnl
	113	* lock and may fail under memory pressure for non-zero @prio.
	114	*/
	115	static int netprio_set_prio(struct cgroup cgrp, struct net_device dev,
	116	u32 prio)
	117	{
	118	struct netprio_map *map;
	119	int ret;
	120
	121	/* avoid extending priomap for zero writes */
	122	map = rtnl_dereference(dev->priomap);
	123	if (!prio && (!map \|\| map->priomap_len <= cgrp->id))
	124	return 0;
	125
	126	ret = extend_netdev_table(dev, cgrp->id);
	127	if (ret)
	128	return ret;
	129
	130	map = rtnl_dereference(dev->priomap);
	131	map->priomap[cgrp->id] = prio;
	132	return 0;
	133	}
	134
92fb9748	135	static struct cgroup_subsys_state cgrp_css_alloc(struct cgroup cgrp)
5bc1421e NH	136	{
5bc1421e NH	137	struct cgroup_netprio_state *cs;
88d642fa TH	138
	139	if (cgrp->parent && cgrp->parent->id)
	140	return ERR_PTR(-EINVAL);
5bc1421e NH	141
	142	cs = kzalloc(sizeof(*cs), GFP_KERNEL);
	143	if (!cs)
	144	return ERR_PTR(-ENOMEM);
	145
5bc1421e NH	146	return &cs->css;
	147	}
	148
92fb9748	149	static void cgrp_css_free(struct cgroup *cgrp)
5bc1421e	150	{
88d642fa	151	struct cgroup_netprio_state *cs = cgrp_netprio_state(cgrp);
5bc1421e	152	struct net_device *dev;
5bc1421e	153
5bc1421e	154	rtnl_lock();
666b0ebe TH	155	for_each_netdev(&init_net, dev)
666b0ebe TH	156	WARN_ON_ONCE(netprio_set_prio(cgrp, dev, 0));
5bc1421e	157	rtnl_unlock();
5bc1421e NH	158	kfree(cs);
	159	}
	160
	161	static u64 read_prioidx(struct cgroup cgrp, struct cftype cft)
	162	{
88d642fa	163	return cgrp->id;
5bc1421e NH	164	}
	165
	166	static int read_priomap(struct cgroup cont, struct cftype cft,
	167	struct cgroup_map_cb *cb)
	168	{
	169	struct net_device *dev;
5bc1421e NH	170
5bc1421e NH	171	rcu_read_lock();
666b0ebe TH	172	for_each_netdev_rcu(&init_net, dev)
666b0ebe TH	173	cb->fill(cb, dev->name, netprio_prio(cont, dev));
5bc1421e NH	174	rcu_read_unlock();
	175	return 0;
	176	}
	177
	178	static int write_priomap(struct cgroup cgrp, struct cftype cft,
	179	const char *buffer)
	180	{
6d5759dd	181	char devname[IFNAMSIZ + 1];
5bc1421e	182	struct net_device *dev;
6d5759dd TH	183	u32 prio;
6d5759dd TH	184	int ret;
5bc1421e	185
6d5759dd TH	186	if (sscanf(buffer, "%"__stringify(IFNAMSIZ)"s %u", devname, &prio) != 2)
6d5759dd TH	187	return -EINVAL;
5bc1421e NH	188
	189	dev = dev_get_by_name(&init_net, devname);
	190	if (!dev)
6d5759dd	191	return -ENODEV;
5bc1421e	192
476ad154	193	rtnl_lock();
6d5759dd	194
666b0ebe	195	ret = netprio_set_prio(cgrp, dev, prio);
ef209f15	196
476ad154	197	rtnl_unlock();
5bc1421e	198	dev_put(dev);
5bc1421e NH	199	return ret;
	200	}
	201
c3c073f8 AV	202	static int update_netprio(const void v, struct file file, unsigned n)
	203	{
	204	int err;
	205	struct socket *sock = sock_from_file(file, &err);
	206	if (sock)
	207	sock->sk->sk_cgrp_prioidx = (u32)(unsigned long)v;
	208	return 0;
	209	}
	210
406a3c63 JF	211	void net_prio_attach(struct cgroup cgrp, struct cgroup_taskset tset)
	212	{
	213	struct task_struct *p;
c3c073f8	214	void *v;
406a3c63 JF	215
406a3c63 JF	216	cgroup_taskset_for_each(p, cgrp, tset) {
406a3c63	217	task_lock(p);
c3c073f8 AV	218	v = (void *)(unsigned long)task_netprioidx(p);
c3c073f8 AV	219	iterate_fd(p->files, 0, update_netprio, v);
406a3c63 JF	220	task_unlock(p);
406a3c63 JF	221	}
406a3c63 JF	222	}
406a3c63 JF	223
5bc1421e NH	224	static struct cftype ss_files[] = {
	225	{
	226	.name = "prioidx",
	227	.read_u64 = read_prioidx,
	228	},
	229	{
	230	.name = "ifpriomap",
	231	.read_map = read_priomap,
	232	.write_string = write_priomap,
	233	},
4baf6e33	234	{ } /* terminate */
5bc1421e NH	235	};
5bc1421e NH	236
676f7c8f TH	237	struct cgroup_subsys net_prio_subsys = {
676f7c8f TH	238	.name = "net_prio",
92fb9748 TH	239	.css_alloc = cgrp_css_alloc,
92fb9748 TH	240	.css_free = cgrp_css_free,
406a3c63	241	.attach = net_prio_attach,
676f7c8f	242	.subsys_id = net_prio_subsys_id,
4baf6e33	243	.base_cftypes = ss_files,
8c7f6edb TH	244	.module = THIS_MODULE,
	245
	246	/*
	247	* net_prio has artificial limit on the number of cgroups and
	248	* disallows nesting making it impossible to co-mount it with other
	249	* hierarchical subsystems. Remove the artificially low PRIOIDX_SZ
	250	* limit and properly nest configuration such that children follow
	251	* their parents' configurations by default and are allowed to
	252	* override and remove the following.
	253	*/
	254	.broken_hierarchy = true,
676f7c8f	255	};
5bc1421e NH	256
	257	static int netprio_device_event(struct notifier_block *unused,
	258	unsigned long event, void *ptr)
	259	{
	260	struct net_device *dev = ptr;
	261	struct netprio_map *old;
5bc1421e NH	262
	263	/*
	264	* Note this is called with rtnl_lock held so we have update side
	265	* protection on our rcu assignments
	266	*/
	267
	268	switch (event) {
5bc1421e NH	269	case NETDEV_UNREGISTER:
5bc1421e NH	270	old = rtnl_dereference(dev->priomap);
2cfa5a04	271	RCU_INIT_POINTER(dev->priomap, NULL);
5bc1421e NH	272	if (old)
	273	kfree_rcu(old, rcu);
	274	break;
	275	}
	276	return NOTIFY_DONE;
	277	}
	278
	279	static struct notifier_block netprio_device_notifier = {
	280	.notifier_call = netprio_device_event
	281	};
	282
	283	static int __init init_cgroup_netprio(void)
	284	{
	285	int ret;
	286
	287	ret = cgroup_load_subsys(&net_prio_subsys);
	288	if (ret)
	289	goto out;
5bc1421e NH	290
	291	register_netdevice_notifier(&netprio_device_notifier);
	292
	293	out:
	294	return ret;
	295	}
	296
	297	static void __exit exit_cgroup_netprio(void)
	298	{
	299	struct netprio_map *old;
	300	struct net_device *dev;
	301
	302	unregister_netdevice_notifier(&netprio_device_notifier);
	303
	304	cgroup_unload_subsys(&net_prio_subsys);
	305
5bc1421e NH	306	rtnl_lock();
	307	for_each_netdev(&init_net, dev) {
	308	old = rtnl_dereference(dev->priomap);
2cfa5a04	309	RCU_INIT_POINTER(dev->priomap, NULL);
5bc1421e NH	310	if (old)
	311	kfree_rcu(old, rcu);
	312	}
	313	rtnl_unlock();
	314	}
	315
	316	module_init(init_cgroup_netprio);
	317	module_exit(exit_cgroup_netprio);
	318	MODULE_LICENSE("GPL v2");