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 :
94 :
95 : #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 0 : 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 */
|