[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 <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;
	struct net_generic *ng;

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

	error = -ENOMEM;
	ng = kzalloc(sizeof(struct net_generic) +
			INITIAL_NET_GEN_PTRS * sizeof(void *), GFP_KERNEL);
	if (ng == NULL)
		goto out;

	ng->len = INITIAL_NET_GEN_PTRS;
	rcu_assign_pointer(net->gen, ng);

	error = 0;
	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();
	kfree(ng);
	goto out;
}

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

static struct net *net_alloc(void)
{
	return kmem_cache_zalloc(net_cachep, GFP_KERNEL);
}

static void net_free(struct net *net)
{
	if (!net)
		return;

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

struct net *copy_net_ns(unsigned long flags, struct net *old_net)
{
	struct net *new_net = NULL;
	int err;

	get_net(old_net);

	if (!(flags & CLONE_NEWNET))
		return old_net;

	err = -ENOMEM;
	new_net = net_alloc();
	if (!new_net)
		goto out;

	mutex_lock(&net_mutex);
	err = setup_net(new_net);
	if (err)
		goto out_unlock;

	rtnl_lock();
	list_add_tail(&new_net->list, &net_namespace_list);
	rtnl_unlock();


out_unlock:
	mutex_unlock(&net_mutex);
out:
	put_net(old_net);
	if (err) {
		net_free(new_net);
		new_net = ERR_PTR(err);
	}
	return new_net;
}

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

	/* Be very certain incoming network packets will not find us */
	rcu_barrier();

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

	mutex_lock(&net_mutex);

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

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

static int __init net_ns_init(void)
{
	int err;

	printk(KERN_INFO "net_namespace: %zd bytes\n", sizeof(struct net));
#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

	mutex_lock(&net_mutex);
	err = setup_net(&init_net);

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

	mutex_unlock(&net_mutex);
	if (err)
		panic("Could not setup the initial network namespace");

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

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