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

Commit 07b26c94 authored by Steffen Klassert's avatar Steffen Klassert Committed by David S. Miller
Browse files

gso: Support partial splitting at the frag_list pointer 



Since commit 8a29111c ("net: gro: allow to build full sized skb")
gro may build buffers with a frag_list. This can hurt forwarding
because most NICs can't offload such packets, they need to be
segmented in software. This patch splits buffers with a frag_list
at the frag_list pointer into buffers that can be TSO offloaded.

Signed-off-by: default avatarSteffen Klassert <steffen.klassert@secunet.com>
Acked-by: default avatarAlexander Duyck <alexander.h.duyck@intel.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent e867e87a

net/core/skbuff.c

+40 −11
Original line number Original line Diff line number Diff line
@@ -3097,11 +3097,31 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb, 
	sg = !!(features & NETIF_F_SG);

	sg = !!(features & NETIF_F_SG);

	csum = !!can_checksum_protocol(features, proto);

	csum = !!can_checksum_protocol(features, proto);





	if (sg && csum && (mss != GSO_BY_FRAGS))  {

		if (!(features & NETIF_F_GSO_PARTIAL)) {

			struct sk_buff *iter;



			if (!list_skb ||

			    !net_gso_ok(features, skb_shinfo(head_skb)->gso_type))

				goto normal;



			/* Split the buffer at the frag_list pointer.

			 * This is based on the assumption that all

			 * buffers in the chain excluding the last

			 * containing the same amount of data.

			 */

			skb_walk_frags(head_skb, iter) {

				if (skb_headlen(iter))

					goto normal;



				len -= iter->len;

			}

		}



		/* GSO partial only requires that we trim off any excess that

		/* GSO partial only requires that we trim off any excess that

		 * doesn't fit into an MSS sized block, so take care of that

		 * doesn't fit into an MSS sized block, so take care of that

		 * now.

		 * now.

		 */

		 */

	if (sg && csum && (features & NETIF_F_GSO_PARTIAL)) {

		partial_segs = len / mss;

		partial_segs = len / mss;

		if (partial_segs > 1)

		if (partial_segs > 1)

			mss *= partial_segs;

			mss *= partial_segs;
@@ -3109,6 +3129,7 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb, 
			partial_segs = 0;

			partial_segs = 0;

	}

	}





normal:

	headroom = skb_headroom(head_skb);

	headroom = skb_headroom(head_skb);

	pos = skb_headlen(head_skb);

	pos = skb_headlen(head_skb);
