Commit c5441932 authored by Pravin B Shelar's avatar Pravin B Shelar Committed by David S. Miller
Browse files

GRE: Refactor GRE tunneling code. 



Following patch refactors GRE code into ip tunneling code and GRE
specific code. Common tunneling code is moved to ip_tunnel module.
ip_tunnel module is written as generic library which can be used
by different tunneling implementations.

ip_tunnel module contains following components:
 - packet xmit and rcv generic code. xmit flow looks like
   (gre_xmit/ipip_xmit)->ip_tunnel_xmit->ip_local_out.
 - hash table of all devices.
 - lookup for tunnel devices.
 - control plane operations like device create, destroy, ioctl, netlink
   operations code.
 - registration for tunneling modules, like gre, ipip etc.
 - define single pcpu_tstats dev->tstats.
 - struct tnl_ptk_info added to pass parsed tunnel packet parameters.

ipip.h header is renamed to ip_tunnel.h

Signed-off-by: default avatarPravin B Shelar <pshelar@nicira.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent eaac5f3d

drivers/net/vxlan.c

+1 −1
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ 
#include <net/arp.h>

#include <net/ndisc.h>

#include <net/ip.h>

#include <net/ipip.h>

#include <net/ip_tunnels.h>

#include <net/icmp.h>

#include <net/udp.h>

#include <net/rtnetlink.h>

include/net/gre.h

+51 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
#define __LINUX_GRE_H



#include <linux/skbuff.h>

#include <net/ip_tunnels.h>



#define GREPROTO_CISCO		0

#define GREPROTO_PPTP		1
@@ -12,7 +13,57 @@ struct gre_protocol { 
	void (*err_handler)(struct sk_buff *skb, u32 info);

};



struct gre_base_hdr {

	__be16 flags;

	__be16 protocol;

};

#define GRE_HEADER_SECTION 4



int gre_add_protocol(const struct gre_protocol *proto, u8 version);

int gre_del_protocol(const struct gre_protocol *proto, u8 version);



static inline __be16 gre_flags_to_tnl_flags(__be16 flags)

{

	__be16 tflags = 0;



	if (flags & GRE_CSUM)

		tflags |= TUNNEL_CSUM;

	if (flags & GRE_ROUTING)

		tflags |= TUNNEL_ROUTING;

	if (flags & GRE_KEY)

		tflags |= TUNNEL_KEY;

	if (flags & GRE_SEQ)

		tflags |= TUNNEL_SEQ;

	if (flags & GRE_STRICT)

		tflags |= TUNNEL_STRICT;

	if (flags & GRE_REC)

		tflags |= TUNNEL_REC;

	if (flags & GRE_VERSION)

		tflags |= TUNNEL_VERSION;



	return tflags;

}



static inline __be16 tnl_flags_to_gre_flags(__be16 tflags)

{

	__be16 flags = 0;



	if (tflags & TUNNEL_CSUM)

		flags |= GRE_CSUM;

	if (tflags & TUNNEL_ROUTING)

		flags |= GRE_ROUTING;

	if (tflags & TUNNEL_KEY)

		flags |= GRE_KEY;

	if (tflags & TUNNEL_SEQ)

		flags |= GRE_SEQ;

	if (tflags & TUNNEL_STRICT)

		flags |= GRE_STRICT;

	if (tflags & TUNNEL_REC)

		flags |= GRE_REC;

	if (tflags & TUNNEL_VERSION)

		flags |= GRE_VERSION;



	return flags;

}



#endif

include/net/ip6_tunnel.h

+1 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 


#include <linux/ipv6.h>

#include <linux/netdevice.h>

#include <linux/if_tunnel.h>

#include <linux/ip6_tunnel.h>



#define IP6TUNNEL_ERR_TIMEO (30*HZ)

include/net/ipip.h→include/net/ip_tunnels.h

