[mirror_ubuntu-artful-kernel.git] / net / core / net_namespace.c

#include <linux/workqueue.h>
#include <linux/rtnetlink.h>
#include <linux/cache.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/idr.h>
#include <linux/rculist.h>
#include <linux/nsproxy.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>

/*
 *	Our network namespace constructor/destructor lists
 */

static LIST_HEAD(pernet_list);
static struct list_head *first_device = &pernet_list;
static DEFINE_MUTEX(net_mutex);

LIST_HEAD(net_namespace_list);
EXPORT_SYMBOL_GPL(net_namespace_list);

struct net init_net;
EXPORT_SYMBOL(init_net);

#define INITIAL_NET_GEN_PTRS	13 /* +1 for len +2 for rcu_head */

/*
 * setup_net runs the initializers for the network namespace object.
 */
static __net_init int setup_net(struct net *net)
{
	/* Must be called with net_mutex held */
	struct pernet_operations *ops;
	int error = 0;

	atomic_set(&net->count, 1);

#ifdef NETNS_REFCNT_DEBUG
	atomic_set(&net->use_count, 0);
#endif

	list_for_each_entry(ops, &pernet_list, list) {
		if (ops->init) {
			error = ops->init(net);
			if (error < 0)
				goto out_undo;
		}
	}
out:
	return error;

out_undo:
	/* Walk through the list backwards calling the exit functions
	 * for the pernet modules whose init functions did not fail.
	 */
	list_for_each_entry_continue_reverse(ops, &pernet_list, list) {
		if (ops->exit)
			ops->exit(net);
	}

	rcu_barrier();
	goto out;
}

static struct net_generic *net_alloc_generic(void)
{
	struct net_generic *ng;
	size_t generic_size = sizeof(struct net_generic) +
		INITIAL_NET_GEN_PTRS * sizeof(void *);

	ng = kzalloc(generic_size, GFP_KERNEL);
	if (ng)
		ng->len = INITIAL_NET_GEN_PTRS;

	return ng;
}

#ifdef CONFIG_NET_NS
static struct kmem_cache *net_cachep;
static struct workqueue_struct *netns_wq;

static struct net *net_alloc(void)
{
	struct net *net = NULL;
	struct net_generic *ng;

	ng = net_alloc_generic();
	if (!ng)
		goto out;

	net = kmem_cache_zalloc(net_cachep, GFP_KERNEL);
	if (!net)
		goto out_free;

	rcu_assign_pointer(net->gen, ng);
out:
	return net;

out_free:
	kfree(ng);
	goto out;
}

static void net_free(struct net *net)
{
#ifdef NETNS_REFCNT_DEBUG
	if (unlikely(atomic_read(&net->use_count) != 0)) {
		printk(KERN_EMERG "network namespace not free! Usage: %d\n",
			atomic_read(&net->use_count));
		return;
	}
#endif
	kfree(net->gen);
	kmem_cache_free(net_cachep, net);
}

static struct net *net_create(void)
{
	struct net *net;
	int rv;

	net = net_alloc();
	if (!net)
		return ERR_PTR(-ENOMEM);
	mutex_lock(&net_mutex);
	rv = setup_net(net);
	if (rv == 0) {
		rtnl_lock();
		list_add_tail_rcu(&net->list, &net_namespace_list);
		rtnl_unlock();
	}
	mutex_unlock(&net_mutex);
	if (rv < 0) {
		net_free(net);
		return ERR_PTR(rv);
	}
	return net;
}

struct net *copy_net_ns(unsigned long flags, struct net *old_net)
{
	if (!(flags & CLONE_NEWNET))
		return get_net(old_net);
	return net_create();
}

static void cleanup_net(struct work_struct *work)
{
	struct pernet_operations *ops;
	struct net *net;

	net = container_of(work, struct net, work);

	mutex_lock(&net_mutex);

	/* Don't let anyone else find us. */
	rtnl_lock();
	list_del_rcu(&net->list);
	rtnl_unlock();

	/*
	 * Another CPU might be rcu-iterating the list, wait for it.
	 * This needs to be before calling the exit() notifiers, so
	 * the rcu_barrier() below isn't sufficient alone.
	 */
	synchronize_rcu();

	/* Run all of the network namespace exit methods */
	list_for_each_entry_reverse(ops, &pernet_list, list) {
		if (ops->exit)
			ops->exit(net);
	}

	mutex_unlock(&net_mutex);

	/* Ensure there are no outstanding rcu callbacks using this
	 * network namespace.
	 */
	rcu_barrier();

	/* Finally it is safe to free my network namespace structure */
	net_free(net);
}

