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 <net/net_namespace.h>
   9
  10 /*
  11  *      Our network namespace constructor/destructor lists
  12  */
  13
  14 static LIST_HEAD(pernet_list);
  15 static struct list_head *first_device = &pernet_list;
  16 static DEFINE_MUTEX(net_mutex);
  17
  18 LIST_HEAD(net_namespace_list);
  19
  20 static struct kmem_cache *net_cachep;
  21
  22 struct net init_net;
  23 EXPORT_SYMBOL_GPL(init_net);
  24
  25 static struct net *net_alloc(void)
  26 {
  27         return kmem_cache_alloc(net_cachep, GFP_KERNEL);
  28 }
  29
  30 static void net_free(struct net *net)
  31 {
  32         if (!net)
  33                 return;
  34
  35         if (unlikely(atomic_read(&net->use_count) != 0)) {
  36                 printk(KERN_EMERG "network namespace not free! Usage: %d\n",
  37                         atomic_read(&net->use_count));
  38                 return;
  39         }
  40
  41         kmem_cache_free(net_cachep, net);
  42 }
  43
  44 static void cleanup_net(struct work_struct *work)
  45 {
  46         struct pernet_operations *ops;
  47         struct net *net;
  48
  49         net = container_of(work, struct net, work);
  50
  51         mutex_lock(&net_mutex);
  52
  53         /* Don't let anyone else find us. */
  54         rtnl_lock();
  55         list_del(&net->list);
  56         rtnl_unlock();
  57
  58         /* Run all of the network namespace exit methods */
  59         list_for_each_entry_reverse(ops, &pernet_list, list) {
  60                 if (ops->exit)
  61                         ops->exit(net);
  62         }
  63
  64         mutex_unlock(&net_mutex);
  65
  66         /* Ensure there are no outstanding rcu callbacks using this
  67          * network namespace.
  68          */
  69         rcu_barrier();
  70
  71         /* Finally it is safe to free my network namespace structure */
  72         net_free(net);
  73 }
  74
  75
  76 void __put_net(struct net *net)
  77 {
  78         /* Cleanup the network namespace in process context */
  79         INIT_WORK(&net->work, cleanup_net);
  80         schedule_work(&net->work);
  81 }
  82 EXPORT_SYMBOL_GPL(__put_net);
  83
  84 /*
  85  * setup_net runs the initializers for the network namespace object.
  86  */
  87 static int setup_net(struct net *net)
  88 {
  89         /* Must be called with net_mutex held */
  90         struct pernet_operations *ops;
  91         int error;
  92
  93         memset(net, 0, sizeof(struct net));
  94         atomic_set(&net->count, 1);
  95         atomic_set(&net->use_count, 0);
  96
  97         error = 0;
  98         list_for_each_entry(ops, &pernet_list, list) {
  99                 if (ops->init) {
 100                         error = ops->init(net);
 101                         if (error < 0)
 102                                 goto out_undo;
 103                 }
 104         }
 105 out:
 106         return error;
 107
 108 out_undo:
 109         /* Walk through the list backwards calling the exit functions
 110          * for the pernet modules whose init functions did not fail.
 111          */
 112         list_for_each_entry_continue_reverse(ops, &pernet_list, list) {
 113                 if (ops->exit)
 114                         ops->exit(net);
 115         }
 116         goto out;
 117 }
 118
 119 struct net *copy_net_ns(unsigned long flags, struct net *old_net)
 120 {
 121         struct net *new_net = NULL;
 122         int err;
 123
 124         get_net(old_net);
 125
 126         if (!(flags & CLONE_NEWNET))
 127                 return old_net;
 128
 129 #ifndef CONFIG_NET_NS
 130         return ERR_PTR(-EINVAL);
 131 #endif
 132
 133         err = -ENOMEM;
 134         new_net = net_alloc();
 135         if (!new_net)
 136                 goto out;
 137
 138         mutex_lock(&net_mutex);
 139         err = setup_net(new_net);
 140         if (err)
 141                 goto out_unlock;
 142
 143         rtnl_lock();
 144         list_add_tail(&new_net->list, &net_namespace_list);
 145         rtnl_unlock();
 146
 147
 148 out_unlock:
 149         mutex_unlock(&net_mutex);
 150 out:
 151         put_net(old_net);
 152         if (err) {
 153                 net_free(new_net);
 154                 new_net = ERR_PTR(err);
 155         }
 156         return new_net;
 157 }
 158
 159 static int __init net_ns_init(void)
 160 {
 161         int err;
 162
 163         printk(KERN_INFO "net_namespace: %zd bytes\n", sizeof(struct net));
 164         net_cachep = kmem_cache_create("net_namespace", sizeof(struct net),
 165                                         SMP_CACHE_BYTES,
 166                                         SLAB_PANIC, NULL);
 167         mutex_lock(&net_mutex);
 168         err = setup_net(&init_net);
 169
 170         rtnl_lock();
 171         list_add_tail(&init_net.list, &net_namespace_list);
 172         rtnl_unlock();
 173
 174         mutex_unlock(&net_mutex);
 175         if (err)
 176                 panic("Could not setup the initial network namespace");
 177
 178         return 0;
 179 }
 180
 181 pure_initcall(net_ns_init);
 182
 183 static int register_pernet_operations(struct list_head *list,
 184                                       struct pernet_operations *ops)
 185 {
 186         struct net *net, *undo_net;
 187         int error;
 188
 189         error = 0;
 190         list_add_tail(&ops->list, list);
 191         for_each_net(net) {
 192                 if (ops->init) {
 193                         error = ops->init(net);
 194                         if (error)
 195                                 goto out_undo;
 196                 }
 197         }
 198 out:
 199         return error;
 200
 201 out_undo:
 202         /* If I have an error cleanup all namespaces I initialized */
 203         list_del(&ops->list);
 204         for_each_net(undo_net) {
 205                 if (undo_net == net)
 206                         goto undone;
 207                 if (ops->exit)
 208                         ops->exit(undo_net);
 209         }
 210 undone:
 211         goto out;
 212 }
 213
 214 static void unregister_pernet_operations(struct pernet_operations *ops)
 215 {
 216         struct net *net;
 217
 218         list_del(&ops->list);
 219         for_each_net(net)
 220                 if (ops->exit)
 221                         ops->exit(net);
 222 }
 223
 224 /**
 225  *      register_pernet_subsys - register a network namespace subsystem
 226  *      @ops:  pernet operations structure for the subsystem
 227  *
 228  *      Register a subsystem which has init and exit functions
 229  *      that are called when network namespaces are created and
 230  *      destroyed respectively.
 231  *
 232  *      When registered all network namespace init functions are
 233  *      called for every existing network namespace.  Allowing kernel
 234  *      modules to have a race free view of the set of network namespaces.
 235  *
 236  *      When a new network namespace is created all of the init
 237  *      methods are called in the order in which they were registered.
 238  *
 239  *      When a network namespace is destroyed all of the exit methods
 240  *      are called in the reverse of the order with which they were
 241  *      registered.
 242  */
 243 int register_pernet_subsys(struct pernet_operations *ops)
 244 {
 245         int error;
 246         mutex_lock(&net_mutex);
 247         error =  register_pernet_operations(first_device, ops);
 248         mutex_unlock(&net_mutex);
 249         return error;
 250 }
 251 EXPORT_SYMBOL_GPL(register_pernet_subsys);
 252
 253 /**
 254  *      unregister_pernet_subsys - unregister a network namespace subsystem
 255  *      @ops: pernet operations structure to manipulate
 256  *
 257  *      Remove the pernet operations structure from the list to be
 258  *      used when network namespaces are created or destoryed.  In
 259  *      addition run the exit method for all existing network
 260  *      namespaces.
 261  */
 262 void unregister_pernet_subsys(struct pernet_operations *module)
 263 {
 264         mutex_lock(&net_mutex);
 265         unregister_pernet_operations(module);
 266         mutex_unlock(&net_mutex);
 267 }
 268 EXPORT_SYMBOL_GPL(unregister_pernet_subsys);
 269
 270 /**
 271  *      register_pernet_device - register a network namespace device
 272  *      @ops:  pernet operations structure for the subsystem
 273  *
 274  *      Register a device which has init and exit functions
 275  *      that are called when network namespaces are created and
 276  *      destroyed respectively.
 277  *
 278  *      When registered all network namespace init functions are
 279  *      called for every existing network namespace.  Allowing kernel
 280  *      modules to have a race free view of the set of network namespaces.
 281  *
 282  *      When a new network namespace is created all of the init
 283  *      methods are called in the order in which they were registered.
 284  *
 285  *      When a network namespace is destroyed all of the exit methods
 286  *      are called in the reverse of the order with which they were
 287  *      registered.
 288  */
 289 int register_pernet_device(struct pernet_operations *ops)
 290 {
 291         int error;
 292         mutex_lock(&net_mutex);
 293         error = register_pernet_operations(&pernet_list, ops);
 294         if (!error && (first_device == &pernet_list))
 295                 first_device = &ops->list;
 296         mutex_unlock(&net_mutex);
 297         return error;
 298 }
 299 EXPORT_SYMBOL_GPL(register_pernet_device);
 300
 301 /**
 302  *      unregister_pernet_device - unregister a network namespace netdevice
 303  *      @ops: pernet operations structure to manipulate
 304  *
 305  *      Remove the pernet operations structure from the list to be
 306  *      used when network namespaces are created or destoryed.  In
 307  *      addition run the exit method for all existing network
 308  *      namespaces.
 309  */
 310 void unregister_pernet_device(struct pernet_operations *ops)
 311 {
 312         mutex_lock(&net_mutex);
 313         if (&ops->list == first_device)
 314                 first_device = first_device->next;
 315         unregister_pernet_operations(ops);
 316         mutex_unlock(&net_mutex);
 317 }
 318 EXPORT_SYMBOL_GPL(unregister_pernet_device);