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

Commit 6ae23ad3 authored by Tom Herbert's avatar Tom Herbert Committed by David S. Miller
Browse files

net: Add driver helper functions to determine checksum offloadability 



Add skb_csum_offload_chk driver helper function to determine if a
device with limited checksum offload capabilities is able to offload the
checksum for a given packet.

This patch includes:
  - The skb_csum_offload_chk function. Returns true if checksum is
    offloadable, else false. Optionally, in the case that the checksum
    is not offloable, the function can call skb_checksum_help to resolve
    the checksum. skb_csum_offload_chk also returns whether the checksum
    refers to an encapsulated checksum.
  - Definition of skb_csum_offl_spec structure that caller uses to
    indicate rules about what it can offload (e.g. IPv4/v6, TCP/UDP only,
    whether encapsulated checksums can be offloaded, whether checksum with
    IPv6 extension headers can be offloaded).
  - Ancilary functions called skb_csum_offload_chk_help,
    skb_csum_off_chk_help_cmn, skb_csum_off_chk_help_cmn_v4_only.

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

include/linux/netdevice.h

+78 −0
Original line number Diff line number Diff line
@@ -2522,6 +2522,71 @@ static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb, 
	remcsum_unadjust((__sum16 *)ptr, grc->delta);

}



struct skb_csum_offl_spec {

	__u16		ipv4_okay:1,

			ipv6_okay:1,

			encap_okay:1,

			ip_options_okay:1,

			ext_hdrs_okay:1,

			tcp_okay:1,

			udp_okay:1,

			sctp_okay:1,

			vlan_okay:1,

			no_encapped_ipv6:1,

			no_not_encapped:1;

};



bool __skb_csum_offload_chk(struct sk_buff *skb,

			    const struct skb_csum_offl_spec *spec,

			    bool *csum_encapped,

			    bool csum_help);



static inline bool skb_csum_offload_chk(struct sk_buff *skb,

					const struct skb_csum_offl_spec *spec,

					bool *csum_encapped,

					bool csum_help)

{

	if (skb->ip_summed != CHECKSUM_PARTIAL)

		return false;



	return __skb_csum_offload_chk(skb, spec, csum_encapped, csum_help);

}



static inline bool skb_csum_offload_chk_help(struct sk_buff *skb,

					     const struct skb_csum_offl_spec *spec)

{

	bool csum_encapped;



	return skb_csum_offload_chk(skb, spec, &csum_encapped, true);

}



static inline bool skb_csum_off_chk_help_cmn(struct sk_buff *skb)

{

	static const struct skb_csum_offl_spec csum_offl_spec = {

		.ipv4_okay = 1,

		.ip_options_okay = 1,

		.ipv6_okay = 1,

		.vlan_okay = 1,

		.tcp_okay = 1,

		.udp_okay = 1,

	};



	return skb_csum_offload_chk_help(skb, &csum_offl_spec);

}



static inline bool skb_csum_off_chk_help_cmn_v4_only(struct sk_buff *skb)

{

	static const struct skb_csum_offl_spec csum_offl_spec = {

		.ipv4_okay = 1,

		.ip_options_okay = 1,

		.tcp_okay = 1,

		.udp_okay = 1,

		.vlan_okay = 1,

	};



	return skb_csum_offload_chk_help(skb, &csum_offl_spec);

}



static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,

				  unsigned short type,

				  const void *daddr, const void *saddr,
@@ -3711,6 +3776,19 @@ static inline bool can_checksum_protocol(netdev_features_t features, 
	}

}



/* Map an ethertype into IP protocol if possible */

static inline int eproto_to_ipproto(int eproto)

{

	switch (eproto) {

	case htons(ETH_P_IP):

		return IPPROTO_IP;

	case htons(ETH_P_IPV6):

		return IPPROTO_IPV6;

	default:

		return -1;

	}

}



#ifdef CONFIG_BUG

void netdev_rx_csum_fault(struct net_device *dev);

#else

net/core/dev.c

+136 −0
Original line number Diff line number Diff line
@@ -138,6 +138,7 @@ 
#include <linux/errqueue.h>

#include <linux/hrtimer.h>

#include <linux/netfilter_ingress.h>

#include <linux/sctp.h>



#include "net-sysfs.h"
@@ -2471,6 +2472,141 @@ int skb_checksum_help(struct sk_buff *skb) 
}

EXPORT_SYMBOL(skb_checksum_help);



