netns: fix net_generic array leak
[linux-3.10.git] / net / core / net_namespace.c
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 <linux/idr.h>
9 #include <net/net_namespace.h>
10 #include <net/netns/generic.h>
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
20 LIST_HEAD(net_namespace_list);
21 EXPORT_SYMBOL_GPL(net_namespace_list);
22
23 struct net init_net;
24 EXPORT_SYMBOL(init_net);
25
26 #define INITIAL_NET_GEN_PTRS    13 /* +1 for len +2 for rcu_head */
27
28 /*
29  * setup_net runs the initializers for the network namespace object.
30  */
31 static __net_init int setup_net(struct net *net)
32 {
33         /* Must be called with net_mutex held */
34         struct pernet_operations *ops;
35         int error;
36         struct net_generic *ng;
37
38         atomic_set(&net->count, 1);
39 #ifdef NETNS_REFCNT_DEBUG
40         atomic_set(&net->use_count, 0);
41 #endif
42
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;
50         INIT_RCU_HEAD(&ng->rcu);
51         rcu_assign_pointer(net->gen, ng);
52
53         error = 0;
54         list_for_each_entry(ops, &pernet_list, list) {
55                 if (ops->init) {
56                         error = ops->init(net);
57                         if (error < 0)
58                                 goto out_undo;
59                 }
60         }
61 out:
62         return error;
63
64 out_undo:
65         /* Walk through the list backwards calling the exit functions
66          * for the pernet modules whose init functions did not fail.
67          */
68         list_for_each_entry_continue_reverse(ops, &pernet_list, list) {
69                 if (ops->exit)
70                         ops->exit(net);
71         }
72
73         rcu_barrier();
74         kfree(ng);
75         goto out;
76 }
77
78 #ifdef CONFIG_NET_NS
79 static struct kmem_cache *net_cachep;
80 static struct workqueue_struct *netns_wq;
81
82 static struct net *net_alloc(void)
83 {
84         return kmem_cache_zalloc(net_cachep, GFP_KERNEL);
85 }
86
87 static void net_free(struct net *net)
88 {
89         if (!net)
90                 return;
91
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));
96                 return;
97         }
98 #endif
99         kfree(net->gen);
100         kmem_cache_free(net_cachep, net);
101 }
102
103 struct net *copy_net_ns(unsigned long flags, struct net *old_net)
104 {
105         struct net *new_net = NULL;
106         int err;
107
108         get_net(old_net);
109
110         if (!(flags & CLONE_NEWNET))
111                 return old_net;
112
113         err = -ENOMEM;
114         new_net = net_alloc();
115         if (!new_net)
116                 goto out;
117
118         mutex_lock(&net_mutex);
119         err = setup_net(new_net);
120         if (err)
121                 goto out_unlock;
122
123         rtnl_lock();
124         list_add_tail(&new_net->list, &net_namespace_list);
125         rtnl_unlock();
126
127
128 out_unlock:
129         mutex_unlock(&net_mutex);
130 out:
131         put_net(old_net);
132         if (err) {
133                 net_free(new_net);
134                 new_net = ERR_PTR(err);
135         }
136         return new_net;
137 }
138
139 static void cleanup_net(struct work_struct *work)
140 {
141         struct pernet_operations *ops;
142         struct net *net;
143
144         /* Be very certain incoming network packets will not find us */
145         rcu_barrier();
146
147         net = container_of(work, struct net, work);
148
149         mutex_lock(&net_mutex);
150
151         /* Don't let anyone else find us. */
152         rtnl_lock();
153         list_del(&net->list);
154         rtnl_unlock();
155
156         /* Run all of the network namespace exit methods */
157         list_for_each_entry_reverse(ops, &pernet_list, list) {
158                 if (ops->exit)
159                         ops->exit(net);
160         }
161
162         mutex_unlock(&net_mutex);
163
164         /* Ensure there are no outstanding rcu callbacks using this
165          * network namespace.
166          */
167         rcu_barrier();
168
169         /* Finally it is safe to free my network namespace structure */
170         net_free(net);
171 }
172
173 void __put_net(struct net *net)
174 {
175         /* Cleanup the network namespace in process context */
176         INIT_WORK(&net->work, cleanup_net);
177         queue_work(netns_wq, &net->work);
178 }
179 EXPORT_SYMBOL_GPL(__put_net);
180
181 #else
182 struct net *copy_net_ns(unsigned long flags, struct net *old_net)
183 {
184         if (flags & CLONE_NEWNET)
185                 return ERR_PTR(-EINVAL);
186         return old_net;
187 }
188 #endif
189
190 static int __init net_ns_init(void)
191 {
192         int err;
193
194         printk(KERN_INFO "net_namespace: %zd bytes\n", sizeof(struct net));
195 #ifdef CONFIG_NET_NS
196         net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
197                                         SMP_CACHE_BYTES,
198                                         SLAB_PANIC, NULL);
199
200         /* Create workqueue for cleanup */
201         netns_wq = create_singlethread_workqueue("netns");
202         if (!netns_wq)
203                 panic("Could not create netns workq");
204 #endif
205
206         mutex_lock(&net_mutex);
207         err = setup_net(&init_net);
208
209         rtnl_lock();
210         list_add_tail(&init_net.list, &net_namespace_list);
211         rtnl_unlock();
212
213         mutex_unlock(&net_mutex);
214         if (err)
215                 panic("Could not setup the initial network namespace");
216
217         return 0;
218 }
219
220 pure_initcall(net_ns_init);
221
222 #ifdef CONFIG_NET_NS
223 static int register_pernet_operations(struct list_head *list,
224                                       struct pernet_operations *ops)
225 {
226         struct net *net, *undo_net;
227         int error;
228
229         list_add_tail(&ops->list, list);
230         if (ops->init) {
231                 for_each_net(net) {
232                         error = ops->init(net);
233                         if (error)
234                                 goto out_undo;
235                 }
236         }
237         return 0;
238
239 out_undo:
240         /* If I have an error cleanup all namespaces I initialized */
241         list_del(&ops->list);
242         if (ops->exit) {
243                 for_each_net(undo_net) {
244                         if (undo_net == net)
245                                 goto undone;
246                         ops->exit(undo_net);
247                 }
248         }
249 undone:
250         return error;
251 }
252
253 static void unregister_pernet_operations(struct pernet_operations *ops)
254 {
255         struct net *net;
256
257         list_del(&ops->list);
258         if (ops->exit)
259                 for_each_net(net)
260                         ops->exit(net);
261 }
262
263 #else
264
265 static int register_pernet_operations(struct list_head *list,
266                                       struct pernet_operations *ops)
267 {
268         if (ops->init == NULL)
269                 return 0;
270         return ops->init(&init_net);
271 }
272
273 static void unregister_pernet_operations(struct pernet_operations *ops)
274 {
275         if (ops->exit)
276                 ops->exit(&init_net);
277 }
278 #endif
279
280 static DEFINE_IDA(net_generic_ids);
281
282 /**
283  *      register_pernet_subsys - register a network namespace subsystem
284  *      @ops:  pernet operations structure for the subsystem
285  *
286  *      Register a subsystem which has init and exit functions
287  *      that are called when network namespaces are created and
288  *      destroyed respectively.
289  *
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.
293  *
294  *      When a new network namespace is created all of the init
295  *      methods are called in the order in which they were registered.
296  *
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
299  *      registered.
300  */
301 int register_pernet_subsys(struct pernet_operations *ops)
302 {
303         int error;
304         mutex_lock(&net_mutex);
305         error =  register_pernet_operations(first_device, ops);
306         mutex_unlock(&net_mutex);
307         return error;
308 }
309 EXPORT_SYMBOL_GPL(register_pernet_subsys);
310
311 /**
312  *      unregister_pernet_subsys - unregister a network namespace subsystem
313  *      @ops: pernet operations structure to manipulate
314  *
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
318  *      namespaces.
319  */
320 void unregister_pernet_subsys(struct pernet_operations *module)
321 {
322         mutex_lock(&net_mutex);
323         unregister_pernet_operations(module);
324         mutex_unlock(&net_mutex);
325 }
326 EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
327
328 /**
329  *      register_pernet_device - register a network namespace device
330  *      @ops:  pernet operations structure for the subsystem
331  *
332  *      Register a device which has init and exit functions
333  *      that are called when network namespaces are created and
334  *      destroyed respectively.
335  *
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.
339  *
340  *      When a new network namespace is created all of the init
341  *      methods are called in the order in which they were registered.
342  *
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
345  *      registered.
346  */
347 int register_pernet_device(struct pernet_operations *ops)
348 {
349         int error;
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);
355         return error;
356 }
357 EXPORT_SYMBOL_GPL(register_pernet_device);
358
359 int register_pernet_gen_device(int *id, struct pernet_operations *ops)
360 {
361         int error;
362         mutex_lock(&net_mutex);
363 again:
364         error = ida_get_new_above(&net_generic_ids, 1, id);
365         if (error) {
366                 if (error == -EAGAIN) {
367                         ida_pre_get(&net_generic_ids, GFP_KERNEL);
368                         goto again;
369                 }
370                 goto out;
371         }
372         error = register_pernet_operations(&pernet_list, ops);
373         if (error)
374                 ida_remove(&net_generic_ids, *id);
375         else if (first_device == &pernet_list)
376                 first_device = &ops->list;
377 out:
378         mutex_unlock(&net_mutex);
379         return error;
380 }
381 EXPORT_SYMBOL_GPL(register_pernet_gen_device);
382
383 /**
384  *      unregister_pernet_device - unregister a network namespace netdevice
385  *      @ops: pernet operations structure to manipulate
386  *
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
390  *      namespaces.
391  */
392 void unregister_pernet_device(struct pernet_operations *ops)
393 {
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);
399 }
400 EXPORT_SYMBOL_GPL(unregister_pernet_device);
401
402 void unregister_pernet_gen_device(int id, struct pernet_operations *ops)
403 {
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);
410 }
411 EXPORT_SYMBOL_GPL(unregister_pernet_gen_device);
412
413 static void net_generic_release(struct rcu_head *rcu)
414 {
415         struct net_generic *ng;
416
417         ng = container_of(rcu, struct net_generic, rcu);
418         kfree(ng);
419 }
420
421 int net_assign_generic(struct net *net, int id, void *data)
422 {
423         struct net_generic *ng, *old_ng;
424
425         BUG_ON(!mutex_is_locked(&net_mutex));
426         BUG_ON(id == 0);
427
428         ng = old_ng = net->gen;
429         if (old_ng->len >= id)
430                 goto assign;
431
432         ng = kzalloc(sizeof(struct net_generic) +
433                         id * sizeof(void *), GFP_KERNEL);
434         if (ng == NULL)
435                 return -ENOMEM;
436
437         /*
438          * Some synchronisation notes:
439          *
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).
443          *
444          * That said, we simply duplicate this array and schedule
445          * the old copy for kfree after a grace period.
446          */
447
448         ng->len = id;
449         INIT_RCU_HEAD(&ng->rcu);
450         memcpy(&ng->ptr, &old_ng->ptr, old_ng->len);
451
452         rcu_assign_pointer(net->gen, ng);
453         call_rcu(&old_ng->rcu, net_generic_release);
454 assign:
455         ng->ptr[id - 1] = data;
456         return 0;
457 }
458 EXPORT_SYMBOL_GPL(net_assign_generic);