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 : 6085 : static inline struct net *get_net(struct net *net)
240 : : {
241 : 6085 : refcount_inc(&net->count);
242 [ - - # # ]: 6085 : 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 : 5420 : static inline void put_net(struct net *net)
258 : : {
259 [ - + ]: 5420 : if (refcount_dec_and_test(&net->count))
260 : 0 : __put_net(net);
261 : 5420 : }
262 : :
263 : : static inline
264 : 29603 : int net_eq(const struct net *net1, const struct net *net2)
265 : : {
266 [ + + + + : 15464 : 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 : 22180 : static inline void write_pnet(possible_net_t *pnet, struct net *net)
314 : : {
315 : : #ifdef CONFIG_NET_NS
316 [ + + - - ]: 22167 : pnet->net = net;
317 : : #endif
318 : : }
319 : :
320 : 141528 : static inline struct net *read_pnet(const possible_net_t *pnet)
321 : : {
322 : : #ifdef CONFIG_NET_NS
323 [ + + + + : 141073 : 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 : 52 : static inline int rt_genid_ipv4(const struct net *net)
431 : : {
432 : 52 : return atomic_read(&net->ipv4.rt_genid);
433 : : }
434 : :
435 : 91 : static inline void rt_genid_bump_ipv4(struct net *net)
436 : : {
437 : 91 : atomic_inc(&net->ipv4.rt_genid);
438 : 0 : }
439 : :
440 : : extern void (*__fib6_flush_trees)(struct net *net);
441 : 13 : static inline void rt_genid_bump_ipv6(struct net *net)
442 : : {
443 [ - - + - : 13 : if (__fib6_flush_trees)
- - ]
444 : 13 : __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 */
|
