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 <net/net_namespace.h>
10 #include <net/netns/generic.h>
13 * Our network namespace constructor/destructor lists
16 static LIST_HEAD(pernet_list
);
17 static struct list_head
*first_device
= &pernet_list
;
18 static DEFINE_MUTEX(net_mutex
);
20 LIST_HEAD(net_namespace_list
);
21 EXPORT_SYMBOL_GPL(net_namespace_list
);
24 EXPORT_SYMBOL(init_net
);
26 #define INITIAL_NET_GEN_PTRS 13 /* +1 for len +2 for rcu_head */
29 * setup_net runs the initializers for the network namespace object.
31 static __net_init
int setup_net(struct net
*net
)
33 /* Must be called with net_mutex held */
34 struct pernet_operations
*ops
;
36 struct net_generic
*ng
;
38 atomic_set(&net
->count
, 1);
39 #ifdef NETNS_REFCNT_DEBUG
40 atomic_set(&net
->use_count
, 0);
44 ng
= kzalloc(sizeof(struct net_generic
) +
45 INITIAL_NET_GEN_PTRS
* sizeof(void *), GFP_KERNEL
);
49 ng
->len
= INITIAL_NET_GEN_PTRS
;
50 INIT_RCU_HEAD(&ng
->rcu
);
51 rcu_assign_pointer(net
->gen
, ng
);
54 list_for_each_entry(ops
, &pernet_list
, list
) {
56 error
= ops
->init(net
);
65 /* Walk through the list backwards calling the exit functions
66 * for the pernet modules whose init functions did not fail.
68 list_for_each_entry_continue_reverse(ops
, &pernet_list
, list
) {
79 static struct kmem_cache
*net_cachep
;
80 static struct workqueue_struct
*netns_wq
;
82 static struct net
*net_alloc(void)
84 return kmem_cache_zalloc(net_cachep
, GFP_KERNEL
);
87 static void net_free(struct net
*net
)
92 #ifdef NETNS_REFCNT_DEBUG
93 if (unlikely(atomic_read(&net
->use_count
) != 0)) {
94 printk(KERN_EMERG
"network namespace not free! Usage: %d\n",
95 atomic_read(&net
->use_count
));
100 kmem_cache_free(net_cachep
, net
);
103 struct net
*copy_net_ns(unsigned long flags
, struct net
*old_net
)
105 struct net
*new_net
= NULL
;
110 if (!(flags
& CLONE_NEWNET
))
114 new_net
= net_alloc();
118 mutex_lock(&net_mutex
);
119 err
= setup_net(new_net
);
124 list_add_tail(&new_net
->list
, &net_namespace_list
);
129 mutex_unlock(&net_mutex
);
134 new_net
= ERR_PTR(err
);
139 static void cleanup_net(struct work_struct
*work
)
141 struct pernet_operations
*ops
;
144 /* Be very certain incoming network packets will not find us */
147 net
= container_of(work
, struct net
, work
);
149 mutex_lock(&net_mutex
);
151 /* Don't let anyone else find us. */
153 list_del(&net
->list
);
156 /* Run all of the network namespace exit methods */
157 list_for_each_entry_reverse(ops
, &pernet_list
, list
) {
162 mutex_unlock(&net_mutex
);
164 /* Ensure there are no outstanding rcu callbacks using this
169 /* Finally it is safe to free my network namespace structure */
173 void __put_net(struct net
*net
)
175 /* Cleanup the network namespace in process context */
176 INIT_WORK(&net
->work
, cleanup_net
);
177 queue_work(netns_wq
, &net
->work
);
179 EXPORT_SYMBOL_GPL(__put_net
);
182 struct net
*copy_net_ns(unsigned long flags
, struct net
*old_net
)
184 if (flags
& CLONE_NEWNET
)
185 return ERR_PTR(-EINVAL
);
190 static int __init
net_ns_init(void)
194 printk(KERN_INFO
"net_namespace: %zd bytes\n", sizeof(struct net
));
196 net_cachep
= kmem_cache_create("net_namespace", sizeof(struct net
),
200 /* Create workqueue for cleanup */
201 netns_wq
= create_singlethread_workqueue("netns");
203 panic("Could not create netns workq");
206 mutex_lock(&net_mutex
);
207 err
= setup_net(&init_net
);
210 list_add_tail(&init_net
.list
, &net_namespace_list
);
213 mutex_unlock(&net_mutex
);
215 panic("Could not setup the initial network namespace");
220 pure_initcall(net_ns_init
);
223 static int register_pernet_operations(struct list_head
*list
,
224 struct pernet_operations
*ops
)
226 struct net
*net
, *undo_net
;
229 list_add_tail(&ops
->list
, list
);
232 error
= ops
->init(net
);
240 /* If I have an error cleanup all namespaces I initialized */
241 list_del(&ops
->list
);
243 for_each_net(undo_net
) {
253 static void unregister_pernet_operations(struct pernet_operations
*ops
)
257 list_del(&ops
->list
);
265 static int register_pernet_operations(struct list_head
*list
,
266 struct pernet_operations
*ops
)
268 if (ops
->init
== NULL
)
270 return ops
->init(&init_net
);
273 static void unregister_pernet_operations(struct pernet_operations
*ops
)
276 ops
->exit(&init_net
);
280 static DEFINE_IDA(net_generic_ids
);
283 * register_pernet_subsys - register a network namespace subsystem
284 * @ops: pernet operations structure for the subsystem
286 * Register a subsystem which has init and exit functions
287 * that are called when network namespaces are created and
288 * destroyed respectively.
290 * When registered all network namespace init functions are
291 * called for every existing network namespace. Allowing kernel
292 * modules to have a race free view of the set of network namespaces.
294 * When a new network namespace is created all of the init
295 * methods are called in the order in which they were registered.
297 * When a network namespace is destroyed all of the exit methods
298 * are called in the reverse of the order with which they were
301 int register_pernet_subsys(struct pernet_operations
*ops
)
304 mutex_lock(&net_mutex
);
305 error
= register_pernet_operations(first_device
, ops
);
306 mutex_unlock(&net_mutex
);
309 EXPORT_SYMBOL_GPL(register_pernet_subsys
);
312 * unregister_pernet_subsys - unregister a network namespace subsystem
313 * @ops: pernet operations structure to manipulate
315 * Remove the pernet operations structure from the list to be
316 * used when network namespaces are created or destroyed. In
317 * addition run the exit method for all existing network
320 void unregister_pernet_subsys(struct pernet_operations
*module
)
322 mutex_lock(&net_mutex
);
323 unregister_pernet_operations(module
);
324 mutex_unlock(&net_mutex
);
326 EXPORT_SYMBOL_GPL(unregister_pernet_subsys
);
329 * register_pernet_device - register a network namespace device
330 * @ops: pernet operations structure for the subsystem
332 * Register a device which has init and exit functions
333 * that are called when network namespaces are created and
334 * destroyed respectively.
336 * When registered all network namespace init functions are
337 * called for every existing network namespace. Allowing kernel
338 * modules to have a race free view of the set of network namespaces.
340 * When a new network namespace is created all of the init
341 * methods are called in the order in which they were registered.
343 * When a network namespace is destroyed all of the exit methods
344 * are called in the reverse of the order with which they were
347 int register_pernet_device(struct pernet_operations
*ops
)
350 mutex_lock(&net_mutex
);
351 error
= register_pernet_operations(&pernet_list
, ops
);
352 if (!error
&& (first_device
== &pernet_list
))
353 first_device
= &ops
->list
;
354 mutex_unlock(&net_mutex
);
357 EXPORT_SYMBOL_GPL(register_pernet_device
);
359 int register_pernet_gen_device(int *id
, struct pernet_operations
*ops
)
362 mutex_lock(&net_mutex
);
364 error
= ida_get_new_above(&net_generic_ids
, 1, id
);
366 if (error
== -EAGAIN
) {
367 ida_pre_get(&net_generic_ids
, GFP_KERNEL
);
372 error
= register_pernet_operations(&pernet_list
, ops
);
374 ida_remove(&net_generic_ids
, *id
);
375 else if (first_device
== &pernet_list
)
376 first_device
= &ops
->list
;
378 mutex_unlock(&net_mutex
);
381 EXPORT_SYMBOL_GPL(register_pernet_gen_device
);
384 * unregister_pernet_device - unregister a network namespace netdevice
385 * @ops: pernet operations structure to manipulate
387 * Remove the pernet operations structure from the list to be
388 * used when network namespaces are created or destroyed. In
389 * addition run the exit method for all existing network
392 void unregister_pernet_device(struct pernet_operations
*ops
)
394 mutex_lock(&net_mutex
);
395 if (&ops
->list
== first_device
)
396 first_device
= first_device
->next
;
397 unregister_pernet_operations(ops
);
398 mutex_unlock(&net_mutex
);
400 EXPORT_SYMBOL_GPL(unregister_pernet_device
);
402 void unregister_pernet_gen_device(int id
, struct pernet_operations
*ops
)
404 mutex_lock(&net_mutex
);
405 if (&ops
->list
== first_device
)
406 first_device
= first_device
->next
;
407 unregister_pernet_operations(ops
);
408 ida_remove(&net_generic_ids
, id
);
409 mutex_unlock(&net_mutex
);
411 EXPORT_SYMBOL_GPL(unregister_pernet_gen_device
);
413 static void net_generic_release(struct rcu_head
*rcu
)
415 struct net_generic
*ng
;
417 ng
= container_of(rcu
, struct net_generic
, rcu
);
421 int net_assign_generic(struct net
*net
, int id
, void *data
)
423 struct net_generic
*ng
, *old_ng
;
425 BUG_ON(!mutex_is_locked(&net_mutex
));
428 ng
= old_ng
= net
->gen
;
429 if (old_ng
->len
>= id
)
432 ng
= kzalloc(sizeof(struct net_generic
) +
433 id
* sizeof(void *), GFP_KERNEL
);
438 * Some synchronisation notes:
440 * The net_generic explores the net->gen array inside rcu
441 * read section. Besides once set the net->gen->ptr[x]
442 * pointer never changes (see rules in netns/generic.h).
444 * That said, we simply duplicate this array and schedule
445 * the old copy for kfree after a grace period.
449 INIT_RCU_HEAD(&ng
->rcu
);
450 memcpy(&ng
->ptr
, &old_ng
->ptr
, old_ng
->len
);
452 rcu_assign_pointer(net
->gen
, ng
);
453 call_rcu(&old_ng
->rcu
, net_generic_release
);
455 ng
->ptr
[id
- 1] = data
;
458 EXPORT_SYMBOL_GPL(net_assign_generic
);