net/core/net_namespace.c

   1 #include <linux/workqueue.h>
   2 #include <linux/rtnetlink.h>
   3 #include <linux/cache.h>
   4 #include <linux/slab.h>
   5 #include <linux/list.h>
   6 #include <linux/delay.h>
   7 #include <linux/sched.h>
   8 #include <linux/idr.h>
   9 #include <net/net_namespace.h>
  10 #include <net/netns/generic.h>
  11
  12 /*
  13  *      Our network namespace constructor/destructor lists
  14  */
  15
  16 static LIST_HEAD(pernet_list);
  17 static struct list_head *first_device = &pernet_list;
  18 static DEFINE_MUTEX(net_mutex);
  19
  20 LIST_HEAD(net_namespace_list);
  21 EXPORT_SYMBOL_GPL(net_namespace_list);
  22
  23 struct net init_net;
  24 EXPORT_SYMBOL(init_net);
  25
  26 #define INITIAL_NET_GEN_PTRS    13 /* +1 for len +2 for rcu_head */
  27
  28 /*
  29  * setup_net runs the initializers for the network namespace object.
  30  */
  31 static __net_init int setup_net(struct net *net)
  32 {
  33         /* Must be called with net_mutex held */
  34         struct pernet_operations *ops;
  35         int error;
  36         struct net_generic *ng;
  37
  38         atomic_set(&net->count, 1);
  39 #ifdef NETNS_REFCNT_DEBUG
  40         atomic_set(&net->use_count, 0);
  41 #endif
  42
  43         error = -ENOMEM;
  44         ng = kzalloc(sizeof(struct net_generic) +
  45                         INITIAL_NET_GEN_PTRS * sizeof(void *), GFP_KERNEL);
  46         if (ng == NULL)
  47                 goto out;
  48
  49         ng->len = INITIAL_NET_GEN_PTRS;
  50         INIT_RCU_HEAD(&ng->rcu);
  51         rcu_assign_pointer(net->gen, ng);
  52
  53         error = 0;
  54         list_for_each_entry(ops, &pernet_list, list) {
  55                 if (ops->init) {
  56                         error = ops->init(net);
  57                         if (error < 0)
  58                                 goto out_undo;
  59                 }
  60         }
  61 out:
  62         return error;
  63
  64 out_undo:
  65         /* Walk through the list backwards calling the exit functions
  66          * for the pernet modules whose init functions did not fail.
  67          */
  68         list_for_each_entry_continue_reverse(ops, &pernet_list, list) {
  69                 if (ops->exit)
  70                         ops->exit(net);
  71         }
  72
  73         rcu_barrier();
  74         kfree(ng);
  75         goto out;
  76 }
  77
  78 #ifdef CONFIG_NET_NS
  79 static struct kmem_cache *net_cachep;
  80 static struct workqueue_struct *netns_wq;
  81
  82 static struct net *net_alloc(void)
  83 {
  84         return kmem_cache_zalloc(net_cachep, GFP_KERNEL);
  85 }
  86
  87 static void net_free(struct net *net)
  88 {
  89         if (!net)
  90                 return;
  91
  92 #ifdef NETNS_REFCNT_DEBUG
  93         if (unlikely(atomic_read(&net->use_count) != 0)) {
  94                 printk(KERN_EMERG "network namespace not free! Usage: %d\n",
  95                         atomic_read(&net->use_count));
  96                 return;
  97         }
  98 #endif
  99         kfree(net->gen);
 100         kmem_cache_free(net_cachep, net);
 101 }
 102
 103 struct net *copy_net_ns(unsigned long flags, struct net *old_net)
 104 {
 105         struct net *new_net = NULL;
 106         int err;
 107
 108         get_net(old_net);
 109
 110         if (!(flags & CLONE_NEWNET))
 111                 return old_net;
 112
 113         err = -ENOMEM;
 114         new_net = net_alloc();
 115         if (!new_net)
 116                 goto out;
 117
 118         mutex_lock(&net_mutex);
 119         err = setup_net(new_net);
 120         if (err)
 121                 goto out_unlock;
 122
 123         rtnl_lock();
 124         list_add_tail(&new_net->list, &net_namespace_list);
 125         rtnl_unlock();
 126
 127
 128 out_unlock:
 129         mutex_unlock(&net_mutex);
 130 out:
 131         put_net(old_net);
 132         if (err) {
 133                 net_free(new_net);
 134                 new_net = ERR_PTR(err);
 135         }
 136         return new_net;
 137 }
 138
 139 static void cleanup_net(struct work_struct *work)
 140 {
 141         struct pernet_operations *ops;
 142         struct net *net;
 143
 144         /* Be very certain incoming network packets will not find us */
 145         rcu_barrier();
 146
 147         net = container_of(work, struct net, work);
 148
 149         mutex_lock(&net_mutex);
 150
 151         /* Don't let anyone else find us. */
 152         rtnl_lock();
 153         list_del(&net->list);
 154         rtnl_unlock();
 155
 156         /* Run all of the network namespace exit methods */
 157         list_for_each_entry_reverse(ops, &pernet_list, list) {
 158                 if (ops->exit)
 159                         ops->exit(net);
 160         }
 161
 162         mutex_unlock(&net_mutex);
 163
 164         /* Ensure there are no outstanding rcu callbacks using this
 165          * network namespace.
 166          */
 167         rcu_barrier();
 168
 169         /* Finally it is safe to free my network namespace structure */
 170         net_free(net);
 171 }
 172
 173 void __put_net(struct net *net)
 174 {
 175         /* Cleanup the network namespace in process context */
 176         INIT_WORK(&net->work, cleanup_net);
 177         queue_work(netns_wq, &net->work);
 178 }
 179 EXPORT_SYMBOL_GPL(__put_net);
 180
 181 #else
 182 struct net *copy_net_ns(unsigned long flags, struct net *old_net)
 183 {
 184         if (flags & CLONE_NEWNET)
 185                 return ERR_PTR(-EINVAL);
 186         return old_net;
 187 }
 188 #endif
 189
 190 static int __init net_ns_init(void)
 191 {
 192         int err;
 193
 194         printk(KERN_INFO "net_namespace: %zd bytes\n", sizeof(struct net));
 195 #ifdef CONFIG_NET_NS
 196         net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
 197                                         SMP_CACHE_BYTES,
 198                                         SLAB_PANIC, NULL);
 199
 200         /* Create workqueue for cleanup */
 201         netns_wq = create_singlethread_workqueue("netns");
 202         if (!netns_wq)
 203                 panic("Could not create netns workq");
 204 #endif
 205
 206         mutex_lock(&net_mutex);
 207         err = setup_net(&init_net);
 208
 209         rtnl_lock();
 210         list_add_tail(&init_net.list, &net_namespace_list);
 211         rtnl_unlock();
 212
 213         mutex_unlock(&net_mutex);
 214         if (err)
 215                 panic("Could not setup the initial network namespace");
 216
 217         return 0;
 218 }
 219
 220 pure_initcall(net_ns_init);
 221
 222 #ifdef CONFIG_NET_NS
 223 static int register_pernet_operations(struct list_head *list,
 224                                       struct pernet_operations *ops)
 225 {
 226         struct net *net, *undo_net;
 227         int error;
 228
 229         list_add_tail(&ops->list, list);
 230         if (ops->init) {
 231                 for_each_net(net) {
 232                         error = ops->init(net);
 233                         if (error)
 234                                 goto out_undo;
 235                 }
 236         }
 237         return 0;
 238
 239 out_undo:
 240         /* If I have an error cleanup all namespaces I initialized */
 241         list_del(&ops->list);
 242         if (ops->exit) {
 243                 for_each_net(undo_net) {
 244                         if (undo_net == net)
 245                                 goto undone;
 246                         ops->exit(undo_net);
 247                 }
 248         }
 249 undone:
 250         return error;
 251 }
 252
 253 static void unregister_pernet_operations(struct pernet_operations *ops)
 254 {
 255         struct net *net;
 256
 257         list_del(&ops->list);
 258         if (ops->exit)
 259                 for_each_net(net)
 260                         ops->exit(net);
 261 }
 262
 263 #else
 264
 265 static int register_pernet_operations(struct list_head *list,
 266                                       struct pernet_operations *ops)
 267 {
 268         if (ops->init == NULL)
 269                 return 0;
 270         return ops->init(&init_net);
 271 }
 272
 273 static void unregister_pernet_operations(struct pernet_operations *ops)
 274 {
 275         if (ops->exit)
 276                 ops->exit(&init_net);
 277 }
 278 #endif
 279
 280 static DEFINE_IDA(net_generic_ids);
 281
 282 /**
 283  *      register_pernet_subsys - register a network namespace subsystem
 284  *      @ops:  pernet operations structure for the subsystem
 285  *
 286  *      Register a subsystem which has init and exit functions
 287  *      that are called when network namespaces are created and
 288  *      destroyed respectively.
 289  *
 290  *      When registered all network namespace init functions are
 291  *      called for every existing network namespace.  Allowing kernel
 292  *      modules to have a race free view of the set of network namespaces.
 293  *
 294  *      When a new network namespace is created all of the init
 295  *      methods are called in the order in which they were registered.
 296  *
 297  *      When a network namespace is destroyed all of the exit methods
 298  *      are called in the reverse of the order with which they were
 299  *      registered.
 300  */
 301 int register_pernet_subsys(struct pernet_operations *ops)
 302 {
 303         int error;
 304         mutex_lock(&net_mutex);
 305         error =  register_pernet_operations(first_device, ops);
 306         mutex_unlock(&net_mutex);
 307         return error;
 308 }
 309 EXPORT_SYMBOL_GPL(register_pernet_subsys);
 310
 311 /**
 312  *      unregister_pernet_subsys - unregister a network namespace subsystem
 313  *      @ops: pernet operations structure to manipulate
 314  *
 315  *      Remove the pernet operations structure from the list to be
 316  *      used when network namespaces are created or destroyed.  In
 317  *      addition run the exit method for all existing network
 318  *      namespaces.
 319  */
 320 void unregister_pernet_subsys(struct pernet_operations *module)
 321 {
 322         mutex_lock(&net_mutex);
 323         unregister_pernet_operations(module);
 324         mutex_unlock(&net_mutex);
 325 }
 326 EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
 327
 328 int register_pernet_gen_subsys(int *id, struct pernet_operations *ops)
 329 {
 330         int rv;
 331
 332         mutex_lock(&net_mutex);
 333 again:
 334         rv = ida_get_new_above(&net_generic_ids, 1, id);
 335         if (rv < 0) {
 336                 if (rv == -EAGAIN) {
 337                         ida_pre_get(&net_generic_ids, GFP_KERNEL);
 338                         goto again;
 339                 }
 340                 goto out;
 341         }
 342         rv = register_pernet_operations(first_device, ops);
 343         if (rv < 0)
 344                 ida_remove(&net_generic_ids, *id);
 345 out:
 346         mutex_unlock(&net_mutex);
 347         return rv;
 348 }
 349 EXPORT_SYMBOL_GPL(register_pernet_gen_subsys);
 350
 351 void unregister_pernet_gen_subsys(int id, struct pernet_operations *ops)
 352 {
 353         mutex_lock(&net_mutex);
 354         unregister_pernet_operations(ops);
 355         ida_remove(&net_generic_ids, id);
 356         mutex_unlock(&net_mutex);
 357 }
 358 EXPORT_SYMBOL_GPL(unregister_pernet_gen_subsys);
 359
 360 /**
 361  *      register_pernet_device - register a network namespace device
 362  *      @ops:  pernet operations structure for the subsystem
 363  *
 364  *      Register a device which has init and exit functions
 365  *      that are called when network namespaces are created and
 366  *      destroyed respectively.
 367  *
 368  *      When registered all network namespace init functions are
 369  *      called for every existing network namespace.  Allowing kernel
 370  *      modules to have a race free view of the set of network namespaces.
 371  *
 372  *      When a new network namespace is created all of the init
 373  *      methods are called in the order in which they were registered.
 374  *
 375  *      When a network namespace is destroyed all of the exit methods
 376  *      are called in the reverse of the order with which they were
 377  *      registered.
 378  */
 379 int register_pernet_device(struct pernet_operations *ops)
 380 {
 381         int error;
 382         mutex_lock(&net_mutex);
 383         error = register_pernet_operations(&pernet_list, ops);
 384         if (!error && (first_device == &pernet_list))
 385                 first_device = &ops->list;
 386         mutex_unlock(&net_mutex);
 387         return error;
 388 }
 389 EXPORT_SYMBOL_GPL(register_pernet_device);
 390
 391 int register_pernet_gen_device(int *id, struct pernet_operations *ops)
 392 {
 393         int error;
 394         mutex_lock(&net_mutex);
 395 again:
 396         error = ida_get_new_above(&net_generic_ids, 1, id);
 397         if (error) {
 398                 if (error == -EAGAIN) {
 399                         ida_pre_get(&net_generic_ids, GFP_KERNEL);
 400                         goto again;
 401                 }
 402                 goto out;
 403         }
 404         error = register_pernet_operations(&pernet_list, ops);
 405         if (error)
 406                 ida_remove(&net_generic_ids, *id);
 407         else if (first_device == &pernet_list)
 408                 first_device = &ops->list;
 409 out:
 410         mutex_unlock(&net_mutex);
 411         return error;
 412 }
 413 EXPORT_SYMBOL_GPL(register_pernet_gen_device);
 414
 415 /**
 416  *      unregister_pernet_device - unregister a network namespace netdevice
 417  *      @ops: pernet operations structure to manipulate
 418  *
 419  *      Remove the pernet operations structure from the list to be
 420  *      used when network namespaces are created or destroyed.  In
 421  *      addition run the exit method for all existing network
 422  *      namespaces.
 423  */
 424 void unregister_pernet_device(struct pernet_operations *ops)
 425 {
 426         mutex_lock(&net_mutex);
 427         if (&ops->list == first_device)
 428                 first_device = first_device->next;
 429         unregister_pernet_operations(ops);
 430         mutex_unlock(&net_mutex);
 431 }
 432 EXPORT_SYMBOL_GPL(unregister_pernet_device);
 433
 434 void unregister_pernet_gen_device(int id, struct pernet_operations *ops)
 435 {
 436         mutex_lock(&net_mutex);
 437         if (&ops->list == first_device)
 438                 first_device = first_device->next;
 439         unregister_pernet_operations(ops);
 440         ida_remove(&net_generic_ids, id);
 441         mutex_unlock(&net_mutex);
 442 }
 443 EXPORT_SYMBOL_GPL(unregister_pernet_gen_device);
 444
 445 static void net_generic_release(struct rcu_head *rcu)
 446 {
 447         struct net_generic *ng;
 448
 449         ng = container_of(rcu, struct net_generic, rcu);
 450         kfree(ng);
 451 }
 452
 453 int net_assign_generic(struct net *net, int id, void *data)
 454 {
 455         struct net_generic *ng, *old_ng;
 456
 457         BUG_ON(!mutex_is_locked(&net_mutex));
 458         BUG_ON(id == 0);
 459
 460         ng = old_ng = net->gen;
 461         if (old_ng->len >= id)
 462                 goto assign;
 463
 464         ng = kzalloc(sizeof(struct net_generic) +
 465                         id * sizeof(void *), GFP_KERNEL);
 466         if (ng == NULL)
 467                 return -ENOMEM;
 468
 469         /*
 470          * Some synchronisation notes:
 471          *
 472          * The net_generic explores the net->gen array inside rcu
 473          * read section. Besides once set the net->gen->ptr[x]
 474          * pointer never changes (see rules in netns/generic.h).
 475          *
 476          * That said, we simply duplicate this array and schedule
 477          * the old copy for kfree after a grace period.
 478          */
 479
 480         ng->len = id;
 481         INIT_RCU_HEAD(&ng->rcu);
 482         memcpy(&ng->ptr, &old_ng->ptr, old_ng->len);
 483
 484         rcu_assign_pointer(net->gen, ng);
 485         call_rcu(&old_ng->rcu, net_generic_release);
 486 assign:
 487         ng->ptr[id - 1] = data;
 488         return 0;
 489 }
 490 EXPORT_SYMBOL_GPL(net_assign_generic);