void __put_net(struct net *net)
{
	/* Cleanup the network namespace in process context */
	INIT_WORK(&net->work, cleanup_net);
	queue_work(netns_wq, &net->work);
}
EXPORT_SYMBOL_GPL(__put_net);

#else
struct net *copy_net_ns(unsigned long flags, struct net *old_net)
{
	if (flags & CLONE_NEWNET)
		return ERR_PTR(-EINVAL);
	return old_net;
}
#endif

struct net *get_net_ns_by_pid(pid_t pid)
{
	struct task_struct *tsk;
	struct net *net;

	/* Lookup the network namespace */
	net = ERR_PTR(-ESRCH);
	rcu_read_lock();
	tsk = find_task_by_vpid(pid);
	if (tsk) {
		struct nsproxy *nsproxy;
		nsproxy = task_nsproxy(tsk);
		if (nsproxy)
			net = get_net(nsproxy->net_ns);
	}
	rcu_read_unlock();
	return net;
}
EXPORT_SYMBOL_GPL(get_net_ns_by_pid);

static int __init net_ns_init(void)
{
	struct net_generic *ng;

#ifdef CONFIG_NET_NS
	net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
					SMP_CACHE_BYTES,
					SLAB_PANIC, NULL);

	/* Create workqueue for cleanup */
	netns_wq = create_singlethread_workqueue("netns");
	if (!netns_wq)
		panic("Could not create netns workq");
#endif

	ng = net_alloc_generic();
	if (!ng)
		panic("Could not allocate generic netns");

	rcu_assign_pointer(init_net.gen, ng);

	mutex_lock(&net_mutex);
	if (setup_net(&init_net))
		panic("Could not setup the initial network namespace");

	rtnl_lock();
	list_add_tail_rcu(&init_net.list, &net_namespace_list);
	rtnl_unlock();

	mutex_unlock(&net_mutex);

	return 0;
}

pure_initcall(net_ns_init);

#ifdef CONFIG_NET_NS
static int register_pernet_operations(struct list_head *list,
				      struct pernet_operations *ops)
{
	struct net *net, *undo_net;
	int error;

	list_add_tail(&ops->list, list);
	if (ops->init) {
		for_each_net(net) {
			error = ops->init(net);
			if (error)
				goto out_undo;
		}
	}
	return 0;

out_undo:
	/* If I have an error cleanup all namespaces I initialized */
	list_del(&ops->list);
	if (ops->exit) {
		for_each_net(undo_net) {
			if (net_eq(undo_net, net))
				goto undone;
			ops->exit(undo_net);
		}
	}
undone:
	return error;
}

static void unregister_pernet_operations(struct pernet_operations *ops)
{
	struct net *net;

	list_del(&ops->list);
	if (ops->exit)
		for_each_net(net)
			ops->exit(net);
}

#else

static int register_pernet_operations(struct list_head *list,
				      struct pernet_operations *ops)
{
	if (ops->init == NULL)
		return 0;
	return ops->init(&init_net);
}

static void unregister_pernet_operations(struct pernet_operations *ops)
{
	if (ops->exit)
		ops->exit(&init_net);
}
#endif

static DEFINE_IDA(net_generic_ids);

/**
 *      register_pernet_subsys - register a network namespace subsystem
 *	@ops:  pernet operations structure for the subsystem
 *
 *	Register a subsystem which has init and exit functions
 *	that are called when network namespaces are created and
 *	destroyed respectively.
 *
 *	When registered all network namespace init functions are
 *	called for every existing network namespace.  Allowing kernel
 *	modules to have a race free view of the set of network namespaces.
 *
 *	When a new network namespace is created all of the init
 *	methods are called in the order in which they were registered.
 *
 *	When a network namespace is destroyed all of the exit methods
 *	are called in the reverse of the order with which they were
 *	registered.
 */
int register_pernet_subsys(struct pernet_operations *ops)
{
	int error;
	mutex_lock(&net_mutex);
	error =  register_pernet_operations(first_device, ops);
	mutex_unlock(&net_mutex);
	return error;
}
EXPORT_SYMBOL_GPL(register_pernet_subsys);

