]> git.karo-electronics.de Git - karo-tx-linux.git/blob - include/net/net_namespace.h
Merge tag 'iwlwifi-next-for-kalle-2015-03-07' of https://git.kernel.org/pub/scm/linux...
[karo-tx-linux.git] / include / net / net_namespace.h
1 /*
2  * Operations on the network namespace
3  */
4 #ifndef __NET_NET_NAMESPACE_H
5 #define __NET_NET_NAMESPACE_H
6
7 #include <linux/atomic.h>
8 #include <linux/workqueue.h>
9 #include <linux/list.h>
10 #include <linux/sysctl.h>
11
12 #include <net/flow.h>
13 #include <net/netns/core.h>
14 #include <net/netns/mib.h>
15 #include <net/netns/unix.h>
16 #include <net/netns/packet.h>
17 #include <net/netns/ipv4.h>
18 #include <net/netns/ipv6.h>
19 #include <net/netns/ieee802154_6lowpan.h>
20 #include <net/netns/sctp.h>
21 #include <net/netns/dccp.h>
22 #include <net/netns/netfilter.h>
23 #include <net/netns/x_tables.h>
24 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
25 #include <net/netns/conntrack.h>
26 #endif
27 #include <net/netns/nftables.h>
28 #include <net/netns/xfrm.h>
29 #include <net/netns/mpls.h>
30 #include <linux/ns_common.h>
31
32 struct user_namespace;
33 struct proc_dir_entry;
34 struct net_device;
35 struct sock;
36 struct ctl_table_header;
37 struct net_generic;
38 struct sock;
39 struct netns_ipvs;
40
41
42 #define NETDEV_HASHBITS    8
43 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
44
45 struct net {
46         atomic_t                passive;        /* To decided when the network
47                                                  * namespace should be freed.
48                                                  */
49         atomic_t                count;          /* To decided when the network
50                                                  *  namespace should be shut down.
51                                                  */
52 #ifdef NETNS_REFCNT_DEBUG
53         atomic_t                use_count;      /* To track references we
54                                                  * destroy on demand
55                                                  */
56 #endif
57         spinlock_t              rules_mod_lock;
58
59         struct list_head        list;           /* list of network namespaces */
60         struct list_head        cleanup_list;   /* namespaces on death row */
61         struct list_head        exit_list;      /* Use only net_mutex */
62
63         struct user_namespace   *user_ns;       /* Owning user namespace */
64         struct idr              netns_ids;
65
66         struct ns_common        ns;
67
68         struct proc_dir_entry   *proc_net;
69         struct proc_dir_entry   *proc_net_stat;
70
71 #ifdef CONFIG_SYSCTL
72         struct ctl_table_set    sysctls;
73 #endif
74
75         struct sock             *rtnl;                  /* rtnetlink socket */
76         struct sock             *genl_sock;
77
78         struct list_head        dev_base_head;
79         struct hlist_head       *dev_name_head;
80         struct hlist_head       *dev_index_head;
81         unsigned int            dev_base_seq;   /* protected by rtnl_mutex */
82         int                     ifindex;
83         unsigned int            dev_unreg_count;
84
85         /* core fib_rules */
86         struct list_head        rules_ops;
87
88
89         struct net_device       *loopback_dev;          /* The loopback */
90         struct netns_core       core;
91         struct netns_mib        mib;
92         struct netns_packet     packet;
93         struct netns_unix       unx;
94         struct netns_ipv4       ipv4;
95 #if IS_ENABLED(CONFIG_IPV6)
96         struct netns_ipv6       ipv6;
97 #endif
98 #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
99         struct netns_ieee802154_lowpan  ieee802154_lowpan;
100 #endif
101 #if defined(CONFIG_IP_SCTP) || defined(CONFIG_IP_SCTP_MODULE)
102         struct netns_sctp       sctp;
103 #endif
104 #if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
105         struct netns_dccp       dccp;
106 #endif
107 #ifdef CONFIG_NETFILTER
108         struct netns_nf         nf;
109         struct netns_xt         xt;
110 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
111         struct netns_ct         ct;
112 #endif
113 #if defined(CONFIG_NF_TABLES) || defined(CONFIG_NF_TABLES_MODULE)
114         struct netns_nftables   nft;
115 #endif
116 #if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
117         struct netns_nf_frag    nf_frag;
118 #endif
119         struct sock             *nfnl;
120         struct sock             *nfnl_stash;
121 #endif
122 #ifdef CONFIG_WEXT_CORE
123         struct sk_buff_head     wext_nlevents;
124 #endif
125         struct net_generic __rcu        *gen;
126
127         /* Note : following structs are cache line aligned */
128 #ifdef CONFIG_XFRM
129         struct netns_xfrm       xfrm;
130 #endif
131 #if IS_ENABLED(CONFIG_IP_VS)
132         struct netns_ipvs       *ipvs;
133 #endif
134 #if IS_ENABLED(CONFIG_MPLS)
135         struct netns_mpls       mpls;
136 #endif
137         struct sock             *diag_nlsk;
138         atomic_t                fnhe_genid;
139 };
140
141 #include <linux/seq_file_net.h>
142
143 /* Init's network namespace */
144 extern struct net init_net;
145
146 #ifdef CONFIG_NET_NS
147 struct net *copy_net_ns(unsigned long flags, struct user_namespace *user_ns,
148                         struct net *old_net);
149
150 #else /* CONFIG_NET_NS */
151 #include <linux/sched.h>
152 #include <linux/nsproxy.h>
153 static inline struct net *copy_net_ns(unsigned long flags,
154         struct user_namespace *user_ns, struct net *old_net)
155 {
156         if (flags & CLONE_NEWNET)
157                 return ERR_PTR(-EINVAL);
158         return old_net;
159 }
160 #endif /* CONFIG_NET_NS */
161
162
163 extern struct list_head net_namespace_list;
164
165 struct net *get_net_ns_by_pid(pid_t pid);
166 struct net *get_net_ns_by_fd(int pid);
167
168 #ifdef CONFIG_SYSCTL
169 void ipx_register_sysctl(void);
170 void ipx_unregister_sysctl(void);
171 #else
172 #define ipx_register_sysctl()
173 #define ipx_unregister_sysctl()
174 #endif
175
176 #ifdef CONFIG_NET_NS
177 void __put_net(struct net *net);
178
179 static inline struct net *get_net(struct net *net)
180 {
181         atomic_inc(&net->count);
182         return net;
183 }
184
185 static inline struct net *maybe_get_net(struct net *net)
186 {
187         /* Used when we know struct net exists but we
188          * aren't guaranteed a previous reference count
189          * exists.  If the reference count is zero this
190          * function fails and returns NULL.
191          */
192         if (!atomic_inc_not_zero(&net->count))
193                 net = NULL;
194         return net;
195 }
196
197 static inline void put_net(struct net *net)
198 {
199         if (atomic_dec_and_test(&net->count))
200                 __put_net(net);
201 }
202
203 static inline
204 int net_eq(const struct net *net1, const struct net *net2)
205 {
206         return net1 == net2;
207 }
208
209 void net_drop_ns(void *);
210
211 #else
212
213 static inline struct net *get_net(struct net *net)
214 {
215         return net;
216 }
217
218 static inline void put_net(struct net *net)
219 {
220 }
221
222 static inline struct net *maybe_get_net(struct net *net)
223 {
224         return net;
225 }
226
227 static inline
228 int net_eq(const struct net *net1, const struct net *net2)
229 {
230         return 1;
231 }
232
233 #define net_drop_ns NULL
234 #endif
235
236
237 #ifdef NETNS_REFCNT_DEBUG
238 static inline struct net *hold_net(struct net *net)
239 {
240         if (net)
241                 atomic_inc(&net->use_count);
242         return net;
243 }
244
245 static inline void release_net(struct net *net)
246 {
247         if (net)
248                 atomic_dec(&net->use_count);
249 }
250 #else
251 static inline struct net *hold_net(struct net *net)
252 {
253         return net;
254 }
255
256 static inline void release_net(struct net *net)
257 {
258 }
259 #endif
260
261 #ifdef CONFIG_NET_NS
262
263 static inline void write_pnet(struct net **pnet, struct net *net)
264 {
265         *pnet = net;
266 }
267
268 static inline struct net *read_pnet(struct net * const *pnet)
269 {
270         return *pnet;
271 }
272
273 #else
274
275 #define write_pnet(pnet, net)   do { (void)(net);} while (0)
276 #define read_pnet(pnet)         (&init_net)
277
278 #endif
279
280 #define for_each_net(VAR)                               \
281         list_for_each_entry(VAR, &net_namespace_list, list)
282
283 #define for_each_net_rcu(VAR)                           \
284         list_for_each_entry_rcu(VAR, &net_namespace_list, list)
285
286 #ifdef CONFIG_NET_NS
287 #define __net_init
288 #define __net_exit
289 #define __net_initdata
290 #define __net_initconst
291 #else
292 #define __net_init      __init
293 #define __net_exit      __exit_refok
294 #define __net_initdata  __initdata
295 #define __net_initconst __initconst
296 #endif
297
298 int peernet2id(struct net *net, struct net *peer);
299 struct net *get_net_ns_by_id(struct net *net, int id);
300
301 struct pernet_operations {
302         struct list_head list;
303         int (*init)(struct net *net);
304         void (*exit)(struct net *net);
305         void (*exit_batch)(struct list_head *net_exit_list);
306         int *id;
307         size_t size;
308 };
309
310 /*
311  * Use these carefully.  If you implement a network device and it
312  * needs per network namespace operations use device pernet operations,
313  * otherwise use pernet subsys operations.
314  *
315  * Network interfaces need to be removed from a dying netns _before_
316  * subsys notifiers can be called, as most of the network code cleanup
317  * (which is done from subsys notifiers) runs with the assumption that
318  * dev_remove_pack has been called so no new packets will arrive during
319  * and after the cleanup functions have been called.  dev_remove_pack
320  * is not per namespace so instead the guarantee of no more packets
321  * arriving in a network namespace is provided by ensuring that all
322  * network devices and all sockets have left the network namespace
323  * before the cleanup methods are called.
324  *
325  * For the longest time the ipv4 icmp code was registered as a pernet
326  * device which caused kernel oops, and panics during network
327  * namespace cleanup.   So please don't get this wrong.
328  */
329 int register_pernet_subsys(struct pernet_operations *);
330 void unregister_pernet_subsys(struct pernet_operations *);
331 int register_pernet_device(struct pernet_operations *);
332 void unregister_pernet_device(struct pernet_operations *);
333
334 struct ctl_table;
335 struct ctl_table_header;
336
337 #ifdef CONFIG_SYSCTL
338 int net_sysctl_init(void);
339 struct ctl_table_header *register_net_sysctl(struct net *net, const char *path,
340                                              struct ctl_table *table);
341 void unregister_net_sysctl_table(struct ctl_table_header *header);
342 #else
343 static inline int net_sysctl_init(void) { return 0; }
344 static inline struct ctl_table_header *register_net_sysctl(struct net *net,
345         const char *path, struct ctl_table *table)
346 {
347         return NULL;
348 }
349 static inline void unregister_net_sysctl_table(struct ctl_table_header *header)
350 {
351 }
352 #endif
353
354 static inline int rt_genid_ipv4(struct net *net)
355 {
356         return atomic_read(&net->ipv4.rt_genid);
357 }
358
359 static inline void rt_genid_bump_ipv4(struct net *net)
360 {
361         atomic_inc(&net->ipv4.rt_genid);
362 }
363
364 extern void (*__fib6_flush_trees)(struct net *net);
365 static inline void rt_genid_bump_ipv6(struct net *net)
366 {
367         if (__fib6_flush_trees)
368                 __fib6_flush_trees(net);
369 }
370
371 #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
372 static inline struct netns_ieee802154_lowpan *
373 net_ieee802154_lowpan(struct net *net)
374 {
375         return &net->ieee802154_lowpan;
376 }
377 #endif
378
379 /* For callers who don't really care about whether it's IPv4 or IPv6 */
380 static inline void rt_genid_bump_all(struct net *net)
381 {
382         rt_genid_bump_ipv4(net);
383         rt_genid_bump_ipv6(net);
384 }
385
386 static inline int fnhe_genid(struct net *net)
387 {
388         return atomic_read(&net->fnhe_genid);
389 }
390
391 static inline void fnhe_genid_bump(struct net *net)
392 {
393         atomic_inc(&net->fnhe_genid);
394 }
395
396 #endif /* __NET_NET_NAMESPACE_H */