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 <net/sock.h>
  20 #include <net/netlink.h>
  21 #include <net/net_namespace.h>
  22 #include <net/netns/generic.h>
  23
  24 /*
  25  *      Our network namespace constructor/destructor lists
  26  */
  27
  28 static LIST_HEAD(pernet_list);
  29 static struct list_head *first_device = &pernet_list;
  30 DEFINE_MUTEX(net_mutex);
  31
  32 LIST_HEAD(net_namespace_list);
  33 EXPORT_SYMBOL_GPL(net_namespace_list);
  34
  35 struct net init_net = {
  36         .dev_base_head = LIST_HEAD_INIT(init_net.dev_base_head),
  37 };
  38 EXPORT_SYMBOL(init_net);
  39
  40 #define INITIAL_NET_GEN_PTRS    13 /* +1 for len +2 for rcu_head */
  41
  42 static unsigned int max_gen_ptrs = INITIAL_NET_GEN_PTRS;
  43
  44 static struct net_generic *net_alloc_generic(void)
  45 {
  46         struct net_generic *ng;
  47         size_t generic_size = offsetof(struct net_generic, ptr[max_gen_ptrs]);
  48
  49         ng = kzalloc(generic_size, GFP_KERNEL);
  50         if (ng)
  51                 ng->len = max_gen_ptrs;
  52
  53         return ng;
  54 }
  55
  56 static int net_assign_generic(struct net *net, int id, void *data)
  57 {
  58         struct net_generic *ng, *old_ng;
  59
  60         BUG_ON(!mutex_is_locked(&net_mutex));
  61         BUG_ON(id == 0);
  62
  63         old_ng = rcu_dereference_protected(net->gen,
  64                                            lockdep_is_held(&net_mutex));
  65         ng = old_ng;
  66         if (old_ng->len >= id)
  67                 goto assign;
  68
  69         ng = net_alloc_generic();
  70         if (ng == NULL)
  71                 return -ENOMEM;
  72
  73         /*
  74          * Some synchronisation notes:
  75          *
  76          * The net_generic explores the net->gen array inside rcu
  77          * read section. Besides once set the net->gen->ptr[x]
  78          * pointer never changes (see rules in netns/generic.h).
  79          *
  80          * That said, we simply duplicate this array and schedule
  81          * the old copy for kfree after a grace period.
  82          */
  83
  84         memcpy(&ng->ptr, &old_ng->ptr, old_ng->len * sizeof(void*));
  85
  86         rcu_assign_pointer(net->gen, ng);
  87         kfree_rcu(old_ng, rcu);
  88 assign:
  89         ng->ptr[id - 1] = data;
  90         return 0;
  91 }
  92
  93 static int ops_init(const struct pernet_operations *ops, struct net *net)
  94 {
  95         int err = -ENOMEM;
  96         void *data = NULL;
  97
  98         if (ops->id && ops->size) {
  99                 data = kzalloc(ops->size, GFP_KERNEL);
 100                 if (!data)
 101                         goto out;
 102
 103                 err = net_assign_generic(net, *ops->id, data);
 104                 if (err)
 105                         goto cleanup;
 106         }
 107         err = 0;
 108         if (ops->init)
 109                 err = ops->init(net);
 110         if (!err)
 111                 return 0;
 112
 113 cleanup:
 114         kfree(data);
 115
 116 out:
 117         return err;
 118 }
 119
 120 static void ops_free(const struct pernet_operations *ops, struct net *net)
 121 {
 122         if (ops->id && ops->size) {
 123                 int id = *ops->id;
 124                 kfree(net_generic(net, id));
 125         }
 126 }
 127
 128 static void ops_exit_list(const struct pernet_operations *ops,
 129                           struct list_head *net_exit_list)
 130 {
 131         struct net *net;
 132         if (ops->exit) {
 133                 list_for_each_entry(net, net_exit_list, exit_list)
 134                         ops->exit(net);
 135         }
 136         if (ops->exit_batch)
 137                 ops->exit_batch(net_exit_list);
 138 }
 139
 140 static void ops_free_list(const struct pernet_operations *ops,
 141                           struct list_head *net_exit_list)
 142 {
 143         struct net *net;
 144         if (ops->size && ops->id) {
 145                 list_for_each_entry(net, net_exit_list, exit_list)
 146                         ops_free(ops, net);
 147         }
 148 }
 149
 150 static int alloc_netid(struct net *net, struct net *peer, int reqid)
 151 {
 152         int min = 0, max = 0;
 153
 154         ASSERT_RTNL();
 155
 156         if (reqid >= 0) {
 157                 min = reqid;
 158                 max = reqid + 1;
 159         }
 160
 161         return idr_alloc(&net->netns_ids, peer, min, max, GFP_KERNEL);
 162 }
 163
 164 /* This function is used by idr_for_each(). If net is equal to peer, the
 165  * function returns the id so that idr_for_each() stops. Because we cannot
 166  * returns the id 0 (idr_for_each() will not stop), we return the magic value
 167  * NET_ID_ZERO (-1) for it.
 168  */
 169 #define NET_ID_ZERO -1
 170 static int net_eq_idr(int id, void *net, void *peer)
 171 {
 172         if (net_eq(net, peer))
 173                 return id ? : NET_ID_ZERO;
 174         return 0;
 175 }
 176
 177 static int __peernet2id_alloc(struct net *net, struct net *peer, bool *alloc)
 178 {
 179         int id = idr_for_each(&net->netns_ids, net_eq_idr, peer);
 180         bool alloc_it = *alloc;
 181
 182         ASSERT_RTNL();
 183
 184         *alloc = false;
 185
 186         /* Magic value for id 0. */
 187         if (id == NET_ID_ZERO)
 188                 return 0;
 189         if (id > 0)
 190                 return id;
 191
 192         if (alloc_it) {
 193                 id = alloc_netid(net, peer, -1);
 194                 *alloc = true;
 195                 return id >= 0 ? id : NETNSA_NSID_NOT_ASSIGNED;
 196         }
 197
 198         return NETNSA_NSID_NOT_ASSIGNED;
 199 }
 200
 201 static int __peernet2id(struct net *net, struct net *peer)
 202 {
 203         bool no = false;
 204
 205         return __peernet2id_alloc(net, peer, &no);
 206 }
 207
 208 static void rtnl_net_notifyid(struct net *net, int cmd, int id);
 209 /* This function returns the id of a peer netns. If no id is assigned, one will
 210  * be allocated and returned.
 211  */
 212 int peernet2id_alloc(struct net *net, struct net *peer)
 213 {
 214         bool alloc = atomic_read(&peer->count) == 0 ? false : true;
 215         int id;
 216
 217         id = __peernet2id_alloc(net, peer, &alloc);
 218         if (alloc && id >= 0)
 219                 rtnl_net_notifyid(net, RTM_NEWNSID, id);
 220         return id;
 221 }
 222 EXPORT_SYMBOL(peernet2id_alloc);
 223
 224 struct net *get_net_ns_by_id(struct net *net, int id)
 225 {
 226         struct net *peer;
 227
 228         if (id < 0)
 229                 return NULL;
 230
 231         rcu_read_lock();
 232         peer = idr_find(&net->netns_ids, id);
 233         if (peer)
 234                 get_net(peer);
 235         rcu_read_unlock();
 236
 237         return peer;
 238 }
 239
 240 /*
 241  * setup_net runs the initializers for the network namespace object.
 242  */
 243 static __net_init int setup_net(struct net *net, struct user_namespace *user_ns)
 244 {
 245         /* Must be called with net_mutex held */
 246         const struct pernet_operations *ops, *saved_ops;
 247         int error = 0;
 248         LIST_HEAD(net_exit_list);
 249
 250         atomic_set(&net->count, 1);
 251         atomic_set(&net->passive, 1);
 252         net->dev_base_seq = 1;
 253         net->user_ns = user_ns;
 254         idr_init(&net->netns_ids);
 255
 256         list_for_each_entry(ops, &pernet_list, list) {
 257                 error = ops_init(ops, net);
 258                 if (error < 0)
 259                         goto out_undo;
 260         }
 261 out:
 262         return error;
 263
 264 out_undo:
 265         /* Walk through the list backwards calling the exit functions
 266          * for the pernet modules whose init functions did not fail.
 267          */
 268         list_add(&net->exit_list, &net_exit_list);
 269         saved_ops = ops;
 270         list_for_each_entry_continue_reverse(ops, &pernet_list, list)
 271                 ops_exit_list(ops, &net_exit_list);
 272
 273         ops = saved_ops;
 274         list_for_each_entry_continue_reverse(ops, &pernet_list, list)
 275                 ops_free_list(ops, &net_exit_list);
 276
 277         rcu_barrier();
 278         goto out;
 279 }
 280
 281
 282 #ifdef CONFIG_NET_NS
 283 static struct kmem_cache *net_cachep;
 284 static struct workqueue_struct *netns_wq;
 285
 286 static struct net *net_alloc(void)
 287 {
 288         struct net *net = NULL;
 289         struct net_generic *ng;
 290
 291         ng = net_alloc_generic();
 292         if (!ng)
 293                 goto out;
 294
 295         net = kmem_cache_zalloc(net_cachep, GFP_KERNEL);
 296         if (!net)
 297                 goto out_free;
 298
 299         rcu_assign_pointer(net->gen, ng);
 300 out:
 301         return net;
 302
 303 out_free:
 304         kfree(ng);
 305         goto out;
 306 }
 307
 308 static void net_free(struct net *net)
 309 {
 310         kfree(rcu_access_pointer(net->gen));
 311         kmem_cache_free(net_cachep, net);
 312 }
 313
 314 void net_drop_ns(void *p)
 315 {
 316         struct net *ns = p;
 317         if (ns && atomic_dec_and_test(&ns->passive))
 318                 net_free(ns);
 319 }
 320
 321 struct net *copy_net_ns(unsigned long flags,
 322                         struct user_namespace *user_ns, struct net *old_net)
 323 {
 324         struct net *net;
 325         int rv;
 326
 327         if (!(flags & CLONE_NEWNET))
 328                 return get_net(old_net);
 329
 330         net = net_alloc();
 331         if (!net)
 332                 return ERR_PTR(-ENOMEM);
 333
 334         get_user_ns(user_ns);
 335
 336         mutex_lock(&net_mutex);
 337         rv = setup_net(net, user_ns);
 338         if (rv == 0) {
 339                 rtnl_lock();
 340                 list_add_tail_rcu(&net->list, &net_namespace_list);
 341                 rtnl_unlock();
 342         }
 343         mutex_unlock(&net_mutex);
 344         if (rv < 0) {
 345                 put_user_ns(user_ns);
 346                 net_drop_ns(net);
 347                 return ERR_PTR(rv);
 348         }
 349         return net;
 350 }
 351
 352 static DEFINE_SPINLOCK(cleanup_list_lock);
 353 static LIST_HEAD(cleanup_list);  /* Must hold cleanup_list_lock to touch */
 354
 355 static void cleanup_net(struct work_struct *work)
 356 {
 357         const struct pernet_operations *ops;
 358         struct net *net, *tmp;
 359         struct list_head net_kill_list;
 360         LIST_HEAD(net_exit_list);
 361
 362         /* Atomically snapshot the list of namespaces to cleanup */
 363         spin_lock_irq(&cleanup_list_lock);
 364         list_replace_init(&cleanup_list, &net_kill_list);
 365         spin_unlock_irq(&cleanup_list_lock);
 366
 367         mutex_lock(&net_mutex);
 368
 369         /* Don't let anyone else find us. */
 370         rtnl_lock();
 371         list_for_each_entry(net, &net_kill_list, cleanup_list) {
 372                 list_del_rcu(&net->list);
 373                 list_add_tail(&net->exit_list, &net_exit_list);
 374                 for_each_net(tmp) {
 375                         int id = __peernet2id(tmp, net);
 376
 377                         if (id >= 0) {
 378                                 rtnl_net_notifyid(tmp, RTM_DELNSID, id);
 379                                 idr_remove(&tmp->netns_ids, id);
 380                         }
 381                 }
 382                 idr_destroy(&net->netns_ids);
 383
 384         }
 385         rtnl_unlock();
 386
 387         /*
 388          * Another CPU might be rcu-iterating the list, wait for it.
 389          * This needs to be before calling the exit() notifiers, so
 390          * the rcu_barrier() below isn't sufficient alone.
 391          */
 392         synchronize_rcu();
 393
 394         /* Run all of the network namespace exit methods */
 395         list_for_each_entry_reverse(ops, &pernet_list, list)
 396                 ops_exit_list(ops, &net_exit_list);
 397
 398         /* Free the net generic variables */
 399         list_for_each_entry_reverse(ops, &pernet_list, list)
 400                 ops_free_list(ops, &net_exit_list);
 401
 402         mutex_unlock(&net_mutex);
 403
 404         /* Ensure there are no outstanding rcu callbacks using this
 405          * network namespace.
 406          */
 407         rcu_barrier();
 408
 409         /* Finally it is safe to free my network namespace structure */
 410         list_for_each_entry_safe(net, tmp, &net_exit_list, exit_list) {
 411                 list_del_init(&net->exit_list);
 412                 put_user_ns(net->user_ns);
 413                 net_drop_ns(net);
 414         }
 415 }
 416 static DECLARE_WORK(net_cleanup_work, cleanup_net);
 417
 418 void __put_net(struct net *net)
 419 {
 420         /* Cleanup the network namespace in process context */
 421         unsigned long flags;
 422
 423         spin_lock_irqsave(&cleanup_list_lock, flags);
 424         list_add(&net->cleanup_list, &cleanup_list);
 425         spin_unlock_irqrestore(&cleanup_list_lock, flags);
 426
 427         queue_work(netns_wq, &net_cleanup_work);
 428 }
 429 EXPORT_SYMBOL_GPL(__put_net);
 430
 431 struct net *get_net_ns_by_fd(int fd)
 432 {
 433         struct file *file;
 434         struct ns_common *ns;
 435         struct net *net;
 436
 437         file = proc_ns_fget(fd);
 438         if (IS_ERR(file))
 439                 return ERR_CAST(file);
 440
 441         ns = get_proc_ns(file_inode(file));
 442         if (ns->ops == &netns_operations)
 443                 net = get_net(container_of(ns, struct net, ns));
 444         else
 445                 net = ERR_PTR(-EINVAL);
 446
 447         fput(file);
 448         return net;
 449 }
 450
 451 #else
 452 struct net *get_net_ns_by_fd(int fd)
 453 {
 454         return ERR_PTR(-EINVAL);
 455 }
 456 #endif
 457 EXPORT_SYMBOL_GPL(get_net_ns_by_fd);
 458
 459 struct net *get_net_ns_by_pid(pid_t pid)
 460 {
 461         struct task_struct *tsk;
 462         struct net *net;
 463
 464         /* Lookup the network namespace */
 465         net = ERR_PTR(-ESRCH);
 466         rcu_read_lock();
 467         tsk = find_task_by_vpid(pid);
 468         if (tsk) {
 469                 struct nsproxy *nsproxy;
 470                 task_lock(tsk);
 471                 nsproxy = tsk->nsproxy;
 472                 if (nsproxy)
 473                         net = get_net(nsproxy->net_ns);
 474                 task_unlock(tsk);
 475         }
 476         rcu_read_unlock();
 477         return net;
 478 }
 479 EXPORT_SYMBOL_GPL(get_net_ns_by_pid);
 480
 481 static __net_init int net_ns_net_init(struct net *net)
 482 {
 483 #ifdef CONFIG_NET_NS
 484         net->ns.ops = &netns_operations;
 485 #endif
 486         return ns_alloc_inum(&net->ns);
 487 }
 488
 489 static __net_exit void net_ns_net_exit(struct net *net)
 490 {
 491         ns_free_inum(&net->ns);
 492 }
 493
 494 static struct pernet_operations __net_initdata net_ns_ops = {
 495         .init = net_ns_net_init,
 496         .exit = net_ns_net_exit,
 497 };
 498
 499 static struct nla_policy rtnl_net_policy[NETNSA_MAX + 1] = {
 500         [NETNSA_NONE]           = { .type = NLA_UNSPEC },
 501         [NETNSA_NSID]           = { .type = NLA_S32 },
 502         [NETNSA_PID]            = { .type = NLA_U32 },
 503         [NETNSA_FD]             = { .type = NLA_U32 },
 504 };
 505
 506 static int rtnl_net_newid(struct sk_buff *skb, struct nlmsghdr *nlh)
 507 {
 508         struct net *net = sock_net(skb->sk);
 509         struct nlattr *tb[NETNSA_MAX + 1];
 510         struct net *peer;
 511         int nsid, err;
 512
 513         err = nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, NETNSA_MAX,
 514                           rtnl_net_policy);
 515         if (err < 0)
 516                 return err;
 517         if (!tb[NETNSA_NSID])
 518                 return -EINVAL;
 519         nsid = nla_get_s32(tb[NETNSA_NSID]);
 520
 521         if (tb[NETNSA_PID])
 522                 peer = get_net_ns_by_pid(nla_get_u32(tb[NETNSA_PID]));
 523         else if (tb[NETNSA_FD])
 524                 peer = get_net_ns_by_fd(nla_get_u32(tb[NETNSA_FD]));
 525         else
 526                 return -EINVAL;
 527         if (IS_ERR(peer))
 528                 return PTR_ERR(peer);
 529
 530         if (__peernet2id(net, peer) >= 0) {
 531                 err = -EEXIST;
 532                 goto out;
 533         }
 534
 535         err = alloc_netid(net, peer, nsid);
 536         if (err >= 0) {
 537                 rtnl_net_notifyid(net, RTM_NEWNSID, err);
 538                 err = 0;
 539         }
 540 out:
 541         put_net(peer);
 542         return err;
 543 }
 544
 545 static int rtnl_net_get_size(void)
 546 {
 547         return NLMSG_ALIGN(sizeof(struct rtgenmsg))
 548                + nla_total_size(sizeof(s32)) /* NETNSA_NSID */
 549                ;
 550 }
 551
 552 static int rtnl_net_fill(struct sk_buff *skb, u32 portid, u32 seq, int flags,
 553                          int cmd, struct net *net, int nsid)
 554 {
 555         struct nlmsghdr *nlh;
 556         struct rtgenmsg *rth;
 557
 558         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rth), flags);
 559         if (!nlh)
 560                 return -EMSGSIZE;
 561
 562         rth = nlmsg_data(nlh);
 563         rth->rtgen_family = AF_UNSPEC;
 564
 565         if (nla_put_s32(skb, NETNSA_NSID, nsid))
 566                 goto nla_put_failure;
 567
 568         nlmsg_end(skb, nlh);
 569         return 0;
 570
 571 nla_put_failure:
 572         nlmsg_cancel(skb, nlh);
 573         return -EMSGSIZE;
 574 }
 575
 576 static int rtnl_net_getid(struct sk_buff *skb, struct nlmsghdr *nlh)
 577 {
 578         struct net *net = sock_net(skb->sk);
 579         struct nlattr *tb[NETNSA_MAX + 1];
 580         struct sk_buff *msg;
 581         struct net *peer;
 582         int err, id;
 583
 584         err = nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, NETNSA_MAX,
 585                           rtnl_net_policy);
 586         if (err < 0)
 587                 return err;
 588         if (tb[NETNSA_PID])
 589                 peer = get_net_ns_by_pid(nla_get_u32(tb[NETNSA_PID]));
 590         else if (tb[NETNSA_FD])
 591                 peer = get_net_ns_by_fd(nla_get_u32(tb[NETNSA_FD]));
 592         else
 593                 return -EINVAL;
 594
 595         if (IS_ERR(peer))
 596                 return PTR_ERR(peer);
 597
 598         msg = nlmsg_new(rtnl_net_get_size(), GFP_KERNEL);
 599         if (!msg) {
 600                 err = -ENOMEM;
 601                 goto out;
 602         }
 603
 604         id = __peernet2id(net, peer);
 605         err = rtnl_net_fill(msg, NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
 606                             RTM_GETNSID, net, id);
 607         if (err < 0)
 608                 goto err_out;
 609
 610         err = rtnl_unicast(msg, net, NETLINK_CB(skb).portid);
 611         goto out;
 612
 613 err_out:
 614         nlmsg_free(msg);
 615 out:
 616         put_net(peer);
 617         return err;
 618 }
 619
 620 struct rtnl_net_dump_cb {
 621         struct net *net;
 622         struct sk_buff *skb;
 623         struct netlink_callback *cb;
 624         int idx;
 625         int s_idx;
 626 };
 627
 628 static int rtnl_net_dumpid_one(int id, void *peer, void *data)
 629 {
 630         struct rtnl_net_dump_cb *net_cb = (struct rtnl_net_dump_cb *)data;
 631         int ret;
 632
 633         if (net_cb->idx < net_cb->s_idx)
 634                 goto cont;
 635
 636         ret = rtnl_net_fill(net_cb->skb, NETLINK_CB(net_cb->cb->skb).portid,
 637                             net_cb->cb->nlh->nlmsg_seq, NLM_F_MULTI,
 638                             RTM_NEWNSID, net_cb->net, id);
 639         if (ret < 0)
 640                 return ret;
 641
 642 cont:
 643         net_cb->idx++;
 644         return 0;
 645 }
 646
 647 static int rtnl_net_dumpid(struct sk_buff *skb, struct netlink_callback *cb)
 648 {
 649         struct net *net = sock_net(skb->sk);
 650         struct rtnl_net_dump_cb net_cb = {
 651                 .net = net,
 652                 .skb = skb,
 653                 .cb = cb,
 654                 .idx = 0,
 655                 .s_idx = cb->args[0],
 656         };
 657
 658         ASSERT_RTNL();
 659
 660         idr_for_each(&net->netns_ids, rtnl_net_dumpid_one, &net_cb);
 661
 662         cb->args[0] = net_cb.idx;
 663         return skb->len;
 664 }
 665
 666 static void rtnl_net_notifyid(struct net *net, int cmd, int id)
 667 {
 668         struct sk_buff *msg;
 669         int err = -ENOMEM;
 670
 671         msg = nlmsg_new(rtnl_net_get_size(), GFP_KERNEL);
 672         if (!msg)
 673                 goto out;
 674
 675         err = rtnl_net_fill(msg, 0, 0, 0, cmd, net, id);
 676         if (err < 0)
 677                 goto err_out;
 678
 679         rtnl_notify(msg, net, 0, RTNLGRP_NSID, NULL, 0);
 680         return;
 681
 682 err_out:
 683         nlmsg_free(msg);
 684 out:
 685         rtnl_set_sk_err(net, RTNLGRP_NSID, err);
 686 }
 687
 688 static int __init net_ns_init(void)
 689 {
 690         struct net_generic *ng;
 691
 692 #ifdef CONFIG_NET_NS
 693         net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
 694                                         SMP_CACHE_BYTES,
 695                                         SLAB_PANIC, NULL);
 696
 697         /* Create workqueue for cleanup */
 698         netns_wq = create_singlethread_workqueue("netns");
 699         if (!netns_wq)
 700                 panic("Could not create netns workq");
 701 #endif
 702
 703         ng = net_alloc_generic();
 704         if (!ng)
 705                 panic("Could not allocate generic netns");
 706
 707         rcu_assign_pointer(init_net.gen, ng);
 708
 709         mutex_lock(&net_mutex);
 710         if (setup_net(&init_net, &init_user_ns))
 711                 panic("Could not setup the initial network namespace");
 712
 713         rtnl_lock();
 714         list_add_tail_rcu(&init_net.list, &net_namespace_list);
 715         rtnl_unlock();
 716
 717         mutex_unlock(&net_mutex);
 718
 719         register_pernet_subsys(&net_ns_ops);
 720
 721         rtnl_register(PF_UNSPEC, RTM_NEWNSID, rtnl_net_newid, NULL, NULL);
 722         rtnl_register(PF_UNSPEC, RTM_GETNSID, rtnl_net_getid, rtnl_net_dumpid,
 723                       NULL);
 724
 725         return 0;
 726 }
 727
 728 pure_initcall(net_ns_init);
 729
 730 #ifdef CONFIG_NET_NS
 731 static int __register_pernet_operations(struct list_head *list,
 732                                         struct pernet_operations *ops)
 733 {
 734         struct net *net;
 735         int error;
 736         LIST_HEAD(net_exit_list);
 737
 738         list_add_tail(&ops->list, list);
 739         if (ops->init || (ops->id && ops->size)) {
 740                 for_each_net(net) {
 741                         error = ops_init(ops, net);
 742                         if (error)
 743                                 goto out_undo;
 744                         list_add_tail(&net->exit_list, &net_exit_list);
 745                 }
 746         }
 747         return 0;
 748
 749 out_undo:
 750         /* If I have an error cleanup all namespaces I initialized */
 751         list_del(&ops->list);
 752         ops_exit_list(ops, &net_exit_list);
 753         ops_free_list(ops, &net_exit_list);
 754         return error;
 755 }
 756
 757 static void __unregister_pernet_operations(struct pernet_operations *ops)
 758 {
 759         struct net *net;
 760         LIST_HEAD(net_exit_list);
 761
 762         list_del(&ops->list);
 763         for_each_net(net)
 764                 list_add_tail(&net->exit_list, &net_exit_list);
 765         ops_exit_list(ops, &net_exit_list);
 766         ops_free_list(ops, &net_exit_list);
 767 }
 768
 769 #else
 770
 771 static int __register_pernet_operations(struct list_head *list,
 772                                         struct pernet_operations *ops)
 773 {
 774         return ops_init(ops, &init_net);
 775 }
 776
 777 static void __unregister_pernet_operations(struct pernet_operations *ops)
 778 {
 779         LIST_HEAD(net_exit_list);
 780         list_add(&init_net.exit_list, &net_exit_list);
 781         ops_exit_list(ops, &net_exit_list);
 782         ops_free_list(ops, &net_exit_list);
 783 }
 784
 785 #endif /* CONFIG_NET_NS */
 786
 787 static DEFINE_IDA(net_generic_ids);
 788
 789 static int register_pernet_operations(struct list_head *list,
 790                                       struct pernet_operations *ops)
 791 {
 792         int error;
 793
 794         if (ops->id) {
 795 again:
 796                 error = ida_get_new_above(&net_generic_ids, 1, ops->id);
 797                 if (error < 0) {
 798                         if (error == -EAGAIN) {
 799                                 ida_pre_get(&net_generic_ids, GFP_KERNEL);
 800                                 goto again;
 801                         }
 802                         return error;
 803                 }
 804                 max_gen_ptrs = max_t(unsigned int, max_gen_ptrs, *ops->id);
 805         }
 806         error = __register_pernet_operations(list, ops);
 807         if (error) {
 808                 rcu_barrier();
 809                 if (ops->id)
 810                         ida_remove(&net_generic_ids, *ops->id);
 811         }
 812
 813         return error;
 814 }
 815
 816 static void unregister_pernet_operations(struct pernet_operations *ops)
 817 {
 818
 819         __unregister_pernet_operations(ops);
 820         rcu_barrier();
 821         if (ops->id)
 822                 ida_remove(&net_generic_ids, *ops->id);
 823 }
 824
 825 /**
 826  *      register_pernet_subsys - register a network namespace subsystem
 827  *      @ops:  pernet operations structure for the subsystem
 828  *
 829  *      Register a subsystem which has init and exit functions
 830  *      that are called when network namespaces are created and
 831  *      destroyed respectively.
 832  *
 833  *      When registered all network namespace init functions are
 834  *      called for every existing network namespace.  Allowing kernel
 835  *      modules to have a race free view of the set of network namespaces.
 836  *
 837  *      When a new network namespace is created all of the init
 838  *      methods are called in the order in which they were registered.
 839  *
 840  *      When a network namespace is destroyed all of the exit methods
 841  *      are called in the reverse of the order with which they were
 842  *      registered.
 843  */
 844 int register_pernet_subsys(struct pernet_operations *ops)
 845 {
 846         int error;
 847         mutex_lock(&net_mutex);
 848         error =  register_pernet_operations(first_device, ops);
 849         mutex_unlock(&net_mutex);
 850         return error;
 851 }
 852 EXPORT_SYMBOL_GPL(register_pernet_subsys);
 853
 854 /**
 855  *      unregister_pernet_subsys - unregister a network namespace subsystem
 856  *      @ops: pernet operations structure to manipulate
 857  *
 858  *      Remove the pernet operations structure from the list to be
 859  *      used when network namespaces are created or destroyed.  In
 860  *      addition run the exit method for all existing network
 861  *      namespaces.
 862  */
 863 void unregister_pernet_subsys(struct pernet_operations *ops)
 864 {
 865         mutex_lock(&net_mutex);
 866         unregister_pernet_operations(ops);
 867         mutex_unlock(&net_mutex);
 868 }
 869 EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
 870
 871 /**
 872  *      register_pernet_device - register a network namespace device
 873  *      @ops:  pernet operations structure for the subsystem
 874  *
 875  *      Register a device which has init and exit functions
 876  *      that are called when network namespaces are created and
 877  *      destroyed respectively.
 878  *
 879  *      When registered all network namespace init functions are
 880  *      called for every existing network namespace.  Allowing kernel
 881  *      modules to have a race free view of the set of network namespaces.
 882  *
 883  *      When a new network namespace is created all of the init
 884  *      methods are called in the order in which they were registered.
 885  *
 886  *      When a network namespace is destroyed all of the exit methods
 887  *      are called in the reverse of the order with which they were
 888  *      registered.
 889  */
 890 int register_pernet_device(struct pernet_operations *ops)
 891 {
 892         int error;
 893         mutex_lock(&net_mutex);
 894         error = register_pernet_operations(&pernet_list, ops);
 895         if (!error && (first_device == &pernet_list))
 896                 first_device = &ops->list;
 897         mutex_unlock(&net_mutex);
 898         return error;
 899 }
 900 EXPORT_SYMBOL_GPL(register_pernet_device);
 901
 902 /**
 903  *      unregister_pernet_device - unregister a network namespace netdevice
 904  *      @ops: pernet operations structure to manipulate
 905  *
 906  *      Remove the pernet operations structure from the list to be
 907  *      used when network namespaces are created or destroyed.  In
 908  *      addition run the exit method for all existing network
 909  *      namespaces.
 910  */
 911 void unregister_pernet_device(struct pernet_operations *ops)
 912 {
 913         mutex_lock(&net_mutex);
 914         if (&ops->list == first_device)
 915                 first_device = first_device->next;
 916         unregister_pernet_operations(ops);
 917         mutex_unlock(&net_mutex);
 918 }
 919 EXPORT_SYMBOL_GPL(unregister_pernet_device);
 920
 921 #ifdef CONFIG_NET_NS
 922 static struct ns_common *netns_get(struct task_struct *task)
 923 {
 924         struct net *net = NULL;
 925         struct nsproxy *nsproxy;
 926
 927         task_lock(task);
 928         nsproxy = task->nsproxy;
 929         if (nsproxy)
 930                 net = get_net(nsproxy->net_ns);
 931         task_unlock(task);
 932
 933         return net ? &net->ns : NULL;
 934 }
 935
 936 static inline struct net *to_net_ns(struct ns_common *ns)
 937 {
 938         return container_of(ns, struct net, ns);
 939 }
 940
 941 static void netns_put(struct ns_common *ns)
 942 {
 943         put_net(to_net_ns(ns));
 944 }
 945
 946 static int netns_install(struct nsproxy *nsproxy, struct ns_common *ns)
 947 {
 948         struct net *net = to_net_ns(ns);
 949
 950         if (!ns_capable(net->user_ns, CAP_SYS_ADMIN) ||
 951             !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
 952                 return -EPERM;
 953
 954         put_net(nsproxy->net_ns);
 955         nsproxy->net_ns = get_net(net);
 956         return 0;
 957 }
 958
 959 const struct proc_ns_operations netns_operations = {
 960         .name           = "net",
 961         .type           = CLONE_NEWNET,
 962         .get            = netns_get,
 963         .put            = netns_put,
 964         .install        = netns_install,
 965 };
 966 #endif