~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/ip_tunnels.h

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef __NET_IP_TUNNELS_H
  2 #define __NET_IP_TUNNELS_H 1
  3 
  4 #include <linux/if_tunnel.h>
  5 #include <linux/netdevice.h>
  6 #include <linux/skbuff.h>
  7 #include <linux/socket.h>
  8 #include <linux/types.h>
  9 #include <linux/u64_stats_sync.h>
 10 #include <linux/bitops.h>
 11 
 12 #include <net/dsfield.h>
 13 #include <net/gro_cells.h>
 14 #include <net/inet_ecn.h>
 15 #include <net/netns/generic.h>
 16 #include <net/rtnetlink.h>
 17 #include <net/lwtunnel.h>
 18 #include <net/dst_cache.h>
 19 
 20 #if IS_ENABLED(CONFIG_IPV6)
 21 #include <net/ipv6.h>
 22 #include <net/ip6_fib.h>
 23 #include <net/ip6_route.h>
 24 #endif
 25 
 26 /* Keep error state on tunnel for 30 sec */
 27 #define IPTUNNEL_ERR_TIMEO      (30*HZ)
 28 
 29 /* Used to memset ip_tunnel padding. */
 30 #define IP_TUNNEL_KEY_SIZE      offsetofend(struct ip_tunnel_key, tp_dst)
 31 
 32 /* Used to memset ipv4 address padding. */
 33 #define IP_TUNNEL_KEY_IPV4_PAD  offsetofend(struct ip_tunnel_key, u.ipv4.dst)
 34 #define IP_TUNNEL_KEY_IPV4_PAD_LEN                              \
 35         (FIELD_SIZEOF(struct ip_tunnel_key, u) -                \
 36          FIELD_SIZEOF(struct ip_tunnel_key, u.ipv4))
 37 
 38 struct ip_tunnel_key {
 39         __be64                  tun_id;
 40         union {
 41                 struct {
 42                         __be32  src;
 43                         __be32  dst;
 44                 } ipv4;
 45                 struct {
 46                         struct in6_addr src;
 47                         struct in6_addr dst;
 48                 } ipv6;
 49         } u;
 50         __be16                  tun_flags;
 51         u8                      tos;            /* TOS for IPv4, TC for IPv6 */
 52         u8                      ttl;            /* TTL for IPv4, HL for IPv6 */
 53         __be32                  label;          /* Flow Label for IPv6 */
 54         __be16                  tp_src;
 55         __be16                  tp_dst;
 56 };
 57 
 58 /* Flags for ip_tunnel_info mode. */
 59 #define IP_TUNNEL_INFO_TX       0x01    /* represents tx tunnel parameters */
 60 #define IP_TUNNEL_INFO_IPV6     0x02    /* key contains IPv6 addresses */
 61 
 62 /* Maximum tunnel options length. */
 63 #define IP_TUNNEL_OPTS_MAX                                      \
 64         GENMASK((FIELD_SIZEOF(struct ip_tunnel_info,            \
 65                               options_len) * BITS_PER_BYTE) - 1, 0)
 66 
 67 struct ip_tunnel_info {
 68         struct ip_tunnel_key    key;
 69 #ifdef CONFIG_DST_CACHE
 70         struct dst_cache        dst_cache;
 71 #endif
 72         u8                      options_len;
 73         u8                      mode;
 74 };
 75 
 76 /* 6rd prefix/relay information */
 77 #ifdef CONFIG_IPV6_SIT_6RD
 78 struct ip_tunnel_6rd_parm {
 79         struct in6_addr         prefix;
 80         __be32                  relay_prefix;
 81         u16                     prefixlen;
 82         u16                     relay_prefixlen;
 83 };
 84 #endif
 85 
 86 struct ip_tunnel_encap {
 87         u16                     type;
 88         u16                     flags;
 89         __be16                  sport;
 90         __be16                  dport;
 91 };
 92 
 93 struct ip_tunnel_prl_entry {
 94         struct ip_tunnel_prl_entry __rcu *next;
 95         __be32                          addr;
 96         u16                             flags;
 97         struct rcu_head                 rcu_head;
 98 };
 99 
