Commit 9fb426a6 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'gso_send_check' 



Tom Herbert says:

====================
net: Eliminate gso_send_check

gso_send_check presents a lot of complexity for what it is being used
for. It seems that there are only two cases where it might be effective:
TCP and UFO paths. In these cases, the gso_send_check function
initializes the TCP or UDP checksum respectively to the pseudo header
checksum so that the checksum computation is appropriately offloaded or
computed in the gso_segment functions. The gso_send_check functions
are only called from dev.c in skb_mac_gso_segment when ip_summed !=
CHECKSUM_PARTIAL (which seems very unlikely in TCP case). We can move
the logic of this into the respective gso_segment functions where the
checksum is initialized if ip_summed != CHECKSUM_PARTIAL.

With the above cases handled, gso_send_check is no longer needed, so
we can remove all uses of it and the fields in the offload callbacks.
With this change, ip_summed in the skb should be preserved though all
the layers of gso_segment calls.

In follow-on patches, we may be able to remove the check setup code in
tcp_gso_segment if we can guarantee that ip_summed will always be
CHECKSUM_PARTIAL (verify all paths and probably add an assert in
tcp_gro_segment).

Tested these patches by:
  - netperf TCP_STREAM test with GSO enabled
  - Forced ip_summed != CHECKSUM_PARTIAL with above
  - Ran UDP_RR with 10000 request size over GRE tunnel. This exercised
    UFO path.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 2fdbfea5 53e50398

include/linux/netdevice.h

+0 −1
Original line number Diff line number Diff line
@@ -1911,7 +1911,6 @@ struct packet_type { 
struct offload_callbacks {

	struct sk_buff		*(*gso_segment)(struct sk_buff *skb,

						netdev_features_t features);

	int			(*gso_send_check)(struct sk_buff *skb);

	struct sk_buff		**(*gro_receive)(struct sk_buff **head,

					       struct sk_buff *skb);

	int			(*gro_complete)(struct sk_buff *skb, int nhoff);

net/core/dev.c

+0 −10
Original line number Diff line number Diff line
@@ -2422,16 +2422,6 @@ struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb, 
	rcu_read_lock();

	list_for_each_entry_rcu(ptype, &offload_base, list) {

		if (ptype->type == type && ptype->callbacks.gso_segment) {

			if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {

				int err;



				err = ptype->callbacks.gso_send_check(skb);

				segs = ERR_PTR(err);

				if (err || skb_gso_ok(skb, features))

					break;

				__skb_push(skb, (skb->data -

						 skb_network_header(skb)));

			}

			segs = ptype->callbacks.gso_segment(skb, features);

			break;

		}

net/ipv4/af_inet.c

+0 −36
Original line number Diff line number Diff line
@@ -1197,40 +1197,6 @@ int inet_sk_rebuild_header(struct sock *sk) 
}

EXPORT_SYMBOL(inet_sk_rebuild_header);



static int inet_gso_send_check(struct sk_buff *skb)

{

	const struct net_offload *ops;

	const struct iphdr *iph;

	int proto;

	int ihl;

	int err = -EINVAL;



	if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))

		goto out;



	iph = ip_hdr(skb);

	ihl = iph->ihl * 4;

	if (ihl < sizeof(*iph))

		goto out;



	proto = iph->protocol;



	/* Warning: after this point, iph might be no longer valid */

	if (unlikely(!pskb_may_pull(skb, ihl)))

		goto out;

	__skb_pull(skb, ihl);



	skb_reset_transport_header(skb);

	err = -EPROTONOSUPPORT;



	ops = rcu_dereference(inet_offloads[proto]);

	if (likely(ops && ops->callbacks.gso_send_check))

		err = ops->callbacks.gso_send_check(skb);



out:

	return err;

}



static struct sk_buff *inet_gso_segment(struct sk_buff *skb,

					netdev_features_t features)

