LCOV - code coverage report
Current view: top level - include/net - net_namespace.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 19 31 61.3 %
Date: 2022-04-01 14:58:12 Functions: 1 1 100.0 %
Branches: 34 110 30.9 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Operations on the network namespace
       4                 :            :  */
       5                 :            : #ifndef __NET_NET_NAMESPACE_H
       6                 :            : #define __NET_NET_NAMESPACE_H
       7                 :            : 
       8                 :            : #include <linux/atomic.h>
       9                 :            : #include <linux/refcount.h>
      10                 :            : #include <linux/workqueue.h>
      11                 :            : #include <linux/list.h>
      12                 :            : #include <linux/sysctl.h>
      13                 :            : #include <linux/uidgid.h>
      14                 :            : 
      15                 :            : #include <net/flow.h>
      16                 :            : #include <net/netns/core.h>
      17                 :            : #include <net/netns/mib.h>
      18                 :            : #include <net/netns/unix.h>
      19                 :            : #include <net/netns/packet.h>
      20                 :            : #include <net/netns/ipv4.h>
      21                 :            : #include <net/netns/ipv6.h>
      22                 :            : #include <net/netns/nexthop.h>
      23                 :            : #include <net/netns/ieee802154_6lowpan.h>
      24                 :            : #include <net/netns/sctp.h>
      25                 :            : #include <net/netns/dccp.h>
      26                 :            : #include <net/netns/netfilter.h>
      27                 :            : #include <net/netns/x_tables.h>
      28                 :            : #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
      29                 :            : #include <net/netns/conntrack.h>
      30                 :            : #endif
      31                 :            : #include <net/netns/nftables.h>
      32                 :            : #include <net/netns/xfrm.h>
      33                 :            : #include <net/netns/mpls.h>
      34                 :            : #include <net/netns/can.h>
      35                 :            : #include <net/netns/xdp.h>
      36                 :            : #include <linux/ns_common.h>
      37                 :            : #include <linux/idr.h>
      38                 :            : #include <linux/skbuff.h>
      39                 :            : #include <linux/notifier.h>
      40                 :            : 
      41                 :            : struct user_namespace;
      42                 :            : struct proc_dir_entry;
      43                 :            : struct net_device;
      44                 :            : struct sock;
      45                 :            : struct ctl_table_header;
      46                 :            : struct net_generic;
      47                 :            : struct uevent_sock;
      48                 :            : struct netns_ipvs;
      49                 :            : struct bpf_prog;
      50                 :            : 
      51                 :            : 
      52                 :            : #define NETDEV_HASHBITS    8
      53                 :            : #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
      54                 :            : 
      55                 :            : struct net {
      56                 :            :         /* First cache line can be often dirtied.
      57                 :            :          * Do not place here read-mostly fields.
      58                 :            :          */
      59                 :            :         refcount_t              passive;        /* To decide when the network
      60                 :            :                                                  * namespace should be freed.
      61                 :            :                                                  */
      62                 :            :         refcount_t              count;          /* To decided when the network
      63                 :            :                                                  *  namespace should be shut down.
      64                 :            :                                                  */
      65                 :            :         spinlock_t              rules_mod_lock;
      66                 :            : 
      67                 :            :         unsigned int            dev_unreg_count;
      68                 :            : 
      69                 :            :         unsigned int            dev_base_seq;   /* protected by rtnl_mutex */
      70                 :            :         int                     ifindex;
      71                 :            : 
      72                 :            :         spinlock_t              nsid_lock;
      73                 :            :         atomic_t                fnhe_genid;
      74                 :            : 
      75                 :            :         struct list_head        list;           /* list of network namespaces */
      76                 :            :         struct list_head        exit_list;      /* To linked to call pernet exit
      77                 :            :                                                  * methods on dead net (
      78                 :            :                                                  * pernet_ops_rwsem read locked),
      79                 :            :                                                  * or to unregister pernet ops
      80                 :            :                                                  * (pernet_ops_rwsem write locked).
      81                 :            :                                                  */
      82                 :            :         struct llist_node       cleanup_list;   /* namespaces on death row */
      83                 :            : 
      84                 :            : #ifdef CONFIG_KEYS
      85                 :            :         struct key_tag          *key_domain;    /* Key domain of operation tag */
      86                 :            : #endif
      87                 :            :         struct user_namespace   *user_ns;       /* Owning user namespace */
      88                 :            :         struct ucounts          *ucounts;
      89                 :            :         struct idr              netns_ids;
      90                 :            : 
      91                 :            :         struct ns_common        ns;
      92                 :            : 
      93                 :            :         struct list_head        dev_base_head;
      94                 :            :         struct proc_dir_entry   *proc_net;
      95                 :            :         struct proc_dir_entry   *proc_net_stat;
      96                 :            : 
      97                 :            : #ifdef CONFIG_SYSCTL
      98                 :            :         struct ctl_table_set    sysctls;
      99                 :            : #endif
     100                 :            : 
     101                 :            :         struct sock             *rtnl;                  /* rtnetlink socket */
     102                 :            :         struct sock             *genl_sock;
     103                 :            : 
     104                 :            :         struct uevent_sock      *uevent_sock;           /* uevent socket */
     105                 :            : 
     106                 :            :         struct hlist_head       *dev_name_head;
     107                 :            :         struct hlist_head       *dev_index_head;
     108                 :            :         struct raw_notifier_head        netdev_chain;
     109                 :            : 
     110                 :            :         /* Note that @hash_mix can be read millions times per second,
     111                 :            :          * it is critical that it is on a read_mostly cache line.
     112                 :            :          */
     113                 :            :         u32                     hash_mix;
     114                 :            : 
     115                 :            :         struct net_device       *loopback_dev;          /* The loopback */
     116                 :            : 
     117                 :            :         /* core fib_rules */
     118                 :            :         struct list_head        rules_ops;
     119                 :            : 
     120                 :            :         struct netns_core       core;
     121                 :            :         struct netns_mib        mib;
     122                 :            :         struct netns_packet     packet;
     123                 :            :         struct netns_unix       unx;
     124                 :            :         struct netns_nexthop    nexthop;
     125                 :            :         struct netns_ipv4       ipv4;
     126                 :            : #if IS_ENABLED(CONFIG_IPV6)
     127                 :            :         struct netns_ipv6       ipv6;
     128                 :            : #endif
     129                 :            : #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
     130                 :            :         struct netns_ieee802154_lowpan  ieee802154_lowpan;
     131                 :            : #endif
     132                 :            : #if defined(CONFIG_IP_SCTP) || defined(CONFIG_IP_SCTP_MODULE)
     133                 :            :         struct netns_sctp       sctp;
     134                 :            : #endif
     135                 :            : #if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
     136                 :            :         struct netns_dccp       dccp;
     137                 :            : #endif
     138                 :            : #ifdef CONFIG_NETFILTER
     139                 :            :         struct netns_nf         nf;
     140                 :            :         struct netns_xt         xt;
     141                 :            : #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
     142                 :            :         struct netns_ct         ct;
     143                 :            : #endif
     144                 :            : #if defined(CONFIG_NF_TABLES) || defined(CONFIG_NF_TABLES_MODULE)
     145                 :            :         struct netns_nftables   nft;
     146                 :            : #endif
     147                 :            : #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
     148                 :            :         struct netns_nf_frag    nf_frag;
     149                 :            :         struct ctl_table_header *nf_frag_frags_hdr;
     150                 :            : #endif
     151                 :            :         struct sock             *nfnl;
     152                 :            :         struct sock             *nfnl_stash;
     153                 :            : #if IS_ENABLED(CONFIG_NETFILTER_NETLINK_ACCT)
     154                 :            :         struct list_head        nfnl_acct_list;
     155                 :            : #endif
     156                 :            : #if IS_ENABLED(CONFIG_NF_CT_NETLINK_TIMEOUT)
     157                 :            :         struct list_head        nfct_timeout_list;
     158                 :            : #endif
     159                 :            : #endif
     160                 :            : #ifdef CONFIG_WEXT_CORE
     161                 :            :         struct sk_buff_head     wext_nlevents;
     162                 :            : #endif
     163                 :            :         struct net_generic __rcu        *gen;
     164                 :            : 
     165                 :            :         struct bpf_prog __rcu   *flow_dissector_prog;
     166                 :            : 
     167                 :            :         /* Note : following structs are cache line aligned */
     168                 :            : #ifdef CONFIG_XFRM
     169                 :            :         struct netns_xfrm       xfrm;
     170                 :            : #endif
     171                 :            : #if IS_ENABLED(CONFIG_IP_VS)
     172                 :            :         struct netns_ipvs       *ipvs;
     173                 :            : #endif
     174                 :            : #if IS_ENABLED(CONFIG_MPLS)
     175                 :            :         struct netns_mpls       mpls;
     176                 :            : #endif
     177                 :            : #if IS_ENABLED(CONFIG_CAN)
     178                 :            :         struct netns_can        can;
     179                 :            : #endif
     180                 :            : #ifdef CONFIG_XDP_SOCKETS
     181                 :            :         struct netns_xdp        xdp;
     182                 :            : #endif
     183                 :            : #if IS_ENABLED(CONFIG_CRYPTO_USER)
     184                 :            :         struct sock             *crypto_nlsk;
     185                 :            : #endif
     186                 :            :         struct sock             *diag_nlsk;
     187                 :            : } __randomize_layout;
     188                 :            : 
     189                 :            : #include <linux/seq_file_net.h>
     190                 :            : 
     191                 :            : /* Init's network namespace */
     192                 :            : extern struct net init_net;
     193                 :            : 
     194                 :            : #ifdef CONFIG_NET_NS
     195                 :            : struct net *copy_net_ns(unsigned long flags, struct user_namespace *user_ns,
     196                 :            :                         struct net *old_net);
     197                 :            : 
     198                 :            : void net_ns_get_ownership(const struct net *net, kuid_t *uid, kgid_t *gid);
     199                 :            : 
     200                 :            : void net_ns_barrier(void);
     201                 :            : #else /* CONFIG_NET_NS */
     202                 :            : #include <linux/sched.h>
     203                 :            : #include <linux/nsproxy.h>
     204                 :            : static inline struct net *copy_net_ns(unsigned long flags,
     205                 :            :         struct user_namespace *user_ns, struct net *old_net)
     206                 :            : {
     207                 :            :         if (flags & CLONE_NEWNET)
     208                 :            :                 return ERR_PTR(-EINVAL);
     209                 :            :         return old_net;
     210                 :            : }
     211                 :            : 
     212                 :            : static inline void net_ns_get_ownership(const struct net *net,
     213                 :            :                                         kuid_t *uid, kgid_t *gid)
     214                 :            : {
     215                 :            :         *uid = GLOBAL_ROOT_UID;
     216                 :            :         *gid = GLOBAL_ROOT_GID;
     217                 :            : }
     218                 :            : 
     219                 :            : static inline void net_ns_barrier(void) {}
     220                 :            : #endif /* CONFIG_NET_NS */
     221                 :            : 
     222                 :            : 
     223                 :            : extern struct list_head net_namespace_list;
     224                 :            : 
     225                 :            : struct net *get_net_ns_by_pid(pid_t pid);
     226                 :            : struct net *get_net_ns_by_fd(int fd);
     227                 :            : 
     228                 :            : #ifdef CONFIG_SYSCTL
     229                 :            : void ipx_register_sysctl(void);
     230                 :            : void ipx_unregister_sysctl(void);
     231                 :            : #else
     232                 :            : #define ipx_register_sysctl()
     233                 :            : #define ipx_unregister_sysctl()
     234                 :            : #endif
     235                 :            : 
     236                 :            : #ifdef CONFIG_NET_NS
     237                 :            : void __put_net(struct net *net);
     238                 :            : 
     239                 :       1419 : static inline struct net *get_net(struct net *net)
     240                 :            : {
     241                 :       1419 :         refcount_inc(&net->count);
     242   [ -  -  #  # ]:       1419 :         return net;
     243                 :            : }
     244                 :            : 
     245                 :          0 : static inline struct net *maybe_get_net(struct net *net)
     246                 :            : {
     247                 :            :         /* Used when we know struct net exists but we
     248                 :            :          * aren't guaranteed a previous reference count
     249                 :            :          * exists.  If the reference count is zero this
     250                 :            :          * function fails and returns NULL.
     251                 :            :          */
     252   [ #  #  #  # ]:          0 :         if (!refcount_inc_not_zero(&net->count))
     253                 :          0 :                 net = NULL;
     254   [ #  #  #  # ]:          0 :         return net;
     255                 :            : }
     256                 :            : 
     257                 :       1260 : static inline void put_net(struct net *net)
     258                 :            : {
     259         [ -  + ]:       1260 :         if (refcount_dec_and_test(&net->count))
     260                 :          0 :                 __put_net(net);
     261                 :       1260 : }
     262                 :            : 
     263                 :            : static inline
     264                 :       6933 : int net_eq(const struct net *net1, const struct net *net2)
     265                 :            : {
     266   [ +  +  +  +  :       3636 :         return net1 == net2;
          -  -  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
     267                 :            : }
     268                 :            : 
     269                 :          0 : static inline int check_net(const struct net *net)
     270                 :            : {
     271                 :          0 :         return refcount_read(&net->count) != 0;
     272                 :            : }
     273                 :            : 
     274                 :            : void net_drop_ns(void *);
     275                 :            : 
     276                 :            : #else
     277                 :            : 
     278                 :            : static inline struct net *get_net(struct net *net)
     279                 :            : {
     280                 :            :         return net;
     281                 :            : }
     282                 :            : 
     283                 :            : static inline void put_net(struct net *net)
     284                 :            : {
     285                 :            : }
     286                 :            : 
     287                 :            : static inline struct net *maybe_get_net(struct net *net)
     288                 :            : {
     289                 :            :         return net;
     290                 :            : }
     291                 :            : 
     292                 :            : static inline
     293                 :            : int net_eq(const struct net *net1, const struct net *net2)
     294                 :            : {
     295                 :            :         return 1;
     296                 :            : }
     297                 :            : 
     298                 :            : static inline int check_net(const struct net *net)
     299                 :            : {
     300                 :            :         return 1;
     301                 :            : }
     302                 :            : 
     303                 :            : #define net_drop_ns NULL
     304                 :            : #endif
     305                 :            : 
     306                 :            : 
     307                 :            : typedef struct {
     308                 :            : #ifdef CONFIG_NET_NS
     309                 :            :         struct net *net;
     310                 :            : #endif
     311                 :            : } possible_net_t;
     312                 :            : 
     313                 :       5196 : static inline void write_pnet(possible_net_t *pnet, struct net *net)
     314                 :            : {
     315                 :            : #ifdef CONFIG_NET_NS
     316   [ -  +  -  - ]:       5193 :         pnet->net = net;
     317                 :            : #endif
     318                 :            : }
     319                 :            : 
     320                 :      33591 : static inline struct net *read_pnet(const possible_net_t *pnet)
     321                 :            : {
     322                 :            : #ifdef CONFIG_NET_NS
     323   [ +  +  +  +  :      33450 :         return pnet->net;
          +  +  +  +  +  
          +  +  +  +  +  
          -  -  +  -  +  
          -  +  -  +  +  
          -  -  -  -  +  
          +  -  -  +  -  
          +  -  -  +  -  
          -  -  +  +  -  
          +  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
                   -  - ]
     324                 :            : #else
     325                 :            :         return &init_net;
     326                 :            : #endif
     327                 :            : }
     328                 :            : 
     329                 :            : /* Protected by net_rwsem */
     330                 :            : #define for_each_net(VAR)                               \
     331                 :            :         list_for_each_entry(VAR, &net_namespace_list, list)
     332                 :            : #define for_each_net_continue_reverse(VAR)              \
     333                 :            :         list_for_each_entry_continue_reverse(VAR, &net_namespace_list, list)
     334                 :            : #define for_each_net_rcu(VAR)                           \
     335                 :            :         list_for_each_entry_rcu(VAR, &net_namespace_list, list)
     336                 :            : 
     337                 :            : #ifdef CONFIG_NET_NS
     338                 :            : #define __net_init
     339                 :            : #define __net_exit
     340                 :            : #define __net_initdata
     341                 :            : #define __net_initconst
     342                 :            : #else
     343                 :            : #define __net_init      __init
     344                 :            : #define __net_exit      __ref
     345                 :            : #define __net_initdata  __initdata
     346                 :            : #define __net_initconst __initconst
     347                 :            : #endif
     348                 :            : 
     349                 :            : int peernet2id_alloc(struct net *net, struct net *peer, gfp_t gfp);
     350                 :            : int peernet2id(const struct net *net, struct net *peer);
     351                 :            : bool peernet_has_id(const struct net *net, struct net *peer);
     352                 :            : struct net *get_net_ns_by_id(const struct net *net, int id);
     353                 :            : 
     354                 :            : struct pernet_operations {
     355                 :            :         struct list_head list;
     356                 :            :         /*
     357                 :            :          * Below methods are called without any exclusive locks.
     358                 :            :          * More than one net may be constructed and destructed
     359                 :            :          * in parallel on several cpus. Every pernet_operations
     360                 :            :          * have to keep in mind all other pernet_operations and
     361                 :            :          * to introduce a locking, if they share common resources.
     362                 :            :          *
     363                 :            :          * The only time they are called with exclusive lock is
     364                 :            :          * from register_pernet_subsys(), unregister_pernet_subsys()
     365                 :            :          * register_pernet_device() and unregister_pernet_device().
     366                 :            :          *
     367                 :            :          * Exit methods using blocking RCU primitives, such as
     368                 :            :          * synchronize_rcu(), should be implemented via exit_batch.
     369                 :            :          * Then, destruction of a group of net requires single
     370                 :            :          * synchronize_rcu() related to these pernet_operations,
     371                 :            :          * instead of separate synchronize_rcu() for every net.
     372                 :            :          * Please, avoid synchronize_rcu() at all, where it's possible.
     373                 :            :          *
     374                 :            :          * Note that a combination of pre_exit() and exit() can
     375                 :            :          * be used, since a synchronize_rcu() is guaranteed between
     376                 :            :          * the calls.
     377                 :            :          */
     378                 :            :         int (*init)(struct net *net);
     379                 :            :         void (*pre_exit)(struct net *net);
     380                 :            :         void (*exit)(struct net *net);
     381                 :            :         void (*exit_batch)(struct list_head *net_exit_list);
     382                 :            :         unsigned int *id;
     383                 :            :         size_t size;
     384                 :            : };
     385                 :            : 
     386                 :            : /*
     387                 :            :  * Use these carefully.  If you implement a network device and it
     388                 :            :  * needs per network namespace operations use device pernet operations,
     389                 :            :  * otherwise use pernet subsys operations.
     390                 :            :  *
     391                 :            :  * Network interfaces need to be removed from a dying netns _before_
     392                 :            :  * subsys notifiers can be called, as most of the network code cleanup
     393                 :            :  * (which is done from subsys notifiers) runs with the assumption that
     394                 :            :  * dev_remove_pack has been called so no new packets will arrive during
     395                 :            :  * and after the cleanup functions have been called.  dev_remove_pack
     396                 :            :  * is not per namespace so instead the guarantee of no more packets
     397                 :            :  * arriving in a network namespace is provided by ensuring that all
     398                 :            :  * network devices and all sockets have left the network namespace
     399                 :            :  * before the cleanup methods are called.
     400                 :            :  *
     401                 :            :  * For the longest time the ipv4 icmp code was registered as a pernet
     402                 :            :  * device which caused kernel oops, and panics during network
     403                 :            :  * namespace cleanup.   So please don't get this wrong.
     404                 :            :  */
     405                 :            : int register_pernet_subsys(struct pernet_operations *);
     406                 :            : void unregister_pernet_subsys(struct pernet_operations *);
     407                 :            : int register_pernet_device(struct pernet_operations *);
     408                 :            : void unregister_pernet_device(struct pernet_operations *);
     409                 :            : 
     410                 :            : struct ctl_table;
     411                 :            : struct ctl_table_header;
     412                 :            : 
     413                 :            : #ifdef CONFIG_SYSCTL
     414                 :            : int net_sysctl_init(void);
     415                 :            : struct ctl_table_header *register_net_sysctl(struct net *net, const char *path,
     416                 :            :                                              struct ctl_table *table);
     417                 :            : void unregister_net_sysctl_table(struct ctl_table_header *header);
     418                 :            : #else
     419                 :            : static inline int net_sysctl_init(void) { return 0; }
     420                 :            : static inline struct ctl_table_header *register_net_sysctl(struct net *net,
     421                 :            :         const char *path, struct ctl_table *table)
     422                 :            : {
     423                 :            :         return NULL;
     424                 :            : }
     425                 :            : static inline void unregister_net_sysctl_table(struct ctl_table_header *header)
     426                 :            : {
     427                 :            : }
     428                 :            : #endif
     429                 :            : 
     430                 :         12 : static inline int rt_genid_ipv4(const struct net *net)
     431                 :            : {
     432                 :         12 :         return atomic_read(&net->ipv4.rt_genid);
     433                 :            : }
     434                 :            : 
     435                 :         30 : static inline void rt_genid_bump_ipv4(struct net *net)
     436                 :            : {
     437                 :         30 :         atomic_inc(&net->ipv4.rt_genid);
     438                 :          0 : }
     439                 :            : 
     440                 :            : extern void (*__fib6_flush_trees)(struct net *net);
     441                 :          6 : static inline void rt_genid_bump_ipv6(struct net *net)
     442                 :            : {
     443   [ -  -  +  -  :          6 :         if (__fib6_flush_trees)
                   -  - ]
     444                 :          6 :                 __fib6_flush_trees(net);
     445                 :            : }
     446                 :            : 
     447                 :            : #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
     448                 :            : static inline struct netns_ieee802154_lowpan *
     449                 :            : net_ieee802154_lowpan(struct net *net)
     450                 :            : {
     451                 :            :         return &net->ieee802154_lowpan;
     452                 :            : }
     453                 :            : #endif
     454                 :            : 
     455                 :            : /* For callers who don't really care about whether it's IPv4 or IPv6 */
     456                 :            : static inline void rt_genid_bump_all(struct net *net)
     457                 :            : {
     458                 :            :         rt_genid_bump_ipv4(net);
     459                 :            :         rt_genid_bump_ipv6(net);
     460                 :            : }
     461                 :            : 
     462                 :          0 : static inline int fnhe_genid(const struct net *net)
     463                 :            : {
     464                 :          0 :         return atomic_read(&net->fnhe_genid);
     465                 :            : }
     466                 :            : 
     467                 :          0 : static inline void fnhe_genid_bump(struct net *net)
     468                 :            : {
     469                 :          0 :         atomic_inc(&net->fnhe_genid);
     470                 :            : }
     471                 :            : 
     472                 :            : #endif /* __NET_NET_NAMESPACE_H */

Generated by: LCOV version 1.14