100 struct metadata_dst;
101 
102 struct ip_tunnel {
103         struct ip_tunnel __rcu  *next;
104         struct hlist_node hash_node;
105         struct net_device       *dev;
106         struct net              *net;   /* netns for packet i/o */
107 
108         int             err_count;      /* Number of arrived ICMP errors */
109         unsigned long   err_time;       /* Time when the last ICMP error
110                                          * arrived */
111 
112         /* These four fields used only by GRE */
113         u32             i_seqno;        /* The last seen seqno  */
114         u32             o_seqno;        /* The last output seqno */
115         int             tun_hlen;       /* Precalculated header length */
116         int             mlink;
117 
118         struct dst_cache dst_cache;
119 
120         struct ip_tunnel_parm parms;
121 
122         int             encap_hlen;     /* Encap header length (FOU,GUE) */
123         struct ip_tunnel_encap encap;
124 
125         int             hlen;           /* tun_hlen + encap_hlen */
126 
127         /* for SIT */
128 #ifdef CONFIG_IPV6_SIT_6RD
129         struct ip_tunnel_6rd_parm ip6rd;
130 #endif
131         struct ip_tunnel_prl_entry __rcu *prl;  /* potential router list */
132         unsigned int            prl_count;      /* # of entries in PRL */
133         int                     ip_tnl_net_id;
134         struct gro_cells        gro_cells;
135         bool                    collect_md;
136 };
137 
138 #define TUNNEL_CSUM             __cpu_to_be16(0x01)
139 #define TUNNEL_ROUTING          __cpu_to_be16(0x02)
140 #define TUNNEL_KEY              __cpu_to_be16(0x04)
141 #define TUNNEL_SEQ              __cpu_to_be16(0x08)
142 #define TUNNEL_STRICT           __cpu_to_be16(0x10)
143 #define TUNNEL_REC              __cpu_to_be16(0x20)
144 #define TUNNEL_VERSION          __cpu_to_be16(0x40)
145 #define TUNNEL_NO_KEY           __cpu_to_be16(0x80)
146 #define TUNNEL_DONT_FRAGMENT    __cpu_to_be16(0x0100)
147 #define TUNNEL_OAM              __cpu_to_be16(0x0200)
148 #define TUNNEL_CRIT_OPT         __cpu_to_be16(0x0400)
149 #define TUNNEL_GENEVE_OPT       __cpu_to_be16(0x0800)
150 #define TUNNEL_VXLAN_OPT        __cpu_to_be16(0x1000)
151 #define TUNNEL_NOCACHE          __cpu_to_be16(0x2000)
152 
153 #define TUNNEL_OPTIONS_PRESENT  (TUNNEL_GENEVE_OPT | TUNNEL_VXLAN_OPT)
154 
155 struct tnl_ptk_info {
156         __be16 flags;
157         __be16 proto;
158         __be32 key;
159         __be32 seq;
160 };
161 
162 #define PACKET_RCVD     0
163 #define PACKET_REJECT   1
164 
165 #define IP_TNL_HASH_BITS   7
166 #define IP_TNL_HASH_SIZE   (1 << IP_TNL_HASH_BITS)
167 
168 struct ip_tunnel_net {
169         struct net_device *fb_tunnel_dev;
170         struct hlist_head tunnels[IP_TNL_HASH_SIZE];
171         struct ip_tunnel __rcu *collect_md_tun;
172 };
173 
174 struct ip_tunnel_encap_ops {
175         size_t (*encap_hlen)(struct ip_tunnel_encap *e);
176         int (*build_header)(struct sk_buff *skb, struct ip_tunnel_encap *e,
177                             u8 *protocol, struct flowi4 *fl4);
178 };
179 
180 #define MAX_IPTUN_ENCAP_OPS 8
181 
182 extern const struct ip_tunnel_encap_ops __rcu *
183                 iptun_encaps[MAX_IPTUN_ENCAP_OPS];
184 
185 int ip_tunnel_encap_add_ops(const struct ip_tunnel_encap_ops *op,
186                             unsigned int num);
187 int ip_tunnel_encap_del_ops(const struct ip_tunnel_encap_ops *op,
188                             unsigned int num);
189 
190 static inline void ip_tunnel_key_init(struct ip_tunnel_key *key,
191                                       __be32 saddr, __be32 daddr,
192                                       u8 tos, u8 ttl, __be32 label,
193                                       __be16 tp_src, __be16 tp_dst,
194                                       __be64 tun_id, __be16 tun_flags)
195 {
196         key->tun_id = tun_id;
197         key->u.ipv4.src = saddr;
198         key->u.ipv4.dst = daddr;
199         memset((unsigned char *)key + IP_TUNNEL_KEY_IPV4_PAD,
200                0, IP_TUNNEL_KEY_IPV4_PAD_LEN);
201         key->tos = tos;
202         key->ttl = ttl;
203         key->label = label;
204         key->tun_flags = tun_flags;
205 
206         /* For the tunnel types on the top of IPsec, the tp_src and tp_dst of
207          * the upper tunnel are used.
208          * E.g: GRE over IPSEC, the tp_src and tp_port are zero.
209          */
210         key->tp_src = tp_src;
211         key->tp_dst = tp_dst;
212 
213         /* Clear struct padding. */
214         if (sizeof(*key) != IP_TUNNEL_KEY_SIZE)
215                 memset((unsigned char *)key + IP_TUNNEL_KEY_SIZE,
216                        0, sizeof(*key) - IP_TUNNEL_KEY_SIZE);
217 }
218 
219 static inline bool
220 ip_tunnel_dst_cache_usable(const struct sk_buff *skb,
221                            const struct ip_tunnel_info *info)
222 {
223         if (skb->mark)
224                 return false;
225         if (!info)
226                 return true;
227         if (info->key.tun_flags & TUNNEL_NOCACHE)
228                 return false;
229 
230         return true;
231 }
232 
233 static inline unsigned short ip_tunnel_info_af(const struct ip_tunnel_info
234                                                *tun_info)
235 {
236         return tun_info->mode & IP_TUNNEL_INFO_IPV6 ? AF_INET6 : AF_INET;
237 }
238 
239 #ifdef CONFIG_INET
240 
241 int ip_tunnel_init(struct net_device *dev);
242 void ip_tunnel_uninit(struct net_device *dev);
243 void  ip_tunnel_dellink(struct net_device *dev, struct list_head *head);
244 struct net *ip_tunnel_get_link_net(const struct net_device *dev);
245 int ip_tunnel_get_iflink(const struct net_device *dev);
246 int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
247                        struct rtnl_link_ops *ops, char *devname);
248 
249 void ip_tunnel_delete_net(struct ip_tunnel_net *itn, struct rtnl_link_ops *ops);
250 
251 void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
252                     const struct iphdr *tnl_params, const u8 protocol);
253 int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd);
254 int ip_tunnel_encap(struct sk_buff *skb, struct ip_tunnel *t,
255                     u8 *protocol, struct flowi4 *fl4);
256 int __ip_tunnel_change_mtu(struct net_device *dev, int new_mtu, bool strict);
257 int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu);
258 
259 struct rtnl_link_stats64 *ip_tunnel_get_stats64(struct net_device *dev,
260                                                 struct rtnl_link_stats64 *tot);
261 struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,
262                                    int link, __be16 flags,
263                                    __be32 remote, __be32 local,
264                                    __be32 key);
265 
266 int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,
267                   const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,
268                   bool log_ecn_error);
269 int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],
270                          struct ip_tunnel_parm *p);
271 int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],
272                       struct ip_tunnel_parm *p);
273 void ip_tunnel_setup(struct net_device *dev, int net_id);
274 int ip_tunnel_encap_setup(struct ip_tunnel *t,
275                           struct ip_tunnel_encap *ipencap);
276 
277 /* Extract dsfield from inner protocol */
278 static inline u8 ip_tunnel_get_dsfield(const struct iphdr *iph,
279                                        const struct sk_buff *skb)
280 {
281         if (skb->protocol == htons(ETH_P_IP))
282                 return iph->tos;
283         else if (skb->protocol == htons(ETH_P_IPV6))
284                 return ipv6_get_dsfield((const struct ipv6hdr *)iph);
285         else
286                 return 0;
287 }
288 
289 /* Propogate ECN bits out */
290 static inline u8 ip_tunnel_ecn_encap(u8 tos, const struct iphdr *iph,
291                                      const struct sk_buff *skb)
292 {
293         u8 inner = ip_tunnel_get_dsfield(iph, skb);
294 
295         return INET_ECN_encapsulate(tos, inner);
296 }
297 
298 int iptunnel_pull_header(struct sk_buff *skb, int hdr_len, __be16 inner_proto,
299                          bool xnet);
300 void iptunnel_xmit(struct sock *sk, struct rtable *rt, struct sk_buff *skb,
301                    __be32 src, __be32 dst, u8 proto,
302                    u8 tos, u8 ttl, __be16 df, bool xnet);
303 struct metadata_dst *iptunnel_metadata_reply(struct metadata_dst *md,
304                                              gfp_t flags);
305 
306 struct sk_buff *iptunnel_handle_offloads(struct sk_buff *skb, int gso_type_mask);
307 
308 static inline int iptunnel_pull_offloads(struct sk_buff *skb)
309 {
310         if (skb_is_gso(skb)) {
311                 int err;
312 
313                 err = skb_unclone(skb, GFP_ATOMIC);
314                 if (unlikely(err))
315                         return err;
316                 skb_shinfo(skb)->gso_type &= ~(NETIF_F_GSO_ENCAP_ALL >>
317                                                NETIF_F_GSO_SHIFT);
318         }
319 
320         skb->encapsulation = 0;
321         return 0;
322 }
323 
324 static inline void iptunnel_xmit_stats(struct net_device *dev, int pkt_len)
325 {
326         if (pkt_len > 0) {
327                 struct pcpu_sw_netstats *tstats = get_cpu_ptr(dev->tstats);
328 
329                 u64_stats_update_begin(&tstats->syncp);
330                 tstats->tx_bytes += pkt_len;
331                 tstats->tx_packets++;
332                 u64_stats_update_end(&tstats->syncp);
333                 put_cpu_ptr(tstats);
334         } else {
335                 struct net_device_stats *err_stats = &dev->stats;
336 
337                 if (pkt_len < 0) {
338                         err_stats->tx_errors++;
339                         err_stats->tx_aborted_errors++;
340                 } else {
341                         err_stats->tx_dropped++;
342                 }
343         }
344 }
345 
346 static inline void *ip_tunnel_info_opts(struct ip_tunnel_info *info)
347 {
348         return info + 1;
349 }
350 
351 static inline void ip_tunnel_info_opts_get(void *to,
352                                            const struct ip_tunnel_info *info)
353 {
354         memcpy(to, info + 1, info->options_len);
355 }
356 
357 static inline void ip_tunnel_info_opts_set(struct ip_tunnel_info *info,
358                                            const void *from, int len)
359 {
360         memcpy(ip_tunnel_info_opts(info), from, len);
361         info->options_len = len;
362 }
363 
364 static inline struct ip_tunnel_info *lwt_tun_info(struct lwtunnel_state *lwtstate)
365 {
366         return (struct ip_tunnel_info *)lwtstate->data;
367 }
368 
369 extern struct static_key ip_tunnel_metadata_cnt;
370 
371 /* Returns > 0 if metadata should be collected */
372 static inline int ip_tunnel_collect_metadata(void)
373 {
374         return static_key_false(&ip_tunnel_metadata_cnt);
375 }
376 
377 void __init ip_tunnel_core_init(void);
378 
379 void ip_tunnel_need_metadata(void);
380 void ip_tunnel_unneed_metadata(void);
381 
382 #else /* CONFIG_INET */
383 
384 static inline struct ip_tunnel_info *lwt_tun_info(struct lwtunnel_state *lwtstate)
385 {
386         return NULL;
387 }
388 
389 static inline void ip_tunnel_need_metadata(void)
390 {
391 }
392 
393 static inline void ip_tunnel_unneed_metadata(void)
394 {
395 }
396 
397 static inline void ip_tunnel_info_opts_get(void *to,
398                                            const struct ip_tunnel_info *info)
399 {
400 }
401 
402 static inline void ip_tunnel_info_opts_set(struct ip_tunnel_info *info,
403                                            const void *from, int len)
404 {
405         info->options_len = 0;
406 }
407 
408 #endif /* CONFIG_INET */
409 
410 #endif /* __NET_IP_TUNNELS_H */
411 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp