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