[net-next-2.6.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 */

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

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

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

static int ops_init(const struct pernet_operations *ops, struct net *net)
{
	int err;
	if (ops->id && ops->size) {
		void *data = kzalloc(ops->size, GFP_KERNEL);
		if (!data)
			return -ENOMEM;

		err = net_assign_generic(net, *ops->id, data);
		if (err) {
			kfree(data);
			return err;
		}
	}
	if (ops->init)
		return ops->init(net);
	return 0;
}

static void ops_free(const struct pernet_operations *ops, struct net *net)
{
	if (ops->id && ops->size) {
		int id = *ops->id;
		kfree(net_generic(net, id));
	}
}

static void ops_exit_list(const struct pernet_operations *ops,
			  struct list_head *net_exit_list)
{
	struct net *net;
	if (ops->exit) {
		list_for_each_entry(net, net_exit_list, exit_list)
			ops->exit(net);
	}
	if (ops->exit_batch)
		ops->exit_batch(net_exit_list);
}

static void ops_free_list(const struct pernet_operations *ops,
			  struct list_head *net_exit_list)
{
	struct net *net;
	if (ops->size && ops->id) {
		list_for_each_entry(net, net_exit_list, exit_list)
			ops_free(ops, net);
	}
}

/*
 * 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 */
	const struct pernet_operations *ops, *saved_ops;
	int error = 0;
	LIST_HEAD(net_exit_list);

	atomic_set(&net->count, 1);

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

	list_for_each_entry(ops, &pernet_list, list) {
		error = ops_init(ops, 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_add(&net->exit_list, &net_exit_list);
	saved_ops = ops;
	list_for_each_entry_continue_reverse(ops, &pernet_list, list)
		ops_exit_list(ops, &net_exit_list);

	ops = saved_ops;
	list_for_each_entry_continue_reverse(ops, &pernet_list, list)
		ops_free_list(ops, &net_exit_list);

	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 DEFINE_SPINLOCK(cleanup_list_lock);
static LIST_HEAD(cleanup_list);  /* Must hold cleanup_list_lock to touch */

static void cleanup_net(struct work_struct *work)
{
	const struct pernet_operations *ops;
	struct net *net, *tmp;
	LIST_HEAD(net_kill_list);
	LIST_HEAD(net_exit_list);

	/* Atomically snapshot the list of namespaces to cleanup */
	spin_lock_irq(&cleanup_list_lock);
	list_replace_init(&cleanup_list, &net_kill_list);
	spin_unlock_irq(&cleanup_list_lock);

	mutex_lock(&net_mutex);

	/* Don't let anyone else find us. */
	rtnl_lock();
	list_for_each_entry(net, &net_kill_list, cleanup_list) {
		list_del_rcu(&net->list);
		list_add_tail(&net->exit_list, &net_exit_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)
		ops_exit_list(ops, &net_exit_list);

	/* Free the net generic variables */
	list_for_each_entry_reverse(ops, &pernet_list, list)
		ops_free_list(ops, &net_exit_list);

	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 */
	list_for_each_entry_safe(net, tmp, &net_exit_list, exit_list) {
		list_del_init(&net->exit_list);
		net_free(net);
	}
}
static DECLARE_WORK(net_cleanup_work, cleanup_net);

void __put_net(struct net *net)
{
	/* Cleanup the network namespace in process context */
	unsigned long flags;

	spin_lock_irqsave(&cleanup_list_lock, flags);
	list_add(&net->cleanup_list, &cleanup_list);
	spin_unlock_irqrestore(&cleanup_list_lock, flags);

	queue_work(netns_wq, &net_cleanup_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;
	int error;
	LIST_HEAD(net_exit_list);

	list_add_tail(&ops->list, list);
	if (ops->init || (ops->id && ops->size)) {
		for_each_net(net) {
			error = ops_init(ops, net);
			if (error)
				goto out_undo;
			list_add_tail(&net->exit_list, &net_exit_list);
		}
	}
	return 0;

out_undo:
	/* If I have an error cleanup all namespaces I initialized */
	list_del(&ops->list);
	ops_exit_list(ops, &net_exit_list);
	ops_free_list(ops, &net_exit_list);
	return error;
}

static void __unregister_pernet_operations(struct pernet_operations *ops)
{
	struct net *net;
	LIST_HEAD(net_exit_list);

	list_del(&ops->list);
	for_each_net(net)
		list_add_tail(&net->exit_list, &net_exit_list);
	ops_exit_list(ops, &net_exit_list);
	ops_free_list(ops, &net_exit_list);
}

#else

static int __register_pernet_operations(struct list_head *list,
					struct pernet_operations *ops)
{
	int err = 0;
	err = ops_init(ops, &init_net);
	if (err)
		ops_free(ops, &init_net);
	return err;
	
}

static void __unregister_pernet_operations(struct pernet_operations *ops)
{
	LIST_HEAD(net_exit_list);
	list_add(&init_net.exit_list, &net_exit_list);
	ops_exit_list(ops, &net_exit_list);
	ops_free_list(ops, &net_exit_list);
}

#endif /* CONFIG_NET_NS */

static DEFINE_IDA(net_generic_ids);

static int register_pernet_operations(struct list_head *list,
				      struct pernet_operations *ops)
{
	int error;

	if (ops->id) {
again:
		error = ida_get_new_above(&net_generic_ids, 1, ops->id);
		if (error < 0) {
			if (error == -EAGAIN) {
				ida_pre_get(&net_generic_ids, GFP_KERNEL);
				goto again;
			}
			return error;
		}
	}
	error = __register_pernet_operations(list, ops);
	if (error) {
		rcu_barrier();
		if (ops->id)
			ida_remove(&net_generic_ids, *ops->id);
	}

	return error;
}

static void unregister_pernet_operations(struct pernet_operations *ops)
{
	
	__unregister_pernet_operations(ops);
	rcu_barrier();
	if (ops->id)
		ida_remove(&net_generic_ids, *ops->id);
}

/**
 *      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 *ops)
{
	mutex_lock(&net_mutex);
	unregister_pernet_operations(ops);
	mutex_unlock(&net_mutex);
}
EXPORT_SYMBOL_GPL(unregister_pernet_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);

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