{
@@ -1655,7 +1621,6 @@ static int ipv4_proc_init(void); 
static struct packet_offload ip_packet_offload __read_mostly = {

	.type = cpu_to_be16(ETH_P_IP),

	.callbacks = {

		.gso_send_check = inet_gso_send_check,

		.gso_segment = inet_gso_segment,

		.gro_receive = inet_gro_receive,

		.gro_complete = inet_gro_complete,
@@ -1664,7 +1629,6 @@ static struct packet_offload ip_packet_offload __read_mostly = { 


static const struct net_offload ipip_offload = {

	.callbacks = {

		.gso_send_check = inet_gso_send_check,

		.gso_segment	= inet_gso_segment,

		.gro_receive	= inet_gro_receive,

		.gro_complete	= inet_gro_complete,

net/ipv4/gre_offload.c

+3 −8
Original line number Diff line number Diff line
@@ -15,13 +15,6 @@ 
#include <net/protocol.h>

#include <net/gre.h>



static int gre_gso_send_check(struct sk_buff *skb)

{

	if (!skb->encapsulation)

		return -EINVAL;

	return 0;

}



static struct sk_buff *gre_gso_segment(struct sk_buff *skb,

				       netdev_features_t features)

{
@@ -46,6 +39,9 @@ static struct sk_buff *gre_gso_segment(struct sk_buff *skb, 
				  SKB_GSO_IPIP)))

		goto out;



	if (!skb->encapsulation)

		goto out;



	if (unlikely(!pskb_may_pull(skb, sizeof(*greh))))

		goto out;
@@ -256,7 +252,6 @@ static int gre_gro_complete(struct sk_buff *skb, int nhoff) 


static const struct net_offload gre_offload = {

	.callbacks = {

		.gso_send_check = gre_gso_send_check,

		.gso_segment = gre_gso_segment,

		.gro_receive = gre_gro_receive,

		.gro_complete = gre_gro_complete,

net/ipv4/tcp_offload.c

+23 −22
Original line number Diff line number Diff line
@@ -29,6 +29,28 @@ static void tcp_gso_tstamp(struct sk_buff *skb, unsigned int ts_seq, 
	}

}



struct sk_buff *tcp4_gso_segment(struct sk_buff *skb,

				 netdev_features_t features)

{

	if (!pskb_may_pull(skb, sizeof(struct tcphdr)))

		return ERR_PTR(-EINVAL);



	if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {

		const struct iphdr *iph = ip_hdr(skb);

		struct tcphdr *th = tcp_hdr(skb);



		/* Set up checksum pseudo header, usually expect stack to

		 * have done this already.

		 */



		th->check = 0;

		skb->ip_summed = CHECKSUM_PARTIAL;

		__tcp_v4_send_check(skb, iph->saddr, iph->daddr);

	}



	return tcp_gso_segment(skb, features);

}



struct sk_buff *tcp_gso_segment(struct sk_buff *skb,

				netdev_features_t features)

{
@@ -44,9 +66,6 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb, 
	__sum16 newcheck;

	bool ooo_okay, copy_destructor;



	if (!pskb_may_pull(skb, sizeof(*th)))

		goto out;



	th = tcp_hdr(skb);

	thlen = th->doff * 4;

	if (thlen < sizeof(*th))
@@ -269,23 +288,6 @@ int tcp_gro_complete(struct sk_buff *skb) 
}

EXPORT_SYMBOL(tcp_gro_complete);



static int tcp_v4_gso_send_check(struct sk_buff *skb)

{

	const struct iphdr *iph;

	struct tcphdr *th;



	if (!pskb_may_pull(skb, sizeof(*th)))

		return -EINVAL;



	iph = ip_hdr(skb);

	th = tcp_hdr(skb);



	th->check = 0;

	skb->ip_summed = CHECKSUM_PARTIAL;

	__tcp_v4_send_check(skb, iph->saddr, iph->daddr);

	return 0;

}



static struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)

{

	/* Don't bother verifying checksum if we're going to flush anyway. */
@@ -313,8 +315,7 @@ static int tcp4_gro_complete(struct sk_buff *skb, int thoff) 


static const struct net_offload tcpv4_offload = {

	.callbacks = {

		.gso_send_check	=	tcp_v4_gso_send_check,

		.gso_segment	=	tcp_gso_segment,

		.gso_segment	=	tcp4_gso_segment,

		.gro_receive	=	tcp4_gro_receive,

		.gro_complete	=	tcp4_gro_complete,

	},

CRA Git | Maintained and supported by SUSTech CRA and CCSE