net_namespace.h 9.13 KB
Newer Older
1 2 3 4 5 6
/*
 * Operations on the network namespace
 */
#ifndef __NET_NET_NAMESPACE_H
#define __NET_NET_NAMESPACE_H

Arun Sharma's avatar
Arun Sharma committed
7
#include <linux/atomic.h>
8 9
#include <linux/workqueue.h>
#include <linux/list.h>
10
#include <linux/sysctl.h>
11

12
#include <net/netns/core.h>
Pavel Emelyanov's avatar
Pavel Emelyanov committed
13
#include <net/netns/mib.h>
14
#include <net/netns/unix.h>
15
#include <net/netns/packet.h>
16
#include <net/netns/ipv4.h>
17
#include <net/netns/ipv6.h>
18
#include <net/netns/ieee802154_6lowpan.h>
19
#include <net/netns/sctp.h>
20
#include <net/netns/dccp.h>
21
#include <net/netns/netfilter.h>
22
#include <net/netns/x_tables.h>
23 24 25
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
#include <net/netns/conntrack.h>
#endif
26
#include <net/netns/nftables.h>
27
#include <net/netns/xfrm.h>
28

29
struct user_namespace;
30
struct proc_dir_entry;
31
struct net_device;
32
struct sock;
33
struct ctl_table_header;
34
struct net_generic;
Johannes Berg's avatar
Johannes Berg committed
35
struct sock;
36
struct netns_ipvs;
37

38 39 40 41

#define NETDEV_HASHBITS    8
#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)

42
struct net {
43 44 45
	atomic_t		passive;	/* To decided when the network
						 * namespace should be freed.
						 */
46
	atomic_t		count;		/* To decided when the network
47
						 *  namespace should be shut down.
48
						 */
49
#ifdef NETNS_REFCNT_DEBUG
50 51 52
	atomic_t		use_count;	/* To track references we
						 * destroy on demand
						 */
53
#endif
54 55
	spinlock_t		rules_mod_lock;

56
	struct list_head	list;		/* list of network namespaces */
57
	struct list_head	cleanup_list;	/* namespaces on death row */
58
	struct list_head	exit_list;	/* Use only net_mutex */
59

60 61
	struct user_namespace   *user_ns;	/* Owning user namespace */

62 63
	unsigned int		proc_inum;

64 65
	struct proc_dir_entry 	*proc_net;
	struct proc_dir_entry 	*proc_net_stat;
66

67 68 69
#ifdef CONFIG_SYSCTL
	struct ctl_table_set	sysctls;
#endif
70

71 72
	struct sock 		*rtnl;			/* rtnetlink socket */
	struct sock		*genl_sock;
73

74 75 76
	struct list_head 	dev_base_head;
	struct hlist_head 	*dev_name_head;
	struct hlist_head	*dev_index_head;
77
	unsigned int		dev_base_seq;	/* protected by rtnl_mutex */
78
	int			ifindex;
79
	unsigned int		dev_unreg_count;
80

81 82 83
	/* core fib_rules */
	struct list_head	rules_ops;

84

85
	struct net_device       *loopback_dev;          /* The loopback */
86
	struct netns_core	core;
Pavel Emelyanov's avatar
Pavel Emelyanov committed
87
	struct netns_mib	mib;
88
	struct netns_packet	packet;
89
	struct netns_unix	unx;
90
	struct netns_ipv4	ipv4;
91
#if IS_ENABLED(CONFIG_IPV6)
92 93
	struct netns_ipv6	ipv6;
#endif
94 95 96
#if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
	struct netns_ieee802154_lowpan	ieee802154_lowpan;
#endif
97 98 99
#if defined(CONFIG_IP_SCTP) || defined(CONFIG_IP_SCTP_MODULE)
	struct netns_sctp	sctp;
#endif
100 101 102
#if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
	struct netns_dccp	dccp;
#endif
103
#ifdef CONFIG_NETFILTER
104
	struct netns_nf		nf;
105
	struct netns_xt		xt;
106 107
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
	struct netns_ct		ct;
108
#endif
109 110 111
#if defined(CONFIG_NF_TABLES) || defined(CONFIG_NF_TABLES_MODULE)
	struct netns_nftables	nft;
#endif
112 113
#if IS_ENABLED(CONFIG_NF_DEFRAG_IPV6)
	struct netns_nf_frag	nf_frag;
114
#endif
115 116
	struct sock		*nfnl;
	struct sock		*nfnl_stash;
117
#endif
Johannes Berg's avatar
Johannes Berg committed
118
#ifdef CONFIG_WEXT_CORE
119
	struct sk_buff_head	wext_nlevents;
120
#endif
Eric Dumazet's avatar
Eric Dumazet committed
121
	struct net_generic __rcu	*gen;
122 123 124 125 126

