Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef __NET_IP_TUNNELS_H
3 : : #define __NET_IP_TUNNELS_H 1
4 : :
5 : : #include <linux/if_tunnel.h>
6 : : #include <linux/netdevice.h>
7 : : #include <linux/skbuff.h>
8 : : #include <linux/socket.h>
9 : : #include <linux/types.h>
10 : : #include <linux/u64_stats_sync.h>
11 : : #include <linux/bitops.h>
12 : :
13 : : #include <net/dsfield.h>
14 : : #include <net/gro_cells.h>
15 : : #include <net/inet_ecn.h>
16 : : #include <net/netns/generic.h>
17 : : #include <net/rtnetlink.h>
18 : : #include <net/lwtunnel.h>
19 : : #include <net/dst_cache.h>
20 : :
21 : : #if IS_ENABLED(CONFIG_IPV6)
22 : : #include <net/ipv6.h>
23 : : #include <net/ip6_fib.h>
24 : : #include <net/ip6_route.h>
25 : : #endif
26 : :
27 : : /* Keep error state on tunnel for 30 sec */
28 : : #define IPTUNNEL_ERR_TIMEO (30*HZ)
29 : :
30 : : /* Used to memset ip_tunnel padding. */
31 : : #define IP_TUNNEL_KEY_SIZE offsetofend(struct ip_tunnel_key, tp_dst)
32 : :
33 : : /* Used to memset ipv4 address padding. */
34 : : #define IP_TUNNEL_KEY_IPV4_PAD offsetofend(struct ip_tunnel_key, u.ipv4.dst)
35 : : #define IP_TUNNEL_KEY_IPV4_PAD_LEN \
36 : : (FIELD_SIZEOF(struct ip_tunnel_key, u) - \
37 : : FIELD_SIZEOF(struct ip_tunnel_key, u.ipv4))
38 : :
39 : : struct ip_tunnel_key {
40 : : __be64 tun_id;
41 : : union {
42 : : struct {
43 : : __be32 src;
44 : : __be32 dst;
45 : : } ipv4;
46 : : struct {
47 : : struct in6_addr src;
48 : : struct in6_addr dst;
49 : : } ipv6;
50 : : } u;
51 : : __be16 tun_flags;
52 : : u8 tos; /* TOS for IPv4, TC for IPv6 */
53 : : u8 ttl; /* TTL for IPv4, HL for IPv6 */
54 : : __be32 label; /* Flow Label for IPv6 */
55 : : __be16 tp_src;
56 : : __be16 tp_dst;
57 : : };
58 : :
59 : : /* Flags for ip_tunnel_info mode. */
60 : : #define IP_TUNNEL_INFO_TX 0x01 /* represents tx tunnel parameters */
61 : : #define IP_TUNNEL_INFO_IPV6 0x02 /* key contains IPv6 addresses */
62 : : #define IP_TUNNEL_INFO_BRIDGE 0x04 /* represents a bridged tunnel id */
63 : :
64 : : /* Maximum tunnel options length. */
65 : : #define IP_TUNNEL_OPTS_MAX \
66 : : GENMASK((FIELD_SIZEOF(struct ip_tunnel_info, \
67 : : options_len) * BITS_PER_BYTE) - 1, 0)
68 : :
69 : : struct ip_tunnel_info {
70 : : struct ip_tunnel_key key;
71 : : #ifdef CONFIG_DST_CACHE
72 : : struct dst_cache dst_cache;
73 : : #endif
74 : : u8 options_len;
75 : : u8 mode;
76 : : };
77 : :
78 : : /* 6rd prefix/relay information */
79 : : #ifdef CONFIG_IPV6_SIT_6RD
80 : : struct ip_tunnel_6rd_parm {
81 : : struct in6_addr prefix;
82 : : __be32 relay_prefix;
83 : : u16 prefixlen;
84 : : u16 relay_prefixlen;
85 : : };
86 : : #endif
87 : :
88 : : struct ip_tunnel_encap {
89 : : u16 type;
90 : : u16 flags;
91 : : __be16 sport;
92 : : __be16 dport;
93 : : };
94 : :
95 : : struct ip_tunnel_prl_entry {
96 : : struct ip_tunnel_prl_entry __rcu *next;
97 : : __be32 addr;
98 : : u16 flags;
99 : : struct rcu_head rcu_head;
100 : : };
101 : :
102 : : struct metadata_dst;
103 : :
104 : : struct ip_tunnel {
105 : : struct ip_tunnel __rcu *next;
106 : : struct hlist_node hash_node;
107 : : struct net_device *dev;
108 : : struct net *net; /* netns for packet i/o */
109 : :
110 : : unsigned long err_time; /* Time when the last ICMP error
111 : : * arrived */
112 : : int err_count; /* Number of arrived ICMP errors */
113 : :
114 : : /* These four fields used only by GRE */
115 : : u32 i_seqno; /* The last seen seqno */
116 : : u32 o_seqno; /* The last output seqno */
117 : : int tun_hlen; /* Precalculated header length */
118 : :
119 : : /* These four fields used only by ERSPAN */
120 : : u32 index; /* ERSPAN type II index */
121 : : u8 erspan_ver; /* ERSPAN version */
122 : : u8 dir; /* ERSPAN direction */
123 : : u16 hwid; /* ERSPAN hardware ID */
124 : :
125 : : struct dst_cache dst_cache;
126 : :
127 : : struct ip_tunnel_parm parms;
128 : :
129 : : int mlink;
130 : : int encap_hlen; /* Encap header length (FOU,GUE) */
131 : : int hlen; /* tun_hlen + encap_hlen */
132 : : struct ip_tunnel_encap encap;
133 : :
134 : : /* for SIT */
135 : : #ifdef CONFIG_IPV6_SIT_6RD
136 : : struct ip_tunnel_6rd_parm ip6rd;
137 : : #endif
138 : : struct ip_tunnel_prl_entry __rcu *prl; /* potential router list */
139 : : unsigned int prl_count; /* # of entries in PRL */
140 : : unsigned int ip_tnl_net_id;
141 : : struct gro_cells gro_cells;
142 : : __u32 fwmark;
143 : : bool collect_md;
144 : : bool ignore_df;
145 : : };
146 : :
147 : : struct tnl_ptk_info {
148 : : __be16 flags;
149 : : __be16 proto;
150 : : __be32 key;
151 : : __be32 seq;
152 : : int hdr_len;
153 : : };
154 : :
155 : : #define PACKET_RCVD 0
156 : : #define PACKET_REJECT 1
157 : : #define PACKET_NEXT 2
158 : :
159 : : #define IP_TNL_HASH_BITS 7
160 : : #define IP_TNL_HASH_SIZE (1 << IP_TNL_HASH_BITS)
161 : :
162 : : struct ip_tunnel_net {
163 : : struct net_device *fb_tunnel_dev;
164 : : struct rtnl_link_ops *rtnl_link_ops;
165 : : struct hlist_head tunnels[IP_TNL_HASH_SIZE];
166 : : struct ip_tunnel __rcu *collect_md_tun;
167 : : int type;
168 : : };
169 : :
170 : : static inline void ip_tunnel_key_init(struct ip_tunnel_key *key,
171 : : __be32 saddr, __be32 daddr,
172 : : u8 tos, u8 ttl, __be32 label,
173 : : __be16 tp_src, __be16 tp_dst,
174 : : __be64 tun_id, __be16 tun_flags)
175 : : {
176 : : key->tun_id = tun_id;
177 : : key->u.ipv4.src = saddr;
178 : : key->u.ipv4.dst = daddr;
179 : : memset((unsigned char *)key + IP_TUNNEL_KEY_IPV4_PAD,
180 : : 0, IP_TUNNEL_KEY_IPV4_PAD_LEN);
181 : : key->tos = tos;
182 : : key->ttl = ttl;
183 : : key->label = label;
184 : : key->tun_flags = tun_flags;
185 : :
186 : : /* For the tunnel types on the top of IPsec, the tp_src and tp_dst of
187 : : * the upper tunnel are used.
188 : : * E.g: GRE over IPSEC, the tp_src and tp_port are zero.
189 : : */
190 : : key->tp_src = tp_src;
191 : : key->tp_dst = tp_dst;
192 : :
193 : : /* Clear struct padding. */
194 : : if (sizeof(*key) != IP_TUNNEL_KEY_SIZE)
195 : : memset((unsigned char *)key + IP_TUNNEL_KEY_SIZE,
196 : : 0, sizeof(*key) - IP_TUNNEL_KEY_SIZE);
197 : : }
198 : :
199 : : static inline bool
200 : : ip_tunnel_dst_cache_usable(const struct sk_buff *skb,
201 : : const struct ip_tunnel_info *info)
202 : : {
203 : : if (skb->mark)
204 : : return false;
205 : : if (!info)
206 : : return true;
207 : : if (info->key.tun_flags & TUNNEL_NOCACHE)
208 : : return false;
209 : :
210 : : return true;
211 : : }
212 : :
213 : 0 : static inline unsigned short ip_tunnel_info_af(const struct ip_tunnel_info
214 : : *tun_info)
215 : : {
216 [ # # ]: 0 : return tun_info->mode & IP_TUNNEL_INFO_IPV6 ? AF_INET6 : AF_INET;
217 : : }
218 : :
219 : : static inline __be64 key32_to_tunnel_id(__be32 key)
220 : : {
221 : : #ifdef __BIG_ENDIAN
222 : : return (__force __be64)key;
223 : : #else
224 : : return (__force __be64)((__force u64)key << 32);
225 : : #endif
226 : : }
227 : :
228 : : /* Returns the least-significant 32 bits of a __be64. */
229 : : static inline __be32 tunnel_id_to_key32(__be64 tun_id)
230 : : {
231 : : #ifdef __BIG_ENDIAN
232 : : return (__force __be32)tun_id;
233 : : #else
234 : 0 : return (__force __be32)((__force u64)tun_id >> 32);
235 : : #endif
236 : : }
237 : :
238 : : #ifdef CONFIG_INET
239 : :
240 : : static inline void ip_tunnel_init_flow(struct flowi4 *fl4,
241 : : int proto,
242 : : __be32 daddr, __be32 saddr,
243 : : __be32 key, __u8 tos, int oif,
244 : : __u32 mark, __u32 tun_inner_hash)
245 : : {
246 : : memset(fl4, 0, sizeof(*fl4));
247 : : fl4->flowi4_oif = oif;
248 : : fl4->daddr = daddr;
249 : : fl4->saddr = saddr;
250 : : fl4->flowi4_tos = tos;
251 : : fl4->flowi4_proto = proto;
252 : : fl4->fl4_gre_key = key;
253 : : fl4->flowi4_mark = mark;
254 : : fl4->flowi4_multipath_hash = tun_inner_hash;
255 : : }
256 : :
257 : : int ip_tunnel_init(struct net_device *dev);
258 : : void ip_tunnel_uninit(struct net_device *dev);
259 : : void ip_tunnel_dellink(struct net_device *dev, struct list_head *head);
260 : : struct net *ip_tunnel_get_link_net(const struct net_device *dev);
261 : : int ip_tunnel_get_iflink(const struct net_device *dev);
262 : : int ip_tunnel_init_net(struct net *net, unsigned int ip_tnl_net_id,
263 : : struct rtnl_link_ops *ops, char *devname);
264 : :
265 : : void ip_tunnel_delete_nets(struct list_head *list_net, unsigned int id,
266 : : struct rtnl_link_ops *ops);
267 : :
268 : : void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
269 : : const struct iphdr *tnl_params, const u8 protocol);
270 : : void ip_md_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
271 : : const u8 proto, int tunnel_hlen);
272 : : int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd);
273 : : int __ip_tunnel_change_mtu(struct net_device *dev, int new_mtu, bool strict);
274 : : int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu);
275 : :
276 : : void ip_tunnel_get_stats64(struct net_device *dev,
277 : : struct rtnl_link_stats64 *tot);
278 : : struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
279 : : int link, __be16 flags,
280 : : __be32 remote, __be32 local,
281 : : __be32 key);
282 : :
283 : : int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
284 : : const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,
285 : : bool log_ecn_error);
286 : : int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
287 : : struct ip_tunnel_parm *p, __u32 fwmark);
288 : : int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
289 : : struct ip_tunnel_parm *p, __u32 fwmark);
290 : : void ip_tunnel_setup(struct net_device *dev, unsigned int net_id);
291 : :
292 : : struct ip_tunnel_encap_ops {
293 : : size_t (*encap_hlen)(struct ip_tunnel_encap *e);
294 : : int (*build_header)(struct sk_buff *skb, struct ip_tunnel_encap *e,
295 : : u8 *protocol, struct flowi4 *fl4);
296 : : int (*err_handler)(struct sk_buff *skb, u32 info);
297 : : };
298 : :
299 : : #define MAX_IPTUN_ENCAP_OPS 8
300 : :
301 : : extern const struct ip_tunnel_encap_ops __rcu *
302 : : iptun_encaps[MAX_IPTUN_ENCAP_OPS];
303 : :
304 : : int ip_tunnel_encap_add_ops(const struct ip_tunnel_encap_ops *op,
305 : : unsigned int num);
306 : : int ip_tunnel_encap_del_ops(const struct ip_tunnel_encap_ops *op,
307 : : unsigned int num);
308 : :
309 : : int ip_tunnel_encap_setup(struct ip_tunnel *t,
310 : : struct ip_tunnel_encap *ipencap);
311 : :
312 : 0 : static inline bool pskb_inet_may_pull(struct sk_buff *skb)
313 : : {
314 : : int nhlen;
315 : :
316 [ # # # ]: 0 : switch (skb->protocol) {
317 : : #if IS_ENABLED(CONFIG_IPV6)
318 : : case htons(ETH_P_IPV6):
319 : : nhlen = sizeof(struct ipv6hdr);
320 : : break;
321 : : #endif
322 : : case htons(ETH_P_IP):
323 : : nhlen = sizeof(struct iphdr);
324 : 0 : break;
325 : : default:
326 : : nhlen = 0;
327 : : }
328 : :
329 : 0 : return pskb_network_may_pull(skb, nhlen);
330 : : }
331 : :
332 : : static inline int ip_encap_hlen(struct ip_tunnel_encap *e)
333 : : {
334 : : const struct ip_tunnel_encap_ops *ops;
335 : : int hlen = -EINVAL;
336 : :
337 : : if (e->type == TUNNEL_ENCAP_NONE)
338 : : return 0;
339 : :
340 : : if (e->type >= MAX_IPTUN_ENCAP_OPS)
341 : : return -EINVAL;
342 : :
343 : : rcu_read_lock();
344 : : ops = rcu_dereference(iptun_encaps[e->type]);
345 : : if (likely(ops && ops->encap_hlen))
346 : : hlen = ops->encap_hlen(e);
347 : : rcu_read_unlock();
348 : :
349 : : return hlen;
350 : : }
351 : :
352 : : static inline int ip_tunnel_encap(struct sk_buff *skb, struct ip_tunnel *t,
353 : : u8 *protocol, struct flowi4 *fl4)
354 : : {
355 : : const struct ip_tunnel_encap_ops *ops;
356 : : int ret = -EINVAL;
357 : :
358 : : if (t->encap.type == TUNNEL_ENCAP_NONE)
359 : : return 0;
360 : :
361 : : if (t->encap.type >= MAX_IPTUN_ENCAP_OPS)
362 : : return -EINVAL;
363 : :
364 : : rcu_read_lock();
365 : : ops = rcu_dereference(iptun_encaps[t->encap.type]);
366 : : if (likely(ops && ops->build_header))
367 : : ret = ops->build_header(skb, &t->encap, protocol, fl4);
368 : : rcu_read_unlock();
369 : :
370 : : return ret;
371 : : }
372 : :
373 : : /* Extract dsfield from inner protocol */
374 : : static inline u8 ip_tunnel_get_dsfield(const struct iphdr *iph,
375 : : const struct sk_buff *skb)
376 : : {
377 : : if (skb->protocol == htons(ETH_P_IP))
378 : : return iph->tos;
379 : : else if (skb->protocol == htons(ETH_P_IPV6))
380 : : return ipv6_get_dsfield((const struct ipv6hdr *)iph);
381 : : else
382 : : return 0;
383 : : }
384 : :
385 : : static inline u8 ip_tunnel_get_ttl(const struct iphdr *iph,
386 : : const struct sk_buff *skb)
387 : : {
388 : : if (skb->protocol == htons(ETH_P_IP))
389 : : return iph->ttl;
390 : : else if (skb->protocol == htons(ETH_P_IPV6))
391 : : return ((const struct ipv6hdr *)iph)->hop_limit;
392 : : else
393 : : return 0;
394 : : }
395 : :
396 : : /* Propogate ECN bits out */
397 : : static inline u8 ip_tunnel_ecn_encap(u8 tos, const struct iphdr *iph,
398 : : const struct sk_buff *skb)
399 : : {
400 : : u8 inner = ip_tunnel_get_dsfield(iph, skb);
401 : :
402 : : return INET_ECN_encapsulate(tos, inner);
403 : : }
404 : :
405 : : int __iptunnel_pull_header(struct sk_buff *skb, int hdr_len,
406 : : __be16 inner_proto, bool raw_proto, bool xnet);
407 : :
408 : : static inline int iptunnel_pull_header(struct sk_buff *skb, int hdr_len,
409 : : __be16 inner_proto, bool xnet)
410 : : {
411 : : return __iptunnel_pull_header(skb, hdr_len, inner_proto, false, xnet);
412 : : }
413 : :
414 : : void iptunnel_xmit(struct sock *sk, struct rtable *rt, struct sk_buff *skb,
415 : : __be32 src, __be32 dst, u8 proto,
416 : : u8 tos, u8 ttl, __be16 df, bool xnet);
417 : : struct metadata_dst *iptunnel_metadata_reply(struct metadata_dst *md,
418 : : gfp_t flags);
419 : :
420 : : int iptunnel_handle_offloads(struct sk_buff *skb, int gso_type_mask);
421 : :
422 : 0 : static inline int iptunnel_pull_offloads(struct sk_buff *skb)
423 : : {
424 [ # # ]: 0 : if (skb_is_gso(skb)) {
425 : : int err;
426 : :
427 : 0 : err = skb_unclone(skb, GFP_ATOMIC);
428 [ # # ]: 0 : if (unlikely(err))
429 : : return err;
430 : 0 : skb_shinfo(skb)->gso_type &= ~(NETIF_F_GSO_ENCAP_ALL >>
431 : : NETIF_F_GSO_SHIFT);
432 : : }
433 : :
434 : 0 : skb->encapsulation = 0;
435 : 0 : return 0;
436 : : }
437 : :
438 : 0 : static inline void iptunnel_xmit_stats(struct net_device *dev, int pkt_len)
439 : : {
440 [ # # ]: 0 : if (pkt_len > 0) {
441 : 0 : struct pcpu_sw_netstats *tstats = get_cpu_ptr(dev->tstats);
442 : :
443 : : u64_stats_update_begin(&tstats->syncp);
444 : 0 : tstats->tx_bytes += pkt_len;
445 : 0 : tstats->tx_packets++;
446 : : u64_stats_update_end(&tstats->syncp);
447 : 0 : put_cpu_ptr(tstats);
448 : : } else {
449 : : struct net_device_stats *err_stats = &dev->stats;
450 : :
451 [ # # ]: 0 : if (pkt_len < 0) {
452 : 0 : err_stats->tx_errors++;
453 : 0 : err_stats->tx_aborted_errors++;
454 : : } else {
455 : 0 : err_stats->tx_dropped++;
456 : : }
457 : : }
458 : 0 : }
459 : :
460 : : static inline void *ip_tunnel_info_opts(struct ip_tunnel_info *info)
461 : : {
462 : 0 : return info + 1;
463 : : }
464 : :
465 : 0 : static inline void ip_tunnel_info_opts_get(void *to,
466 : : const struct ip_tunnel_info *info)
467 : : {
468 : 0 : memcpy(to, info + 1, info->options_len);
469 : 0 : }
470 : :
471 : 0 : static inline void ip_tunnel_info_opts_set(struct ip_tunnel_info *info,
472 : : const void *from, int len,
473 : : __be16 flags)
474 : : {
475 : 0 : memcpy(ip_tunnel_info_opts(info), from, len);
476 : 0 : info->options_len = len;
477 : 0 : info->key.tun_flags |= flags;
478 : 0 : }
479 : :
480 : : static inline struct ip_tunnel_info *lwt_tun_info(struct lwtunnel_state *lwtstate)
481 : : {
482 : 0 : return (struct ip_tunnel_info *)lwtstate->data;
483 : : }
484 : :
485 : : DECLARE_STATIC_KEY_FALSE(ip_tunnel_metadata_cnt);
486 : :
487 : : /* Returns > 0 if metadata should be collected */
488 : : static inline int ip_tunnel_collect_metadata(void)
489 : : {
490 : : return static_branch_unlikely(&ip_tunnel_metadata_cnt);
491 : : }
492 : :
493 : : void __init ip_tunnel_core_init(void);
494 : :
495 : : void ip_tunnel_need_metadata(void);
496 : : void ip_tunnel_unneed_metadata(void);
497 : :
498 : : #else /* CONFIG_INET */
499 : :
500 : : static inline struct ip_tunnel_info *lwt_tun_info(struct lwtunnel_state *lwtstate)
501 : : {
502 : : return NULL;
503 : : }
504 : :
505 : : static inline void ip_tunnel_need_metadata(void)
506 : : {
507 : : }
508 : :
509 : : static inline void ip_tunnel_unneed_metadata(void)
510 : : {
511 : : }
512 : :
513 : : static inline void ip_tunnel_info_opts_get(void *to,
514 : : const struct ip_tunnel_info *info)
515 : : {
516 : : }
517 : :
518 : : static inline void ip_tunnel_info_opts_set(struct ip_tunnel_info *info,
519 : : const void *from, int len,
520 : : __be16 flags)
521 : : {
522 : : info->options_len = 0;
523 : : info->key.tun_flags |= flags;
524 : : }
525 : :
526 : : #endif /* CONFIG_INET */
527 : :
528 : : #endif /* __NET_IP_TUNNELS_H */
|