/**
 *      unregister_pernet_subsys - unregister a network namespace subsystem
 *	@ops: pernet operations structure to manipulate
 *
 *	Remove the pernet operations structure from the list to be
 *	used when network namespaces are created or destroyed.  In
 *	addition run the exit method for all existing network
 *	namespaces.
 */
void unregister_pernet_subsys(struct pernet_operations *module)
{
	mutex_lock(&net_mutex);
	unregister_pernet_operations(module);
	mutex_unlock(&net_mutex);
}
EXPORT_SYMBOL_GPL(unregister_pernet_subsys);

int register_pernet_gen_subsys(int *id, struct pernet_operations *ops)
{
	int rv;

	mutex_lock(&net_mutex);
again:
	rv = ida_get_new_above(&net_generic_ids, 1, id);
	if (rv < 0) {
		if (rv == -EAGAIN) {
			ida_pre_get(&net_generic_ids, GFP_KERNEL);
			goto again;
		}
		goto out;
	}
	rv = register_pernet_operations(first_device, ops);
	if (rv < 0)
		ida_remove(&net_generic_ids, *id);
out:
	mutex_unlock(&net_mutex);
	return rv;
}
EXPORT_SYMBOL_GPL(register_pernet_gen_subsys);

void unregister_pernet_gen_subsys(int id, struct pernet_operations *ops)
{
	mutex_lock(&net_mutex);
	unregister_pernet_operations(ops);
	ida_remove(&net_generic_ids, id);
	mutex_unlock(&net_mutex);
}
EXPORT_SYMBOL_GPL(unregister_pernet_gen_subsys);

/**
 *      register_pernet_device - register a network namespace device
 *	@ops:  pernet operations structure for the subsystem
 *
 *	Register a device which has init and exit functions
 *	that are called when network namespaces are created and
 *	destroyed respectively.
 *
 *	When registered all network namespace init functions are
 *	called for every existing network namespace.  Allowing kernel
 *	modules to have a race free view of the set of network namespaces.
 *
 *	When a new network namespace is created all of the init
 *	methods are called in the order in which they were registered.
 *
 *	When a network namespace is destroyed all of the exit methods
 *	are called in the reverse of the order with which they were
 *	registered.
 */
int register_pernet_device(struct pernet_operations *ops)
{
	int error;
	mutex_lock(&net_mutex);
	error = register_pernet_operations(&pernet_list, ops);
	if (!error && (first_device == &pernet_list))
		first_device = &ops->list;
	mutex_unlock(&net_mutex);
	return error;
}
EXPORT_SYMBOL_GPL(register_pernet_device);

int register_pernet_gen_device(int *id, struct pernet_operations *ops)
{
	int error;
	mutex_lock(&net_mutex);
again:
	error = ida_get_new_above(&net_generic_ids, 1, id);
	if (error) {
		if (error == -EAGAIN) {
			ida_pre_get(&net_generic_ids, GFP_KERNEL);
			goto again;
		}
		goto out;
	}
	error = register_pernet_operations(&pernet_list, ops);
	if (error)
		ida_remove(&net_generic_ids, *id);
	else if (first_device == &pernet_list)
		first_device = &ops->list;
out:
	mutex_unlock(&net_mutex);
	return error;
}
EXPORT_SYMBOL_GPL(register_pernet_gen_device);

/**
 *      unregister_pernet_device - unregister a network namespace netdevice
 *	@ops: pernet operations structure to manipulate
 *
 *	Remove the pernet operations structure from the list to be
 *	used when network namespaces are created or destroyed.  In
 *	addition run the exit method for all existing network
 *	namespaces.
 */
void unregister_pernet_device(struct pernet_operations *ops)
{
	mutex_lock(&net_mutex);
	if (&ops->list == first_device)
		first_device = first_device->next;
	unregister_pernet_operations(ops);
	mutex_unlock(&net_mutex);
}
EXPORT_SYMBOL_GPL(unregister_pernet_device);

void unregister_pernet_gen_device(int id, struct pernet_operations *ops)
{
	mutex_lock(&net_mutex);
	if (&ops->list == first_device)
		first_device = first_device->next;
	unregister_pernet_operations(ops);
	ida_remove(&net_generic_ids, id);
	mutex_unlock(&net_mutex);
}
EXPORT_SYMBOL_GPL(unregister_pernet_gen_device);