	/* Note : following structs are cache line aligned */
#ifdef CONFIG_XFRM
	struct netns_xfrm	xfrm;
#endif
127
#if IS_ENABLED(CONFIG_IP_VS)
128
	struct netns_ipvs	*ipvs;
129
#endif
130
	struct sock		*diag_nlsk;
131
	atomic_t		fnhe_genid;
132 133
};

134 135 136 137 138 139 140
/*
 * ifindex generation is per-net namespace, and loopback is
 * always the 1st device in ns (see net_dev_init), thus any
 * loopback device should get ifindex 1
 */

#define LOOPBACK_IFINDEX	1
141

142 143
#include <linux/seq_file_net.h>

144
/* Init's network namespace */
145
extern struct net init_net;
146

147
#ifdef CONFIG_NET_NS
148 149
struct net *copy_net_ns(unsigned long flags, struct user_namespace *user_ns,
			struct net *old_net);
150

151 152 153
#else /* CONFIG_NET_NS */
#include <linux/sched.h>
#include <linux/nsproxy.h>
154 155
static inline struct net *copy_net_ns(unsigned long flags,
	struct user_namespace *user_ns, struct net *old_net)
156
{
157 158 159
	if (flags & CLONE_NEWNET)
		return ERR_PTR(-EINVAL);
	return old_net;
160
}
161
#endif /* CONFIG_NET_NS */
162 163 164


extern struct list_head net_namespace_list;
165

166 167
struct net *get_net_ns_by_pid(pid_t pid);
struct net *get_net_ns_by_fd(int pid);
168

169 170 171 172 173 174 175 176
#ifdef CONFIG_SYSCTL
void ipx_register_sysctl(void);
void ipx_unregister_sysctl(void);
#else
#define ipx_register_sysctl()
#define ipx_unregister_sysctl()
#endif

177
#ifdef CONFIG_NET_NS
178
void __put_net(struct net *net);
179 180 181 182 183 184 185

static inline struct net *get_net(struct net *net)
{
	atomic_inc(&net->count);
	return net;
}

186 187 188 189 190 191 192 193 194 195 196 197
static inline struct net *maybe_get_net(struct net *net)
{
	/* Used when we know struct net exists but we
	 * aren't guaranteed a previous reference count
	 * exists.  If the reference count is zero this
	 * function fails and returns NULL.
	 */
	if (!atomic_inc_not_zero(&net->count))
		net = NULL;
	return net;
}

198 199 200 201 202 203
static inline void put_net(struct net *net)
{
	if (atomic_dec_and_test(&net->count))
		__put_net(net);
}

204 205 206 207 208
static inline
int net_eq(const struct net *net1, const struct net *net2)
{
	return net1 == net2;
}
209

210
void net_drop_ns(void *);
211

212
#else
213

214 215 216 217 218 219 220 221 222
static inline struct net *get_net(struct net *net)
{
	return net;
}

static inline void put_net(struct net *net)
{
}

223 224 225 226 227 228 229 230 231 232
static inline struct net *maybe_get_net(struct net *net)
{
	return net;
}

static inline
int net_eq(const struct net *net1, const struct net *net2)
{
	return 1;
}
233 234

#define net_drop_ns NULL
235 236 237 238
#endif


#ifdef NETNS_REFCNT_DEBUG
239 240
static inline struct net *hold_net(struct net *net)
{
241 242
	if (net)
		atomic_inc(&net->use_count);
243 244 245 246 247
	return net;
}

static inline void release_net(struct net *net)
{
248 249
	if (net)
		atomic_dec(&net->use_count);
250
}
251 252
#else
static inline struct net *hold_net(struct net *net)
253 254 255
{
	return net;
}
256

257
static inline void release_net(struct net *net)
258 259
{
}
260
#endif
261

262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
#ifdef CONFIG_NET_NS

static inline void write_pnet(struct net **pnet, struct net *net)
{
	*pnet = net;
}

static inline struct net *read_pnet(struct net * const *pnet)
{
	return *pnet;
}

#else

#define write_pnet(pnet, net)	do { (void)(net);} while (0)
#define read_pnet(pnet)		(&init_net)