+177 −0
Original line number Diff line number Diff line 
#ifndef __NET_IPIP_H

#define __NET_IPIP_H 1

#ifndef __NET_IP_TUNNELS_H

#define __NET_IP_TUNNELS_H 1



#include <linux/if_tunnel.h>

#include <linux/netdevice.h>

#include <linux/skbuff.h>

#include <linux/types.h>

#include <linux/u64_stats_sync.h>

#include <net/dsfield.h>

#include <net/gro_cells.h>

#include <net/inet_ecn.h>

#include <net/ip.h>

#include <net/rtnetlink.h>



#if IS_ENABLED(CONFIG_IPV6)

#include <net/ipv6.h>

#include <net/ip6_fib.h>

#include <net/ip6_route.h>

#endif



/* Keep error state on tunnel for 30 sec */

#define IPTUNNEL_ERR_TIMEO	(30*HZ)



/* 6rd prefix/relay information */

#ifdef CONFIG_IPV6_SIT_6RD

struct ip_tunnel_6rd_parm {

	struct in6_addr		prefix;

	__be32			relay_prefix;

	u16			prefixlen;

	u16			relay_prefixlen;

};

#endif



struct ip_tunnel_prl_entry {

	struct ip_tunnel_prl_entry __rcu *next;

	__be32				addr;

	u16				flags;

	struct rcu_head			rcu_head;

};



struct ip_tunnel {

	struct ip_tunnel __rcu	*next;

	struct hlist_node hash_node;

	struct net_device	*dev;



	int		err_count;	/* Number of arrived ICMP errors */

	unsigned long		err_time;	/* Time when the last ICMP error arrived */

	unsigned long	err_time;	/* Time when the last ICMP error

					 * arrived */



	/* These four fields used only by GRE */

	__u32		i_seqno;	/* The last seen seqno	*/

	__u32		o_seqno;	/* The last output seqno */

	int			hlen;		/* Precalculated GRE header length */

	int		hlen;		/* Precalculated header length */

	int		mlink;



	struct ip_tunnel_parm parms;
@@ -37,17 +61,100 @@ struct ip_tunnel { 
#endif

	struct ip_tunnel_prl_entry __rcu *prl;	/* potential router list */

	unsigned int		prl_count;	/* # of entries in PRL */



	int			ip_tnl_net_id;

	struct gro_cells	gro_cells;

};



struct ip_tunnel_prl_entry {

	struct ip_tunnel_prl_entry __rcu *next;

	__be32				addr;

	u16				flags;

	struct rcu_head			rcu_head;

#define TUNNEL_CSUM	__cpu_to_be16(0x01)

#define TUNNEL_ROUTING	__cpu_to_be16(0x02)

#define TUNNEL_KEY	__cpu_to_be16(0x04)

#define TUNNEL_SEQ	__cpu_to_be16(0x08)

#define TUNNEL_STRICT	__cpu_to_be16(0x10)

#define TUNNEL_REC	__cpu_to_be16(0x20)

#define TUNNEL_VERSION	__cpu_to_be16(0x40)

#define TUNNEL_NO_KEY	__cpu_to_be16(0x80)



struct tnl_ptk_info {

	__be16 flags;

	__be16 proto;

	__be32 key;

	__be32 seq;

};



#define PACKET_RCVD	0

#define PACKET_REJECT	1



#define IP_TNL_HASH_BITS   10

#define IP_TNL_HASH_SIZE   (1 << IP_TNL_HASH_BITS)



struct ip_tunnel_net {

	struct hlist_head *tunnels;

	struct net_device *fb_tunnel_dev;

};



int ip_tunnel_init(struct net_device *dev);

void ip_tunnel_uninit(struct net_device *dev);

void  ip_tunnel_dellink(struct net_device *dev, struct list_head *head);

int __net_init ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,

				  struct rtnl_link_ops *ops, char *devname);



void __net_exit ip_tunnel_delete_net(struct ip_tunnel_net *itn);



void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,