static void net_generic_release(struct rcu_head *rcu)
{
	struct net_generic *ng;

	ng = container_of(rcu, struct net_generic, rcu);
	kfree(ng);
}

int net_assign_generic(struct net *net, int id, void *data)
{
	struct net_generic *ng, *old_ng;

	BUG_ON(!mutex_is_locked(&net_mutex));
	BUG_ON(id == 0);

	ng = old_ng = net->gen;
	if (old_ng->len >= id)
		goto assign;

	ng = kzalloc(sizeof(struct net_generic) +
			id * sizeof(void *), GFP_KERNEL);
	if (ng == NULL)
		return -ENOMEM;

	/*
	 * Some synchronisation notes:
	 *
	 * The net_generic explores the net->gen array inside rcu
	 * read section. Besides once set the net->gen->ptr[x]
	 * pointer never changes (see rules in netns/generic.h).
	 *
	 * That said, we simply duplicate this array and schedule
	 * the old copy for kfree after a grace period.
	 */

	ng->len = id;
	memcpy(&ng->ptr, &old_ng->ptr, old_ng->len * sizeof(void*));

	rcu_assign_pointer(net->gen, ng);
	call_rcu(&old_ng->rcu, net_generic_release);
assign:
	ng->ptr[id - 1] = data;
	return 0;
}
EXPORT_SYMBOL_GPL(net_assign_generic);
Commit	Line	Data
5f256bec EB	1	#include <linux/workqueue.h>
	2	#include <linux/rtnetlink.h>
	3	#include <linux/cache.h>
	4	#include <linux/slab.h>
	5	#include <linux/list.h>
	6	#include <linux/delay.h>
9dd776b6	7	#include <linux/sched.h>
c93cf61f	8	#include <linux/idr.h>
11a28d37	9	#include <linux/rculist.h>
30ffee84	10	#include <linux/nsproxy.h>
5f256bec	11	#include <net/net_namespace.h>
dec827d1	12	#include <net/netns/generic.h>
5f256bec EB	13
	14	/*
	15	* Our network namespace constructor/destructor lists
	16	*/
	17
	18	static LIST_HEAD(pernet_list);
	19	static struct list_head *first_device = &pernet_list;
	20	static DEFINE_MUTEX(net_mutex);
	21
5f256bec	22	LIST_HEAD(net_namespace_list);
b76a461f	23	EXPORT_SYMBOL_GPL(net_namespace_list);
5f256bec	24
5f256bec	25	struct net init_net;
ff4b9502	26	EXPORT_SYMBOL(init_net);
5f256bec	27
dec827d1 PE	28	#define INITIAL_NET_GEN_PTRS 13 /* +1 for len +2 for rcu_head */
dec827d1 PE	29
5f256bec EB	30	/*
	31	* setup_net runs the initializers for the network namespace object.
	32	*/
1a2ee93d	33	static __net_init int setup_net(struct net *net)
5f256bec EB	34	{
	35	/* Must be called with net_mutex held */
	36	struct pernet_operations *ops;
486a87f1	37	int error = 0;
5f256bec	38
5f256bec	39	atomic_set(&net->count, 1);
486a87f1	40
5d1e4468	41	#ifdef NETNS_REFCNT_DEBUG
5f256bec	42	atomic_set(&net->use_count, 0);
5d1e4468	43	#endif
5f256bec	44
768f3591	45	list_for_each_entry(ops, &pernet_list, list) {
5f256bec EB	46	if (ops->init) {
	47	error = ops->init(net);
	48	if (error < 0)
	49	goto out_undo;
	50	}
	51	}
	52	out:
	53	return error;
768f3591	54
5f256bec EB	55	out_undo:
	56	/* Walk through the list backwards calling the exit functions
	57	* for the pernet modules whose init functions did not fail.
	58	*/
768f3591	59	list_for_each_entry_continue_reverse(ops, &pernet_list, list) {
5f256bec EB	60	if (ops->exit)
	61	ops->exit(net);
	62	}
310928d9 DL	63
310928d9 DL	64	rcu_barrier();
5f256bec EB	65	goto out;
	66	}
	67
