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