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>
7 #include <linux/sched.h>
9 #include <linux/rculist.h>
10 #include <linux/nsproxy.h>
11 #include <linux/proc_fs.h>
12 #include <linux/file.h>
13 #include <net/net_namespace.h>
14 #include <net/netns/generic.h>
17 * Our network namespace constructor/destructor lists
20 static LIST_HEAD(pernet_list
);
21 static struct list_head
*first_device
= &pernet_list
;
22 static DEFINE_MUTEX(net_mutex
);
24 LIST_HEAD(net_namespace_list
);
25 EXPORT_SYMBOL_GPL(net_namespace_list
);
28 EXPORT_SYMBOL(init_net
);
30 #define INITIAL_NET_GEN_PTRS 13 /* +1 for len +2 for rcu_head */
32 static int net_assign_generic(struct net
*net
, int id
, void *data
)
34 struct net_generic
*ng
, *old_ng
;
36 BUG_ON(!mutex_is_locked(&net_mutex
));
39 old_ng
= rcu_dereference_protected(net
->gen
,
40 lockdep_is_held(&net_mutex
));
42 if (old_ng
->len
>= id
)
45 ng
= kzalloc(sizeof(struct net_generic
) +
46 id
* sizeof(void *), GFP_KERNEL
);
51 * Some synchronisation notes:
53 * The net_generic explores the net->gen array inside rcu
54 * read section. Besides once set the net->gen->ptr[x]
55 * pointer never changes (see rules in netns/generic.h).
57 * That said, we simply duplicate this array and schedule
58 * the old copy for kfree after a grace period.
62 memcpy(&ng
->ptr
, &old_ng
->ptr
, old_ng
->len
* sizeof(void*));
64 rcu_assign_pointer(net
->gen
, ng
);
65 kfree_rcu(old_ng
, rcu
);
67 ng
->ptr
[id
- 1] = data
;
71 static int ops_init(const struct pernet_operations
*ops
, struct net
*net
)
74 if (ops
->id
&& ops
->size
) {
75 void *data
= kzalloc(ops
->size
, GFP_KERNEL
);
79 err
= net_assign_generic(net
, *ops
->id
, data
);
86 return ops
->init(net
);
90 static void ops_free(const struct pernet_operations
*ops
, struct net
*net
)
92 if (ops
->id
&& ops
->size
) {
94 kfree(net_generic(net
, id
));
98 static void ops_exit_list(const struct pernet_operations
*ops
,
99 struct list_head
*net_exit_list
)
103 list_for_each_entry(net
, net_exit_list
, exit_list
)
107 ops
->exit_batch(net_exit_list
);
110 static void ops_free_list(const struct pernet_operations
*ops
,
111 struct list_head
*net_exit_list
)
114 if (ops
->size
&& ops
->id
) {
115 list_for_each_entry(net
, net_exit_list
, exit_list
)
121 * setup_net runs the initializers for the network namespace object.
123 static __net_init
int setup_net(struct net
*net
)
125 /* Must be called with net_mutex held */
126 const struct pernet_operations
*ops
, *saved_ops
;
128 LIST_HEAD(net_exit_list
);
130 atomic_set(&net
->count
, 1);
131 atomic_set(&net
->passive
, 1);
133 #ifdef NETNS_REFCNT_DEBUG
134 atomic_set(&net
->use_count
, 0);
137 list_for_each_entry(ops
, &pernet_list
, list
) {
138 error
= ops_init(ops
, net
);
146 /* Walk through the list backwards calling the exit functions
147 * for the pernet modules whose init functions did not fail.
149 list_add(&net
->exit_list
, &net_exit_list
);
151 list_for_each_entry_continue_reverse(ops
, &pernet_list
, list
)
152 ops_exit_list(ops
, &net_exit_list
);
155 list_for_each_entry_continue_reverse(ops
, &pernet_list
, list
)
156 ops_free_list(ops
, &net_exit_list
);
162 static struct net_generic
*net_alloc_generic(void)
164 struct net_generic
*ng
;
165 size_t generic_size
= sizeof(struct net_generic
) +
166 INITIAL_NET_GEN_PTRS
* sizeof(void *);
168 ng
= kzalloc(generic_size
, GFP_KERNEL
);
170 ng
->len
= INITIAL_NET_GEN_PTRS
;
176 static struct kmem_cache
*net_cachep
;
177 static struct workqueue_struct
*netns_wq
;
179 static struct net
*net_alloc(void)
181 struct net
*net
= NULL
;
182 struct net_generic
*ng
;
184 ng
= net_alloc_generic();
188 net
= kmem_cache_zalloc(net_cachep
, GFP_KERNEL
);
192 rcu_assign_pointer(net
->gen
, ng
);
201 static void net_free(struct net
*net
)
203 #ifdef NETNS_REFCNT_DEBUG
204 if (unlikely(atomic_read(&net
->use_count
) != 0)) {
205 printk(KERN_EMERG
"network namespace not free! Usage: %d\n",
206 atomic_read(&net
->use_count
));
211 kmem_cache_free(net_cachep
, net
);
214 void net_drop_ns(void *p
)
217 if (ns
&& atomic_dec_and_test(&ns
->passive
))
221 struct net
*copy_net_ns(unsigned long flags
, struct net
*old_net
)
226 if (!(flags
& CLONE_NEWNET
))
227 return get_net(old_net
);
231 return ERR_PTR(-ENOMEM
);
232 mutex_lock(&net_mutex
);
236 list_add_tail_rcu(&net
->list
, &net_namespace_list
);
239 mutex_unlock(&net_mutex
);
247 static DEFINE_SPINLOCK(cleanup_list_lock
);
248 static LIST_HEAD(cleanup_list
); /* Must hold cleanup_list_lock to touch */
250 static void cleanup_net(struct work_struct
*work
)
252 const struct pernet_operations
*ops
;
253 struct net
*net
, *tmp
;
254 LIST_HEAD(net_kill_list
);
255 LIST_HEAD(net_exit_list
);
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
);
262 mutex_lock(&net_mutex
);
264 /* Don't let anyone else find us. */
266 list_for_each_entry(net
, &net_kill_list
, cleanup_list
) {
267 list_del_rcu(&net
->list
);
268 list_add_tail(&net
->exit_list
, &net_exit_list
);
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.
279 /* Run all of the network namespace exit methods */
280 list_for_each_entry_reverse(ops
, &pernet_list
, list
)
281 ops_exit_list(ops
, &net_exit_list
);
283 /* Free the net generic variables */
284 list_for_each_entry_reverse(ops
, &pernet_list
, list
)
285 ops_free_list(ops
, &net_exit_list
);
287 mutex_unlock(&net_mutex
);
289 /* Ensure there are no outstanding rcu callbacks using this
294 /* Finally it is safe to free my network namespace structure */
295 list_for_each_entry_safe(net
, tmp
, &net_exit_list
, exit_list
) {
296 list_del_init(&net
->exit_list
);
300 static DECLARE_WORK(net_cleanup_work
, cleanup_net
);
302 void __put_net(struct net
*net
)
304 /* Cleanup the network namespace in process context */
307 spin_lock_irqsave(&cleanup_list_lock
, flags
);
308 list_add(&net
->cleanup_list
, &cleanup_list
);
309 spin_unlock_irqrestore(&cleanup_list_lock
, flags
);
311 queue_work(netns_wq
, &net_cleanup_work
);
313 EXPORT_SYMBOL_GPL(__put_net
);
315 struct net
*get_net_ns_by_fd(int fd
)
317 struct proc_inode
*ei
;
321 file
= proc_ns_fget(fd
);
323 return ERR_CAST(file
);
325 ei
= PROC_I(file
->f_dentry
->d_inode
);
326 if (ei
->ns_ops
== &netns_operations
)
327 net
= get_net(ei
->ns
);
329 net
= ERR_PTR(-EINVAL
);
336 struct net
*copy_net_ns(unsigned long flags
, struct net
*old_net
)
338 if (flags
& CLONE_NEWNET
)
339 return ERR_PTR(-EINVAL
);
343 struct net
*get_net_ns_by_fd(int fd
)
345 return ERR_PTR(-EINVAL
);
349 struct net
*get_net_ns_by_pid(pid_t pid
)
351 struct task_struct
*tsk
;
354 /* Lookup the network namespace */
355 net
= ERR_PTR(-ESRCH
);
357 tsk
= find_task_by_vpid(pid
);
359 struct nsproxy
*nsproxy
;
360 nsproxy
= task_nsproxy(tsk
);
362 net
= get_net(nsproxy
->net_ns
);
367 EXPORT_SYMBOL_GPL(get_net_ns_by_pid
);
369 static int __init
net_ns_init(void)
371 struct net_generic
*ng
;
374 net_cachep
= kmem_cache_create("net_namespace", sizeof(struct net
),
378 /* Create workqueue for cleanup */
379 netns_wq
= create_singlethread_workqueue("netns");
381 panic("Could not create netns workq");
384 ng
= net_alloc_generic();
386 panic("Could not allocate generic netns");
388 rcu_assign_pointer(init_net
.gen
, ng
);
390 mutex_lock(&net_mutex
);
391 if (setup_net(&init_net
))
392 panic("Could not setup the initial network namespace");
395 list_add_tail_rcu(&init_net
.list
, &net_namespace_list
);
398 mutex_unlock(&net_mutex
);
403 pure_initcall(net_ns_init
);
406 static int __register_pernet_operations(struct list_head
*list
,
407 struct pernet_operations
*ops
)
411 LIST_HEAD(net_exit_list
);
413 list_add_tail(&ops
->list
, list
);
414 if (ops
->init
|| (ops
->id
&& ops
->size
)) {
416 error
= ops_init(ops
, net
);
419 list_add_tail(&net
->exit_list
, &net_exit_list
);
425 /* If I have an error cleanup all namespaces I initialized */
426 list_del(&ops
->list
);
427 ops_exit_list(ops
, &net_exit_list
);
428 ops_free_list(ops
, &net_exit_list
);
432 static void __unregister_pernet_operations(struct pernet_operations
*ops
)
435 LIST_HEAD(net_exit_list
);
437 list_del(&ops
->list
);
439 list_add_tail(&net
->exit_list
, &net_exit_list
);
440 ops_exit_list(ops
, &net_exit_list
);
441 ops_free_list(ops
, &net_exit_list
);
446 static int __register_pernet_operations(struct list_head
*list
,
447 struct pernet_operations
*ops
)
450 err
= ops_init(ops
, &init_net
);
452 ops_free(ops
, &init_net
);
457 static void __unregister_pernet_operations(struct pernet_operations
*ops
)
459 LIST_HEAD(net_exit_list
);
460 list_add(&init_net
.exit_list
, &net_exit_list
);
461 ops_exit_list(ops
, &net_exit_list
);
462 ops_free_list(ops
, &net_exit_list
);
465 #endif /* CONFIG_NET_NS */
467 static DEFINE_IDA(net_generic_ids
);
469 static int register_pernet_operations(struct list_head
*list
,
470 struct pernet_operations
*ops
)
476 error
= ida_get_new_above(&net_generic_ids
, 1, ops
->id
);
478 if (error
== -EAGAIN
) {
479 ida_pre_get(&net_generic_ids
, GFP_KERNEL
);
485 error
= __register_pernet_operations(list
, ops
);
489 ida_remove(&net_generic_ids
, *ops
->id
);
495 static void unregister_pernet_operations(struct pernet_operations
*ops
)
498 __unregister_pernet_operations(ops
);
501 ida_remove(&net_generic_ids
, *ops
->id
);
505 * register_pernet_subsys - register a network namespace subsystem
506 * @ops: pernet operations structure for the subsystem
508 * Register a subsystem which has init and exit functions
509 * that are called when network namespaces are created and
510 * destroyed respectively.
512 * When registered all network namespace init functions are
513 * called for every existing network namespace. Allowing kernel
514 * modules to have a race free view of the set of network namespaces.
516 * When a new network namespace is created all of the init
517 * methods are called in the order in which they were registered.
519 * When a network namespace is destroyed all of the exit methods
520 * are called in the reverse of the order with which they were
523 int register_pernet_subsys(struct pernet_operations
*ops
)
526 mutex_lock(&net_mutex
);
527 error
= register_pernet_operations(first_device
, ops
);
528 mutex_unlock(&net_mutex
);
531 EXPORT_SYMBOL_GPL(register_pernet_subsys
);
534 * unregister_pernet_subsys - unregister a network namespace subsystem
535 * @ops: pernet operations structure to manipulate
537 * Remove the pernet operations structure from the list to be
538 * used when network namespaces are created or destroyed. In
539 * addition run the exit method for all existing network
542 void unregister_pernet_subsys(struct pernet_operations
*ops
)
544 mutex_lock(&net_mutex
);
545 unregister_pernet_operations(ops
);
546 mutex_unlock(&net_mutex
);
548 EXPORT_SYMBOL_GPL(unregister_pernet_subsys
);
551 * register_pernet_device - register a network namespace device
552 * @ops: pernet operations structure for the subsystem
554 * Register a device which has init and exit functions
555 * that are called when network namespaces are created and
556 * destroyed respectively.
558 * When registered all network namespace init functions are
559 * called for every existing network namespace. Allowing kernel
560 * modules to have a race free view of the set of network namespaces.
562 * When a new network namespace is created all of the init
563 * methods are called in the order in which they were registered.
565 * When a network namespace is destroyed all of the exit methods
566 * are called in the reverse of the order with which they were
569 int register_pernet_device(struct pernet_operations
*ops
)
572 mutex_lock(&net_mutex
);
573 error
= register_pernet_operations(&pernet_list
, ops
);
574 if (!error
&& (first_device
== &pernet_list
))
575 first_device
= &ops
->list
;
576 mutex_unlock(&net_mutex
);
579 EXPORT_SYMBOL_GPL(register_pernet_device
);
582 * unregister_pernet_device - unregister a network namespace netdevice
583 * @ops: pernet operations structure to manipulate
585 * Remove the pernet operations structure from the list to be
586 * used when network namespaces are created or destroyed. In
587 * addition run the exit method for all existing network
590 void unregister_pernet_device(struct pernet_operations
*ops
)
592 mutex_lock(&net_mutex
);
593 if (&ops
->list
== first_device
)
594 first_device
= first_device
->next
;
595 unregister_pernet_operations(ops
);
596 mutex_unlock(&net_mutex
);
598 EXPORT_SYMBOL_GPL(unregister_pernet_device
);
601 static void *netns_get(struct task_struct
*task
)
603 struct net
*net
= NULL
;
604 struct nsproxy
*nsproxy
;
607 nsproxy
= task_nsproxy(task
);
609 net
= get_net(nsproxy
->net_ns
);
615 static void netns_put(void *ns
)
620 static int netns_install(struct nsproxy
*nsproxy
, void *ns
)
622 put_net(nsproxy
->net_ns
);
623 nsproxy
->net_ns
= get_net(ns
);
627 const struct proc_ns_operations netns_operations
= {
629 .type
= CLONE_NEWNET
,
632 .install
= netns_install
,