486a87f1	68	static struct net_generic *net_alloc_generic(void)
6a1a3b9f	69	{
486a87f1 DL	70	struct net_generic *ng;
	71	size_t generic_size = sizeof(struct net_generic) +
	72	INITIAL_NET_GEN_PTRS * sizeof(void *);
	73
	74	ng = kzalloc(generic_size, GFP_KERNEL);
	75	if (ng)
	76	ng->len = INITIAL_NET_GEN_PTRS;
	77
	78	return ng;
6a1a3b9f PE	79	}
6a1a3b9f PE	80
ebe47d47 CN	81	#ifdef CONFIG_NET_NS
	82	static struct kmem_cache *net_cachep;
	83	static struct workqueue_struct *netns_wq;
	84
486a87f1	85	static struct net *net_alloc(void)
45a19b0a	86	{
486a87f1 DL	87	struct net *net = NULL;
	88	struct net_generic *ng;
	89
	90	ng = net_alloc_generic();
	91	if (!ng)
	92	goto out;
	93
	94	net = kmem_cache_zalloc(net_cachep, GFP_KERNEL);
45a19b0a	95	if (!net)
486a87f1	96	goto out_free;
45a19b0a	97
486a87f1 DL	98	rcu_assign_pointer(net->gen, ng);
	99	out:
	100	return net;
	101
	102	out_free:
	103	kfree(ng);
	104	goto out;
	105	}
	106
	107	static void net_free(struct net *net)
	108	{
5d1e4468	109	#ifdef NETNS_REFCNT_DEBUG
45a19b0a JFS	110	if (unlikely(atomic_read(&net->use_count) != 0)) {
	111	printk(KERN_EMERG "network namespace not free! Usage: %d\n",
	112	atomic_read(&net->use_count));
	113	return;
	114	}
5d1e4468	115	#endif
4ef079cc	116	kfree(net->gen);
45a19b0a JFS	117	kmem_cache_free(net_cachep, net);
	118	}
	119
088eb2d9	120	static struct net *net_create(void)
9dd776b6	121	{
088eb2d9 AD	122	struct net *net;
088eb2d9 AD	123	int rv;
9dd776b6	124
088eb2d9 AD	125	net = net_alloc();
	126	if (!net)
	127	return ERR_PTR(-ENOMEM);
9dd776b6	128	mutex_lock(&net_mutex);
088eb2d9 AD	129	rv = setup_net(net);
088eb2d9 AD	130	if (rv == 0) {
486a87f1	131	rtnl_lock();
11a28d37	132	list_add_tail_rcu(&net->list, &net_namespace_list);
486a87f1 DL	133	rtnl_unlock();
486a87f1 DL	134	}
9dd776b6	135	mutex_unlock(&net_mutex);
088eb2d9 AD	136	if (rv < 0) {
	137	net_free(net);
	138	return ERR_PTR(rv);
	139	}
	140	return net;
	141	}
486a87f1	142
088eb2d9 AD	143	struct net copy_net_ns(unsigned long flags, struct net old_net)
	144	{
	145	if (!(flags & CLONE_NEWNET))
	146	return get_net(old_net);
	147	return net_create();
9dd776b6 EB	148	}
9dd776b6 EB	149
6a1a3b9f PE	150	static void cleanup_net(struct work_struct *work)
	151	{
	152	struct pernet_operations *ops;
	153	struct net *net;
	154
	155	net = container_of(work, struct net, work);
	156
	157	mutex_lock(&net_mutex);
	158
	159	/* Don't let anyone else find us. */
	160	rtnl_lock();
11a28d37	161	list_del_rcu(&net->list);
6a1a3b9f PE	162	rtnl_unlock();
6a1a3b9f PE	163
11a28d37 JB	164	/*
	165	* Another CPU might be rcu-iterating the list, wait for it.
	166	* This needs to be before calling the exit() notifiers, so
	167	* the rcu_barrier() below isn't sufficient alone.
	168	*/
	169	synchronize_rcu();
	170
6a1a3b9f PE	171	/* Run all of the network namespace exit methods */
	172	list_for_each_entry_reverse(ops, &pernet_list, list) {
	173	if (ops->exit)
	174	ops->exit(net);
	175	}
	176
	177	mutex_unlock(&net_mutex);
	178
	179	/* Ensure there are no outstanding rcu callbacks using this
	180	* network namespace.
	181	*/
	182	rcu_barrier();
	183
	184	/* Finally it is safe to free my network namespace structure */
	185	net_free(net);
	186	}
	187
	188	void __put_net(struct net *net)
	189	{
	190	/* Cleanup the network namespace in process context */
	191	INIT_WORK(&net->work, cleanup_net);
3ef1355d	192	queue_work(netns_wq, &net->work);
6a1a3b9f PE	193	}
	194	EXPORT_SYMBOL_GPL(__put_net);
	195
	196	#else
	197	struct net copy_net_ns(unsigned long flags, struct net old_net)
	198	{
	199	if (flags & CLONE_NEWNET)
	200	return ERR_PTR(-EINVAL);
	201	return old_net;
	202	}
	203	#endif
	204
