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

Commit 2ba38943 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'eth_get_headlen' 



Alexander Duyck says:

====================
net: Drop get_headlen functions in favor of generic function

This series replaces the igb_get_headlen and ixgbe_get_headlen functions
with a generic function named eth_get_headlen.

I have done some performance testing on ixgbe with 258 byte frames since
the calls are only used on frames larger than 256 bytes and have seen no
significant difference in CPU utilization.

v2: renamed __skb_get_poff to skb_get_poff
    renamed ___skb_get_poff to __skb_get_poff
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 2c048e64 8496e338

drivers/net/ethernet/intel/igb/igb_main.c

+1 −108
Original line number Diff line number Diff line
@@ -6768,113 +6768,6 @@ static bool igb_is_non_eop(struct igb_ring *rx_ring, 
	return true;

}



/**

 *  igb_get_headlen - determine size of header for LRO/GRO

 *  @data: pointer to the start of the headers

 *  @max_len: total length of section to find headers in

 *

 *  This function is meant to determine the length of headers that will

 *  be recognized by hardware for LRO, and GRO offloads.  The main

 *  motivation of doing this is to only perform one pull for IPv4 TCP

 *  packets so that we can do basic things like calculating the gso_size

 *  based on the average data per packet.

 **/

static unsigned int igb_get_headlen(unsigned char *data,

				    unsigned int max_len)

{

	union {

		unsigned char *network;

		/* l2 headers */

		struct ethhdr *eth;

		struct vlan_hdr *vlan;

		/* l3 headers */

		struct iphdr *ipv4;

		struct ipv6hdr *ipv6;

	} hdr;

	__be16 protocol;

	u8 nexthdr = 0;	/* default to not TCP */

	u8 hlen;



	/* this should never happen, but better safe than sorry */

	if (max_len < ETH_HLEN)

		return max_len;



	/* initialize network frame pointer */

	hdr.network = data;



	/* set first protocol and move network header forward */

	protocol = hdr.eth->h_proto;

	hdr.network += ETH_HLEN;



	/* handle any vlan tag if present */

	if (protocol == htons(ETH_P_8021Q)) {

		if ((hdr.network - data) > (max_len - VLAN_HLEN))

			return max_len;



		protocol = hdr.vlan->h_vlan_encapsulated_proto;

		hdr.network += VLAN_HLEN;

	}



	/* handle L3 protocols */

	if (protocol == htons(ETH_P_IP)) {

		if ((hdr.network - data) > (max_len - sizeof(struct iphdr)))

			return max_len;



		/* access ihl as a u8 to avoid unaligned access on ia64 */

		hlen = (hdr.network[0] & 0x0F) << 2;



		/* verify hlen meets minimum size requirements */

		if (hlen < sizeof(struct iphdr))

			return hdr.network - data;



		/* record next protocol if header is present */

		if (!(hdr.ipv4->frag_off & htons(IP_OFFSET)))

			nexthdr = hdr.ipv4->protocol;

	} else if (protocol == htons(ETH_P_IPV6)) {

		if ((hdr.network - data) > (max_len - sizeof(struct ipv6hdr)))

			return max_len;



		/* record next protocol */

		nexthdr = hdr.ipv6->nexthdr;

		hlen = sizeof(struct ipv6hdr);

	} else {

		return hdr.network - data;

	}



	/* relocate pointer to start of L4 header */

	hdr.network += hlen;



	/* finally sort out TCP */

	if (nexthdr == IPPROTO_TCP) {

		if ((hdr.network - data) > (max_len - sizeof(struct tcphdr)))

			return max_len;



		/* access doff as a u8 to avoid unaligned access on ia64 */

		hlen = (hdr.network[12] & 0xF0) >> 2;



		/* verify hlen meets minimum size requirements */

		if (hlen < sizeof(struct tcphdr))

			return hdr.network - data;



		hdr.network += hlen;

	} else if (nexthdr == IPPROTO_UDP) {

		if ((hdr.network - data) > (max_len - sizeof(struct udphdr)))

			return max_len;



		hdr.network += sizeof(struct udphdr);

	}



	/* If everything has gone correctly hdr.network should be the

	 * data section of the packet and will be the end of the header.

	 * If not then it probably represents the end of the last recognized

	 * header.

	 */

	if ((hdr.network - data) < max_len)

		return hdr.network - data;

	else

		return max_len;

}



/**

 *  igb_pull_tail - igb specific version of skb_pull_tail

 *  @rx_ring: rx descriptor ring packet is being transacted on
@@ -6919,7 +6812,7 @@ static void igb_pull_tail(struct igb_ring *rx_ring, 
	/* we need the header to contain the greater of either ETH_HLEN or

	 * 60 bytes if the skb->len is less than 60 for skb_pad.

	 */

	pull_len = igb_get_headlen(va, IGB_RX_HDR_LEN);

	pull_len = eth_get_headlen(va, IGB_RX_HDR_LEN);



	/* align pull length to size of long to optimize memcpy performance */

	skb_copy_to_linear_data(skb, va, ALIGN(pull_len, sizeof(long)));

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

+1 −115
Original line number Diff line number Diff line
@@ -1521,120 +1521,6 @@ void ixgbe_alloc_rx_buffers(struct ixgbe_ring *rx_ring, u16 cleaned_count) 
		ixgbe_release_rx_desc(rx_ring, i);

}