@@ -3300,21 +3321,29 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb, 
	 */

	 */

	segs->prev = tail;

	segs->prev = tail;





	/* Update GSO info on first skb in partial sequence. */

	if (partial_segs) {

	if (partial_segs) {

		struct sk_buff *iter;

		int type = skb_shinfo(head_skb)->gso_type;

		int type = skb_shinfo(head_skb)->gso_type;

		unsigned short gso_size = skb_shinfo(head_skb)->gso_size;





		/* Update type to add partial and then remove dodgy if set */

		/* Update type to add partial and then remove dodgy if set */

		type |= SKB_GSO_PARTIAL;

		type |= (features & NETIF_F_GSO_PARTIAL) / NETIF_F_GSO_PARTIAL * SKB_GSO_PARTIAL;

		type &= ~SKB_GSO_DODGY;

		type &= ~SKB_GSO_DODGY;





		/* Update GSO info and prepare to start updating headers on

		/* Update GSO info and prepare to start updating headers on

		 * our way back down the stack of protocols.

		 * our way back down the stack of protocols.

		 */

		 */

		skb_shinfo(segs)->gso_size = skb_shinfo(head_skb)->gso_size;

		for (iter = segs; iter; iter = iter->next) {

		skb_shinfo(segs)->gso_segs = partial_segs;

			skb_shinfo(iter)->gso_size = gso_size;

		skb_shinfo(segs)->gso_type = type;

			skb_shinfo(iter)->gso_segs = partial_segs;

		SKB_GSO_CB(segs)->data_offset = skb_headroom(segs) + doffset;

			skb_shinfo(iter)->gso_type = type;

			SKB_GSO_CB(iter)->data_offset = skb_headroom(iter) + doffset;

		}



		if (tail->len - doffset <= gso_size)

			skb_shinfo(tail)->gso_size = 0;

		else if (tail != segs)

			skb_shinfo(tail)->gso_segs = DIV_ROUND_UP(tail->len - doffset, gso_size);

	}

	}





	/* Following permits correct backpressure, for protocols

	/* Following permits correct backpressure, for protocols

net/ipv4/af_inet.c

+10 −4
Original line number Original line Diff line number Diff line
@@ -1192,7 +1192,7 @@ EXPORT_SYMBOL(inet_sk_rebuild_header); 
struct sk_buff *inet_gso_segment(struct sk_buff *skb,

struct sk_buff *inet_gso_segment(struct sk_buff *skb,

				 netdev_features_t features)

				 netdev_features_t features)

{

{

	bool udpfrag = false, fixedid = false, encap;

	bool udpfrag = false, fixedid = false, gso_partial, encap;

	struct sk_buff *segs = ERR_PTR(-EINVAL);

	struct sk_buff *segs = ERR_PTR(-EINVAL);

	const struct net_offload *ops;

	const struct net_offload *ops;

	unsigned int offset = 0;

	unsigned int offset = 0;
@@ -1245,6 +1245,8 @@ struct sk_buff *inet_gso_segment(struct sk_buff *skb, 
	if (IS_ERR_OR_NULL(segs))

	if (IS_ERR_OR_NULL(segs))

		goto out;

		goto out;





	gso_partial = !!(skb_shinfo(segs)->gso_type & SKB_GSO_PARTIAL);



	skb = segs;

	skb = segs;

	do {

	do {

		iph = (struct iphdr *)(skb_mac_header(skb) + nhoff);

		iph = (struct iphdr *)(skb_mac_header(skb) + nhoff);
@@ -1259,9 +1261,13 @@ struct sk_buff *inet_gso_segment(struct sk_buff *skb, 
				iph->id = htons(id);

				iph->id = htons(id);

				id += skb_shinfo(skb)->gso_segs;

				id += skb_shinfo(skb)->gso_segs;

			}

			}



			if (gso_partial)

				tot_len = skb_shinfo(skb)->gso_size +

				tot_len = skb_shinfo(skb)->gso_size +

					  SKB_GSO_CB(skb)->data_offset +

					  SKB_GSO_CB(skb)->data_offset +

					  skb->head - (unsigned char *)iph;

					  skb->head - (unsigned char *)iph;

			else

				tot_len = skb->len - nhoff;

		} else {

		} else {

			if (!fixedid)

			if (!fixedid)

				iph->id = htons(id++);

				iph->id = htons(id++);

net/ipv4/gre_offload.c

+4 −2
Original line number Original line Diff line number Diff line
@@ -24,7 +24,7 @@ static struct sk_buff *gre_gso_segment(struct sk_buff *skb, 
	__be16 protocol = skb->protocol;

	__be16 protocol = skb->protocol;

	u16 mac_len = skb->mac_len;

	u16 mac_len = skb->mac_len;

	int gre_offset, outer_hlen;

	int gre_offset, outer_hlen;

	bool need_csum, ufo;

	bool need_csum, ufo, gso_partial;





	if (!skb->encapsulation)

	if (!skb->encapsulation)

		goto out;

		goto out;
@@ -69,6 +69,8 @@ static struct sk_buff *gre_gso_segment(struct sk_buff *skb, 
		goto out;

		goto out;

	}

	}





	gso_partial = !!(skb_shinfo(segs)->gso_type & SKB_GSO_PARTIAL);



	outer_hlen = skb_tnl_header_len(skb);

	outer_hlen = skb_tnl_header_len(skb);

	gre_offset = outer_hlen - tnl_hlen;

	gre_offset = outer_hlen - tnl_hlen;

	skb = segs;

	skb = segs;
@@ -96,7 +98,7 @@ static struct sk_buff *gre_gso_segment(struct sk_buff *skb, 
		greh = (struct gre_base_hdr *)skb_transport_header(skb);

		greh = (struct gre_base_hdr *)skb_transport_header(skb);

		pcsum = (__sum16 *)(greh + 1);

		pcsum = (__sum16 *)(greh + 1);





		if (skb_is_gso(skb)) {

		if (gso_partial) {

			unsigned int partial_adj;

			unsigned int partial_adj;





			/* Adjust checksum to account for the fact that

			/* Adjust checksum to account for the fact that

net/ipv4/tcp_offload.c

+7 −6
Original line number Original line Diff line number Diff line
@@ -90,12 +90,6 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb, 
		goto out;

		goto out;

	}

	}





	/* GSO partial only requires splitting the frame into an MSS

	 * multiple and possibly a remainder.  So update the mss now.

	 */

	if (features & NETIF_F_GSO_PARTIAL)

		mss = skb->len - (skb->len % mss);



	copy_destructor = gso_skb->destructor == tcp_wfree;

	copy_destructor = gso_skb->destructor == tcp_wfree;

	ooo_okay = gso_skb->ooo_okay;

	ooo_okay = gso_skb->ooo_okay;

	/* All segments but the first should have ooo_okay cleared */

	/* All segments but the first should have ooo_okay cleared */
