Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0d3c703a authored by Tom Herbert's avatar Tom Herbert Committed by David S. Miller
Browse files

ipv6: Cleanup IPv6 tunnel receive path 



Some basic changes to make IPv6 tunnel receive path look more like
IPv4 path:
  - Make ip6_tnl_rcv non-static so that GREv6 and others can call it
  - Make ip6_tnl_rcv look like ip_tunnel_rcv
  - Switch to gro_cells_receive
  - Make ip6_tnl_rcv non-static and export it

Signed-off-by: default avatarTom Herbert <tom@herbertland.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 570d6320

include/net/ip6_tunnel.h

+4 −0
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ struct ip6_tnl { 
	struct __ip6_tnl_parm parms;	/* tunnel configuration parameters */

	struct flowi fl;	/* flowi template for xmit */

	struct dst_cache dst_cache;	/* cached dst */

	struct gro_cells gro_cells;



	int err_count;

	unsigned long err_time;
@@ -63,6 +64,9 @@ struct ipv6_tlv_tnl_enc_lim { 


int ip6_tnl_rcv_ctl(struct ip6_tnl *t, const struct in6_addr *laddr,

		const struct in6_addr *raddr);

int ip6_tnl_rcv(struct ip6_tnl *tunnel, struct sk_buff *skb,

		const struct tnl_ptk_info *tpi, struct metadata_dst *tun_dst,

		bool log_ecn_error);

int ip6_tnl_xmit_ctl(struct ip6_tnl *t, const struct in6_addr *laddr,

		     const struct in6_addr *raddr);

__u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff *skb, __u8 *raw);

net/ipv6/ip6_tunnel.c

+142 −70
Original line number Diff line number Diff line
@@ -238,6 +238,7 @@ static void ip6_dev_free(struct net_device *dev) 
{

	struct ip6_tnl *t = netdev_priv(dev);



	gro_cells_destroy(&t->gro_cells);

	dst_cache_destroy(&t->dst_cache);

	free_percpu(dev->tstats);

	free_netdev(dev);
@@ -753,96 +754,156 @@ int ip6_tnl_rcv_ctl(struct ip6_tnl *t, 
}

EXPORT_SYMBOL_GPL(ip6_tnl_rcv_ctl);



/**

 * ip6_tnl_rcv - decapsulate IPv6 packet and retransmit it locally

 *   @skb: received socket buffer

 *   @protocol: ethernet protocol ID

 *   @dscp_ecn_decapsulate: the function to decapsulate DSCP code and ECN

 *

 * Return: 0

 **/



static int ip6_tnl_rcv(struct sk_buff *skb, __u16 protocol,

		       __u8 ipproto,

static int __ip6_tnl_rcv(struct ip6_tnl *tunnel, struct sk_buff *skb,

			 const struct tnl_ptk_info *tpi,

			 struct metadata_dst *tun_dst,

			 int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,

						const struct ipv6hdr *ipv6h,

						   struct sk_buff *skb))

						struct sk_buff *skb),

			 bool log_ecn_err)