30ffee84 JB	205	struct net *get_net_ns_by_pid(pid_t pid)
	206	{
	207	struct task_struct *tsk;
	208	struct net *net;
	209
	210	/* Lookup the network namespace */
	211	net = ERR_PTR(-ESRCH);
	212	rcu_read_lock();
	213	tsk = find_task_by_vpid(pid);
	214	if (tsk) {
	215	struct nsproxy *nsproxy;
	216	nsproxy = task_nsproxy(tsk);
	217	if (nsproxy)
	218	net = get_net(nsproxy->net_ns);
	219	}
	220	rcu_read_unlock();
	221	return net;
	222	}
	223	EXPORT_SYMBOL_GPL(get_net_ns_by_pid);
	224
5f256bec EB	225	static int __init net_ns_init(void)
5f256bec EB	226	{
486a87f1	227	struct net_generic *ng;
5f256bec	228
d57a9212	229	#ifdef CONFIG_NET_NS
5f256bec EB	230	net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
	231	SMP_CACHE_BYTES,
	232	SLAB_PANIC, NULL);
3ef1355d BT	233
	234	/* Create workqueue for cleanup */
	235	netns_wq = create_singlethread_workqueue("netns");
	236	if (!netns_wq)
	237	panic("Could not create netns workq");
d57a9212	238	#endif
3ef1355d	239
486a87f1 DL	240	ng = net_alloc_generic();
	241	if (!ng)
	242	panic("Could not allocate generic netns");
	243
	244	rcu_assign_pointer(init_net.gen, ng);
	245
5f256bec	246	mutex_lock(&net_mutex);
ca0f3112 SH	247	if (setup_net(&init_net))
ca0f3112 SH	248	panic("Could not setup the initial network namespace");
5f256bec	249
f4618d39	250	rtnl_lock();
11a28d37	251	list_add_tail_rcu(&init_net.list, &net_namespace_list);
f4618d39	252	rtnl_unlock();
5f256bec EB	253
5f256bec EB	254	mutex_unlock(&net_mutex);
5f256bec EB	255
	256	return 0;
	257	}
	258
	259	pure_initcall(net_ns_init);
	260
ed160e83	261	#ifdef CONFIG_NET_NS
5f256bec EB	262	static int register_pernet_operations(struct list_head *list,
	263	struct pernet_operations *ops)
	264	{
	265	struct net net, undo_net;
	266	int error;
	267
5f256bec	268	list_add_tail(&ops->list, list);
1dba323b PE	269	if (ops->init) {
1dba323b PE	270	for_each_net(net) {
5f256bec EB	271	error = ops->init(net);
	272	if (error)
	273	goto out_undo;
	274	}
	275	}
1dba323b	276	return 0;
5f256bec EB	277
	278	out_undo:
	279	/* If I have an error cleanup all namespaces I initialized */
	280	list_del(&ops->list);
1dba323b PE	281	if (ops->exit) {
1dba323b PE	282	for_each_net(undo_net) {
09ad9bc7	283	if (net_eq(undo_net, net))
1dba323b	284	goto undone;
5f256bec	285	ops->exit(undo_net);
1dba323b	286	}
5f256bec EB	287	}
5f256bec EB	288	undone:
1dba323b	289	return error;
5f256bec EB	290	}
	291
	292	static void unregister_pernet_operations(struct pernet_operations *ops)
	293	{
	294	struct net *net;
	295
	296	list_del(&ops->list);
1dba323b PE	297	if (ops->exit)
1dba323b PE	298	for_each_net(net)
5f256bec EB	299	ops->exit(net);
	300	}
	301