#endif
280

281 282 283
#define for_each_net(VAR)				\
	list_for_each_entry(VAR, &net_namespace_list, list)

284 285 286
#define for_each_net_rcu(VAR)				\
	list_for_each_entry_rcu(VAR, &net_namespace_list, list)

287 288 289
#ifdef CONFIG_NET_NS
#define __net_init
#define __net_exit
290
#define __net_initdata
291
#define __net_initconst
292 293 294
#else
#define __net_init	__init
#define __net_exit	__exit_refok
295
#define __net_initdata	__initdata
296
#define __net_initconst	__initconst
297
#endif
298 299 300 301 302

struct pernet_operations {
	struct list_head list;
	int (*init)(struct net *net);
	void (*exit)(struct net *net);
303
	void (*exit_batch)(struct list_head *net_exit_list);
304 305
	int *id;
	size_t size;
306 307
};

Eric W. Biederman's avatar
Eric W. Biederman committed
308 309 310 311 312
/*
 * Use these carefully.  If you implement a network device and it
 * needs per network namespace operations use device pernet operations,
 * otherwise use pernet subsys operations.
 *
313 314 315 316 317 318 319 320 321
 * Network interfaces need to be removed from a dying netns _before_
 * subsys notifiers can be called, as most of the network code cleanup
 * (which is done from subsys notifiers) runs with the assumption that
 * dev_remove_pack has been called so no new packets will arrive during
 * and after the cleanup functions have been called.  dev_remove_pack
 * is not per namespace so instead the guarantee of no more packets
 * arriving in a network namespace is provided by ensuring that all
 * network devices and all sockets have left the network namespace
 * before the cleanup methods are called.
Eric W. Biederman's avatar
Eric W. Biederman committed
322 323 324 325 326
 *
 * For the longest time the ipv4 icmp code was registered as a pernet
 * device which caused kernel oops, and panics during network
 * namespace cleanup.   So please don't get this wrong.
 */
327 328 329 330
int register_pernet_subsys(struct pernet_operations *);
void unregister_pernet_subsys(struct pernet_operations *);
int register_pernet_device(struct pernet_operations *);
void unregister_pernet_device(struct pernet_operations *);
331

332 333
struct ctl_table;
struct ctl_table_header;
334

335
#ifdef CONFIG_SYSCTL
336 337 338 339
int net_sysctl_init(void);
struct ctl_table_header *register_net_sysctl(struct net *net, const char *path,
					     struct ctl_table *table);
void unregister_net_sysctl_table(struct ctl_table_header *header);
340 341 342 343 344 345 346 347 348 349 350 351
#else
static inline int net_sysctl_init(void) { return 0; }
static inline struct ctl_table_header *register_net_sysctl(struct net *net,
	const char *path, struct ctl_table *table)
{
	return NULL;
}
static inline void unregister_net_sysctl_table(struct ctl_table_header *header)
{
}
#endif

fan.du's avatar
fan.du committed
352
static inline int rt_genid_ipv4(struct net *net)
353
{
fan.du's avatar
fan.du committed
354
	return atomic_read(&net->ipv4.rt_genid);
355 356
}

fan.du's avatar
fan.du committed
357
static inline void rt_genid_bump_ipv4(struct net *net)
358
{
fan.du's avatar
fan.du committed
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
	atomic_inc(&net->ipv4.rt_genid);
}

#if IS_ENABLED(CONFIG_IPV6)
static inline int rt_genid_ipv6(struct net *net)
{
	return atomic_read(&net->ipv6.rt_genid);
}

static inline void rt_genid_bump_ipv6(struct net *net)
{
	atomic_inc(&net->ipv6.rt_genid);
}
#else
static inline int rt_genid_ipv6(struct net *net)
{
	return 0;
}

static inline void rt_genid_bump_ipv6(struct net *net)
{
}
#endif

/* For callers who don't really care about whether it's IPv4 or IPv6 */
static inline void rt_genid_bump_all(struct net *net)
{
	rt_genid_bump_ipv4(net);
	rt_genid_bump_ipv6(net);
388
}
389

390 391 392 393 394 395 396 397 398 399
static inline int fnhe_genid(struct net *net)
{
	return atomic_read(&net->fnhe_genid);
}

static inline void fnhe_genid_bump(struct net *net)
{
	atomic_inc(&net->fnhe_genid);
}

400
#endif /* __NET_NET_NAMESPACE_H */