/* skb_csum_offload_check - Driver helper function to determine if a device

 * with limited checksum offload capabilities is able to offload the checksum

 * for a given packet.

 *

 * Arguments:

 *   skb - sk_buff for the packet in question

 *   spec - contains the description of what device can offload

 *   csum_encapped - returns true if the checksum being offloaded is

 *	      encpasulated. That is it is checksum for the transport header

 *	      in the inner headers.

 *   checksum_help - when set indicates that helper function should

 *	      call skb_checksum_help if offload checks fail

 *

 * Returns:

 *   true: Packet has passed the checksum checks and should be offloadable to

 *	   the device (a driver may still need to check for additional

 *	   restrictions of its device)

 *   false: Checksum is not offloadable. If checksum_help was set then

 *	   skb_checksum_help was called to resolve checksum for non-GSO

 *	   packets and when IP protocol is not SCTP

 */

bool __skb_csum_offload_chk(struct sk_buff *skb,

			    const struct skb_csum_offl_spec *spec,

			    bool *csum_encapped,

			    bool csum_help)

{

	struct iphdr *iph;

	struct ipv6hdr *ipv6;

	void *nhdr;

	int protocol;

	u8 ip_proto;



	if (skb->protocol == htons(ETH_P_8021Q) ||

	    skb->protocol == htons(ETH_P_8021AD)) {

		if (!spec->vlan_okay)

			goto need_help;

	}



	/* We check whether the checksum refers to a transport layer checksum in

	 * the outermost header or an encapsulated transport layer checksum that

	 * corresponds to the inner headers of the skb. If the checksum is for

	 * something else in the packet we need help.

	 */

	if (skb_checksum_start_offset(skb) == skb_transport_offset(skb)) {

		/* Non-encapsulated checksum */

		protocol = eproto_to_ipproto(vlan_get_protocol(skb));

		nhdr = skb_network_header(skb);

		*csum_encapped = false;

		if (spec->no_not_encapped)

			goto need_help;

	} else if (skb->encapsulation && spec->encap_okay &&

		   skb_checksum_start_offset(skb) ==

		   skb_inner_transport_offset(skb)) {

		/* Encapsulated checksum */

		*csum_encapped = true;

		switch (skb->inner_protocol_type) {

		case ENCAP_TYPE_ETHER:

			protocol = eproto_to_ipproto(skb->inner_protocol);

			break;

		case ENCAP_TYPE_IPPROTO:

			protocol = skb->inner_protocol;

			break;

		}

		nhdr = skb_inner_network_header(skb);

	} else {

		goto need_help;

	}



	switch (protocol) {

	case IPPROTO_IP:

		if (!spec->ipv4_okay)

			goto need_help;

		iph = nhdr;

		ip_proto = iph->protocol;

		if (iph->ihl != 5 && !spec->ip_options_okay)

			goto need_help;

		break;

	case IPPROTO_IPV6:

		if (!spec->ipv6_okay)

			goto need_help;

		if (spec->no_encapped_ipv6 && *csum_encapped)

			goto need_help;

		ipv6 = nhdr;

		nhdr += sizeof(*ipv6);

		ip_proto = ipv6->nexthdr;

		break;

	default:

		goto need_help;

	}



ip_proto_again:

	switch (ip_proto) {

	case IPPROTO_TCP:

		if (!spec->tcp_okay ||

		    skb->csum_offset != offsetof(struct tcphdr, check))

			goto need_help;

		break;

	case IPPROTO_UDP:

		if (!spec->udp_okay ||

		    skb->csum_offset != offsetof(struct udphdr, check))

			goto need_help;

		break;

	case IPPROTO_SCTP:

		if (!spec->sctp_okay ||

		    skb->csum_offset != offsetof(struct sctphdr, checksum))

			goto cant_help;

		break;

	case NEXTHDR_HOP:

	case NEXTHDR_ROUTING:

	case NEXTHDR_DEST: {

		u8 *opthdr = nhdr;



		if (protocol != IPPROTO_IPV6 || !spec->ext_hdrs_okay)

			goto need_help;



		ip_proto = opthdr[0];

		nhdr += (opthdr[1] + 1) << 3;



		goto ip_proto_again;

	}

	default:

		goto need_help;

	}



	/* Passed the tests for offloading checksum */

	return true;



need_help:

	if (csum_help && !skb_shinfo(skb)->gso_size)

		skb_checksum_help(skb);

cant_help:

	return false;

}

EXPORT_SYMBOL(__skb_csum_offload_chk);



__be16 skb_network_protocol(struct sk_buff *skb, int *depth)

{

	__be16 type = skb->protocol;