gso/gro forwarding changeset
Subsystems (2)
cover gso/gro forwarding changeset
3.10 does not aggregate ~DF packets via GRO. However, as Marcelo Leitner pointed out to me we can still encounter GSO packets in fwd path in virtual environments where we receive GSO packet eg. via virtio.
Let me know if there are problems.
PATCH 1/3 net: add and use skb_gso_transport_seglen()
commit de960aa9ab4decc3304959f69533eef64d05d8e8 upstream.
[ no skb_gso_seglen helper in 3.10, leave tbf alone ]
This moves part of Eric Dumazets skb_gso_seglen helper from tbf sched to skbuff core so it may be reused by upcoming ip forwarding path patch.
--- include/linux/skbuff.h | 2 ++ net/core/skbuff.c | 25 +++++++++++++++++++++++++ 2 files changed, 27 insertions(+)
include/linux/skbuff.h +2 -0
@@ -2488,6 +2488,8 @@ extern int skb_shift(struct sk_buff *tgt, struct sk_buff *skb,extern struct sk_buff *skb_segment (struct sk_buff *skb,netdev_features_t features); +unsigned int skb_gso_transport_seglen (const struct sk_buff *skb); +static inline void *skb_header_pointer (const struct sk_buff *skb,int offset,int len,void *buffer) {
net/core/skbuff.c +25 -0
@@ -47,6 +47,8 @@#include <linux/in.h> #include <linux/inet.h> #include <linux/slab.h> +#include <linux/tcp.h> +#include <linux/udp.h> #include <linux/netdevice.h> #ifdef CONFIG_NET_CLS_ACT #include <net/pkt_sched.h>
@@ -3471,3 +3473,26 @@ bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,return true; }EXPORT_SYMBOL (skb_try_coalesce); + +/** +* skb_gso_transport_seglen - Return length of individual segments of a gso packet +* +* @skb: GSO skb +* +* skb_gso_transport_seglen is used to determine the real size of the +* individual segments, including Layer4 headers (TCP/UDP). +* +* The MAC/L2 or network (IP, IPv6) headers are not accounted for. +*/ +unsigned int skb_gso_transport_seglen (const struct sk_buff *skb) +{ +const struct skb_shared_info *shinfo =skb_shinfo (skb); +unsigned int hdr_len; + +if (likely (shinfo->gso_type & (SKB_GSO_TCPV4 |SKB_GSO_TCPV6 ))) + hdr_len =tcp_hdrlen (skb); +else + hdr_len =sizeof (struct udphdr ); +return hdr_len + shinfo->gso_size; +} +EXPORT_SYMBOL_GPL (skb_gso_transport_seglen);
Signature · 1 line
1.8.1.5
PATCH 2/3 net: core: introduce netif_skb_dev_features
In reply to Florian Westphalcommit d206940319c41df4299db75ed56142177bb2e5f6 upstream.
Will be used by upcoming ipv4 forward path change that needs to determine feature mask using skb->dst->dev instead of skb->dev.
--- include/linux/netdevice.h | 7 ++++++- net/core/dev.c | 27 ++++++++++++++++----------- 2 files changed, 22 insertions(+), 12 deletions(-)
include/linux/netdevice.h +6 -1
@@ -2761,7 +2761,12 @@ void netdev_change_features(struct net_device *dev);void netif_stacked_transfer_operstate (const struct net_device *rootdev,struct net_device *dev); -netdev_features_t netif_skb_features (struct sk_buff *skb); +netdev_features_t netif_skb_dev_features (struct sk_buff *skb, +const struct net_device *dev); +static inline netdev_features_t netif_skb_features (struct sk_buff *skb) +{ +return netif_skb_dev_features (skb, skb->dev); +}static inline bool net_gso_ok (netdev_features_t features,int gso_type) {
net/core/dev.c +16 -11
@@ -2374,7 +2374,7 @@ EXPORT_SYMBOL(netdev_rx_csum_fault);* 2. No high memory really exists on this machine. */ -static int illegal_highdma (struct net_device *dev,struct sk_buff *skb) +static int illegal_highdma (const struct net_device *dev,struct sk_buff *skb) {#ifdef CONFIG_HIGHMEM int i;
@@ -2454,46 +2454,51 @@ static int dev_gso_segment(struct sk_buff *skb, netdev_features_t features) }static netdev_features_t harmonize_features (struct sk_buff *skb, -__be16 protocol,netdev_features_t features) +__be16 protocol, +const struct net_device *dev, +netdev_features_t features) {if (skb->ip_summed !=CHECKSUM_NONE && !can_checksum_protocol (features, protocol)) { features &= ~NETIF_F_ALL_CSUM ; - }else if (illegal_highdma (skb->dev, skb)) { + }else if (illegal_highdma (dev, skb)) { features &= ~NETIF_F_SG ; }return features; } -netdev_features_t netif_skb_features (struct sk_buff *skb) +netdev_features_t netif_skb_dev_features (struct sk_buff *skb, +const struct net_device *dev) {__be16 protocol = skb->protocol; -netdev_features_t features = skb->dev->features; +netdev_features_t features = dev->features; -if (skb_shinfo (skb)->gso_segs > skb->dev->gso_max_segs) +if (skb_shinfo (skb)->gso_segs > dev->gso_max_segs) features &= ~NETIF_F_GSO_MASK ;if (protocol ==htons (ETH_P_8021Q ) || protocol ==htons (ETH_P_8021AD )) {struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data; protocol = veh->h_vlan_encapsulated_proto; }else if (!vlan_tx_tag_present (skb)) { -return harmonize_features (skb, protocol, features); +return harmonize_features (skb, protocol, dev, features); } - features &= (skb->dev->vlan_features |NETIF_F_HW_VLAN_CTAG_TX | + features &= (dev->vlan_features |NETIF_F_HW_VLAN_CTAG_TX |NETIF_F_HW_VLAN_STAG_TX );if (protocol !=htons (ETH_P_8021Q ) && protocol !=htons (ETH_P_8021AD )) { -return harmonize_features (skb, protocol, features); +return harmonize_features (skb, protocol, dev, features); }else { features &=NETIF_F_SG |NETIF_F_HIGHDMA |NETIF_F_FRAGLIST |NETIF_F_GEN_CSUM |NETIF_F_HW_VLAN_CTAG_TX |NETIF_F_HW_VLAN_STAG_TX ; -return harmonize_features (skb, protocol, features); +return harmonize_features (skb, protocol, dev, features); } + +return harmonize_features (skb, protocol, dev, features); } -EXPORT_SYMBOL (netif_skb_features); +EXPORT_SYMBOL (netif_skb_dev_features);/* * Returns true if either:
Signature · 1 line
1.8.1.5
PATCH 3/3 net: ip, ipv6: handle gso skbs in forwarding path
In reply to Florian Westphalcommit fe6cc55f3a9a053482a76f5a6b2257cee51b4663 upstream.
Marcelo Ricardo Leitner reported problems when the forwarding link path has a lower mtu than the incoming one if the inbound interface supports GRO.
Given:
Host <mtu1500> R1 <mtu1200> R2
Host sends tcp stream which is routed via R1 and R2. R1 performs GRO.
In this case, the kernel will fail to send ICMP fragmentation needed messages (or pkt too big for ipv6), as GSO packets currently bypass dstmtu checks in forward path. Instead, Linux tries to send out packets exceeding the mtu.
When locking route MTU on Host (i.e., no ipv4 DF bit set), R1 does not fragment the packets when forwarding, and again tries to send out packets exceeding R1-R2 link mtu.
This alters the forwarding dstmtu checks to take the individual gso segment lengths into account.
For ipv6, we send out pkt too big error for gso if the individual segments are too big.
For ipv4, we either send icmp fragmentation needed, or, if the DF bit is not set, perform software segmentation and let the output path create fragments when the packet is leaving the machine.
It is not 100% correct as the error message will contain the headers of the GRO skb instead of the original/segmented one, but it seems to work fine in my (limited) tests.
Eric Dumazet suggested to simply shrink mss via ->gso_size to avoid sofware segmentation.
However it turns out that skb_segment() assumes skb nr_frags is related to mss size so we would BUG there. I don't want to mess with it considering Herbert and Eric disagree on what the correct behavior should be.
Hannes Frederic Sowa notes that when we would shrink gso_size skb_segment would then also need to deal with the case where SKB_MAX_FRAGS would be exceeded.
This uses sofware segmentation in the forward path when we hit ipv4 non-DF packets and the outgoing link mtu is too small. Its not perfect, but given the lack of bug reports wrt. GRO fwd being broken this is a rare case anyway. Also its not like this could not be improved later once the dust settles.
--- include/linux/skbuff.h | 17 ++++++++++++ net/ipv4/ip_forward.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++-- net/ipv6/ip6_output.c | 17 ++++++++++-- 3 files changed, 101 insertions(+), 4 deletions(-)
include/linux/skbuff.h +17 -0
@@ -2913,5 +2913,22 @@ static inline bool skb_head_is_locked(const struct sk_buff *skb) {return !skb->head_frag ||skb_cloned (skb); } + +/** +* skb_gso_network_seglen - Return length of individual segments of a gso packet +* +* @skb: GSO skb +* +* skb_gso_network_seglen is used to determine the real size of the +* individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP). +* +* The MAC/L2 header is not accounted for. +*/ +static inline unsigned int skb_gso_network_seglen (const struct sk_buff *skb) +{ +unsigned int hdr_len =skb_transport_header (skb) - +skb_network_header (skb); +return hdr_len +skb_gso_transport_seglen (skb); +}#endif /* __KERNEL__ */ #endif /* _LINUX_SKBUFF_H */
net/ipv4/ip_forward.c +69 -2
89 lines not on this page · raw message
net/ipv6/ip6_output.c +15 -2
@@ -345,6 +345,20 @@ static inline int ip6_forward_finish(struct sk_buff *skb)return dst_output (skb); } +static bool ip6_pkt_too_big (const struct sk_buff *skb,unsigned int mtu) +{ +if (skb->len <= mtu || skb->local_df) +return false; + +if (IP6CB (skb)->frag_max_size &&IP6CB (skb)->frag_max_size > mtu) +return true; + +if (skb_is_gso (skb) &&skb_gso_network_seglen (skb) <= mtu) +return false; + +return true; +} +int ip6_forward (struct sk_buff *skb) {struct dst_entry *dst =skb_dst (skb);
@@ -467,8 +481,7 @@ int ip6_forward(struct sk_buff *skb)if (mtu <IPV6_MIN_MTU ) mtu =IPV6_MIN_MTU ; -if ((!skb->local_df && skb->len > mtu && !skb_is_gso (skb)) || - (IP6CB (skb)->frag_max_size &&IP6CB (skb)->frag_max_size > mtu)) { +if (ip6_pkt_too_big (skb, mtu)) {/* Again, force OUTPUT device used as source address */ skb->dev = dst->dev;icmpv6_send (skb,ICMPV6_PKT_TOOBIG ,0 , mtu);
Signature · 1 line
1.8.1.5
David Miller
maintainerFrom: Florian Westphal <[email protected]>
Date: Sat, 22 Feb 2014 10:30:16 +0100
Quoted 5 lines
3.10 does not aggregate ~DF packets via GRO. However, as Marcelo Leitner pointed out to me we can still encounter GSO packets in fwd path in virtual environments where we receive GSO packet eg. via virtio.
Let me know if there are problems.
All of your backports queued up and submitted to -stable, thanks for doing this work!