{

	struct ip6_tnl *t;

	struct pcpu_sw_netstats *tstats;

	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);

	u8 tproto;

	int err;



	rcu_read_lock();

	t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr, &ipv6h->daddr);

	if (t) {

		struct pcpu_sw_netstats *tstats;

	if ((!(tpi->flags & TUNNEL_CSUM) &&

	     (tunnel->parms.i_flags & TUNNEL_CSUM)) ||

	    ((tpi->flags & TUNNEL_CSUM) &&

	     !(tunnel->parms.i_flags & TUNNEL_CSUM))) {

		tunnel->dev->stats.rx_crc_errors++;

		tunnel->dev->stats.rx_errors++;

		goto drop;

	}



		tproto = ACCESS_ONCE(t->parms.proto);

		if (tproto != ipproto && tproto != 0) {

			rcu_read_unlock();

			goto discard;

	if (tunnel->parms.i_flags & TUNNEL_SEQ) {

		if (!(tpi->flags & TUNNEL_SEQ) ||

		    (tunnel->i_seqno &&

		     (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {

			tunnel->dev->stats.rx_fifo_errors++;

			tunnel->dev->stats.rx_errors++;

			goto drop;

		}

		tunnel->i_seqno = ntohl(tpi->seq) + 1;

	}



		if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {

			rcu_read_unlock();

			goto discard;

	skb->protocol = tpi->proto;



	/* Warning: All skb pointers will be invalidated! */

	if (tunnel->dev->type == ARPHRD_ETHER) {

		if (!pskb_may_pull(skb, ETH_HLEN)) {

			tunnel->dev->stats.rx_length_errors++;

			tunnel->dev->stats.rx_errors++;

			goto drop;

		}



		if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr)) {

			t->dev->stats.rx_dropped++;

			rcu_read_unlock();

			goto discard;

		ipv6h = ipv6_hdr(skb);

		skb->protocol = eth_type_trans(skb, tunnel->dev);

		skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

	} else {

		skb->dev = tunnel->dev;

	}

		skb->mac_header = skb->network_header;



	skb_reset_network_header(skb);

		skb->protocol = htons(protocol);

	memset(skb->cb, 0, sizeof(struct inet6_skb_parm));



		__skb_tunnel_rx(skb, t->dev, t->net);

	__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);



		err = dscp_ecn_decapsulate(t, ipv6h, skb);

	err = dscp_ecn_decapsulate(tunnel, ipv6h, skb);

	if (unlikely(err)) {

			if (log_ecn_error)

				net_info_ratelimited("non-ECT from %pI6 with dsfield=%#x\n",

		if (log_ecn_err)

			net_info_ratelimited("non-ECT from %pI6 with DS=%#x\n",

					     &ipv6h->saddr,

					     ipv6_get_dsfield(ipv6h));

		if (err > 1) {

				++t->dev->stats.rx_frame_errors;

				++t->dev->stats.rx_errors;

				rcu_read_unlock();

				goto discard;

			++tunnel->dev->stats.rx_frame_errors;

			++tunnel->dev->stats.rx_errors;

			goto drop;

		}

	}



		tstats = this_cpu_ptr(t->dev->tstats);

	tstats = this_cpu_ptr(tunnel->dev->tstats);

	u64_stats_update_begin(&tstats->syncp);

	tstats->rx_packets++;

	tstats->rx_bytes += skb->len;

	u64_stats_update_end(&tstats->syncp);



		netif_rx(skb);

	skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));



		rcu_read_unlock();

	gro_cells_receive(&tunnel->gro_cells, skb);

	return 0;



drop:

	kfree_skb(skb);

	return 0;

}



int ip6_tnl_rcv(struct ip6_tnl *t, struct sk_buff *skb,

		const struct tnl_ptk_info *tpi,

		struct metadata_dst *tun_dst,

		bool log_ecn_err)

{

	return __ip6_tnl_rcv(t, skb, tpi, NULL, ip6ip6_dscp_ecn_decapsulate,

			     log_ecn_err);

}

EXPORT_SYMBOL(ip6_tnl_rcv);



static const struct tnl_ptk_info tpi_v6 = {

	/* no tunnel info required for ipxip6. */

	.proto = htons(ETH_P_IPV6),

};



static const struct tnl_ptk_info tpi_v4 = {

	/* no tunnel info required for ipxip6. */

	.proto = htons(ETH_P_IP),

};



static int ipxip6_rcv(struct sk_buff *skb, u8 ipproto,

		      const struct tnl_ptk_info *tpi,

		      int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,

						  const struct ipv6hdr *ipv6h,

						  struct sk_buff *skb))

{

	struct ip6_tnl *t;

	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);

	int ret = -1;



	rcu_read_lock();

	t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr, &ipv6h->daddr);



	if (t) {

		u8 tproto = ACCESS_ONCE(t->parms.proto);



		if (tproto != ipproto && tproto != 0)

			goto drop;

		if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))

			goto drop;

		if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr))

			goto drop;

		if (iptunnel_pull_header(skb, 0, tpi->proto, false))

			goto drop;

		ret = __ip6_tnl_rcv(t, skb, tpi, NULL, dscp_ecn_decapsulate,

				    log_ecn_error);

	}



	rcu_read_unlock();

	return 1;



discard:

	return ret;



drop:

	rcu_read_unlock();

	kfree_skb(skb);

	return 0;

}



static int ip4ip6_rcv(struct sk_buff *skb)

{

	return ip6_tnl_rcv(skb, ETH_P_IP, IPPROTO_IPIP,

	return ipxip6_rcv(skb, IPPROTO_IP, &tpi_v4,

			  ip4ip6_dscp_ecn_decapsulate);

}



static int ip6ip6_rcv(struct sk_buff *skb)

{

	return ip6_tnl_rcv(skb, ETH_P_IPV6, IPPROTO_IPV6,

	return ipxip6_rcv(skb, IPPROTO_IPV6, &tpi_v6,

			  ip6ip6_dscp_ecn_decapsulate);

}
@@ -1370,6 +1431,8 @@ ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 
	struct net *net = t->net;

	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);



	memset(&p1, 0, sizeof(p1));



	switch (cmd) {

	case SIOCGETTUNNEL:

		if (dev == ip6n->fb_tnl_dev) {
@@ -1549,13 +1612,22 @@ ip6_tnl_dev_init_gen(struct net_device *dev) 
		return -ENOMEM;



	ret = dst_cache_init(&t->dst_cache, GFP_KERNEL);

	if (ret) {

	if (ret)

		goto free_stats;



	ret = gro_cells_init(&t->gro_cells, dev);

	if (ret)

		goto destroy_dst;



	return 0;



destroy_dst:

	dst_cache_destroy(&t->dst_cache);

free_stats:

	free_percpu(dev->tstats);

	dev->tstats = NULL;

		return ret;

	}



	return 0;

	return ret;

}



/**