core/net_namespace.c

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