net/core/net_namespace.c

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