ed160e83 DL	302	#else
	303
	304	static int register_pernet_operations(struct list_head *list,
	305	struct pernet_operations *ops)
	306	{
	307	if (ops->init == NULL)
	308	return 0;
	309	return ops->init(&init_net);
	310	}
	311
	312	static void unregister_pernet_operations(struct pernet_operations *ops)
	313	{
	314	if (ops->exit)
	315	ops->exit(&init_net);
	316	}
	317	#endif
	318
c93cf61f PE	319	static DEFINE_IDA(net_generic_ids);
c93cf61f PE	320
5f256bec EB	321	/**
	322	* register_pernet_subsys - register a network namespace subsystem
	323	* @ops: pernet operations structure for the subsystem
	324	*
	325	* Register a subsystem which has init and exit functions
	326	* that are called when network namespaces are created and
	327	* destroyed respectively.
	328	*
	329	* When registered all network namespace init functions are
	330	* called for every existing network namespace. Allowing kernel
	331	* modules to have a race free view of the set of network namespaces.
	332	*
	333	* When a new network namespace is created all of the init
	334	* methods are called in the order in which they were registered.
	335	*
	336	* When a network namespace is destroyed all of the exit methods
	337	* are called in the reverse of the order with which they were
	338	* registered.
	339	*/
	340	int register_pernet_subsys(struct pernet_operations *ops)
	341	{
	342	int error;
	343	mutex_lock(&net_mutex);
	344	error = register_pernet_operations(first_device, ops);
	345	mutex_unlock(&net_mutex);
	346	return error;
	347	}
	348	EXPORT_SYMBOL_GPL(register_pernet_subsys);
	349
	350	/**
	351	* unregister_pernet_subsys - unregister a network namespace subsystem
	352	* @ops: pernet operations structure to manipulate
	353	*
	354	* Remove the pernet operations structure from the list to be
53379e57	355	* used when network namespaces are created or destroyed. In
5f256bec EB	356	* addition run the exit method for all existing network
	357	* namespaces.
	358	*/
	359	void unregister_pernet_subsys(struct pernet_operations *module)
	360	{
	361	mutex_lock(&net_mutex);
	362	unregister_pernet_operations(module);
	363	mutex_unlock(&net_mutex);
	364	}
	365	EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
	366
485ac57b AD	367	int register_pernet_gen_subsys(int id, struct pernet_operations ops)
	368	{
	369	int rv;
	370
	371	mutex_lock(&net_mutex);
	372	again:
	373	rv = ida_get_new_above(&net_generic_ids, 1, id);
	374	if (rv < 0) {
	375	if (rv == -EAGAIN) {
	376	ida_pre_get(&net_generic_ids, GFP_KERNEL);
	377	goto again;
	378	}
	379	goto out;
	380	}
	381	rv = register_pernet_operations(first_device, ops);
	382	if (rv < 0)
	383	ida_remove(&net_generic_ids, *id);
485ac57b	384	out:
357f5b0b	385	mutex_unlock(&net_mutex);
485ac57b AD	386	return rv;
	387	}
	388	EXPORT_SYMBOL_GPL(register_pernet_gen_subsys);
	389
	390	void unregister_pernet_gen_subsys(int id, struct pernet_operations *ops)
	391	{
	392	mutex_lock(&net_mutex);
	393	unregister_pernet_operations(ops);
	394	ida_remove(&net_generic_ids, id);
	395	mutex_unlock(&net_mutex);
	396	}
	397	EXPORT_SYMBOL_GPL(unregister_pernet_gen_subsys);
	398
5f256bec EB	399	/**
	400	* register_pernet_device - register a network namespace device
	401	* @ops: pernet operations structure for the subsystem
	402	*
	403	* Register a device which has init and exit functions
	404	* that are called when network namespaces are created and
	405	* destroyed respectively.
	406	*
	407	* When registered all network namespace init functions are
	408	* called for every existing network namespace. Allowing kernel
	409	* modules to have a race free view of the set of network namespaces.
	410	*
	411	* When a new network namespace is created all of the init
	412	* methods are called in the order in which they were registered.
	413	*
	414	* When a network namespace is destroyed all of the exit methods
	415	* are called in the reverse of the order with which they were
	416	* registered.
	417	*/
	418	int register_pernet_device(struct pernet_operations *ops)
	419	{
	420	int error;
	421	mutex_lock(&net_mutex);
	422	error = register_pernet_operations(&pernet_list, ops);
	423	if (!error && (first_device == &pernet_list))
	424	first_device = &ops->list;
	425	mutex_unlock(&net_mutex);
	426	return error;
	427	}
	428	EXPORT_SYMBOL_GPL(register_pernet_device);
	429