/**

 * ixgbe_get_headlen - determine size of header for RSC/LRO/GRO/FCOE

 * @data: pointer to the start of the headers

 * @max_len: total length of section to find headers in

 *

 * This function is meant to determine the length of headers that will

 * be recognized by hardware for LRO, GRO, and RSC offloads.  The main

 * motivation of doing this is to only perform one pull for IPv4 TCP

 * packets so that we can do basic things like calculating the gso_size

 * based on the average data per packet.

 **/

static unsigned int ixgbe_get_headlen(unsigned char *data,

				      unsigned int max_len)

{

	union {

		unsigned char *network;

		/* l2 headers */

		struct ethhdr *eth;

		struct vlan_hdr *vlan;

		/* l3 headers */

		struct iphdr *ipv4;

		struct ipv6hdr *ipv6;

	} hdr;

	__be16 protocol;

	u8 nexthdr = 0;	/* default to not TCP */

	u8 hlen;



	/* this should never happen, but better safe than sorry */

	if (max_len < ETH_HLEN)

		return max_len;



	/* initialize network frame pointer */

	hdr.network = data;



	/* set first protocol and move network header forward */

	protocol = hdr.eth->h_proto;

	hdr.network += ETH_HLEN;



	/* handle any vlan tag if present */

	if (protocol == htons(ETH_P_8021Q)) {

		if ((hdr.network - data) > (max_len - VLAN_HLEN))

			return max_len;



		protocol = hdr.vlan->h_vlan_encapsulated_proto;

		hdr.network += VLAN_HLEN;

	}



	/* handle L3 protocols */

	if (protocol == htons(ETH_P_IP)) {

		if ((hdr.network - data) > (max_len - sizeof(struct iphdr)))

			return max_len;



		/* access ihl as a u8 to avoid unaligned access on ia64 */

		hlen = (hdr.network[0] & 0x0F) << 2;



		/* verify hlen meets minimum size requirements */

		if (hlen < sizeof(struct iphdr))

			return hdr.network - data;



		/* record next protocol if header is present */

		if (!(hdr.ipv4->frag_off & htons(IP_OFFSET)))

			nexthdr = hdr.ipv4->protocol;

	} else if (protocol == htons(ETH_P_IPV6)) {

		if ((hdr.network - data) > (max_len - sizeof(struct ipv6hdr)))

			return max_len;



		/* record next protocol */

		nexthdr = hdr.ipv6->nexthdr;

		hlen = sizeof(struct ipv6hdr);

#ifdef IXGBE_FCOE

	} else if (protocol == htons(ETH_P_FCOE)) {

		if ((hdr.network - data) > (max_len - FCOE_HEADER_LEN))

			return max_len;

		hlen = FCOE_HEADER_LEN;

#endif

	} else {

		return hdr.network - data;

	}



	/* relocate pointer to start of L4 header */

	hdr.network += hlen;



	/* finally sort out TCP/UDP */

	if (nexthdr == IPPROTO_TCP) {

		if ((hdr.network - data) > (max_len - sizeof(struct tcphdr)))

			return max_len;



		/* access doff as a u8 to avoid unaligned access on ia64 */

		hlen = (hdr.network[12] & 0xF0) >> 2;



		/* verify hlen meets minimum size requirements */

		if (hlen < sizeof(struct tcphdr))

			return hdr.network - data;



		hdr.network += hlen;

	} else if (nexthdr == IPPROTO_UDP) {

		if ((hdr.network - data) > (max_len - sizeof(struct udphdr)))

			return max_len;



		hdr.network += sizeof(struct udphdr);

	}



	/*

	 * If everything has gone correctly hdr.network should be the

	 * data section of the packet and will be the end of the header.

	 * If not then it probably represents the end of the last recognized

	 * header.

	 */

	if ((hdr.network - data) < max_len)

		return hdr.network - data;

	else

		return max_len;

}



static void ixgbe_set_rsc_gso_size(struct ixgbe_ring *ring,

				   struct sk_buff *skb)

{
@@ -1793,7 +1679,7 @@ static void ixgbe_pull_tail(struct ixgbe_ring *rx_ring, 
	 * we need the header to contain the greater of either ETH_HLEN or

	 * 60 bytes if the skb->len is less than 60 for skb_pad.

	 */

	pull_len = ixgbe_get_headlen(va, IXGBE_RX_HDR_SIZE);

	pull_len = eth_get_headlen(va, IXGBE_RX_HDR_SIZE);



	/* align pull length to size of long to optimize memcpy performance */

	skb_copy_to_linear_data(skb, va, ALIGN(pull_len, sizeof(long)));

include/linux/etherdevice.h

+1 −0
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <asm/bitsperlong.h>



#ifdef __KERNEL__

u32 eth_get_headlen(void *data, unsigned int max_len);

__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);

extern const struct header_ops eth_header_ops;

include/linux/skbuff.h

+3 −1
Original line number Diff line number Diff line
@@ -3218,7 +3218,9 @@ bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off); 


int skb_checksum_setup(struct sk_buff *skb, bool recalculate);



u32 __skb_get_poff(const struct sk_buff *skb);

u32 skb_get_poff(const struct sk_buff *skb);

u32 __skb_get_poff(const struct sk_buff *skb, void *data,

		   const struct flow_keys *keys, int hlen);



/**

 * skb_head_is_locked - Determine if the skb->head is locked down

include/net/flow_keys.h

+2 −0
Original line number Diff line number Diff line
@@ -40,4 +40,6 @@ static inline __be32 skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 
	return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);

}

u32 flow_hash_from_keys(struct flow_keys *keys);

unsigned int flow_get_hlen(const unsigned char *data, unsigned int max_len,

			   __be16 protocol);

#endif