		    const struct iphdr *tnl_params);

int ip_tunnel_ioctl(struct net_device *dev, struct ip_tunnel_parm *p, int cmd);

int ip_tunnel_change_mtu(struct net_device *dev, int new_mtu);



struct rtnl_link_stats64 *ip_tunnel_get_stats64(struct net_device *dev,

						struct rtnl_link_stats64 *tot);

struct ip_tunnel *ip_tunnel_lookup(struct ip_tunnel_net *itn,

				   int link, __be16 flags,

				   __be32 remote, __be32 local,

				   __be32 key);



int ip_tunnel_rcv(struct ip_tunnel *tunnel, struct sk_buff *skb,

		  const struct tnl_ptk_info *tpi, bool log_ecn_error);

int ip_tunnel_changelink(struct net_device *dev, struct nlattr *tb[],

			 struct ip_tunnel_parm *p);

int ip_tunnel_newlink(struct net_device *dev, struct nlattr *tb[],

		      struct ip_tunnel_parm *p);

void ip_tunnel_setup(struct net_device *dev, int net_id);



/* Extract dsfield from inner protocol */

static inline u8 ip_tunnel_get_dsfield(const struct iphdr *iph,

				       const struct sk_buff *skb)

{

	if (skb->protocol == htons(ETH_P_IP))

		return iph->tos;

	else if (skb->protocol == htons(ETH_P_IPV6))

		return ipv6_get_dsfield((const struct ipv6hdr *)iph);

	else

		return 0;

}



/* Propogate ECN bits out */

static inline u8 ip_tunnel_ecn_encap(u8 tos, const struct iphdr *iph,

				     const struct sk_buff *skb)

{

	u8 inner = ip_tunnel_get_dsfield(iph, skb);



	return INET_ECN_encapsulate(tos, inner);

}



static inline void tunnel_ip_select_ident(struct sk_buff *skb,

					  const struct iphdr  *old_iph,

					  struct dst_entry *dst)

{

	struct iphdr *iph = ip_hdr(skb);



	/* Use inner packet iph-id if possible. */

	if (skb->protocol == htons(ETH_P_IP) && old_iph->id)

		iph->id	= old_iph->id;

	else

		__ip_select_ident(iph, dst,

				  (skb_shinfo(skb)->gso_segs ?: 1) - 1);

}



static inline void iptunnel_xmit(struct sk_buff *skb, struct net_device *dev)

{

	int err;
@@ -67,18 +174,4 @@ static inline void iptunnel_xmit(struct sk_buff *skb, struct net_device *dev) 
		dev->stats.tx_aborted_errors++;

	}

}



static inline void tunnel_ip_select_ident(struct sk_buff *skb,

					  const struct iphdr  *old_iph,

					  struct dst_entry *dst)

{

	struct iphdr *iph = ip_hdr(skb);



	/* Use inner packet iph-id if possible. */

	if (skb->protocol == htons(ETH_P_IP) && old_iph->id)

		iph->id	= old_iph->id;

	else

		__ip_select_ident(iph, dst,

				  (skb_shinfo(skb)->gso_segs ?: 1) - 1);

}

#endif
 
#endif /* __NET_IP_TUNNELS_H */

net/ipv4/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -186,9 +186,14 @@ config NET_IPGRE_DEMUX 
	 This is helper module to demultiplex GRE packets on GRE version field criteria.

	 Required by ip_gre and pptp modules.



config NET_IP_TUNNEL

	tristate

	default n



config NET_IPGRE

	tristate "IP: GRE tunnels over IP"

	depends on (IPV6 || IPV6=n) && NET_IPGRE_DEMUX

	select NET_IP_TUNNEL

	help

	  Tunneling means encapsulating data of one protocol type within

	  another protocol and sending it over a channel that understands the

CRA Git | Maintained and supported by SUSTech CRA and CCSE