LCOV - code coverage report
Current view: top level - include/net - net_namespace.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 5 5 100.0 %
Date: 2017-01-25 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Operations on the network namespace
       3             :  */
       4             : #ifndef __NET_NET_NAMESPACE_H
       5             : #define __NET_NET_NAMESPACE_H
       6             : 
       7             : #include <asm/atomic.h>
       8             : #include <linux/workqueue.h>
       9             : #include <linux/list.h>
      10             : 
      11             : #include <net/netns/core.h>
      12             : #include <net/netns/mib.h>
      13             : #include <net/netns/unix.h>
      14             : #include <net/netns/packet.h>
      15             : #include <net/netns/ipv4.h>
      16             : #include <net/netns/ipv6.h>
      17             : #include <net/netns/dccp.h>
      18             : #include <net/netns/x_tables.h>
      19             : #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
      20             : #include <net/netns/conntrack.h>
      21             : #endif
      22             : #include <net/netns/xfrm.h>
      23             : 
      24             : struct proc_dir_entry;
      25             : struct net_device;
      26             : struct sock;
      27             : struct ctl_table_header;
      28             : struct net_generic;
      29             : struct sock;
      30             : 
      31             : 
      32             : #define NETDEV_HASHBITS    8
      33             : #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
      34             : 
      35             : struct net {
      36             :         atomic_t                count;          /* To decided when the network
      37             :                                                  *  namespace should be freed.
      38             :                                                  */
      39             : #ifdef NETNS_REFCNT_DEBUG
      40             :         atomic_t                use_count;      /* To track references we
      41             :                                                  * destroy on demand
      42             :                                                  */
      43             : #endif
      44             :         struct list_head        list;           /* list of network namespaces */
      45             :         struct list_head        cleanup_list;   /* namespaces on death row */
      46             :         struct list_head        exit_list;      /* Use only net_mutex */
      47             : 
      48             :         struct proc_dir_entry   *proc_net;
      49             :         struct proc_dir_entry   *proc_net_stat;
      50             : 
      51             : #ifdef CONFIG_SYSCTL
      52             :         struct ctl_table_set    sysctls;
      53             : #endif
      54             : 
      55             :         struct net_device       *loopback_dev;          /* The loopback */
      56             : 
      57             :         struct list_head        dev_base_head;
      58             :         struct hlist_head       *dev_name_head;
      59             :         struct hlist_head       *dev_index_head;
      60             : 
      61             :         /* core fib_rules */
      62             :         struct list_head        rules_ops;
      63             :         spinlock_t              rules_mod_lock;
      64             : 
      65             :         struct sock             *rtnl;                  /* rtnetlink socket */
      66             :         struct sock             *genl_sock;
      67             : 
      68             :         struct netns_core       core;
      69             :         struct netns_mib        mib;
      70             :         struct netns_packet     packet;
      71             :         struct netns_unix       unx;
      72             :         struct netns_ipv4       ipv4;
      73             : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
      74             :         struct netns_ipv6       ipv6;
      75             : #endif
      76             : #if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
      77             :         struct netns_dccp       dccp;
      78             : #endif
      79             : #ifdef CONFIG_NETFILTER
      80             :         struct netns_xt         xt;
      81             : #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
      82             :         struct netns_ct         ct;
      83             : #endif
      84             : #endif
      85             : #ifdef CONFIG_XFRM
      86             :         struct netns_xfrm       xfrm;
      87             : #endif
      88             : #ifdef CONFIG_WEXT_CORE
      89             :         struct sk_buff_head     wext_nlevents;
      90             : #endif
      91             :         struct net_generic      *gen;
      92             : };
      93           1 : 
      94           1 : 
      95           1 : #include <linux/seq_file_net.h>
      96             : 
      97             : /* Init's network namespace */
      98             : extern struct net init_net;
      99             : 
     100             : #ifdef CONFIG_NET
     101             : #define INIT_NET_NS(net_ns) .net_ns = &init_net,
     102             : 
     103             : extern struct net *copy_net_ns(unsigned long flags, struct net *net_ns);
     104             : 
     105             : #else /* CONFIG_NET */
     106             : 
     107             : #define INIT_NET_NS(net_ns)
     108             : 
     109             : static inline struct net *copy_net_ns(unsigned long flags, struct net *net_ns)
     110             : {
     111             :         /* There is nothing to copy so this is a noop */
     112             :         return net_ns;
     113             : }
     114             : #endif /* CONFIG_NET */
     115             : 
     116             : 
     117             : extern struct list_head net_namespace_list;
     118             : 
     119             : extern struct net *get_net_ns_by_pid(pid_t pid);
     120             : 
     121             : #ifdef CONFIG_NET_NS
     122             : extern void __put_net(struct net *net);
     123             : 
     124             : static inline struct net *get_net(struct net *net)
     125             : {
     126             :         atomic_inc(&net->count);
     127             :         return net;
     128             : }
     129             : 
     130             : static inline struct net *maybe_get_net(struct net *net)
     131             : {
     132             :         /* Used when we know struct net exists but we
     133             :          * aren't guaranteed a previous reference count
     134             :          * exists.  If the reference count is zero this
     135             :          * function fails and returns NULL.
     136             :          */
     137             :         if (!atomic_inc_not_zero(&net->count))
     138             :                 net = NULL;
     139             :         return net;
     140             : }
     141             : 
     142             : static inline void put_net(struct net *net)
     143             : {
     144             :         if (atomic_dec_and_test(&net->count))
     145             :                 __put_net(net);
     146             : }
     147             : 
     148             : static inline
     149             : int net_eq(const struct net *net1, const struct net *net2)
     150             : {
     151             :         return net1 == net2;
     152             : }
     153             : #else
     154             : 
     155             : static inline struct net *get_net(struct net *net)
     156             : {
     157             :         return net;
     158             : }
     159             : 
     160             : static inline void put_net(struct net *net)
     161             : {
     162             : }
     163             : 
     164             : static inline struct net *maybe_get_net(struct net *net)
     165             : {
     166             :         return net;
     167             : }
     168             : 
     169             : static inline
     170             : int net_eq(const struct net *net1, const struct net *net2)
     171             : {
     172           1 :         return 1;
     173             : }
     174             : #endif
     175             : 
     176             : 
     177             : #ifdef NETNS_REFCNT_DEBUG
     178             : static inline struct net *hold_net(struct net *net)
     179             : {
     180             :         if (net)
     181             :                 atomic_inc(&net->use_count);
     182             :         return net;
     183             : }
     184             : 
     185             : static inline void release_net(struct net *net)
     186             : {
     187             :         if (net)
     188             :                 atomic_dec(&net->use_count);
     189             : }
     190             : #else
     191             : static inline struct net *hold_net(struct net *net)
     192             : {
     193             :         return net;
     194             : }
     195             : 
     196             : static inline void release_net(struct net *net)
     197             : {
     198             : }
     199           1 : #endif
     200             : 
     201             : #ifdef CONFIG_NET_NS
     202             : 
     203             : static inline void write_pnet(struct net **pnet, struct net *net)
     204             : {
     205             :         *pnet = net;
     206             : }
     207             : 
     208             : static inline struct net *read_pnet(struct net * const *pnet)
     209             : {
     210             :         return *pnet;
     211             : }
     212             : 
     213             : #else
     214             : 
     215             : #define write_pnet(pnet, net)   do { (void)(net);} while (0)
     216             : #define read_pnet(pnet)         (&init_net)
     217             : 
     218             : #endif
     219             : 
     220             : #define for_each_net(VAR)                               \
     221             :         list_for_each_entry(VAR, &net_namespace_list, list)
     222             : 
     223             : #define for_each_net_rcu(VAR)                           \
     224             :         list_for_each_entry_rcu(VAR, &net_namespace_list, list)
     225             : 
     226             : #ifdef CONFIG_NET_NS
     227             : #define __net_init
     228             : #define __net_exit
     229             : #define __net_initdata
     230             : #else
     231             : #define __net_init      __init
     232             : #define __net_exit      __exit_refok
     233             : #define __net_initdata  __initdata
     234             : #endif
     235             : 
     236             : struct pernet_operations {
     237             :         struct list_head list;
     238             :         int (*init)(struct net *net);
     239             :         void (*exit)(struct net *net);
     240             :         void (*exit_batch)(struct list_head *net_exit_list);
     241             :         int *id;
     242             :         size_t size;
     243             : };
     244             : 
     245             : /*
     246             :  * Use these carefully.  If you implement a network device and it
     247             :  * needs per network namespace operations use device pernet operations,
     248             :  * otherwise use pernet subsys operations.
     249             :  *
     250             :  * Network interfaces need to be removed from a dying netns _before_
     251             :  * subsys notifiers can be called, as most of the network code cleanup
     252             :  * (which is done from subsys notifiers) runs with the assumption that
     253             :  * dev_remove_pack has been called so no new packets will arrive during
     254             :  * and after the cleanup functions have been called.  dev_remove_pack
     255             :  * is not per namespace so instead the guarantee of no more packets
     256             :  * arriving in a network namespace is provided by ensuring that all
     257             :  * network devices and all sockets have left the network namespace
     258             :  * before the cleanup methods are called.
     259             :  *
     260             :  * For the longest time the ipv4 icmp code was registered as a pernet
     261             :  * device which caused kernel oops, and panics during network
     262             :  * namespace cleanup.   So please don't get this wrong.
     263             :  */
     264             : extern int register_pernet_subsys(struct pernet_operations *);
     265             : extern void unregister_pernet_subsys(struct pernet_operations *);
     266             : extern int register_pernet_device(struct pernet_operations *);
     267             : extern void unregister_pernet_device(struct pernet_operations *);
     268             : 
     269             : struct ctl_path;
     270             : struct ctl_table;
     271             : struct ctl_table_header;
     272             : 
     273             : extern struct ctl_table_header *register_net_sysctl_table(struct net *net,
     274             :         const struct ctl_path *path, struct ctl_table *table);
     275             : extern struct ctl_table_header *register_net_sysctl_rotable(
     276             :         const struct ctl_path *path, struct ctl_table *table);
     277             : extern void unregister_net_sysctl_table(struct ctl_table_header *header);
     278             : 
     279             : #endif /* __NET_NET_NAMESPACE_H */

Generated by: LCOV version 1.10