@@ -108,6 +102,13 @@ struct sk_buff *tcp_gso_segment(struct sk_buff *skb, 
	/* Only first segment might have ooo_okay set */

	/* Only first segment might have ooo_okay set */

	segs->ooo_okay = ooo_okay;

	segs->ooo_okay = ooo_okay;





	/* GSO partial and frag_list segmentation only requires splitting

	 * the frame into an MSS multiple and possibly a remainder, both

	 * cases return a GSO skb. So update the mss now.

	 */

	if (skb_is_gso(segs))

		mss *= skb_shinfo(segs)->gso_segs;



	delta = htonl(oldlen + (thlen + mss));

	delta = htonl(oldlen + (thlen + mss));





	skb = segs;

	skb = segs;

net/ipv4/udp_offload.c

+4 −2
Original line number Original line Diff line number Diff line
@@ -21,7 +21,7 @@ static struct sk_buff *__skb_udp_tunnel_segment(struct sk_buff *skb, 
	__be16 new_protocol, bool is_ipv6)

	__be16 new_protocol, bool is_ipv6)

{

{

	int tnl_hlen = skb_inner_mac_header(skb) - skb_transport_header(skb);

	int tnl_hlen = skb_inner_mac_header(skb) - skb_transport_header(skb);

	bool remcsum, need_csum, offload_csum, ufo;

	bool remcsum, need_csum, offload_csum, ufo, gso_partial;

	struct sk_buff *segs = ERR_PTR(-EINVAL);

	struct sk_buff *segs = ERR_PTR(-EINVAL);

	struct udphdr *uh = udp_hdr(skb);

	struct udphdr *uh = udp_hdr(skb);

	u16 mac_offset = skb->mac_header;

	u16 mac_offset = skb->mac_header;
@@ -88,6 +88,8 @@ static struct sk_buff *__skb_udp_tunnel_segment(struct sk_buff *skb, 
		goto out;

		goto out;

	}

	}





	gso_partial = !!(skb_shinfo(segs)->gso_type & SKB_GSO_PARTIAL);



	outer_hlen = skb_tnl_header_len(skb);

	outer_hlen = skb_tnl_header_len(skb);

	udp_offset = outer_hlen - tnl_hlen;

	udp_offset = outer_hlen - tnl_hlen;

	skb = segs;

	skb = segs;
@@ -117,7 +119,7 @@ static struct sk_buff *__skb_udp_tunnel_segment(struct sk_buff *skb, 
		 * will be using a length value equal to only one MSS sized

		 * will be using a length value equal to only one MSS sized

		 * segment instead of the entire frame.

		 * segment instead of the entire frame.

		 */

		 */

		if (skb_is_gso(skb)) {

		if (gso_partial) {

			uh->len = htons(skb_shinfo(skb)->gso_size +

			uh->len = htons(skb_shinfo(skb)->gso_size +

					SKB_GSO_CB(skb)->data_offset +

					SKB_GSO_CB(skb)->data_offset +

					skb->head - (unsigned char *)uh);

					skb->head - (unsigned char *)uh);