662e6ea1cecfe550929ebc6e89aaec8f9d6b001f
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>
8 #include <net/net_namespace.h>
11 * Our network namespace constructor/destructor lists
14 static LIST_HEAD(pernet_list
);
15 static struct list_head
*first_device
= &pernet_list
;
16 static DEFINE_MUTEX(net_mutex
);
18 LIST_HEAD(net_namespace_list
);
20 static struct kmem_cache
*net_cachep
;
23 EXPORT_SYMBOL_GPL(init_net
);
25 static struct net
*net_alloc(void)
27 return kmem_cache_zalloc(net_cachep
, GFP_KERNEL
);
30 static void net_free(struct net
*net
)
35 if (unlikely(atomic_read(&net
->use_count
) != 0)) {
36 printk(KERN_EMERG
"network namespace not free! Usage: %d\n",
37 atomic_read(&net
->use_count
));
41 kmem_cache_free(net_cachep
, net
);
44 static void cleanup_net(struct work_struct
*work
)
46 struct pernet_operations
*ops
;
49 net
= container_of(work
, struct net
, work
);
51 mutex_lock(&net_mutex
);
53 /* Don't let anyone else find us. */
58 /* Run all of the network namespace exit methods */
59 list_for_each_entry_reverse(ops
, &pernet_list
, list
) {
64 mutex_unlock(&net_mutex
);
66 /* Ensure there are no outstanding rcu callbacks using this
71 /* Finally it is safe to free my network namespace structure */
76 void __put_net(struct net
*net
)
78 /* Cleanup the network namespace in process context */
79 INIT_WORK(&net
->work
, cleanup_net
);
80 schedule_work(&net
->work
);
82 EXPORT_SYMBOL_GPL(__put_net
);
85 * setup_net runs the initializers for the network namespace object.
87 static int setup_net(struct net
*net
)
89 /* Must be called with net_mutex held */
90 struct pernet_operations
*ops
;
93 atomic_set(&net
->count
, 1);
94 atomic_set(&net
->use_count
, 0);
97 list_for_each_entry(ops
, &pernet_list
, list
) {
99 error
= ops
->init(net
);
108 /* Walk through the list backwards calling the exit functions
109 * for the pernet modules whose init functions did not fail.
111 list_for_each_entry_continue_reverse(ops
, &pernet_list
, list
) {
120 struct net
*copy_net_ns(unsigned long flags
, struct net
*old_net
)
122 struct net
*new_net
= NULL
;
127 if (!(flags
& CLONE_NEWNET
))
130 #ifndef CONFIG_NET_NS
131 return ERR_PTR(-EINVAL
);
135 new_net
= net_alloc();
139 mutex_lock(&net_mutex
);
140 err
= setup_net(new_net
);
145 list_add_tail(&new_net
->list
, &net_namespace_list
);
150 mutex_unlock(&net_mutex
);
155 new_net
= ERR_PTR(err
);
160 static int __init
net_ns_init(void)
164 printk(KERN_INFO
"net_namespace: %zd bytes\n", sizeof(struct net
));
165 net_cachep
= kmem_cache_create("net_namespace", sizeof(struct net
),
168 mutex_lock(&net_mutex
);
169 err
= setup_net(&init_net
);
172 list_add_tail(&init_net
.list
, &net_namespace_list
);
175 mutex_unlock(&net_mutex
);
177 panic("Could not setup the initial network namespace");
182 pure_initcall(net_ns_init
);
184 static int register_pernet_operations(struct list_head
*list
,
185 struct pernet_operations
*ops
)
187 struct net
*net
, *undo_net
;
191 list_add_tail(&ops
->list
, list
);
194 error
= ops
->init(net
);
203 /* If I have an error cleanup all namespaces I initialized */
204 list_del(&ops
->list
);
205 for_each_net(undo_net
) {
215 static void unregister_pernet_operations(struct pernet_operations
*ops
)
219 list_del(&ops
->list
);
226 * register_pernet_subsys - register a network namespace subsystem
227 * @ops: pernet operations structure for the subsystem
229 * Register a subsystem which has init and exit functions
230 * that are called when network namespaces are created and
231 * destroyed respectively.
233 * When registered all network namespace init functions are
234 * called for every existing network namespace. Allowing kernel
235 * modules to have a race free view of the set of network namespaces.
237 * When a new network namespace is created all of the init
238 * methods are called in the order in which they were registered.
240 * When a network namespace is destroyed all of the exit methods
241 * are called in the reverse of the order with which they were
244 int register_pernet_subsys(struct pernet_operations
*ops
)
247 mutex_lock(&net_mutex
);
248 error
= register_pernet_operations(first_device
, ops
);
249 mutex_unlock(&net_mutex
);
252 EXPORT_SYMBOL_GPL(register_pernet_subsys
);
255 * unregister_pernet_subsys - unregister a network namespace subsystem
256 * @ops: pernet operations structure to manipulate
258 * Remove the pernet operations structure from the list to be
259 * used when network namespaces are created or destoryed. In
260 * addition run the exit method for all existing network
263 void unregister_pernet_subsys(struct pernet_operations
*module
)
265 mutex_lock(&net_mutex
);
266 unregister_pernet_operations(module
);
267 mutex_unlock(&net_mutex
);
269 EXPORT_SYMBOL_GPL(unregister_pernet_subsys
);
272 * register_pernet_device - register a network namespace device
273 * @ops: pernet operations structure for the subsystem
275 * Register a device which has init and exit functions
276 * that are called when network namespaces are created and
277 * destroyed respectively.
279 * When registered all network namespace init functions are
280 * called for every existing network namespace. Allowing kernel
281 * modules to have a race free view of the set of network namespaces.
283 * When a new network namespace is created all of the init
284 * methods are called in the order in which they were registered.
286 * When a network namespace is destroyed all of the exit methods
287 * are called in the reverse of the order with which they were
290 int register_pernet_device(struct pernet_operations
*ops
)
293 mutex_lock(&net_mutex
);
294 error
= register_pernet_operations(&pernet_list
, ops
);
295 if (!error
&& (first_device
== &pernet_list
))
296 first_device
= &ops
->list
;
297 mutex_unlock(&net_mutex
);
300 EXPORT_SYMBOL_GPL(register_pernet_device
);
303 * unregister_pernet_device - unregister a network namespace netdevice
304 * @ops: pernet operations structure to manipulate
306 * Remove the pernet operations structure from the list to be
307 * used when network namespaces are created or destoryed. In
308 * addition run the exit method for all existing network
311 void unregister_pernet_device(struct pernet_operations
*ops
)
313 mutex_lock(&net_mutex
);
314 if (&ops
->list
== first_device
)
315 first_device
= first_device
->next
;
316 unregister_pernet_operations(ops
);
317 mutex_unlock(&net_mutex
);
319 EXPORT_SYMBOL_GPL(unregister_pernet_device
);
This page took 0.044297 seconds and 4 git commands to generate.