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 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 /** 329 * register_pernet_device - register a network namespace device 330 * @ops: pernet operations structure for the subsystem 331 * 332 * Register a device which has init and exit functions 333 * that are called when network namespaces are created and 334 * destroyed respectively. 335 * 336 * When registered all network namespace init functions are 337 * called for every existing network namespace. Allowing kernel 338 * modules to have a race free view of the set of network namespaces. 339 * 340 * When a new network namespace is created all of the init 341 * methods are called in the order in which they were registered. 342 * 343 * When a network namespace is destroyed all of the exit methods 344 * are called in the reverse of the order with which they were 345 * registered. 346 */ 347 int register_pernet_device(struct pernet_operations *ops) 348 { 349 int error; 350 mutex_lock(&net_mutex); 351 error = register_pernet_operations(&pernet_list, ops); 352 if (!error && (first_device == &pernet_list)) 353 first_device = &ops->list; 354 mutex_unlock(&net_mutex); 355 return error; 356 } 357 EXPORT_SYMBOL_GPL(register_pernet_device); 358 359 int register_pernet_gen_device(int *id, struct pernet_operations *ops) 360 { 361 int error; 362 mutex_lock(&net_mutex); 363 again: 364 error = ida_get_new_above(&net_generic_ids, 1, id); 365 if (error) { 366 if (error == -EAGAIN) { 367 ida_pre_get(&net_generic_ids, GFP_KERNEL); 368 goto again; 369 } 370 goto out; 371 } 372 error = register_pernet_operations(&pernet_list, ops); 373 if (error) 374 ida_remove(&net_generic_ids, *id); 375 else if (first_device == &pernet_list) 376 first_device = &ops->list; 377 out: 378 mutex_unlock(&net_mutex); 379 return error; 380 } 381 EXPORT_SYMBOL_GPL(register_pernet_gen_device); 382 383 /** 384 * unregister_pernet_device - unregister a network namespace netdevice 385 * @ops: pernet operations structure to manipulate 386 * 387 * Remove the pernet operations structure from the list to be 388 * used when network namespaces are created or destroyed. In 389 * addition run the exit method for all existing network 390 * namespaces. 391 */ 392 void unregister_pernet_device(struct pernet_operations *ops) 393 { 394 mutex_lock(&net_mutex); 395 if (&ops->list == first_device) 396 first_device = first_device->next; 397 unregister_pernet_operations(ops); 398 mutex_unlock(&net_mutex); 399 } 400 EXPORT_SYMBOL_GPL(unregister_pernet_device); 401 402 void unregister_pernet_gen_device(int id, struct pernet_operations *ops) 403 { 404 mutex_lock(&net_mutex); 405 if (&ops->list == first_device) 406 first_device = first_device->next; 407 unregister_pernet_operations(ops); 408 ida_remove(&net_generic_ids, id); 409 mutex_unlock(&net_mutex); 410 } 411 EXPORT_SYMBOL_GPL(unregister_pernet_gen_device); 412 413 static void net_generic_release(struct rcu_head *rcu) 414 { 415 struct net_generic *ng; 416 417 ng = container_of(rcu, struct net_generic, rcu); 418 kfree(ng); 419 } 420 421 int net_assign_generic(struct net *net, int id, void *data) 422 { 423 struct net_generic *ng, *old_ng; 424 425 BUG_ON(!mutex_is_locked(&net_mutex)); 426 BUG_ON(id == 0); 427 428 ng = old_ng = net->gen; 429 if (old_ng->len >= id) 430 goto assign; 431 432 ng = kzalloc(sizeof(struct net_generic) + 433 id * sizeof(void *), GFP_KERNEL); 434 if (ng == NULL) 435 return -ENOMEM; 436 437 /* 438 * Some synchronisation notes: 439 * 440 * The net_generic explores the net->gen array inside rcu 441 * read section. Besides once set the net->gen->ptr[x] 442 * pointer never changes (see rules in netns/generic.h). 443 * 444 * That said, we simply duplicate this array and schedule 445 * the old copy for kfree after a grace period. 446 */ 447 448 ng->len = id; 449 INIT_RCU_HEAD(&ng->rcu); 450 memcpy(&ng->ptr, &old_ng->ptr, old_ng->len); 451 452 rcu_assign_pointer(net->gen, ng); 453 call_rcu(&old_ng->rcu, net_generic_release); 454 assign: 455 ng->ptr[id - 1] = data; 456 return 0; 457 } 458 EXPORT_SYMBOL_GPL(net_assign_generic); 459