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