Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3 : :
4 : : #include <linux/workqueue.h>
5 : : #include <linux/rtnetlink.h>
6 : : #include <linux/cache.h>
7 : : #include <linux/slab.h>
8 : : #include <linux/list.h>
9 : : #include <linux/delay.h>
10 : : #include <linux/sched.h>
11 : : #include <linux/idr.h>
12 : : #include <linux/rculist.h>
13 : : #include <linux/nsproxy.h>
14 : : #include <linux/fs.h>
15 : : #include <linux/proc_ns.h>
16 : : #include <linux/file.h>
17 : : #include <linux/export.h>
18 : : #include <linux/user_namespace.h>
19 : : #include <linux/net_namespace.h>
20 : : #include <linux/sched/task.h>
21 : : #include <linux/uidgid.h>
22 : :
23 : : #include <net/sock.h>
24 : : #include <net/netlink.h>
25 : : #include <net/net_namespace.h>
26 : : #include <net/netns/generic.h>
27 : :
28 : : /*
29 : : * Our network namespace constructor/destructor lists
30 : : */
31 : :
32 : : static LIST_HEAD(pernet_list);
33 : : static struct list_head *first_device = &pernet_list;
34 : :
35 : : LIST_HEAD(net_namespace_list);
36 : : EXPORT_SYMBOL_GPL(net_namespace_list);
37 : :
38 : : /* Protects net_namespace_list. Nests iside rtnl_lock() */
39 : : DECLARE_RWSEM(net_rwsem);
40 : : EXPORT_SYMBOL_GPL(net_rwsem);
41 : :
42 : : #ifdef CONFIG_KEYS
43 : : static struct key_tag init_net_key_domain = { .usage = REFCOUNT_INIT(1) };
44 : : #endif
45 : :
46 : : struct net init_net = {
47 : : .count = REFCOUNT_INIT(1),
48 : : .dev_base_head = LIST_HEAD_INIT(init_net.dev_base_head),
49 : : #ifdef CONFIG_KEYS
50 : : .key_domain = &init_net_key_domain,
51 : : #endif
52 : : };
53 : : EXPORT_SYMBOL(init_net);
54 : :
55 : : static bool init_net_initialized;
56 : : /*
57 : : * pernet_ops_rwsem: protects: pernet_list, net_generic_ids,
58 : : * init_net_initialized and first_device pointer.
59 : : * This is internal net namespace object. Please, don't use it
60 : : * outside.
61 : : */
62 : : DECLARE_RWSEM(pernet_ops_rwsem);
63 : : EXPORT_SYMBOL_GPL(pernet_ops_rwsem);
64 : :
65 : : #define MIN_PERNET_OPS_ID \
66 : : ((sizeof(struct net_generic) + sizeof(void *) - 1) / sizeof(void *))
67 : :
68 : : #define INITIAL_NET_GEN_PTRS 13 /* +1 for len +2 for rcu_head */
69 : :
70 : : static unsigned int max_gen_ptrs = INITIAL_NET_GEN_PTRS;
71 : :
72 : 84 : static struct net_generic *net_alloc_generic(void)
73 : : {
74 : 84 : struct net_generic *ng;
75 : 84 : unsigned int generic_size = offsetof(struct net_generic, ptr[max_gen_ptrs]);
76 : :
77 : 84 : ng = kzalloc(generic_size, GFP_KERNEL);
78 [ + - ]: 84 : if (ng)
79 : 84 : ng->s.len = max_gen_ptrs;
80 : :
81 : 84 : return ng;
82 : : }
83 : :
84 : 336 : static int net_assign_generic(struct net *net, unsigned int id, void *data)
85 : : {
86 : 336 : struct net_generic *ng, *old_ng;
87 : :
88 [ - + ]: 336 : BUG_ON(id < MIN_PERNET_OPS_ID);
89 : :
90 : 336 : old_ng = rcu_dereference_protected(net->gen,
91 : : lockdep_is_held(&pernet_ops_rwsem));
92 [ + + ]: 336 : if (old_ng->s.len > id) {
93 : 280 : old_ng->ptr[id] = data;
94 : 280 : return 0;
95 : : }
96 : :
97 : 56 : ng = net_alloc_generic();
98 [ + - ]: 56 : if (ng == NULL)
99 : : return -ENOMEM;
100 : :
101 : : /*
102 : : * Some synchronisation notes:
103 : : *
104 : : * The net_generic explores the net->gen array inside rcu
105 : : * read section. Besides once set the net->gen->ptr[x]
106 : : * pointer never changes (see rules in netns/generic.h).
107 : : *
108 : : * That said, we simply duplicate this array and schedule
109 : : * the old copy for kfree after a grace period.
110 : : */
111 : :
112 : 56 : memcpy(&ng->ptr[MIN_PERNET_OPS_ID], &old_ng->ptr[MIN_PERNET_OPS_ID],
113 : 56 : (old_ng->s.len - MIN_PERNET_OPS_ID) * sizeof(void *));
114 : 56 : ng->ptr[id] = data;
115 : :
116 [ + - ]: 56 : rcu_assign_pointer(net->gen, ng);
117 [ + - ]: 56 : kfree_rcu(old_ng, s.rcu);
118 : : return 0;
119 : : }
120 : :
121 : 2632 : static int ops_init(const struct pernet_operations *ops, struct net *net)
122 : : {
123 : 2632 : int err = -ENOMEM;
124 : 2632 : void *data = NULL;
125 : :
126 [ + + + - ]: 2632 : if (ops->id && ops->size) {
127 : 336 : data = kzalloc(ops->size, GFP_KERNEL);
128 [ - + ]: 336 : if (!data)
129 : 0 : goto out;
130 : :
131 : 336 : err = net_assign_generic(net, *ops->id, data);
132 [ - + ]: 336 : if (err)
133 : 0 : goto cleanup;
134 : : }
135 : 2632 : err = 0;
136 [ + + ]: 2632 : if (ops->init)
137 : 2604 : err = ops->init(net);
138 [ + - ]: 2604 : if (!err)
139 : 2632 : return 0;
140 : :
141 : 0 : cleanup:
142 : 0 : kfree(data);
143 : :
144 : : out:
145 : : return err;
146 : : }
147 : :
148 : 0 : static void ops_free(const struct pernet_operations *ops, struct net *net)
149 : : {
150 [ # # ]: 0 : if (ops->id && ops->size) {
151 : 0 : kfree(net_generic(net, *ops->id));
152 : : }
153 : : }
154 : :
155 : 0 : static void ops_pre_exit_list(const struct pernet_operations *ops,
156 : : struct list_head *net_exit_list)
157 : : {
158 : 0 : struct net *net;
159 : :
160 : 0 : if (ops->pre_exit) {
161 [ # # # # : 0 : list_for_each_entry(net, net_exit_list, exit_list)
# # # # ]
162 : 0 : ops->pre_exit(net);
163 : : }
164 : : }
165 : :
166 : : static void ops_exit_list(const struct pernet_operations *ops,
167 : : struct list_head *net_exit_list)
168 : : {
169 : : struct net *net;
170 : : if (ops->exit) {
171 : : list_for_each_entry(net, net_exit_list, exit_list)
172 : : ops->exit(net);
173 : : }
174 : : if (ops->exit_batch)
175 : : ops->exit_batch(net_exit_list);
176 : : }
177 : :
178 : 0 : static void ops_free_list(const struct pernet_operations *ops,
179 : : struct list_head *net_exit_list)
180 : : {
181 : 0 : struct net *net;
182 [ # # # # ]: 0 : if (ops->size && ops->id) {
183 [ # # ]: 0 : list_for_each_entry(net, net_exit_list, exit_list)
184 [ # # ]: 0 : ops_free(ops, net);
185 : : }
186 : 0 : }
187 : :
188 : : /* should be called with nsid_lock held */
189 : 0 : static int alloc_netid(struct net *net, struct net *peer, int reqid)
190 : : {
191 : 0 : int min = 0, max = 0;
192 : :
193 : 0 : if (reqid >= 0) {
194 : 0 : min = reqid;
195 : 0 : max = reqid + 1;
196 : : }
197 : :
198 : 0 : return idr_alloc(&net->netns_ids, peer, min, max, GFP_ATOMIC);
199 : : }
200 : :
201 : : /* This function is used by idr_for_each(). If net is equal to peer, the
202 : : * function returns the id so that idr_for_each() stops. Because we cannot
203 : : * returns the id 0 (idr_for_each() will not stop), we return the magic value
204 : : * NET_ID_ZERO (-1) for it.
205 : : */
206 : : #define NET_ID_ZERO -1
207 : 0 : static int net_eq_idr(int id, void *net, void *peer)
208 : : {
209 [ # # ]: 0 : if (net_eq(net, peer))
210 [ # # ]: 0 : return id ? : NET_ID_ZERO;
211 : : return 0;
212 : : }
213 : :
214 : : /* Must be called from RCU-critical section or with nsid_lock held */
215 : 15779 : static int __peernet2id(const struct net *net, struct net *peer)
216 : : {
217 : 15779 : int id = idr_for_each(&net->netns_ids, net_eq_idr, peer);
218 : :
219 : : /* Magic value for id 0. */
220 [ - - - - : 15779 : if (id == NET_ID_ZERO)
- - - - -
- - - + -
- - ]
221 : : return 0;
222 [ - - - - : 15779 : if (id > 0)
- - - - -
- - - - +
- - ]
223 : 0 : return id;
224 : :
225 : : return NETNSA_NSID_NOT_ASSIGNED;
226 : : }
227 : :
228 : : static void rtnl_net_notifyid(struct net *net, int cmd, int id, u32 portid,
229 : : struct nlmsghdr *nlh, gfp_t gfp);
230 : : /* This function returns the id of a peer netns. If no id is assigned, one will
231 : : * be allocated and returned.
232 : : */
233 : 0 : int peernet2id_alloc(struct net *net, struct net *peer, gfp_t gfp)
234 : : {
235 : 0 : int id;
236 : :
237 [ # # ]: 0 : if (refcount_read(&net->count) == 0)
238 : : return NETNSA_NSID_NOT_ASSIGNED;
239 : :
240 : 0 : spin_lock(&net->nsid_lock);
241 : 0 : id = __peernet2id(net, peer);
242 : 0 : if (id >= 0) {
243 : 0 : spin_unlock(&net->nsid_lock);
244 : 0 : return id;
245 : : }
246 : :
247 : : /* When peer is obtained from RCU lists, we may race with
248 : : * its cleanup. Check whether it's alive, and this guarantees
249 : : * we never hash a peer back to net->netns_ids, after it has
250 : : * just been idr_remove()'d from there in cleanup_net().
251 : : */
252 [ # # ]: 0 : if (!maybe_get_net(peer)) {
253 : 0 : spin_unlock(&net->nsid_lock);
254 : 0 : return NETNSA_NSID_NOT_ASSIGNED;
255 : : }
256 : :
257 : 0 : id = alloc_netid(net, peer, -1);
258 : 0 : spin_unlock(&net->nsid_lock);
259 : :
260 : 0 : put_net(peer);
261 [ # # ]: 0 : if (id < 0)
262 : : return NETNSA_NSID_NOT_ASSIGNED;
263 : :
264 : 0 : rtnl_net_notifyid(net, RTM_NEWNSID, id, 0, NULL, gfp);
265 : :
266 : 0 : return id;
267 : : }
268 : : EXPORT_SYMBOL_GPL(peernet2id_alloc);
269 : :
270 : : /* This function returns, if assigned, the id of a peer netns. */
271 : 15779 : int peernet2id(const struct net *net, struct net *peer)
272 : : {
273 : 15779 : int id;
274 : :
275 : 15779 : rcu_read_lock();
276 : 15779 : id = __peernet2id(net, peer);
277 : 15779 : rcu_read_unlock();
278 : :
279 : 15779 : return id;
280 : : }
281 : : EXPORT_SYMBOL(peernet2id);
282 : :
283 : : /* This function returns true is the peer netns has an id assigned into the
284 : : * current netns.
285 : : */
286 : 0 : bool peernet_has_id(const struct net *net, struct net *peer)
287 : : {
288 : 0 : return peernet2id(net, peer) >= 0;
289 : : }
290 : :
291 : 0 : struct net *get_net_ns_by_id(const struct net *net, int id)
292 : : {
293 : 0 : struct net *peer;
294 : :
295 [ # # ]: 0 : if (id < 0)
296 : : return NULL;
297 : :
298 : 0 : rcu_read_lock();
299 : 0 : peer = idr_find(&net->netns_ids, id);
300 [ # # ]: 0 : if (peer)
301 : 0 : peer = maybe_get_net(peer);
302 : 0 : rcu_read_unlock();
303 : :
304 : 0 : return peer;
305 : : }
306 : :
307 : : /*
308 : : * setup_net runs the initializers for the network namespace object.
309 : : */
310 : 28 : static __net_init int setup_net(struct net *net, struct user_namespace *user_ns)
311 : : {
312 : : /* Must be called with pernet_ops_rwsem held */
313 : 28 : const struct pernet_operations *ops, *saved_ops;
314 : 28 : int error = 0;
315 : 28 : LIST_HEAD(net_exit_list);
316 : :
317 : 28 : refcount_set(&net->count, 1);
318 : 28 : refcount_set(&net->passive, 1);
319 : 28 : get_random_bytes(&net->hash_mix, sizeof(u32));
320 : 28 : net->dev_base_seq = 1;
321 : 28 : net->user_ns = user_ns;
322 : 28 : idr_init(&net->netns_ids);
323 : 28 : spin_lock_init(&net->nsid_lock);
324 : 28 : mutex_init(&net->ipv4.ra_mutex);
325 : :
326 [ + + ]: 56 : list_for_each_entry(ops, &pernet_list, list) {
327 : 28 : error = ops_init(ops, net);
328 [ - + ]: 28 : if (error < 0)
329 : 0 : goto out_undo;
330 : : }
331 : 28 : down_write(&net_rwsem);
332 : 28 : list_add_tail_rcu(&net->list, &net_namespace_list);
333 : 28 : up_write(&net_rwsem);
334 : 28 : out:
335 : 28 : return error;
336 : :
337 : : out_undo:
338 : : /* Walk through the list backwards calling the exit functions
339 : : * for the pernet modules whose init functions did not fail.
340 : : */
341 : 0 : list_add(&net->exit_list, &net_exit_list);
342 : 0 : saved_ops = ops;
343 [ # # ]: 0 : list_for_each_entry_continue_reverse(ops, &pernet_list, list)
344 [ # # ]: 0 : ops_pre_exit_list(ops, &net_exit_list);
345 : :
346 : 0 : synchronize_rcu();
347 : :
348 : 0 : ops = saved_ops;
349 [ # # ]: 0 : list_for_each_entry_continue_reverse(ops, &pernet_list, list)
350 : 0 : ops_exit_list(ops, &net_exit_list);
351 : :
352 : 0 : ops = saved_ops;
353 [ # # ]: 0 : list_for_each_entry_continue_reverse(ops, &pernet_list, list)
354 : 0 : ops_free_list(ops, &net_exit_list);
355 : :
356 : 0 : rcu_barrier();
357 : 0 : goto out;
358 : : }
359 : :
360 : 28 : static int __net_init net_defaults_init_net(struct net *net)
361 : : {
362 : 28 : net->core.sysctl_somaxconn = SOMAXCONN;
363 : 28 : return 0;
364 : : }
365 : :
366 : : static struct pernet_operations net_defaults_ops = {
367 : : .init = net_defaults_init_net,
368 : : };
369 : :
370 : 28 : static __init int net_defaults_init(void)
371 : : {
372 [ - + ]: 28 : if (register_pernet_subsys(&net_defaults_ops))
373 : 0 : panic("Cannot initialize net default settings");
374 : :
375 : 28 : return 0;
376 : : }
377 : :
378 : : core_initcall(net_defaults_init);
379 : :
380 : : #ifdef CONFIG_NET_NS
381 : 0 : static struct ucounts *inc_net_namespaces(struct user_namespace *ns)
382 : : {
383 : 0 : return inc_ucount(ns, current_euid(), UCOUNT_NET_NAMESPACES);
384 : : }
385 : :
386 : 0 : static void dec_net_namespaces(struct ucounts *ucounts)
387 : : {
388 : 0 : dec_ucount(ucounts, UCOUNT_NET_NAMESPACES);
389 : : }
390 : :
391 : : static struct kmem_cache *net_cachep __ro_after_init;
392 : : static struct workqueue_struct *netns_wq;
393 : :
394 : 0 : static struct net *net_alloc(void)
395 : : {
396 : 0 : struct net *net = NULL;
397 : 0 : struct net_generic *ng;
398 : :
399 : 0 : ng = net_alloc_generic();
400 [ # # ]: 0 : if (!ng)
401 : 0 : goto out;
402 : :
403 : 0 : net = kmem_cache_zalloc(net_cachep, GFP_KERNEL);
404 [ # # ]: 0 : if (!net)
405 : 0 : goto out_free;
406 : :
407 : : #ifdef CONFIG_KEYS
408 : 0 : net->key_domain = kzalloc(sizeof(struct key_tag), GFP_KERNEL);
409 [ # # ]: 0 : if (!net->key_domain)
410 : 0 : goto out_free_2;
411 : 0 : refcount_set(&net->key_domain->usage, 1);
412 : : #endif
413 : :
414 : 0 : rcu_assign_pointer(net->gen, ng);
415 : 0 : out:
416 : 0 : return net;
417 : :
418 : : #ifdef CONFIG_KEYS
419 : : out_free_2:
420 : 0 : kmem_cache_free(net_cachep, net);
421 : 0 : net = NULL;
422 : : #endif
423 : 0 : out_free:
424 : 0 : kfree(ng);
425 : 0 : goto out;
426 : : }
427 : :
428 : 0 : static void net_free(struct net *net)
429 : : {
430 : 0 : kfree(rcu_access_pointer(net->gen));
431 : 0 : kmem_cache_free(net_cachep, net);
432 : 0 : }
433 : :
434 : 28 : void net_drop_ns(void *p)
435 : : {
436 : 28 : struct net *ns = p;
437 [ + - - + ]: 28 : if (ns && refcount_dec_and_test(&ns->passive))
438 : 0 : net_free(ns);
439 : 28 : }
440 : :
441 : 84 : struct net *copy_net_ns(unsigned long flags,
442 : : struct user_namespace *user_ns, struct net *old_net)
443 : : {
444 : 84 : struct ucounts *ucounts;
445 : 84 : struct net *net;
446 : 84 : int rv;
447 : :
448 [ + - ]: 84 : if (!(flags & CLONE_NEWNET))
449 : 84 : return get_net(old_net);
450 : :
451 : 0 : ucounts = inc_net_namespaces(user_ns);
452 [ # # ]: 0 : if (!ucounts)
453 : : return ERR_PTR(-ENOSPC);
454 : :
455 : 0 : net = net_alloc();
456 [ # # ]: 0 : if (!net) {
457 : 0 : rv = -ENOMEM;
458 : 0 : goto dec_ucounts;
459 : : }
460 : 0 : refcount_set(&net->passive, 1);
461 : 0 : net->ucounts = ucounts;
462 : 0 : get_user_ns(user_ns);
463 : :
464 : 0 : rv = down_read_killable(&pernet_ops_rwsem);
465 [ # # ]: 0 : if (rv < 0)
466 : 0 : goto put_userns;
467 : :
468 : 0 : rv = setup_net(net, user_ns);
469 : :
470 : 0 : up_read(&pernet_ops_rwsem);
471 : :
472 [ # # ]: 0 : if (rv < 0) {
473 : 0 : put_userns:
474 : 0 : key_remove_domain(net->key_domain);
475 : 0 : put_user_ns(user_ns);
476 : 0 : net_drop_ns(net);
477 : 0 : dec_ucounts:
478 : 0 : dec_net_namespaces(ucounts);
479 : 0 : return ERR_PTR(rv);
480 : : }
481 : : return net;
482 : : }
483 : :
484 : : /**
485 : : * net_ns_get_ownership - get sysfs ownership data for @net
486 : : * @net: network namespace in question (can be NULL)
487 : : * @uid: kernel user ID for sysfs objects
488 : : * @gid: kernel group ID for sysfs objects
489 : : *
490 : : * Returns the uid/gid pair of root in the user namespace associated with the
491 : : * given network namespace.
492 : : */
493 : 672 : void net_ns_get_ownership(const struct net *net, kuid_t *uid, kgid_t *gid)
494 : : {
495 [ + - ]: 672 : if (net) {
496 : 672 : kuid_t ns_root_uid = make_kuid(net->user_ns, 0);
497 : 672 : kgid_t ns_root_gid = make_kgid(net->user_ns, 0);
498 : :
499 : 672 : if (uid_valid(ns_root_uid))
500 : 672 : *uid = ns_root_uid;
501 : :
502 : 672 : if (gid_valid(ns_root_gid))
503 : 672 : *gid = ns_root_gid;
504 : : } else {
505 : 0 : *uid = GLOBAL_ROOT_UID;
506 : 0 : *gid = GLOBAL_ROOT_GID;
507 : : }
508 : 672 : }
509 : : EXPORT_SYMBOL_GPL(net_ns_get_ownership);
510 : :
511 : 0 : static void unhash_nsid(struct net *net, struct net *last)
512 : : {
513 : 0 : struct net *tmp;
514 : : /* This function is only called from cleanup_net() work,
515 : : * and this work is the only process, that may delete
516 : : * a net from net_namespace_list. So, when the below
517 : : * is executing, the list may only grow. Thus, we do not
518 : : * use for_each_net_rcu() or net_rwsem.
519 : : */
520 [ # # ]: 0 : for_each_net(tmp) {
521 : 0 : int id;
522 : :
523 : 0 : spin_lock(&tmp->nsid_lock);
524 : 0 : id = __peernet2id(tmp, net);
525 : : if (id >= 0)
526 : 0 : idr_remove(&tmp->netns_ids, id);
527 : 0 : spin_unlock(&tmp->nsid_lock);
528 [ # # ]: 0 : if (id >= 0)
529 : 0 : rtnl_net_notifyid(tmp, RTM_DELNSID, id, 0, NULL,
530 : : GFP_KERNEL);
531 [ # # ]: 0 : if (tmp == last)
532 : : break;
533 : : }
534 : 0 : spin_lock(&net->nsid_lock);
535 : 0 : idr_destroy(&net->netns_ids);
536 : 0 : spin_unlock(&net->nsid_lock);
537 : 0 : }
538 : :
539 : : static LLIST_HEAD(cleanup_list);
540 : :
541 : 0 : static void cleanup_net(struct work_struct *work)
542 : : {
543 : 0 : const struct pernet_operations *ops;
544 : 0 : struct net *net, *tmp, *last;
545 : 0 : struct llist_node *net_kill_list;
546 : 0 : LIST_HEAD(net_exit_list);
547 : :
548 : : /* Atomically snapshot the list of namespaces to cleanup */
549 : 0 : net_kill_list = llist_del_all(&cleanup_list);
550 : :
551 : 0 : down_read(&pernet_ops_rwsem);
552 : :
553 : : /* Don't let anyone else find us. */
554 : 0 : down_write(&net_rwsem);
555 [ # # ]: 0 : llist_for_each_entry(net, net_kill_list, cleanup_list)
556 : 0 : list_del_rcu(&net->list);
557 : : /* Cache last net. After we unlock rtnl, no one new net
558 : : * added to net_namespace_list can assign nsid pointer
559 : : * to a net from net_kill_list (see peernet2id_alloc()).
560 : : * So, we skip them in unhash_nsid().
561 : : *
562 : : * Note, that unhash_nsid() does not delete nsid links
563 : : * between net_kill_list's nets, as they've already
564 : : * deleted from net_namespace_list. But, this would be
565 : : * useless anyway, as netns_ids are destroyed there.
566 : : */
567 : 0 : last = list_last_entry(&net_namespace_list, struct net, list);
568 : 0 : up_write(&net_rwsem);
569 : :
570 [ # # ]: 0 : llist_for_each_entry(net, net_kill_list, cleanup_list) {
571 : 0 : unhash_nsid(net, last);
572 : 0 : list_add_tail(&net->exit_list, &net_exit_list);
573 : : }
574 : :
575 : : /* Run all of the network namespace pre_exit methods */
576 [ # # ]: 0 : list_for_each_entry_reverse(ops, &pernet_list, list)
577 [ # # ]: 0 : ops_pre_exit_list(ops, &net_exit_list);
578 : :
579 : : /*
580 : : * Another CPU might be rcu-iterating the list, wait for it.
581 : : * This needs to be before calling the exit() notifiers, so
582 : : * the rcu_barrier() below isn't sufficient alone.
583 : : * Also the pre_exit() and exit() methods need this barrier.
584 : : */
585 : 0 : synchronize_rcu();
586 : :
587 : : /* Run all of the network namespace exit methods */
588 [ # # ]: 0 : list_for_each_entry_reverse(ops, &pernet_list, list)
589 : 0 : ops_exit_list(ops, &net_exit_list);
590 : :
591 : : /* Free the net generic variables */
592 [ # # ]: 0 : list_for_each_entry_reverse(ops, &pernet_list, list)
593 : 0 : ops_free_list(ops, &net_exit_list);
594 : :
595 : 0 : up_read(&pernet_ops_rwsem);
596 : :
597 : : /* Ensure there are no outstanding rcu callbacks using this
598 : : * network namespace.
599 : : */
600 : 0 : rcu_barrier();
601 : :
602 : : /* Finally it is safe to free my network namespace structure */
603 [ # # ]: 0 : list_for_each_entry_safe(net, tmp, &net_exit_list, exit_list) {
604 : 0 : list_del_init(&net->exit_list);
605 : 0 : dec_net_namespaces(net->ucounts);
606 : 0 : key_remove_domain(net->key_domain);
607 : 0 : put_user_ns(net->user_ns);
608 : 0 : net_drop_ns(net);
609 : : }
610 : 0 : }
611 : :
612 : : /**
613 : : * net_ns_barrier - wait until concurrent net_cleanup_work is done
614 : : *
615 : : * cleanup_net runs from work queue and will first remove namespaces
616 : : * from the global list, then run net exit functions.
617 : : *
618 : : * Call this in module exit path to make sure that all netns
619 : : * ->exit ops have been invoked before the function is removed.
620 : : */
621 : 0 : void net_ns_barrier(void)
622 : : {
623 : 0 : down_write(&pernet_ops_rwsem);
624 : 0 : up_write(&pernet_ops_rwsem);
625 : 0 : }
626 : : EXPORT_SYMBOL(net_ns_barrier);
627 : :
628 : : static DECLARE_WORK(net_cleanup_work, cleanup_net);
629 : :
630 : 0 : void __put_net(struct net *net)
631 : : {
632 : : /* Cleanup the network namespace in process context */
633 [ # # ]: 0 : if (llist_add(&net->cleanup_list, &cleanup_list))
634 : 0 : queue_work(netns_wq, &net_cleanup_work);
635 : 0 : }
636 : : EXPORT_SYMBOL_GPL(__put_net);
637 : :
638 : 0 : struct net *get_net_ns_by_fd(int fd)
639 : : {
640 : 0 : struct file *file;
641 : 0 : struct ns_common *ns;
642 : 0 : struct net *net;
643 : :
644 : 0 : file = proc_ns_fget(fd);
645 [ # # ]: 0 : if (IS_ERR(file))
646 : : return ERR_CAST(file);
647 : :
648 [ # # ]: 0 : ns = get_proc_ns(file_inode(file));
649 [ # # ]: 0 : if (ns->ops == &netns_operations)
650 : 0 : net = get_net(container_of(ns, struct net, ns));
651 : : else
652 : : net = ERR_PTR(-EINVAL);
653 : :
654 : 0 : fput(file);
655 : 0 : return net;
656 : : }
657 : :
658 : : #else
659 : : struct net *get_net_ns_by_fd(int fd)
660 : : {
661 : : return ERR_PTR(-EINVAL);
662 : : }
663 : : #endif
664 : : EXPORT_SYMBOL_GPL(get_net_ns_by_fd);
665 : :
666 : 0 : struct net *get_net_ns_by_pid(pid_t pid)
667 : : {
668 : 0 : struct task_struct *tsk;
669 : 0 : struct net *net;
670 : :
671 : : /* Lookup the network namespace */
672 : 0 : net = ERR_PTR(-ESRCH);
673 : 0 : rcu_read_lock();
674 : 0 : tsk = find_task_by_vpid(pid);
675 [ # # ]: 0 : if (tsk) {
676 : 0 : struct nsproxy *nsproxy;
677 : 0 : task_lock(tsk);
678 : 0 : nsproxy = tsk->nsproxy;
679 [ # # ]: 0 : if (nsproxy)
680 : 0 : net = get_net(nsproxy->net_ns);
681 : 0 : task_unlock(tsk);
682 : : }
683 : 0 : rcu_read_unlock();
684 : 0 : return net;
685 : : }
686 : : EXPORT_SYMBOL_GPL(get_net_ns_by_pid);
687 : :
688 : 28 : static __net_init int net_ns_net_init(struct net *net)
689 : : {
690 : : #ifdef CONFIG_NET_NS
691 : 28 : net->ns.ops = &netns_operations;
692 : : #endif
693 : 28 : return ns_alloc_inum(&net->ns);
694 : : }
695 : :
696 : 0 : static __net_exit void net_ns_net_exit(struct net *net)
697 : : {
698 : 0 : ns_free_inum(&net->ns);
699 : 0 : }
700 : :
701 : : static struct pernet_operations __net_initdata net_ns_ops = {
702 : : .init = net_ns_net_init,
703 : : .exit = net_ns_net_exit,
704 : : };
705 : :
706 : : static const struct nla_policy rtnl_net_policy[NETNSA_MAX + 1] = {
707 : : [NETNSA_NONE] = { .type = NLA_UNSPEC },
708 : : [NETNSA_NSID] = { .type = NLA_S32 },
709 : : [NETNSA_PID] = { .type = NLA_U32 },
710 : : [NETNSA_FD] = { .type = NLA_U32 },
711 : : [NETNSA_TARGET_NSID] = { .type = NLA_S32 },
712 : : };
713 : :
714 : 0 : static int rtnl_net_newid(struct sk_buff *skb, struct nlmsghdr *nlh,
715 : : struct netlink_ext_ack *extack)
716 : : {
717 : 0 : struct net *net = sock_net(skb->sk);
718 : 0 : struct nlattr *tb[NETNSA_MAX + 1];
719 : 0 : struct nlattr *nla;
720 : 0 : struct net *peer;
721 : 0 : int nsid, err;
722 : :
723 : 0 : err = nlmsg_parse_deprecated(nlh, sizeof(struct rtgenmsg), tb,
724 : : NETNSA_MAX, rtnl_net_policy, extack);
725 [ # # ]: 0 : if (err < 0)
726 : : return err;
727 [ # # ]: 0 : if (!tb[NETNSA_NSID]) {
728 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "nsid is missing");
729 : 0 : return -EINVAL;
730 : : }
731 [ # # ]: 0 : nsid = nla_get_s32(tb[NETNSA_NSID]);
732 : :
733 [ # # ]: 0 : if (tb[NETNSA_PID]) {
734 : 0 : peer = get_net_ns_by_pid(nla_get_u32(tb[NETNSA_PID]));
735 : 0 : nla = tb[NETNSA_PID];
736 [ # # ]: 0 : } else if (tb[NETNSA_FD]) {
737 : 0 : peer = get_net_ns_by_fd(nla_get_u32(tb[NETNSA_FD]));
738 : 0 : nla = tb[NETNSA_FD];
739 : : } else {
740 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "Peer netns reference is missing");
741 : 0 : return -EINVAL;
742 : : }
743 [ # # ]: 0 : if (IS_ERR(peer)) {
744 [ # # ]: 0 : NL_SET_BAD_ATTR(extack, nla);
745 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "Peer netns reference is invalid");
746 : 0 : return PTR_ERR(peer);
747 : : }
748 : :
749 : 0 : spin_lock(&net->nsid_lock);
750 : 0 : if (__peernet2id(net, peer) >= 0) {
751 : 0 : spin_unlock(&net->nsid_lock);
752 : 0 : err = -EEXIST;
753 [ # # ]: 0 : NL_SET_BAD_ATTR(extack, nla);
754 [ # # ]: 0 : NL_SET_ERR_MSG(extack,
755 : : "Peer netns already has a nsid assigned");
756 : 0 : goto out;
757 : : }
758 : :
759 [ # # ]: 0 : err = alloc_netid(net, peer, nsid);
760 : 0 : spin_unlock(&net->nsid_lock);
761 [ # # ]: 0 : if (err >= 0) {
762 : 0 : rtnl_net_notifyid(net, RTM_NEWNSID, err, NETLINK_CB(skb).portid,
763 : : nlh, GFP_KERNEL);
764 : 0 : err = 0;
765 [ # # ]: 0 : } else if (err == -ENOSPC && nsid >= 0) {
766 : 0 : err = -EEXIST;
767 [ # # ]: 0 : NL_SET_BAD_ATTR(extack, tb[NETNSA_NSID]);
768 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "The specified nsid is already used");
769 : : }
770 : 0 : out:
771 : 0 : put_net(peer);
772 : 0 : return err;
773 : : }
774 : :
775 : 0 : static int rtnl_net_get_size(void)
776 : : {
777 : 0 : return NLMSG_ALIGN(sizeof(struct rtgenmsg))
778 : : + nla_total_size(sizeof(s32)) /* NETNSA_NSID */
779 : : + nla_total_size(sizeof(s32)) /* NETNSA_CURRENT_NSID */
780 : : ;
781 : : }
782 : :
783 : : struct net_fill_args {
784 : : u32 portid;
785 : : u32 seq;
786 : : int flags;
787 : : int cmd;
788 : : int nsid;
789 : : bool add_ref;
790 : : int ref_nsid;
791 : : };
792 : :
793 : 0 : static int rtnl_net_fill(struct sk_buff *skb, struct net_fill_args *args)
794 : : {
795 : 0 : struct nlmsghdr *nlh;
796 : 0 : struct rtgenmsg *rth;
797 : :
798 [ # # ]: 0 : nlh = nlmsg_put(skb, args->portid, args->seq, args->cmd, sizeof(*rth),
799 : : args->flags);
800 [ # # ]: 0 : if (!nlh)
801 : 0 : return -EMSGSIZE;
802 : :
803 : 0 : rth = nlmsg_data(nlh);
804 : 0 : rth->rtgen_family = AF_UNSPEC;
805 : :
806 [ # # ]: 0 : if (nla_put_s32(skb, NETNSA_NSID, args->nsid))
807 : 0 : goto nla_put_failure;
808 : :
809 [ # # # # ]: 0 : if (args->add_ref &&
810 : 0 : nla_put_s32(skb, NETNSA_CURRENT_NSID, args->ref_nsid))
811 : 0 : goto nla_put_failure;
812 : :
813 : 0 : nlmsg_end(skb, nlh);
814 : 0 : return 0;
815 : :
816 : 0 : nla_put_failure:
817 : 0 : nlmsg_cancel(skb, nlh);
818 : 0 : return -EMSGSIZE;
819 : : }
820 : :
821 : 0 : static int rtnl_net_valid_getid_req(struct sk_buff *skb,
822 : : const struct nlmsghdr *nlh,
823 : : struct nlattr **tb,
824 : : struct netlink_ext_ack *extack)
825 : : {
826 : 0 : int i, err;
827 : :
828 [ # # ]: 0 : if (!netlink_strict_get_check(skb))
829 : 0 : return nlmsg_parse_deprecated(nlh, sizeof(struct rtgenmsg),
830 : : tb, NETNSA_MAX, rtnl_net_policy,
831 : : extack);
832 : :
833 : 0 : err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct rtgenmsg), tb,
834 : : NETNSA_MAX, rtnl_net_policy,
835 : : extack);
836 [ # # ]: 0 : if (err)
837 : : return err;
838 : :
839 [ # # ]: 0 : for (i = 0; i <= NETNSA_MAX; i++) {
840 [ # # ]: 0 : if (!tb[i])
841 : 0 : continue;
842 : :
843 [ # # ]: 0 : switch (i) {
844 : : case NETNSA_PID:
845 : : case NETNSA_FD:
846 : : case NETNSA_NSID:
847 : : case NETNSA_TARGET_NSID:
848 : : break;
849 : 0 : default:
850 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "Unsupported attribute in peer netns getid request");
851 : : return -EINVAL;
852 : : }
853 : : }
854 : :
855 : : return 0;
856 : : }
857 : :
858 : 0 : static int rtnl_net_getid(struct sk_buff *skb, struct nlmsghdr *nlh,
859 : : struct netlink_ext_ack *extack)
860 : : {
861 : 0 : struct net *net = sock_net(skb->sk);
862 : 0 : struct nlattr *tb[NETNSA_MAX + 1];
863 : 0 : struct net_fill_args fillargs = {
864 : 0 : .portid = NETLINK_CB(skb).portid,
865 : 0 : .seq = nlh->nlmsg_seq,
866 : : .cmd = RTM_NEWNSID,
867 : : };
868 : 0 : struct net *peer, *target = net;
869 : 0 : struct nlattr *nla;
870 : 0 : struct sk_buff *msg;
871 : 0 : int err;
872 : :
873 : 0 : err = rtnl_net_valid_getid_req(skb, nlh, tb, extack);
874 [ # # ]: 0 : if (err < 0)
875 : : return err;
876 [ # # ]: 0 : if (tb[NETNSA_PID]) {
877 : 0 : peer = get_net_ns_by_pid(nla_get_u32(tb[NETNSA_PID]));
878 : 0 : nla = tb[NETNSA_PID];
879 [ # # ]: 0 : } else if (tb[NETNSA_FD]) {
880 : 0 : peer = get_net_ns_by_fd(nla_get_u32(tb[NETNSA_FD]));
881 : 0 : nla = tb[NETNSA_FD];
882 [ # # ]: 0 : } else if (tb[NETNSA_NSID]) {
883 : 0 : peer = get_net_ns_by_id(net, nla_get_s32(tb[NETNSA_NSID]));
884 [ # # ]: 0 : if (!peer)
885 : 0 : peer = ERR_PTR(-ENOENT);
886 : 0 : nla = tb[NETNSA_NSID];
887 : : } else {
888 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "Peer netns reference is missing");
889 : 0 : return -EINVAL;
890 : : }
891 : :
892 [ # # ]: 0 : if (IS_ERR(peer)) {
893 [ # # ]: 0 : NL_SET_BAD_ATTR(extack, nla);
894 [ # # ]: 0 : NL_SET_ERR_MSG(extack, "Peer netns reference is invalid");
895 : 0 : return PTR_ERR(peer);
896 : : }
897 : :
898 [ # # ]: 0 : if (tb[NETNSA_TARGET_NSID]) {
899 : 0 : int id = nla_get_s32(tb[NETNSA_TARGET_NSID]);
900 : :
901 : 0 : target = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, id);
902 [ # # ]: 0 : if (IS_ERR(target)) {
903 [ # # ]: 0 : NL_SET_BAD_ATTR(extack, tb[NETNSA_TARGET_NSID]);
904 [ # # ]: 0 : NL_SET_ERR_MSG(extack,
905 : : "Target netns reference is invalid");
906 : 0 : err = PTR_ERR(target);
907 : 0 : goto out;
908 : : }
909 : 0 : fillargs.add_ref = true;
910 : 0 : fillargs.ref_nsid = peernet2id(net, peer);
911 : : }
912 : :
913 : 0 : msg = nlmsg_new(rtnl_net_get_size(), GFP_KERNEL);
914 [ # # ]: 0 : if (!msg) {
915 : 0 : err = -ENOMEM;
916 : 0 : goto out;
917 : : }
918 : :
919 : 0 : fillargs.nsid = peernet2id(target, peer);
920 : 0 : err = rtnl_net_fill(msg, &fillargs);
921 [ # # ]: 0 : if (err < 0)
922 : 0 : goto err_out;
923 : :
924 : 0 : err = rtnl_unicast(msg, net, NETLINK_CB(skb).portid);
925 : 0 : goto out;
926 : :
927 : : err_out:
928 : 0 : nlmsg_free(msg);
929 : 0 : out:
930 [ # # ]: 0 : if (fillargs.add_ref)
931 : 0 : put_net(target);
932 : 0 : put_net(peer);
933 : 0 : return err;
934 : : }
935 : :
936 : : struct rtnl_net_dump_cb {
937 : : struct net *tgt_net;
938 : : struct net *ref_net;
939 : : struct sk_buff *skb;
940 : : struct net_fill_args fillargs;
941 : : int idx;
942 : : int s_idx;
943 : : };
944 : :
945 : : /* Runs in RCU-critical section. */
946 : 0 : static int rtnl_net_dumpid_one(int id, void *peer, void *data)
947 : : {
948 : 0 : struct rtnl_net_dump_cb *net_cb = (struct rtnl_net_dump_cb *)data;
949 : 0 : int ret;
950 : :
951 [ # # ]: 0 : if (net_cb->idx < net_cb->s_idx)
952 : 0 : goto cont;
953 : :
954 : 0 : net_cb->fillargs.nsid = id;
955 [ # # ]: 0 : if (net_cb->fillargs.add_ref)
956 : 0 : net_cb->fillargs.ref_nsid = __peernet2id(net_cb->ref_net, peer);
957 : 0 : ret = rtnl_net_fill(net_cb->skb, &net_cb->fillargs);
958 [ # # ]: 0 : if (ret < 0)
959 : : return ret;
960 : :
961 : 0 : cont:
962 : 0 : net_cb->idx++;
963 : 0 : return 0;
964 : : }
965 : :
966 : : static int rtnl_valid_dump_net_req(const struct nlmsghdr *nlh, struct sock *sk,
967 : : struct rtnl_net_dump_cb *net_cb,
968 : : struct netlink_callback *cb)
969 : : {
970 : : struct netlink_ext_ack *extack = cb->extack;
971 : : struct nlattr *tb[NETNSA_MAX + 1];
972 : : int err, i;
973 : :
974 : : err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct rtgenmsg), tb,
975 : : NETNSA_MAX, rtnl_net_policy,
976 : : extack);
977 : : if (err < 0)
978 : : return err;
979 : :
980 : : for (i = 0; i <= NETNSA_MAX; i++) {
981 : : if (!tb[i])
982 : : continue;
983 : :
984 : : if (i == NETNSA_TARGET_NSID) {
985 : : struct net *net;
986 : :
987 : : net = rtnl_get_net_ns_capable(sk, nla_get_s32(tb[i]));
988 : : if (IS_ERR(net)) {
989 : : NL_SET_BAD_ATTR(extack, tb[i]);
990 : : NL_SET_ERR_MSG(extack,
991 : : "Invalid target network namespace id");
992 : : return PTR_ERR(net);
993 : : }
994 : : net_cb->fillargs.add_ref = true;
995 : : net_cb->ref_net = net_cb->tgt_net;
996 : : net_cb->tgt_net = net;
997 : : } else {
998 : : NL_SET_BAD_ATTR(extack, tb[i]);
999 : : NL_SET_ERR_MSG(extack,
1000 : : "Unsupported attribute in dump request");
1001 : : return -EINVAL;
1002 : : }
1003 : : }
1004 : :
1005 : : return 0;
1006 : : }
1007 : :
1008 : 0 : static int rtnl_net_dumpid(struct sk_buff *skb, struct netlink_callback *cb)
1009 : : {
1010 : 0 : struct rtnl_net_dump_cb net_cb = {
1011 [ # # ]: 0 : .tgt_net = sock_net(skb->sk),
1012 : : .skb = skb,
1013 : : .fillargs = {
1014 : 0 : .portid = NETLINK_CB(cb->skb).portid,
1015 : 0 : .seq = cb->nlh->nlmsg_seq,
1016 : : .flags = NLM_F_MULTI,
1017 : : .cmd = RTM_NEWNSID,
1018 : : },
1019 : : .idx = 0,
1020 : 0 : .s_idx = cb->args[0],
1021 : : };
1022 : 0 : int err = 0;
1023 : :
1024 [ # # ]: 0 : if (cb->strict_check) {
1025 : 0 : err = rtnl_valid_dump_net_req(cb->nlh, skb->sk, &net_cb, cb);
1026 [ # # ]: 0 : if (err < 0)
1027 : 0 : goto end;
1028 : : }
1029 : :
1030 : 0 : rcu_read_lock();
1031 : 0 : idr_for_each(&net_cb.tgt_net->netns_ids, rtnl_net_dumpid_one, &net_cb);
1032 : 0 : rcu_read_unlock();
1033 : :
1034 : 0 : cb->args[0] = net_cb.idx;
1035 : 0 : end:
1036 [ # # ]: 0 : if (net_cb.fillargs.add_ref)
1037 : 0 : put_net(net_cb.tgt_net);
1038 [ # # ]: 0 : return err < 0 ? err : skb->len;
1039 : : }
1040 : :
1041 : 0 : static void rtnl_net_notifyid(struct net *net, int cmd, int id, u32 portid,
1042 : : struct nlmsghdr *nlh, gfp_t gfp)
1043 : : {
1044 : 0 : struct net_fill_args fillargs = {
1045 : : .portid = portid,
1046 [ # # ]: 0 : .seq = nlh ? nlh->nlmsg_seq : 0,
1047 : : .cmd = cmd,
1048 : : .nsid = id,
1049 : : };
1050 : 0 : struct sk_buff *msg;
1051 : 0 : int err = -ENOMEM;
1052 : :
1053 : 0 : msg = nlmsg_new(rtnl_net_get_size(), gfp);
1054 [ # # ]: 0 : if (!msg)
1055 : 0 : goto out;
1056 : :
1057 : 0 : err = rtnl_net_fill(msg, &fillargs);
1058 [ # # ]: 0 : if (err < 0)
1059 : 0 : goto err_out;
1060 : :
1061 : 0 : rtnl_notify(msg, net, portid, RTNLGRP_NSID, nlh, gfp);
1062 : 0 : return;
1063 : :
1064 : : err_out:
1065 : 0 : nlmsg_free(msg);
1066 : 0 : out:
1067 : 0 : rtnl_set_sk_err(net, RTNLGRP_NSID, err);
1068 : : }
1069 : :
1070 : 28 : static int __init net_ns_init(void)
1071 : : {
1072 : 28 : struct net_generic *ng;
1073 : :
1074 : : #ifdef CONFIG_NET_NS
1075 : 28 : net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
1076 : : SMP_CACHE_BYTES,
1077 : : SLAB_PANIC|SLAB_ACCOUNT, NULL);
1078 : :
1079 : : /* Create workqueue for cleanup */
1080 : 28 : netns_wq = create_singlethread_workqueue("netns");
1081 [ - + ]: 28 : if (!netns_wq)
1082 : 0 : panic("Could not create netns workq");
1083 : : #endif
1084 : :
1085 : 28 : ng = net_alloc_generic();
1086 [ - + ]: 28 : if (!ng)
1087 : 0 : panic("Could not allocate generic netns");
1088 : :
1089 : 28 : rcu_assign_pointer(init_net.gen, ng);
1090 : :
1091 : 28 : down_write(&pernet_ops_rwsem);
1092 [ - + ]: 28 : if (setup_net(&init_net, &init_user_ns))
1093 : 0 : panic("Could not setup the initial network namespace");
1094 : :
1095 : 28 : init_net_initialized = true;
1096 : 28 : up_write(&pernet_ops_rwsem);
1097 : :
1098 [ - + ]: 28 : if (register_pernet_subsys(&net_ns_ops))
1099 : 0 : panic("Could not register network namespace subsystems");
1100 : :
1101 : 28 : rtnl_register(PF_UNSPEC, RTM_NEWNSID, rtnl_net_newid, NULL,
1102 : : RTNL_FLAG_DOIT_UNLOCKED);
1103 : 28 : rtnl_register(PF_UNSPEC, RTM_GETNSID, rtnl_net_getid, rtnl_net_dumpid,
1104 : : RTNL_FLAG_DOIT_UNLOCKED);
1105 : :
1106 : 28 : return 0;
1107 : : }
1108 : :
1109 : : pure_initcall(net_ns_init);
1110 : :
1111 : : #ifdef CONFIG_NET_NS
1112 : 2800 : static int __register_pernet_operations(struct list_head *list,
1113 : : struct pernet_operations *ops)
1114 : : {
1115 : 2800 : struct net *net;
1116 : 2800 : int error;
1117 : 2800 : LIST_HEAD(net_exit_list);
1118 : :
1119 [ + + ]: 2800 : list_add_tail(&ops->list, list);
1120 [ + + + + : 2800 : if (ops->init || (ops->id && ops->size)) {
+ - ]
1121 : : /* We held write locked pernet_ops_rwsem, and parallel
1122 : : * setup_net() and cleanup_net() are not possible.
1123 : : */
1124 [ + + ]: 5236 : for_each_net(net) {
1125 : 2604 : error = ops_init(ops, net);
1126 [ - + ]: 2604 : if (error)
1127 : 0 : goto out_undo;
1128 : 2604 : list_add_tail(&net->exit_list, &net_exit_list);
1129 : : }
1130 : : }
1131 : : return 0;
1132 : :
1133 : : out_undo:
1134 : : /* If I have an error cleanup all namespaces I initialized */
1135 [ # # ]: 0 : list_del(&ops->list);
1136 [ # # ]: 0 : ops_pre_exit_list(ops, &net_exit_list);
1137 : 0 : synchronize_rcu();
1138 : 0 : ops_exit_list(ops, &net_exit_list);
1139 : 0 : ops_free_list(ops, &net_exit_list);
1140 : 0 : return error;
1141 : : }
1142 : :
1143 : 0 : static void __unregister_pernet_operations(struct pernet_operations *ops)
1144 : : {
1145 : 0 : struct net *net;
1146 : 0 : LIST_HEAD(net_exit_list);
1147 : :
1148 : 0 : list_del(&ops->list);
1149 : : /* See comment in __register_pernet_operations() */
1150 [ # # ]: 0 : for_each_net(net)
1151 : 0 : list_add_tail(&net->exit_list, &net_exit_list);
1152 [ # # ]: 0 : ops_pre_exit_list(ops, &net_exit_list);
1153 : 0 : synchronize_rcu();
1154 : 0 : ops_exit_list(ops, &net_exit_list);
1155 : 0 : ops_free_list(ops, &net_exit_list);
1156 : 0 : }
1157 : :
1158 : : #else
1159 : :
1160 : : static int __register_pernet_operations(struct list_head *list,
1161 : : struct pernet_operations *ops)
1162 : : {
1163 : : if (!init_net_initialized) {
1164 : : list_add_tail(&ops->list, list);
1165 : : return 0;
1166 : : }
1167 : :
1168 : : return ops_init(ops, &init_net);
1169 : : }
1170 : :
1171 : : static void __unregister_pernet_operations(struct pernet_operations *ops)
1172 : : {
1173 : : if (!init_net_initialized) {
1174 : : list_del(&ops->list);
1175 : : } else {
1176 : : LIST_HEAD(net_exit_list);
1177 : : list_add(&init_net.exit_list, &net_exit_list);
1178 : : ops_pre_exit_list(ops, &net_exit_list);
1179 : : synchronize_rcu();
1180 : : ops_exit_list(ops, &net_exit_list);
1181 : : ops_free_list(ops, &net_exit_list);
1182 : : }
1183 : : }
1184 : :
1185 : : #endif /* CONFIG_NET_NS */
1186 : :
1187 : : static DEFINE_IDA(net_generic_ids);
1188 : :
1189 : 2800 : static int register_pernet_operations(struct list_head *list,
1190 : : struct pernet_operations *ops)
1191 : : {
1192 : 2800 : int error;
1193 : :
1194 [ + + ]: 2800 : if (ops->id) {
1195 : 336 : error = ida_alloc_min(&net_generic_ids, MIN_PERNET_OPS_ID,
1196 : : GFP_KERNEL);
1197 [ + - ]: 336 : if (error < 0)
1198 : : return error;
1199 : 336 : *ops->id = error;
1200 : 336 : max_gen_ptrs = max(max_gen_ptrs, *ops->id + 1);
1201 : : }
1202 : 2800 : error = __register_pernet_operations(list, ops);
1203 [ - + ]: 2800 : if (error) {
1204 : 0 : rcu_barrier();
1205 [ # # ]: 0 : if (ops->id)
1206 : 0 : ida_free(&net_generic_ids, *ops->id);
1207 : : }
1208 : :
1209 : : return error;
1210 : : }
1211 : :
1212 : 0 : static void unregister_pernet_operations(struct pernet_operations *ops)
1213 : : {
1214 : 0 : __unregister_pernet_operations(ops);
1215 : 0 : rcu_barrier();
1216 [ # # ]: 0 : if (ops->id)
1217 : 0 : ida_free(&net_generic_ids, *ops->id);
1218 : 0 : }
1219 : :
1220 : : /**
1221 : : * register_pernet_subsys - register a network namespace subsystem
1222 : : * @ops: pernet operations structure for the subsystem
1223 : : *
1224 : : * Register a subsystem which has init and exit functions
1225 : : * that are called when network namespaces are created and
1226 : : * destroyed respectively.
1227 : : *
1228 : : * When registered all network namespace init functions are
1229 : : * called for every existing network namespace. Allowing kernel
1230 : : * modules to have a race free view of the set of network namespaces.
1231 : : *
1232 : : * When a new network namespace is created all of the init
1233 : : * methods are called in the order in which they were registered.
1234 : : *
1235 : : * When a network namespace is destroyed all of the exit methods
1236 : : * are called in the reverse of the order with which they were
1237 : : * registered.
1238 : : */
1239 : 2688 : int register_pernet_subsys(struct pernet_operations *ops)
1240 : : {
1241 : 2688 : int error;
1242 : 2688 : down_write(&pernet_ops_rwsem);
1243 : 2688 : error = register_pernet_operations(first_device, ops);
1244 : 2688 : up_write(&pernet_ops_rwsem);
1245 : 2688 : return error;
1246 : : }
1247 : : EXPORT_SYMBOL_GPL(register_pernet_subsys);
1248 : :
1249 : : /**
1250 : : * unregister_pernet_subsys - unregister a network namespace subsystem
1251 : : * @ops: pernet operations structure to manipulate
1252 : : *
1253 : : * Remove the pernet operations structure from the list to be
1254 : : * used when network namespaces are created or destroyed. In
1255 : : * addition run the exit method for all existing network
1256 : : * namespaces.
1257 : : */
1258 : 0 : void unregister_pernet_subsys(struct pernet_operations *ops)
1259 : : {
1260 : 0 : down_write(&pernet_ops_rwsem);
1261 : 0 : unregister_pernet_operations(ops);
1262 : 0 : up_write(&pernet_ops_rwsem);
1263 : 0 : }
1264 : : EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
1265 : :
1266 : : /**
1267 : : * register_pernet_device - register a network namespace device
1268 : : * @ops: pernet operations structure for the subsystem
1269 : : *
1270 : : * Register a device which has init and exit functions
1271 : : * that are called when network namespaces are created and
1272 : : * destroyed respectively.
1273 : : *
1274 : : * When registered all network namespace init functions are
1275 : : * called for every existing network namespace. Allowing kernel
1276 : : * modules to have a race free view of the set of network namespaces.
1277 : : *
1278 : : * When a new network namespace is created all of the init
1279 : : * methods are called in the order in which they were registered.
1280 : : *
1281 : : * When a network namespace is destroyed all of the exit methods
1282 : : * are called in the reverse of the order with which they were
1283 : : * registered.
1284 : : */
1285 : 112 : int register_pernet_device(struct pernet_operations *ops)
1286 : : {
1287 : 112 : int error;
1288 : 112 : down_write(&pernet_ops_rwsem);
1289 : 112 : error = register_pernet_operations(&pernet_list, ops);
1290 [ + - + + ]: 112 : if (!error && (first_device == &pernet_list))
1291 : 28 : first_device = &ops->list;
1292 : 112 : up_write(&pernet_ops_rwsem);
1293 : 112 : return error;
1294 : : }
1295 : : EXPORT_SYMBOL_GPL(register_pernet_device);
1296 : :
1297 : : /**
1298 : : * unregister_pernet_device - unregister a network namespace netdevice
1299 : : * @ops: pernet operations structure to manipulate
1300 : : *
1301 : : * Remove the pernet operations structure from the list to be
1302 : : * used when network namespaces are created or destroyed. In
1303 : : * addition run the exit method for all existing network
1304 : : * namespaces.
1305 : : */
1306 : 0 : void unregister_pernet_device(struct pernet_operations *ops)
1307 : : {
1308 : 0 : down_write(&pernet_ops_rwsem);
1309 [ # # ]: 0 : if (&ops->list == first_device)
1310 : 0 : first_device = first_device->next;
1311 : 0 : unregister_pernet_operations(ops);
1312 : 0 : up_write(&pernet_ops_rwsem);
1313 : 0 : }
1314 : : EXPORT_SYMBOL_GPL(unregister_pernet_device);
1315 : :
1316 : : #ifdef CONFIG_NET_NS
1317 : 0 : static struct ns_common *netns_get(struct task_struct *task)
1318 : : {
1319 : 0 : struct net *net = NULL;
1320 : 0 : struct nsproxy *nsproxy;
1321 : :
1322 : 0 : task_lock(task);
1323 : 0 : nsproxy = task->nsproxy;
1324 [ # # ]: 0 : if (nsproxy)
1325 : 0 : net = get_net(nsproxy->net_ns);
1326 : 0 : task_unlock(task);
1327 : :
1328 [ # # ]: 0 : return net ? &net->ns : NULL;
1329 : : }
1330 : :
1331 : 0 : static inline struct net *to_net_ns(struct ns_common *ns)
1332 : : {
1333 : 0 : return container_of(ns, struct net, ns);
1334 : : }
1335 : :
1336 : 0 : static void netns_put(struct ns_common *ns)
1337 : : {
1338 : 0 : put_net(to_net_ns(ns));
1339 : 0 : }
1340 : :
1341 : 0 : static int netns_install(struct nsproxy *nsproxy, struct ns_common *ns)
1342 : : {
1343 : 0 : struct net *net = to_net_ns(ns);
1344 : :
1345 [ # # # # ]: 0 : if (!ns_capable(net->user_ns, CAP_SYS_ADMIN) ||
1346 : 0 : !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
1347 : 0 : return -EPERM;
1348 : :
1349 : 0 : put_net(nsproxy->net_ns);
1350 : 0 : nsproxy->net_ns = get_net(net);
1351 : 0 : return 0;
1352 : : }
1353 : :
1354 : 0 : static struct user_namespace *netns_owner(struct ns_common *ns)
1355 : : {
1356 : 0 : return to_net_ns(ns)->user_ns;
1357 : : }
1358 : :
1359 : : const struct proc_ns_operations netns_operations = {
1360 : : .name = "net",
1361 : : .type = CLONE_NEWNET,
1362 : : .get = netns_get,
1363 : : .put = netns_put,
1364 : : .install = netns_install,
1365 : : .owner = netns_owner,
1366 : : };
1367 : : #endif
|