c93cf61f PE	430	int register_pernet_gen_device(int id, struct pernet_operations ops)
	431	{
	432	int error;
	433	mutex_lock(&net_mutex);
	434	again:
	435	error = ida_get_new_above(&net_generic_ids, 1, id);
	436	if (error) {
	437	if (error == -EAGAIN) {
	438	ida_pre_get(&net_generic_ids, GFP_KERNEL);
	439	goto again;
	440	}
	441	goto out;
	442	}
	443	error = register_pernet_operations(&pernet_list, ops);
	444	if (error)
	445	ida_remove(&net_generic_ids, *id);
	446	else if (first_device == &pernet_list)
	447	first_device = &ops->list;
	448	out:
	449	mutex_unlock(&net_mutex);
	450	return error;
	451	}
	452	EXPORT_SYMBOL_GPL(register_pernet_gen_device);
	453
5f256bec EB	454	/**
	455	* unregister_pernet_device - unregister a network namespace netdevice
	456	* @ops: pernet operations structure to manipulate
	457	*
	458	* Remove the pernet operations structure from the list to be
53379e57	459	* used when network namespaces are created or destroyed. In
5f256bec EB	460	* addition run the exit method for all existing network
	461	* namespaces.
	462	*/
	463	void unregister_pernet_device(struct pernet_operations *ops)
	464	{
	465	mutex_lock(&net_mutex);
	466	if (&ops->list == first_device)
	467	first_device = first_device->next;
	468	unregister_pernet_operations(ops);
	469	mutex_unlock(&net_mutex);
	470	}
	471	EXPORT_SYMBOL_GPL(unregister_pernet_device);
c93cf61f PE	472
	473	void unregister_pernet_gen_device(int id, struct pernet_operations *ops)
	474	{
	475	mutex_lock(&net_mutex);
	476	if (&ops->list == first_device)
	477	first_device = first_device->next;
	478	unregister_pernet_operations(ops);
	479	ida_remove(&net_generic_ids, id);
	480	mutex_unlock(&net_mutex);
	481	}
	482	EXPORT_SYMBOL_GPL(unregister_pernet_gen_device);
dec827d1 PE	483
	484	static void net_generic_release(struct rcu_head *rcu)
	485	{
	486	struct net_generic *ng;
	487
	488	ng = container_of(rcu, struct net_generic, rcu);
	489	kfree(ng);
	490	}
	491
	492	int net_assign_generic(struct net net, int id, void data)
	493	{
	494	struct net_generic ng, old_ng;
	495
	496	BUG_ON(!mutex_is_locked(&net_mutex));
	497	BUG_ON(id == 0);
	498
	499	ng = old_ng = net->gen;
	500	if (old_ng->len >= id)
	501	goto assign;
	502
	503	ng = kzalloc(sizeof(struct net_generic) +
	504	id * sizeof(void *), GFP_KERNEL);
	505	if (ng == NULL)
	506	return -ENOMEM;
	507
	508	/*
	509	* Some synchronisation notes:
	510	*
	511	* The net_generic explores the net->gen array inside rcu
	512	* read section. Besides once set the net->gen->ptr[x]
	513	* pointer never changes (see rules in netns/generic.h).
	514	*
	515	* That said, we simply duplicate this array and schedule
	516	* the old copy for kfree after a grace period.
	517	*/
	518
	519	ng->len = id;
14458630	520	memcpy(&ng->ptr, &old_ng->ptr, old_ng->len * sizeof(void*));
dec827d1 PE	521
	522	rcu_assign_pointer(net->gen, ng);
	523	call_rcu(&old_ng->rcu, net_generic_release);
	524	assign:
	525	ng->ptr[id - 1] = data;
	526	return 0;
	527	}
	528	EXPORT_SYMBOL_GPL(net_assign_generic);